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
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
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)
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():
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'
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()
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")
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):
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):
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
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')
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
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))
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)
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)
# 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()
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')
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():
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
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'))
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:
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
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=',',
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"]
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():
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()
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)
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()
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)
"""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)
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'] = {}
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!"
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
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)
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)
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],
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)
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'))
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()])]