def create_app(test_config=None):
app = Flask(__name__, instance_relative_config=True)
cors = CORS()
app.config['SQLALCHEMY_DATABASE_URI'] = ''
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = 'username'
app.config['SECRET_KEY'] = 'huachimingosal100'
app.config['SECURITY_PASSWORD_SALT'] = 'huachimingosal100'
app.config['DEBUG'] = True
app.config['SESSION_COOKIE_SECURE'] = True
app.config['SQLALCHEMY_POOL_RECYCLE'] = 250
#app.config['SESSION_COOKIE_HTTPONLY']= False
@app.after_request
def creds(response):
response.headers['Access-Control-Allow-Credentials'] = 'true'
return response
# Initialize flask modules (Rest and SQLAlchemy)
db.init_app(app)
api.init_app(app)
cors.init_app(app,
supports_credentials=True,
origins='http://localhost:8080')
security = Security(app, user_datastore)
return app
def create_app_test():
app = Flask(__name__,
template_folder='../Views/templates',
static_url_path='',
static_folder='../Views/static')
json = FlaskJSON()
cors = CORS(resources={r"/api/*": {
"origins": "*"
}},
allow_headers=[
"Content-Type", "Accept", "X-Request-With",
"access-control-allow-origin",
"Access-Control-Allow-Credentials"
],
supports_credentials=True)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
app.config['MONGODB_SETTINGS'] = {
'db': os.environ.get('MONGO_TEST_NAME'),
'host': os.environ.get('MONGO_TEST_URI')
}
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY')
mongo.init_app(app)
# app.config['SESSION_COOKIE_HTTPONLY'] = True
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(minutes=60)
json.init_app(app)
cors.init_app(app)
app.register_blueprint(main)
app.register_blueprint(diagnosis_controller)
app.register_blueprint(patients_controller)
app.register_blueprint(visualisation_controller)
return app
def create_app():
app = Flask(__name__)
app.config.from_mapping(config)
from core.cli import CLI
from core.database import db
from apps.user import UserModule
from apps.post import PostModule
from apps.comment import CommentModule
from apps.category import CategoryModule
from apps.file import FileModule
cli = CLI()
cors = CORS()
migrate = Migrate()
user = UserModule()
post = PostModule()
comment = CommentModule()
category = CategoryModule()
file = FileModule()
cors.init_app(app)
cli.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
user.init_app(app)
post.init_app(app)
comment.init_app(app)
category.init_app(app)
file.init_app(app)
return app
def register_extensions(app):
from flask_cors import CORS
cors = CORS()
cors.init_app(app)
return app
class FlaskApplication:
def __init__(self):
self.__route_list = []
self.__cors_instance = CORS()
self.app = Flask(__name__)
def __unpack_routes(self, routes=None, prefix=''):
if not routes:
from app.routes import ROUTES
routes = ROUTES
for route in routes:
route_prefix = prefix + route.get('prefix', '')
if route.get('group'):
self.__unpack_routes(routes=route.get('group'), prefix=route_prefix)
if route.get('controller'):
self.__route_list.append({
'blueprint': route['controller'],
'url_prefix': route_prefix
})
def __register_blueprints(self):
for route in self.__route_list:
self.app.register_blueprint(**route)
def create(self):
self.__cors_instance.init_app(self.app)
self.__unpack_routes()
self.__register_blueprints()
return self.app
def create_app(app_setting: AppSetting) -> Flask:
os.environ.setdefault('FLASK_ENV', 'production' if app_setting.prod else 'development')
app = Flask(__name__)
app_setting.init_app(app)
cors = CORS()
app.config['CORS_HEADERS'] = 'Content-Type'
cors.init_app(app)
@app.before_first_request
def create_default_user():
from src.users.model_users import UserModel
UserModel.create_user()
@app.before_request
def before_request_fn():
env: dict = request.environ
if not (env.get('REMOTE_ADDR', '') == "127.0.0.1" and "python-requests" in env.get('HTTP_USER_AGENT', '')):
from src.users.model_users import UserModel
UserModel.authorize()
def register_router(_app) -> Flask:
from src.routes import bp_service, bp_system, bp_users
_app.register_blueprint(bp_service)
_app.register_blueprint(bp_system)
_app.register_blueprint(bp_users)
return _app
return register_router(app)
def create_app(app_setting) -> Flask:
os.environ.setdefault('FLASK_ENV',
'production' if app_setting.prod else 'development')
app = Flask(__name__)
cors = CORS()
app_setting = app_setting.init_app(app)
app.config['CORS_HEADERS'] = 'Content-Type'
cors.init_app(app)
db.init_app(__db_setup(app, app_setting))
def setup(self):
gunicorn_logger = logging.getLogger('gunicorn.error')
self.logger.handlers = gunicorn_logger.handlers
self.logger.setLevel(gunicorn_logger.level)
self.logger.info(self.config['SQLALCHEMY_DATABASE_URI'])
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, _):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
def register_router(_app) -> Flask:
from src.routes import bp_generic, bp_system, bp_schedule, bp_point_store_history
_app.register_blueprint(bp_generic)
_app.register_blueprint(bp_system)
_app.register_blueprint(bp_schedule)
_app.register_blueprint(bp_point_store_history)
return _app
setup(app)
return register_router(app)
def init_app(app):
# Allow specific origins
origins = os.environ.get('CORS_ORIGINS', '*')
cors = CORS(origins=origins)
cors.init_app(app)
return cors
def create_app(app_setting) -> Flask:
os.environ.setdefault('FLASK_ENV', 'production' if app_setting.prod else 'development')
app = Flask(__name__)
cors = CORS()
app_setting = app_setting.init_app(app)
app.config['CORS_HEADERS'] = 'Content-Type'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///{}/data.db?timeout=60'.format(app_setting.data_dir)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_ECHO'] = False
cors.init_app(app)
db.init_app(app)
def setup(self):
gunicorn_logger = logging.getLogger('gunicorn.error')
self.logger.handlers = gunicorn_logger.handlers
self.logger.setLevel(gunicorn_logger.level)
self.logger.info(self.config['SQLALCHEMY_DATABASE_URI'])
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, _):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
def register_router(_app) -> Flask:
from src.routes import bp_lora, bp_mapping_lp_gbp, bp_sync, bp_system
_app.register_blueprint(bp_system)
_app.register_blueprint(bp_mapping_lp_gbp)
_app.register_blueprint(bp_sync)
_app.register_blueprint(bp_lora)
return _app
setup(app)
return register_router(app)
def create_app(config=None):
app = Flask(__name__)
cors = CORS(app)
# enable CORS
# CORS(app)
cors.init_app(app, resources={r'/*': {'origins': '*'}})
if app.config["ENV"] == 'production':
print("production")
app.config.from_object('config.ProductionConfig')
else:
print("dev")
app.config.from_object('config.DevelopmentConfig')
if config is not None:
app.config.update(config)
db.init_app(app)
migrate.init_app(app, db)
from routes import (main_route, ping_route, support_route, lotto_his_route)
app.register_blueprint(main_route.bp, url_prefix='/api')
app.register_blueprint(ping_route.bp, url_prefix='/api/ping')
app.register_blueprint(support_route.bp, url_prefix='/api/support')
app.register_blueprint(lotto_his_route.bp, url_prefix='/api/lottohis')
return app
def create_app(self):
"""Create a Flask app from the configured instance
Returns:
Flask: the Flask (uwsgi) app
"""
app = Flask(__name__)
app.config['auth_func'] = self.auth_func
app.config['hydrator_func'] = self.hydrator_func
app.config['database_uri'] = self.database_uri
app.config['hmac_secret'] = self.hmac_secret
cors = CORS()
cors.init_app(app,
resources={
r'/*': {
'origins': self.cors_origins,
'supports_credentials': True
}
})
app.register_blueprint(api_v0.bp)
@app.route('/')
def health_check(): # pylint: disable=unused-variable
"""Can be called by e.g. Kubernetes to verify that the API is up
Returns:
str: the static string "Comet-API", could be anything
"""
return 'Comet-API'
return app
def register_plugin(app):
from app.models.base import db
from flask_cors import CORS
cors = CORS()
cors.init_app(app, resources={"/*": {"origins": "*"}})
db.init_app(app)
with app.app_context():
db.create_all()
def create_app():
app = Flask(__name__,
static_folder="../dist/static",
template_folder="../dist")
app.config.from_object('server.config')
register_blueprint(app)
cors = CORS()
cors.init_app(app, resources={"/*": {"origins": "*"}})
socketio.init_app(app, async_mode="threading")
return socketio, app
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'fuckyouall'
CORS.init_app(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db.init_app(app)
bcrypt.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
ma.init_app(app)
return app
def create_app():
app = Flask(__name__)
app.config.from_object('app.config.secure')
app.config.from_object('app.config.setting')
app.config.from_object('app.config.wx')
register_blueprint(app)
register_plugin(app)
cors = CORS()
cors.init_app(app, resources={"/*": {"origins": "*"}})
return app
def create_app(object_name):
app = Flask(__name__)
app.config.from_object(object_name)
cors = CORS(app)
cors.init_app(app)
bcrypt.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
from .api import create_module as api_create_module
api_create_module(app)
return app
def create(config=None, flask_class=Flask):
""" Create application.
:rtype: Flask
:return: The assembled and configured Flask application.
"""
# setup flask app
app = flask_class(__name__,
static_folder=None,
instance_relative_config=True)
init_config(app, config)
if app.config.get('NUMBER_OF_PROXIES', None):
app.wsgi_app = ProxyFix(
app.wsgi_app, num_proxies=app.config.get('NUMBER_OF_PROXIES'))
init_logging(app)
# setup CORS support
cors = CORS()
cors.init_app(app)
# setup storage
redisclient.init_app(app)
# Handle custom API errors
apierror.init_app(app)
# setup modules
stats.init_app(app)
recaptcha.init_app(app)
auth.init_app(app)
sms.init_app(app)
idm.init_app(app)
language.init_app(app)
template.init_app(app)
api.init_app(app)
# Add cache headers to all responses
@app.after_request
def set_cache_headers(response):
response.headers['Pragma'] = 'no-cache'
response.headers['Cache-Control'] = 'no-cache'
return response
return app
def create_app(app_setting) -> Flask:
os.environ.setdefault('FLASK_ENV',
'production' if app_setting.prod else 'development')
app = Flask(__name__)
cors = CORS()
app_setting = app_setting.init_app(app)
app.config['CORS_HEADERS'] = 'Content-Type'
cors.init_app(app)
db.init_app(__db_setup(app, app_setting))
def setup(self):
gunicorn_logger = logging.getLogger('gunicorn.error')
self.logger.handlers = gunicorn_logger.handlers
self.logger.setLevel(gunicorn_logger.level)
self.logger.info(self.config['SQLALCHEMY_DATABASE_URI'])
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, _):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
@app.before_request
def before_request_fn():
env: dict = request.environ
if not (env.get('REMOTE_ADDR', '') == "127.0.0.1"
and "python-requests" in env.get('HTTP_USER_AGENT', '')):
from src.resources.utils import authorize
authorize()
def register_router(_app) -> Flask:
from src.routes import bp_system, bp_users_summary, bp_fcm_server, bp_sites, bp_apps_ping, bp_apps_users, \
bp_apps_own_users, bp_apps_configs
_app.register_blueprint(bp_system)
_app.register_blueprint(bp_users_summary)
_app.register_blueprint(bp_fcm_server)
_app.register_blueprint(bp_sites)
_app.register_blueprint(bp_apps_ping)
_app.register_blueprint(bp_apps_users)
_app.register_blueprint(bp_apps_own_users)
_app.register_blueprint(bp_apps_configs)
return _app
setup(app)
return register_router(app)
def create_app(env): # type: (str) -> Flask
app = Flask(__name__)
config = {
'development': 'config.DevelopmentConfig',
'staging': 'config.StagingConfig',
'production': 'config.ProductionConfig',
}
app.config.from_object(config[env])
app.config.from_pyfile('config.cfg', silent=True)
cors = CORS()
cors.init_app(app, origins=app.config['ALLOW_ORIGINS'])
import prediction.diagnosis
app.register_blueprint(prediction.diagnosis.app)
return app
def register_plugin(app):
# 解决跨域问题
from flask_cors import CORS
cors = CORS()
cors.init_app(app, resources={"/*": {"origins": "*"}})
# 连接数据库
from app.models.base import db
db.init_app(app)
with app.app_context(): # 手动将app推入栈
db.create_all() # 首次模型映射(ORM ==> SQL),若无则建表; 初始化使用
# Debug模式下可以查阅 API文档
if app.config['DEBUG']:
from flasgger import Swagger
from app.api.v1 import template
swagger = Swagger(template=template) # 可以将secure.py中的SWAGGER全部写入template
swagger.init_app(app)
def create_app():
app = Flask(__name__)
app.config.from_pyfile('config.py')
# db
db.init_app(app)
migrate.init_app(app, db)
marshmallow.init_app(app)
# CORS
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
cors.init_app(app)
# blueprint apps
app.register_blueprint(books_blueprint, url_prefix='/api/books')
# static files for dev
return app
def create_app(test_config=None):
app = Flask(__name__, static_folder=config['STATIC_FOLDER'])
if test_config is not None:
app.config.from_mapping(test_config)
app.config.from_mapping(config)
from core.cli import CLI
from core.database import db
from apps.user import UserModule
from apps.food import FoodModule
from apps.store import StoreModule
from apps.order import OrderModule
from apps.driver import DriverModule
# from apps.category_access import CategoryAccessModule
cli = CLI()
cors = CORS()
migrate = Migrate()
jwt = JWTManager(app)
user = UserModule()
food = FoodModule()
store = StoreModule()
order = OrderModule()
driver = DriverModule()
# category_access = CategoryAccessModule()
jwt.init_app(app)
cli.init_app(app)
cors.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
user.init_app(app)
food.init_app(app)
store.init_app(app)
order.init_app(app)
driver.init_app(app)
# category_access.init_app(app)
return app
def create_app(config_name="development"):
app = Flask(__name__)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config.from_object(config[config_name])
cors = CORS(app, resources={r"/api/*": {"origins": "*"}}, supports_credentials=True)
app.config['CORS_HEADERS'] = 'Content-Type'
db.init_app(app)
migrate.init_app(app, db)
from app.commands import db_manage_bp
from app.errors import errors_bp
from app.api.ver_1_0 import users_api
# CORS(users_api)
from app.api.ver_1_0 import admin_api
CORS(admin_api)
from app.auth import auth_bp
CORS(auth_bp)
app.register_blueprint(db_manage_bp)
app.register_blueprint(errors_bp)
app.register_blueprint(users_api)
app.register_blueprint(auth_bp, url_prefix="/auth")
# fmt: off
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .api.ver_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint)
# fmt: on
# fixme: edit CORS
cors.init_app(app)
socketio.init_app(app, cors_allowed_origins='*')
limiter.init_app(app)
login_manager.init_app(app)
# mysql.init_app(app)
redis.init_app(app)
logging.basicConfig(level=logging.INFO)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
moment.init_app(app)
db.init_app(app)
if config_name == 'development' or config_name == 'testing':
cors = CORS()
print('CORS initiated for ' + config_name + ' environment')
cors.init_app(app)
from .adminboard import adminboard as adminboard_blueprint
app.register_blueprint(adminboard_blueprint, url_prefix='/progeto-admin')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def create_app(test_config=None):
app = Flask(__name__)
if test_config is not None:
app.config.from_mapping(test_config)
app.config.from_mapping(config)
from core.cli import CLI
from core.database import db
from apps.user import UserModule
from apps.file import FileModule
from apps.job import JobModule
from apps.category_access import CategoryAccessModule
cli = CLI()
cors = CORS()
migrate = Migrate()
jwt = JWTManager(app)
user = UserModule()
file = FileModule()
job = JobModule()
category_access = CategoryAccessModule()
jwt.init_app(app)
cli.init_app(app)
cors.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
user.init_app(app)
file.init_app(app)
job.init_app(app)
category_access.init_app(app)
return app
def create_app():
app = Flask(__name__,
static_folder="../dist",
template_folder="../dist",
static_url_path="")
app.config.from_object(Config)
cors = CORS()
cors.init_app(app)
db.init_app(app)
with app.app_context():
# 初始化数据库
db.create_all()
from luwu.backend.v1 import api_v1_blueprint
app.register_blueprint(api_v1_blueprint)
from luwu.backend.views import main_blueprint
app.register_blueprint(main_blueprint)
return app
import math
from baidu import savetodb
from models.words import Words, PinYin
from models.keys import Keys
from models.base import db
from sqlalchemy import or_, and_
import random
app = Flask(__name__, static_url_path='/dictionary/static')
# 引用config文件，获取数据库相关配置
import config
app.config.from_object(config)
# 解决跨域问题
from flask_cors import CORS
cors = CORS()
cors.init_app(app, resources={"/*": {"origins": "*"}})
# 连接数据库
db.init_app(app)
with app.app_context(): # 手动将app推入栈
db.create_all() # 首次模型映射(ORM ==> SQL),若无则建表; 初始化使用
# 這個方法用來轉變model成字典dict，但是不是依據keys，後append的不會被轉入
# def serialize(model):
# from sqlalchemy.orm import class_mapper
# columns = [c.key for c in class_mapper(model.__class__).columns]
# return dict((c, getattr(model, c)) for c in columns)
@app.route("/dictionary/page/<int:page>/")
def page(page):
page = '000' + str(page)
page = page[len(page)-4:len(page)]
#!/usr/bin/env python
import redis
import requests
from flask import Flask
from flask_restful import Resource, Api
from flask_cors import CORS
import sys
app = Flask(__name__)
api = Api(app)
cache = redis.Redis(host='redis', port=6379)
cors = CORS()
cors.init_app(app) # new
dapikey = '000bdb4c-8231-430b-b291-db2b23416ec3'
url = 'https://dictionaryapi.com/api/v3/references/collegiate/json/'
class Product(Resource):
def get(self, word):
r = requests.get(url+word+'?key='+dapikey)
out = r.json()[0]
return out
class Root(Resource):
def get(self):
return 'hi'
class OneLove(object):
class Result(object):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
api = None
app = None
blueprint = None
collect = Collect()
db = MongoEngine()
jwt = JWT()
mail = Mail()
security = Security()
socketio = None
toolbar = None
user_datastore = None
def __init__(self, app=None):
if app is not None:
if app.config["DEBUG"]:
self.cors = CORS()
self.init_app(app)
def init_app(self, app):
global current_app
current_app = self
self.app = app
if app.config["DEBUG"]:
self.cors.init_app(self.app, resources={r"/api/*": {"origins": "*"}})
from api import api_v0, api
self.api = api
self.blueprint = Blueprint(
"onelove", __name__, template_folder="templates", static_folder="static", static_url_path="/static/onelove"
)
self.app.register_blueprint(self.blueprint)
self.app.register_blueprint(api_v0, url_prefix="/api/v0")
self.app.register_blueprint(apidoc.apidoc)
self.mail.init_app(self.app)
self.db.init_app(self.app)
self.user_datastore = MongoEngineUserDatastore(self.db, User, Role)
self.security.init_app(self.app, self.user_datastore)
self.jwt.init_app(self.app)
self.collect.init_app(self.app)
if self.app.config.get("DEBUG_TB_PANELS", False):
from flask_debugtoolbar import DebugToolbarExtension
from flask_debug_api import DebugAPIExtension
self.toolbar = DebugToolbarExtension(self.app)
self.toolbar = DebugAPIExtension(self.app)
self.socketio = SocketIO(self.app, logger=True)
self.app.onelove = self
@jwt.authentication_handler
def authenticate(username, password):
try:
user = User.objects.get(email=username)
except User.DoesNotExist:
return None
result = OneLove.Result(id=str(user.id), email=user.email, first_name=user.first_name, last_name=user.last_name)
if verify_password(password, user.password):
return result
@jwt.identity_handler
def identity(payload):
try:
user = User.objects.get(id=payload["identity"])
except User.DoesNotExist:
user = None
return user
import os
from flask import Flask
from flask_cors import CORS
from app.config import Config
import app.handler as handler
app = Flask(__name__,
template_folder=os.path.join(os.getcwd(), 'templates'),
static_folder=os.path.join(os.getcwd(), 'static'))
# 利用flask-cors解决跨域问题，/*允许所有域外请求通过
cors = CORS(app, resources={r"/*": {"origins": "*"}})
cors.init_app(app) # 跨域初始化
app.config.from_object(Config)
#注册各个模块蓝图
app.register_blueprint(handler.kind_bp)
app.register_blueprint(handler.company_bp)
app.register_blueprint(handler.results_bp)
app.register_blueprint(handler.file_bp)
app.register_blueprint(handler.experts_bp)
app.register_blueprint(handler.productions_bp)
app.register_blueprint(handler.employments_bp)
# 测试
def make_app():
cors = CORS(origins=[
'https://app.communityshare.us:443', # production app
'http://communityshare.localhost:5000', # local dev angular app
'http://communityshare.localhost:8000', # local dev elm app
'https://dmsnell.github.io/cs-elm/', # live elm app
])
compress = Compress()
webpack = Webpack()
app = Flask(__name__, template_folder='../static/')
app.response_class = JsonifyDictResponse
app.config['SQLALCHEMY_DATABASE_URI'] = config.DB_CONNECTION
app.config['WEBPACK_ASSETS_URL'] = config.WEBPACK_ASSETS_URL
app.config['WEBPACK_MANIFEST_PATH'] = config.WEBPACK_MANIFEST_PATH
cors.init_app(app)
compress.init_app(app)
webpack.init_app(app)
if config.SSL != 'NO_SSL':
flask_sslify.SSLify(app)
app.wsgi_app = ReverseProxied(app.wsgi_app)
register_user_routes(app)
register_search_routes(app)
register_conversation_routes(app)
register_share_routes(app)
register_survey_routes(app)
register_email_routes(app)
register_statistics_routes(app)
community_share.api.register_routes(app)
@app.teardown_appcontext
def close_db_connection(exception):
store.session.remove()
@app.errorhandler(BadRequest)
def handle_bad_request(error):
return str(error), HTTPStatus.BAD_REQUEST
app.errorhandler(Unauthorized)(jsonify_with_code(HTTPStatus.UNAUTHORIZED))
app.errorhandler(Forbidden)(jsonify_with_code(HTTPStatus.FORBIDDEN))
app.errorhandler(NotFound)(jsonify_with_code(HTTPStatus.NOT_FOUND))
app.errorhandler(InternalServerError)(jsonify_with_code(HTTPStatus.INTERNAL_SERVER_ERROR))
@app.route('/static/build/<path:filename>')
def build_static(filename):
return send_from_directory(
app.root_path + '/../static/build/',
filename,
cache_timeout=YEAR_IN_SECONDS,
)
@app.route('/static/js/<path:filename>')
def js_static(filename):
return send_from_directory(app.root_path + '/../static/js/', filename)
@app.route('/static/fonts/<path:filename>')
def fonts_static(filename):
return send_from_directory(app.root_path + '/../static/fonts/', filename)
@app.route('/static/css/<path:filename>')
def css_static(filename):
return send_from_directory(app.root_path + '/../static/css/', filename)
@app.route('/static/templates/footer.html')
def footer_template():
return render_template('templates/footer.html', config=config)
@app.route('/static/templates/<path:filename>')
def templates_static(filename):
return send_from_directory(app.root_path + '/../static/templates/', filename)
@app.route('/')
def index():
logger.debug('rendering index')
return render_template('index.html', config=config)
return app
#import threading
import cv2
#import requests
import time
from flask_cors import CORS
#import json,time
#url = "http://111.231.83.141:18890/snapshot/worker"
#url = "http://fabx.aidong-ai.com/snapshot/worker"
camer_list = []
#app = Flask(__name__)
#====1mysetting======
app = Flask(__name__, static_folder='../static', static_url_path='/static')
cors = CORS()
cors.init_app(app)
main = Blueprint('main', __name__)
app.register_blueprint(main, url_prefix="")
time_count = 0
header = {}
log_list = "a"
camer_count = 0
norm_size = 32
@app.route('/')
def index():
global camer_count
camer_count = getcountCameras()
def register_extensions(app):
"""Register extensions."""
cors = CORS()
cors.init_app(app)
