Exemplo n.º 1
0
def create_app(config_name):
    """Create app endpoints"""
    from .views.category import cat
    from .views.client import cli
    from .views.feature import feat

    app = Flask(__name__, static_url_path="")

    for code in default_exceptions.keys():
        app.errorhandler(code)(make_json_error)

    app.json_encoder = CustomJSONEncoder

    app.config.from_object(app_config[config_name])
    app.config.from_pyfile('config.py')
    app._static_folder = "../static"
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

    db.init_app(app)

    app.register_blueprint(cat)
    app.register_blueprint(feat)
    app.register_blueprint(cli)

    @app.route('/', methods=['GET'])
    def root():
        return app.send_static_file("index.html")

    return app
Exemplo n.º 2
0
def create_app(config_name, logging_name=None):
    dapp = Flask(
        __name__,
        template_folder=os.path.join(
            os.path.dirname(os.path.abspath(__file__)), 'templates'),
    )

    login_manager.init_app(dapp)
    login_manager.session_protection = 'strong'
    login_manager.login_view = 'auth.login'

    dappconf = cnf[config_name]
    dapp.config.from_object(dappconf)

    dapp._static_folder = os.path.join(dapp.config['BASEDIR'], 'webapp',
                                       'static')
    dapp.static_url_path = os.path.join('/static')

    # Remove default Flask logger handlers
    dapp.logger.handlers = []

    dappconf.init_app(dapp, logging_name)
    db.init_app(dapp)

    from webapp.main import main as main_blueprint
    dapp.register_blueprint(main_blueprint)

    from webapp.auth import auth as auth_blueprint
    dapp.register_blueprint(auth_blueprint, url_prefix='/auth')

    from webapp.api_1_0 import api as api_1_0_blueprint
    dapp.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')

    return dapp
Exemplo n.º 3
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)
    app._static_folder = os.path.abspath("static/")
    bootstrap.init_app(app)
    mail.init_app(app)
    moment.init_app(app)
    db.init_app(app)
    login_manager.init_app(app)
    csrf.init_app(app)
    # blueprint registration
    from .main import main as main_blueprint
    app.register_blueprint(main_blueprint)
    from .auth import auth as auth_blueprint
    app.register_blueprint(auth_blueprint, url_prefix='/auth')
    from .products import product as products_blueprint
    app.register_blueprint(products_blueprint, url_prefix='/product')
    from .admin import admin as admin_blueprint
    app.register_blueprint(admin_blueprint, url_prefix='/admin')
    from .taiwan import taiwan as taiwan_blueprint
    app.register_blueprint(taiwan_blueprint, url_prefix='/taiwan')
    from .linebot import linebot as linebot_blueprint
    app.register_blueprint(linebot_blueprint, url_prefix='/linebot')
    from .interactive import interactive as interactive_blueprint
    app.register_blueprint(interactive_blueprint, url_prefix='/interactive')
    return app
Exemplo n.º 4
0
def create_app(config_name):
	if config_name != 'test':
	    print "Application created based on config_name: %s" % (config_name)

	app = Flask(__name__)
	app._static_folder = 'static'
	app.debug = True

	app_config = config[config_name]
	app.config.from_object(app_config)
	config[config_name].init_app(app)
	

	app.secret_key = 'tell you'

	db.init_app(app)
	moment.init_app(app)
	login_manager.init_app(app)
	mail.init_app(app)
	pages.init_app(app)
	from .send_mail import sendmail as send_mail_blueprint
	app.register_blueprint(send_mail_blueprint)

	from .webviews import webviews as webviews
	app.register_blueprint(webviews)
	return app
Exemplo n.º 5
0
def create_app():
    app = Flask(__name__)
    app.config.update(
        TEMPLATES_AUTO_RELOAD=True
    )
    # app.config['MONGO_DBNAME'] = 'youtube'
    app._static_folder = 'static/'
    Bootstrap(app)
    return app
Exemplo n.º 6
0
def create_app():
    app = Flask(__name__)
    app._static_folder = "static"

    @app.route('/')
    def index():
        """Route definition for the index page."""
        return render_template('index.html')

    return app
Exemplo n.º 7
0
def create_app(config_name=None):
    if config_name is None:
        config_name = os.getenv('FLASK_CONFIG', 'development')

    app = Flask(__name__)
    app.config.from_object(config[config_name])
    app._static_folder = 'static'
    register_extensions(app)
    register_blueprints(app)

    return app
Exemplo n.º 8
0
def create_app(env=None, start_response=None):
    app = Flask(__name__, static_url_path='/static')
    app._static_folder = os.path.join(os.path.dirname(__file__), 'static')
    app.template_folder = f"{os.path.dirname(os.path.dirname(os.path.abspath(__file__)))}" \
                           f"/lobo-angular/dist/"

    cors = CORS(app, resources={r"/*": {"origins": "*"}})
    config = xconfig.get_config()
    app.config.update(**config.__dict__)

    app.config['SQLALCHEMY_DATABASE_URI'] = _create_db_string(
        afnconfig.get('db'))

    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

    logger = logging.getLogger()
    logger.setLevel(config.log_level)
    coloredlogs.install(
        level='DEBUG',
        fmt=
        '%(asctime)s.%(msecs)03d %(hostname)s [%(process)d] %(name)8s %(levelname)7s %(message)s'
    )
    sys.stdout = LoggerCapture(logger.debug)

    from app.views import index
    from app.views import users
    from app.views import auth
    from app.views import notification
    from app.views import services
    from app.views import event
    from app.views import review
    from app.views import conversation
    from app.views import recommendation
    from app.views import user_events

    app.register_blueprint(index.app)
    app.register_blueprint(users.app)
    app.register_blueprint(auth.app)
    app.register_blueprint(notification.app)
    app.register_blueprint(services.app)
    app.register_blueprint(event.app)
    app.register_blueprint(review.app)
    app.register_blueprint(conversation.app)
    app.register_blueprint(recommendation.app)
    app.register_blueprint(user_events.app)

    db.init_app(app)

    if app.debug:
        logger.info("{app} initialized".format(app='lobo'))

    return app
Exemplo n.º 9
0
def create_app(config_name):
    app = Flask(__name__, instance_relative_config=True)
    app.config.from_object(app_config[config_name])
    app.config.from_pyfile('config.py')
    # en prod app.static_folder = os.path.abspath("./churching/app/static/")
    app._static_folder = os.path.abspath("app/static/")

    Bootstrap(app)
    db.init_app(app)

    app.config['PAGE_SIZE'] = 20
    app.config['VISIBLE_PAGE_COUNT'] = 10

    login_manager.init_app(app)
    # login_manager.login_message = "Debes estar logado para ver esta pagina"
    login_manager.login_view = "auth.login"
    migrate = Migrate(app, db)

    from app import models

    from .miembros import miembros as miembros_blueprint
    app.register_blueprint(miembros_blueprint)

    from .auth import auth as auth_blueprint
    app.register_blueprint(auth_blueprint)

    from .home import home as home_blueprint
    app.register_blueprint(home_blueprint)

    from .ggcc import ggcc as ggcc_blueprint
    app.register_blueprint(ggcc_blueprint)

    from .familias import familias as familias_blueprint
    app.register_blueprint(familias_blueprint)

    from .roles import roles as roles_blueprint
    app.register_blueprint(roles_blueprint)

    from .extras import extras as extras_blueprint
    app.register_blueprint(extras_blueprint)

    from .seguimientos import seguimientos as seguimientos_blueprint
    app.register_blueprint(seguimientos_blueprint)

    from .asistencias import asistencias as asistencias_blueprint
    app.register_blueprint(asistencias_blueprint)

    from .informes import informes as informes_blueprint
    app.register_blueprint(informes_blueprint)

    return app
Exemplo n.º 10
0
def create_app():
    print("In Method: create_app()")

    app = Flask(__name__)

    app.config.update(
        SECRET_KEY=secret
    )

    app.register_blueprint(main_bp)
    app.register_blueprint(user_bp)
    app.register_blueprint(authentication_bp)

    app._static_folder = os.path.abspath("static/")
    return app
Exemplo n.º 11
0
def create_app():
    app = Flask(__name__)
    Bootstrap(app)
    #csrf = CSRFProtect()
    app.config["SECRET_KEY"] = "row the boat"
    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
    #csrf.init_app(app)
    app._static_folder = 'static'

    db.init_app(app)

    from .main import main as main_blueprint
    app.register_blueprint(main_blueprint)

    return app
Exemplo n.º 12
0
def create_app():
    app = Flask(__name__)
    app.config.from_pyfile("config.py")
    app._static_folder = "templates/static"
    db.init_app(app)
    migrate = Migrate(app, db)

    login_manager = LoginManager()
    login_manager.init_app(app)
    login_manager.login_view = "user.login"

    app.register_blueprint(user_bp)
    app.register_blueprint(news_bp)
    app.register_blueprint(admin_bp)

    @login_manager.user_loader
    def load_user(user_id):
        return User.query.get(user_id)

    return app
Exemplo n.º 13
0
def start_app():
    app = Flask(__name__, static_url_path='/static')

    app.config["DEBUG"] = True
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DATABASE_URI")
    CORS(app)

    app._static_folder = os.path.join(os.path.dirname(__file__), 'public')

    @app.errorhandler(ValidationError)
    def handle_marshmallow_validation(err):
        return jsonify(err.messages), 400

    db.init_app(app)
    marsh.init_app(app)

    app.register_blueprint(index.app)

    return app
Exemplo n.º 14
0
def create_app(config_name):
    app = Flask(__name__)  # instance of app
    app._static_folder = "static"
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)  # pass configurations

    bootstrap.init_app(
        app)  # bind app with bootstrap/mail/moment/db/login, etc.
    mail.init_app(app)
    moment.init_app(app)
    login_manager.init_app(app)
    celery.conf.update(app.config)

    from .main import main as main_blueprint
    app.register_blueprint(main_blueprint)

    from .auth import auth as auth_blueprint
    app.register_blueprint(auth_blueprint, url_prefix='/auth')

    from .code import code as code_blueprint
    app.register_blueprint(code_blueprint, url_prefix='/code')

    return app
Exemplo n.º 15
0
import os
import config

from flask import Flask, abort, g, request, url_for, redirect
from flask import render_template as flask_render_template
from distros_installs import distros_installs

from flask.ext.babel import Babel

app = Flask(__name__)
app._static_folder = os.getcwd() + '/website/static'
app.config['SECRET_KEY'] = os.urandom(64)
if app.debug:
    from flaskext.lesscss import lesscss
    lesscss(app)
#app.config.from_pyfile('translations.cfg')
babel = Babel(app, default_locale="en_US.ISO8859-1")

from events import get_rss

def render_template(template, *args, **kwargs):
    lang_path = config.LANG_MAP.get(g.current_lang, 'en_US.ISO8859-1')
    kwargs['include_template'] = "%s/htdocs/%s" % (lang_path, template)
    return flask_render_template(template, *args, **kwargs)

@app.before_request
def before():
    if request.view_args and 'lang_code' in request.view_args:
        if request.view_args['lang_code'] not in config.LANG_CODES:
            print 'aborting'
            return abort(404)
Exemplo n.º 16
0
import os 
from flask import Flask, make_response
from flask.ext import restful
from flask.ext.pymongo import PyMongo
from flask.ext.assets import Environment, Bundle
from bson.json_util import dumps
import jinja2

# basic paths
MONGO_URL = "mongodb://localhost:27017/violence"
ASSETS_DIR=os.path.join(os.path.dirname(os.path.abspath(__file__)), '../static')

# app
app = Flask(__name__)
app._static_folder = ASSETS_DIR
app.config['SECRET_KEY'] = 'secret!'
app.debug = True
app.jinja_loader=jinja2.FileSystemLoader('templates')

# compass config
assets = Environment(app)

main_scss = Bundle('scss/style.scss', 'scss/media.scss', filters='compass', output='css/style.css')
assets.register('main_scss', main_scss)

# mongo db
app.config['MONGO_URI'] = MONGO_URL
mongo = PyMongo(app)

def output_json(obj, code, headers=None):
    resp = make_response(dumps(obj), code)
Exemplo n.º 17
0
import json
from flask import Flask, request, redirect, url_for, send_from_directory
import frame
import classifier
import api
import numpy as np
import sys
import os
import glob
import random
import imageio

# Setup Flask app.
app = Flask(__name__)
app.debug = True
app._static_folder = '../client'


# Setup classifier.
# Creates classification network and node ID --> English string lookup.
# node_lookup = classifier.NodeLookup()
videoFolder = './server/videos'
cacheFolder = './server/cache'
# createdGraph = False

if "cache" not in os.listdir('./server'):
    os.mkdir("./server/cache")

# Routes
@app.route('/')
def root():
Exemplo n.º 18
0
from flask import Flask, render_template, request, url_for

import requests
import pandas as pd
import datetime
import time
import os

app = Flask(__name__, template_folder='Templates')

app._static_folder = os.path.abspath(
    "C:/Users/Nicolas/investors_app/static/style.css")

first_date = datetime.datetime(2019, 1, 7)
current_date = datetime.datetime.now()  #.strftime('%Y-%m-%d')
trading_days = int((current_date - first_date).days * 0.7)
calendar_days = (current_date - first_date).days


@app.route('/')
def get_investors():

    investors = ['Grant', 'Paul', 'Bret', 'Dave', 'Stef', 'Nan', 'Jon']
    return render_template('Investors.html', investors=investors)


@app.route('/<string:investor_name>/metrics/')
def investors_metrics(investor_name):

    login = requests.get(
        'https://www.myfxbook.com/api/[email protected]&password=Trader1'
Exemplo n.º 19
0
Arquivo: main.py Projeto: 10173/SRASH
import os
from flask import Flask, render_template, make_response
from flask import redirect, request, jsonify, url_for

from clarifai.rest import ClarifaiApp
from appclaifai.model.helpers import get_model
from appclaifai.model.helpers import predict

app_obj = ClarifaiApp(api_key = 'a28d6ad6382d434a9cae46a67b97364e')
paper_model = get_model(app_obj, 'general-v1.3')

app = Flask(__name__)
app.secret_key = 's3cr3t'
app.debug = True
app._static_folder = os.path.abspath("pics")

@app.route('/', methods=['GET'])
def home():
    return redirect('https://srash.netlify.com')

@app.route('/<base64image>', methods=['POST'])
def captured(base64image):
    class_probs = predict(paper_model, base64image)

if __name__ == '__main__':
    app.run()
Exemplo n.º 20
0
from flask import Flask,make_response,render_template,redirect,session,escape,request,url_for

from mysql import MySQLDatabase
from imdb_module import IMDataBase

import json

db = MySQLDatabase('imdb','imdb','imdb','localhost')
# imDB = IMDataBase()

DEBUG = 1

# http://flask.pocoo.org/docs/0.10/quickstart/
app = Flask(__name__)
app._static_folder = '/Users/juan/say-it-louder/static/'

# set the secret key.  keep this really secret:
app.secret_key = 'This_is_a_secret'


######################################################################################################################
#                                        Main App and common options                                                 #
######################################################################################################################

@app.route('/')
def index():

    # if not 'user_name' in session:
    #     if DEBUG:
    #         print "Not logged in. Redirecting to /login"
    #     return redirect("/login")
Exemplo n.º 21
0
from wtforms.validators import DataRequired
from flask_bootstrap import Bootstrap
from flask_sqlalchemy import SQLAlchemy
from flask_mail import Mail, Message
from rdbms_ingestor.src.helper import update_conf, generate_message
######################
##### CONFIG ########
####################
app = Flask(__name__)
app.config['SECRET_KEY'] = 'MySecret'
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = "******"
app.config['MAIL_PASSWORD'] = None
app._static_folder = "C:\\Users\mikea\Desktop\Developer\Projects\Work\RDBMS_WebApp\\rdbms_ingestor\static"
bootstrap = Bootstrap(app)
db = SQLAlchemy(app)
mail = Mail(app)


########################
###### MODELS #########
######################
class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(64), unique=True, index=True)
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

    def __repr__(self):
Exemplo n.º 22
0
    return lastnonce


def get_user_by_key(app, key):
    """
    An SQLAlchemy User getting function. Get a user by public key.

    :param str key: the public key the user belongs to
    """
    user = ses.query(SLM_User).join(UserKey).filter(UserKey.key == key).first()
    return user


# Setup flask app and FlaskBitjws
app = Flask(__name__)
app._static_folder = "%s/static" % os.path.realpath(os.path.dirname(__file__))

FlaskBitjws(
    app, privkey=cfg.PRIV_KEY, get_last_nonce=get_last_nonce, get_user_by_key=get_user_by_key, basepath=cfg.BASEPATH
)

# Setup logging
logfile = cfg.LOGFILE if hasattr(cfg, "LOGFILE") else "server.log"
loglevel = cfg.LOGLEVEL if hasattr(cfg, "LOGLEVEL") else logging.INFO
logging.basicConfig(filename=logfile, level=loglevel)
logger = logging.getLogger(__name__)

# Setup CORS
CORS(app)

# Setup database
databases = {
    'login': '******',
    'requests': 'sqlite:///requests.db',
    'ServerState': 'sqlite:///ServerState.db'
}
"""
databases = {
    "login": "******",
    "requests": "sqlite:///requests.sqlite3",
    "ServerState": "sqlite:///ServerState.sqlite3",
}
app.config["SQLALCHEMY_BINDS"] = databases


db = SQLAlchemy(app)
app._static_folder = "/Users/macx/Desktop/大空调/myproject/static/"

room_id = 724
server_mode = "cold"
client_state = "off"
server_state = "off"

server_state_temp = "off"
server_mode_temp = "cold"
client_mode = "cold"
client_power = 0.8

queue = []


def ClientWork(start, room_id):
Exemplo n.º 24
0
import os
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.openid import OpenID
from config import basedir

app = Flask(__name__, static_folder='./public/css/style.css')
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
oid = OpenID(app, os.path.join(basedir, 'tmp'))
app._static_folder = os.path.abspath("static/style.css")
print os.path.abspath(app._static_folder)
from app import views, models
Exemplo n.º 25
0
import os
import sys
import subprocess
from flask_restful import Api, Resource
from flask import Flask, send_file, send_from_directory, safe_join, request, Response, abort

app = Flask(__name__)
api = Api(app)
app._static_folder = "/var/www/dc/dc/static/"

from rest import *

#Define API endpoints
#Map classes to API endpoints
api.add_resource(CharacterList, '/characters.json')
api.add_resource(TeamsList, '/teams.json')
api.add_resource(ShowsList, '/shows.json')
api.add_resource(MoviesList, '/movies.json')
api.add_resource(ComicsList, '/comics.json')
api.add_resource(CreatorsList, '/creators.json')
api.add_resource(CharacterUpdate, '/characters/<string:id>.json')
api.add_resource(TeamsUpdate, '/teams/<string:id>.json')
api.add_resource(ShowsUpdate, '/shows/<string:id>.json')
api.add_resource(MoviesUpdate, '/movies/<string:id>.json')
api.add_resource(ComicsUpdate, '/comics/<string:id>.json')
api.add_resource(CreatorsUpdate, '/creators/<string:id>.json')
api.add_resource(searchDB, '/search/<string:search_text>.json')



Exemplo n.º 26
0
from flask import Flask
from flask.ext.mail import Mail
from flask.ext.script import Server
from flask.ext.sqlalchemy import SQLAlchemy
import os
import yaml


#Initialize Application
app = Flask(__name__, template_folder=os.path.join(os.path.dirname(os.path.abspath(__file__)), '../views'))
app._static_folder = '../../static'


#Load Configs
parsed_config = None
config = {}
config_path = None

env = os.environ.get('FLASK_ENV')

if env == "prod":
    config_path = "config_prod.yaml"
else:
    config_path = "config_dev.yaml"

with open(config_path, 'r') as stream:
    parsed_config = yaml.load(stream)


config["JWT_ALGORITHM"] = 'HS512'
config["BCRYPT_ROUNDS"] = 12
Exemplo n.º 27
0
import struct
import sys,os
import binascii
import fcntl
import time
import random
import threading
from Server import Server
from multiprocessing import Process

import lxml
from lxml.html.clean import Cleaner

app = Flask(__name__)
socketio = SocketIO(app)
app._static_folder = "/home/tyler/Documents/SmartHome/cSocket-Server/"

@app.route('/')
def root():
	return app.send_static_file('index.html') 
	# return "hello"

@socketio.on('checkForNew')
def handle_message(message):
	print "got check request"
	print str(json.dumps(server.getDevList()));
	socketio.emit("deviceList", str(json.dumps(server.getDevList())))# {"list": server.getDevList()})
	# print json.dumps(server.getDevList());
	pass
	
	# print('received message: ' + str(message))
Exemplo n.º 28
0
from flask import Flask, url_for
from flask import render_template
from random import randint
import json

app = Flask(__name__)
app._static_folder = "/var/www/junyi/flask"
max = 10

@app.route('/')
def hello_world():
	return render_template('index.html')

@app.route('/addition')
@app.route('/addition/<name>')
def addition(name="Junyi"):
	num_list = []
	while len(num_list) < 3:
		num_list.append([randint(1, 5), randint(1,5)])
		
	return render_template('addition.html', name=name, num_list=num_list)

if __name__ == '__main__':
	app.run(host='0.0.0.0', debug=True)
Exemplo n.º 29
0
    send_from_directory,
    request, jsonify, g,
    Response)
from database import (db, Sensor,
    Measurement,
    create_tables,
    list_to_dict)
import xml.etree.ElementTree as ElementTree
import os

app = Flask(__name__)
app.debug = True
# get the port from the app cloud or use fallback
port = int(os.getenv("VCAP_APP_PORT") or 8080)

app._static_folder = 'www/'

@app.route('/')
def index():
    '''
        Home page of the weather app
    '''
    return app.send_static_file('index.html')

@app.route('/js/<path:path>')
def send_js(path):
    '''
        Serves static javascript files
    '''
    return send_from_directory('www/js/', path)
Exemplo n.º 30
0
            # then it should be ), otherwise raise an exception
            self._expect('RPAREN')

            # return the previous saved value
            return expr_value
        elif self._accept('DOLLAR'):
            #if it's a dollar we can break
            #raise SyntaxError('Expected $')
            return "not valid"
        else:
            #return "not valid"
            return "not valid"
            #raise SyntaxError('Expect NUMBER or LPAREN')

@app.route('/')
def parse():
    return render_template("index.html")

@app.route('/echo',methods=['POST'])
def my_form_post():
    e = ExpressionEvaluator()
    s = request.form['text']
    b = e.parse(s)
    b = str(b)
    return render_template("index.html", text=b)

if __name__ == '__main__':
    app.debug = True
    app._static_folder = "templates/"
    app.run()
Exemplo n.º 31
0
from flask import url_for
from flask import session
from flask import jsonify
from flask.ext.scrypt import generate_random_salt
from flask.ext.assets import Environment, Bundle
from flask_oauthlib.client import OAuth
from flask_oauthlib.client import OAuthException
# from flask import make_response
# from flask import jsonify
from sqlalchemy import func, cast, Date

init_logging('pajbot')
log = logging.getLogger('pajbot')

app = Flask(__name__)
app._static_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static')
app.register_blueprint(api.page)
app.register_blueprint(admin.page)

assets = Environment(app)

# Basic CSS and Javascript:
# Available under: base_css, semantic_css, base_js
base_css = Bundle('css/base.min.css',
        output='css/base.gen.%(version)s.css')
semantic_css = Bundle('semantic/semantic.min.css',
        output='semantic/semantic.gen.%(version)s.css')
base_js = Bundle('scripts/base.js', filters='jsmin',
        output='scripts/base.gen.%(version)s.js')
semantic_js = Bundle('semantic/semantic.min.js',
        output='semantic/semantic.gen.%(version)s.js')
Exemplo n.º 32
0
from flask import Flask, render_template
import subprocess

app = Flask(__name__)
app._static_folder = '../static'


@app.route('/')
def setup():
    return render_template('index.html', title='Setup')


@app.route('/setupdone')
def setup_done():
    return render_template('setupdone.html', title='Add or Remove')


@app.route('/startcluster', methods=['GET', 'POST'])
def initial_setup():
    subprocess.call("/home/ubuntu/acc3-QTLaaS/add-userdata/start-cluster.sh")
    return render_template('setupdone.html', title='Add or Remove')


@app.route('/addworker', methods=['GET', 'POST'])
def add_worker():
    subprocess.call("/home/ubuntu/acc3-QTLaaS/add-userdata/add-to-cluster.sh")
    return render_template('setupdone.html', title='Add or Remove')


@app.route('/removeworker', methods=['GET', 'POST'])
def delete_worker():
Exemplo n.º 33
0
import GPIOController

config = ConfigParser.ConfigParser()
vibratorManager = VibratorManager()

update_intervall = 1
sequence_time = 120
bEnd = False
tThread = None

lLock = threading.Lock()

from flask import Flask
from flask import send_from_directory
app = Flask(__name__, static_url_path='/')
app._static_folder = os.path.dirname(os.path.realpath(__file__))

app.debug = False


@app.route("/points/<int:value>/")
def setPoints(value):
    global lLock
    lLock.acquire()
    vibratorManager.set_points(value)
    lLock.release()
    return "1"

@app.route("/points/")
def getPoints():
    global lLock
Exemplo n.º 34
0
rate = 49033.
dampingRatio = 0.
mass = 272.2

import os
import json

from flask import Flask, Response, flash, request, render_template
app = Flask(__name__)
app._static_folder = os.path.abspath('./static')


@app.route('/dampingRatio', methods=['POST', 'GET'])
def changeDamping():
    print(request)
    global dampingRatio
    dampingRatio = float(request.form.get('ratio'))
    return str(dampingRatio)


@app.route('/rate', methods=['POST', 'GET'])
def changeRate():
    global rate
    rate = float(request.form.get('rate'))
    return str(rate)


@app.route('/mass', methods=['POST', 'GET'])
def changeMass():
    global mass
    mass = float(request.form.get('mass'))
Exemplo n.º 35
0
from flask import Flask, request, render_template, redirect
from cards import card_dict
# set the project root directory as the static folder, you can set others.

app = Flask(__name__, static_url_path='')
app._static_folder = "static/"


@app.route('/')
def root():
    f = open("card.txt", 'r')
    cur_card = f.read()
    f.close()
    return render_template('index.html', card=card_dict[cur_card])


@app.route('/set', methods=['GET'])
def set_card():
    ranks = ['2', '3', '4', '5', '6',
             '7', '8', '9', '10', 'j',
             'q', 'k', 'a']
    return render_template('set_card.html', ranks=ranks)


@app.route('/save', methods=['GET'])
def save_card():
    suits = ['h', 'd', 'c', 's']
    ranks = ['a', 'k', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'j', 'q']

    bin = request.args.get("bin")
    if bin:
Exemplo n.º 36
0
from forms import simulationForm
from flask import Flask, render_template, redirect, url_for, request
from math import ceil, floor
import random
import os
import sys
reload(sys)
sys.setdefaultencoding('utf8')

app = Flask(__name__)
app._static_folder = "static"
app.config.update(
    dict(SECRET_KEY="powerful secretkey",
         WTF_CSRF_SECRET_KEY="a csrf secret key"))

####################################################################################################
# HELPER FUNCTIONS #
'''
 * Simulate awarding a Bitcoin block
 *  a => Percent of the total network owned by the selfish mining pool
 *  g => Gamma
'''


def awardBlock(a, g):
    #issue: random always returns honest
    #rnd = random.uniform(0, 1)
    #rnd = int(from_bytes(os.urandom(8), byteorder="big") / ((1 << 64) - 1))
    rnd = random.random()
    print rnd
    # Honest miners found a block on top of the selfish block
Exemplo n.º 37
0
from flask import Flask, render_template, url_for, request, redirect
import os
import csv
app = Flask(__name__)
app._static_folder = ''
print(__name__)

#print(os.getcwd())
#os.chdir('/home/paul/Desktop/Python/web server')


@app.route('/<page_name>')
def html_page(page_name):
    return render_template(page_name)


def write_to_file(data):
    with open('database.txt', mode='a') as database:
        email = data["email"]
        subject = data["subject"]
        message = data["message"]
        file = database.write(f'\n {email},{subject},{message}')


def write_to_csv(data):
    with open('database1.csv', mode='a') as database2:
        email = data["email"]
        subject = data["subject"]
        message = data["message"]
        csv_writer = csv.writer(database2,
                                delimiter=',',
Exemplo n.º 38
0
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine, func
from flask_sqlalchemy import SQLAlchemy

from flask import Flask, jsonify, render_template, request, redirect
import get_data

import psycopg2

#################################################
# Flask Setup
#################################################
app = Flask(__name__)

app._static_folder = 'static/'

# load the tickers we want into a dataframe
tickers = pd.DataFrame({
    'Sector' : ['Retail', 'Retail', 'Tech', 'Tech', 'Entertainment', 'Entertainment', 'Ecommerce', 'Ecommerce', 'Airline', 'Airline'],
    'Name' : ['Walmart', 'Target', 'Nvidia', 'Zoom', 'Spotify', 'Netflix', 'Amazon', 'Shopify', 'Delta', 'United Airlines'],
    'Ticker' : ['WMT', 'TGT', 'NVDA', 'ZM', 'SPOT', 'NFLX', 'AMZN', 'SHOP', 'DAL', 'UAL'],
})

##################################

# DATABASE_URL will contain the database connection string


# SQLALCHEMY_DATABASE_URI_AWS links to AWS database
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ["SQLALCHEMY_DATABASE_URI_AWS"]
Exemplo n.º 39
0
from flask import (Flask, jsonify, redirect, request, session)
from flask_api import status
# from Flask-DebugToolbar import DebugToolbarExtension
from flask_sqlalchemy import SQLAlchemy
from flask_cors import CORS, cross_origin
from model import User, Book, BookUser, Genre, BookGenre, connect_to_db, db
from random import choice
import os

################################################################################
################################# SETUP #######################################
################################################################################

app = Flask(__name__)
ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
app._static_folder = os.path.join(ROOT_PATH, 'static')

cors = CORS(app,
            resources={
                r"/*": {
                    r"supports_credentials": True,
                    r"origins": r"http://:3000"
                }
            })

# Required to use Flask sessions and the debug toolbar
app.secret_key = os.environ.get("SECRET_KEY") or b'_5#y2L"F4Q8z\n\xec]/'


@app.before_request
def before():
Exemplo n.º 40
0
from flask import Flask, render_template
from models.conectDB import MongodbDOA, PostgresDAO
app = Flask(__name__)
app._static_folder = "/templates"

pgDB = PostgresDAO()

@app.route("/")
def main():
    pgDB.insertCompany(),
    return render_template('index.html')

@app.route("/cadastro")
def singup():
    pass
@app.route("/login")
def login():
    pass
@app.route('/admin')





if __name__ == "__main__":
    app.run()
Exemplo n.º 41
0
    twitter_user_data["id"] = user_info.id
    twitter_user_data["num_tweets"] = user_info.tweets
    twitter_user_data["following"] = user_info.following
    twitter_user_data["followers"] = user_info.followers


    twitter_user_data["likes"] = user_info.likes

    # List of users the tweet is a reply to
    twitter_user_data["lists"] = user_info.lists
    
    return twitter_user_data

#APP_ROOT = os.path.dirname(os.path.abspath("__file__"))
app.jinja_loader=jinja2.FileSystemLoader(r'C:\Users\SAMARTH G VASIST\flask projects\templates')
app._static_folder = r"C:\Users\SAMARTH G VASIST\flask projects\static"

@app.route("/")

@app.route("/home")

def home():
    flash('Welcome to Root Intelligence', 'success')
    return render_template('home.html')


@app.route("/infoga", methods=["POST"])
def info():
    text= "python phoneinfoga.py -n +91"+num
    os.system(text)
Exemplo n.º 42
0
from flask import session as login_session
import random
import string
import os
from math import floor
from OpenSSL import SSL

from oauth2client.client import flow_from_clientsecrets
from oauth2client.client import FlowExchangeError
import httplib2
import json
from flask import make_response
import requests

app = Flask(__name__)
app._static_folder = "~/Desktop/onlineU/static"

HOST = '0.0.0.0'
PORT = 80

CLIENT_ID = json.loads(
    open('client_secrets.json', 'r').read())['web']['client_id']
APPLICATION_NAME = "Education"


# Connect to Database and create database session
engine = create_engine('sqlite:///' + DATABASE_NAME)
Base.metadata.bind = engine

DBSession = sessionmaker(bind=engine)
session = DBSession()
Exemplo n.º 43
0
from __future__ import division
import sys, os
from flask import Flask, request, render_template, Response

# Globals
app = Flask(__name__)
app._static_folder = "dist"

# Routes
@app.route("/")
@app.route("/<path:path>")
def index(path="index.html"):
    return app.send_static_file(path)


if __name__ == "__main__":
	host = '0.0.0.0'
	port = 5000
	debug = False
	if len(sys.argv) > 1:
		host = sys.argv[1]
	if len(sys.argv) > 2:
		port = int(sys.argv[2])
	if len(sys.argv) > 3:
		debug = bool(sys.argv[3])
        app.run(debug=debug, host=host, port=port)
Exemplo n.º 44
0
"""Flask demo"""
from flask import Flask, render_template, request
import json
import sys
sys.path.append('../PREDICTOR')
from satisfcation_predictor import Predictor

# Init Flas app and Twitter api
app = Flask(__name__)
app._static_folder = "./static/"
predictor = None

@app.route('/')
def index():
    return render_template('/index.html')


@app.route('/show', methods=['GET', 'POST'])
def show_tweets():
    reviewText = request.form['screen_name'].encode('ascii', 'ignore').lower().strip()
    print reviewText
    try:
	print "Review text is ", reviewText
	answer = predictor.predict(reviewText)
	print answer
    except Exception as e:
   	print 'Some error', reviewText, "\n", str(e) 
    else:
    	pass

    return render_template('/index.html', answer=answer, previous_text=reviewText)
Exemplo n.º 45
0
import sys, os, json, pickle
import requests, urllib.parse
from GoogleNews import GoogleNews
from string import punctuation
from collections import Counter
from nltk import sent_tokenize
from newspaper import Article
from geopy.geocoders import Nominatim
from geopy.distance import geodesic
import spacy

# For server
app = Flask(__name__, template_folder='templates/')
app.secret_key = 's3cr3t'
app.debug = True
app._static_folder = os.path.abspath("templates/static/")

# For the Tracker
config = None
state = None
nlp = None
geolocator = None


def search():
    global state, config
    if config is None:
        raise Exception('Call initiateConfig first')
    if state is None:
        state = {}
    state['url'] = {}
Exemplo n.º 46
0
        self.desc_map = {
            self.data : "data",
            self.event : "event",
            self.id : "id"
        }

    def encode(self):
        if not self.data:
            return ""
        lines = ["%s: %s" % (v, k)
                 for k, v in self.desc_map.iteritems() if k]

        return "%s\n\n" % "\n".join(lines)

app = Flask(__name__)
app._static_folder = './'
subs = []

@app.route('/')
def root():
    return app.send_static_file('index.html')

import os
@app.route('/<path:path>')
def static_proxy(path):
    return app.send_static_file(path)

@app.route("/next_video")
def push_nextVideo():
    def notify():
        msg = "NEXT!"
Exemplo n.º 47
0
from flask import Flask, render_template, make_response
from flask import redirect, request, jsonify, url_for
from flask import g

import io
import os
import uuid
import numpy as np
import sqlite3
import ApiExceptions
import json

app = Flask(__name__)
app.secret_key = 's3cr3t'
app.debug = True
app._static_folder = os.path.abspath("static/")


@app.errorhandler(ApiExceptions.InvalidUsage)
def handle_invalid_usage(error):
    response = jsonify(error.to_dict())
    response.status_code = error.status_code
    return response


def get_db():
    db = getattr(g, '_database', None)
    if db is None:
        db = g._database = sqlite3.connect("../Database.db")
        #db = g._database = mysql.connector.connect(host="localhost",user="******",password="******",database="app")
    return db
Exemplo n.º 48
0
from flask import Flask
from base.views import blueprint as main_blueprint

app = Flask(__name__)
app._static_folder = 'base/static'
app.config.update(
    DEBUG=True,
    JQUERY='',
    CFG_SITE_NAME='Invenio Software',
)
app.register_blueprint(main_blueprint)

if __name__ == '__main__':
    app.run(host="0.0.0.0", debug=True)
Exemplo n.º 49
0
from flask import Flask, request, render_template, redirect, session
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user

TEMPLATE_FOLDER_PATH = '/home/pi/Desktop/ComNet-class-project/HTMLtemplate'
STATIC_FOLDER_PATH = '/home/pi/Desktop/ComNet-class-project/static'

app = Flask(__name__, template_folder=TEMPLATE_FOLDER_PATH)
app._static_folder = STATIC_FOLDER_PATH

app.config[
    'SQLALCHEMY_DATABASE_URI'] = 'sqlite:////home/pi/Desktop/ComNet-class-project/database.db'
app.config['SECRET_KEY'] = 'thisissecret'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True

db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'

#declare necessary parameters
ARGO_PER_HOUR = 5000


#define table for users
class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(30), unique=True)
    password = db.Column(db.String(30), unique=True)

Exemplo n.º 50
0
import sys
import logging
import numpy as np

from flask import Flask, request, jsonify, make_response, current_app, \
        render_template
from datetime import datetime
from bus import bus
from flask.ext.cors import CORS

app = Flask(__name__)
app._static_folder = 'static'
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.ERROR)


cors = CORS(app, resources={r"/latlng/*": {"origins": "*"}})

bus_stops = {'10813': [-0.0984574616503, 51.3760929581],
 '1164': [-0.118444497979, 51.4013254207],
 '1441': [-0.111505659588, 51.3886330116],
 '14622': [-0.11532824762, 51.4624163884],
 '15100': [-0.127886565845, 51.4190123595],
 '15101': [-0.123989076582, 51.4147954483],
 '15102': [-0.121592866634, 51.4076438324],
 '15104': [-0.11950429888, 51.4038783631],
 '15105': [-0.119676700562, 51.4045826277],
 '15106': [-0.114913800215, 51.3952345961],
 '15107': [-0.11553210181, 51.3969801748],
 '15108': [-0.112343246015, 51.3902831629],
 '15110': [-0.109847701645, 51.3852700354],
Exemplo n.º 51
0
import time
from time import sleep

arg_parser = argparse.ArgumentParser(description='python based telemetry and command streamer.',add_help=False)
arg_parser.add_argument('--ProjectDir',  default='proj_example',type=str, help='Project folder to pull configuration data from')
arg_parser.add_argument('--NoTlmOut',  action="store_true", help='Disables output telemetry')
arg_parser.add_argument('-v','--verbose',  action="store_true", help='Disables verbose output')
arg_parser.add_argument('--regen_tlmdb',  action="store_true", help='Regenerates the telemetry database')
#arg_parser.add_argument('--uart',    type=str,help='UART device to pull data from')
#arg_parser.add_argument('-h', '--help',  action="store_true", help='Disables output telemetry')
arg_parser.add_help = False
args = arg_parser.parse_known_args()[0]

app = Flask(__name__)

app._static_folder = os.path.dirname(sys.argv[0]) + './openmct-tutorial'
app._static_folder = os.path.abspath(app._static_folder)
app.config.update(user_dir=args.ProjectDir)
#app.config.from_object('config')
app.config['SECRET_KEY'] = 'secret, but not that secret!'

cache = Cache(app, config={'CACHE_TYPE': 'simple'})
Bower(app)
CORS(app)
api = Api(app)
socketio = SocketIO(app,logger=args.verbose,engineio_logger=args.verbose) #async_mode=async_mode,

@app.route('/<path:path>')
def static_file(path):
    print path, "Static request" , app._static_folder 
    return app.send_static_file(path)
Exemplo n.º 52
0
from models import User
from flask import Flask, request, session, redirect, url_for, render_template, flash
from flask_bootstrap import Bootstrap

app = Flask(__name__)
app._static_folder = "/home/pratik/Downloads/MovieBud/moviebud/static"

@app.route('/')
def index():
    return render_template('index.html')
    
@app.route('/register', methods=['GET','POST'])    
def register():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        repassword = request.form['password2']

        if len(username) < 1:
            flash('Your username must be at least one character.')
        elif len(password) < 5:
            flash('Your password must be at least 5 characters.')
        elif (password != repassword):
        	flash('Passwords do not match')
        elif not User(username).register(password):
            flash('A user with that username already exists.')
        else:
            session['login'] = username
            flash('Logged in.')
            return redirect(url_for('index'))
Exemplo n.º 53
0
tf.app.flags.DEFINE_string('model_dir', '', """Path to graph_def pb, """)
tf.app.flags.DEFINE_string('model_name', 'my_inception_v4_freeze.pb', '')
tf.app.flags.DEFINE_string('label_file', 'my_inception_v4_freeze.label', '')
tf.app.flags.DEFINE_string('upload_folder', '/tmp/', '')
tf.app.flags.DEFINE_integer('num_top_predictions', 5,
                            """Display this many predictions.""")
tf.app.flags.DEFINE_integer('port', '5001',
                            'server with port,if no port, use deault port 80')

tf.app.flags.DEFINE_boolean('debug', False, '')

UPLOAD_FOLDER = FLAGS.upload_folder
ALLOWED_EXTENSIONS = set(['jpg', 'JPG', 'jpeg', 'JPEG', 'png'])

app = Flask(__name__)
app._static_folder = UPLOAD_FOLDER


def allowed_files(filename):
    return '.' in filename and \
        filename.rsplit('.', 1)[1] in ALLOWED_EXTENSIONS


def rename_filename(old_file_name):
    basename = os.path.basename(old_file_name)
    name, ext = os.path.splitext(basename)
    new_name = str(uuid.uuid1()) + ext
    return new_name


def inference(file_name):
deacons_list = []
for deacon in deacons_data.iterrows():
    deacons_list.append({
        'name': deacon[1][1],
        'parish': deacon[1][3],
        'lat':  deacon[1][5],
        'lng': deacon[1][6]
    })

names_lowercase_to_uppercase = {x['name'].lower(): x['name'] for x in deacons_list+elders_list+members_list}
info_for_person = {x['name']: x for x in deacons_list+elders_list+members_list}

print "Found", len(members_list), "members,", len(deacons_list), "deacons, and", len(elders_list), "elders."

app = Flask(__name__)
app._static_folder = "."

@app.route("/members")
def members():
    return jsonify(grouped_members_list)

@app.route("/deacons")
def deacons():
    return jsonify(deacons_list)

@app.route("/elders")
def elders():
    return jsonify(elders_list)

def autocomplete_for(string):
    return [v for k, v in names_lowercase_to_uppercase.iteritems() if all([y in k for y in string.lower().split()])]