def create_app( log_path: str, logger: logging.Logger, config: Optional[Dict] = None): """Creates a Flask app based on a configuration.""" APP = flask.Flask( __name__, template_folder="app/templates/", static_folder="app/static/" ) utils.setup_logger(log_path, logger) if config is None: APP.config.from_object("config") else: APP.config.from_mapping(config) CORS(APP) APP.register_blueprint(app.agency_bp) APP.register_blueprint(actors.actors_bp) APP.register_blueprint(movies.movies_bp) return APP
from traceback import print_tb from flask import request, redirect from sqlalchemy import or_, func from sqlalchemy.orm.exc import NoResultFound from app.api import bp from app.api.auth import is_user_oc_member, authenticate from app.models import Language, Resource, Category, Key from app import Config, db from app.utils import Paginator, standardize_response, setup_logger from dateutil import parser from datetime import datetime import uuid logger = setup_logger('routes_logger', 'log/routes.log') # Routes @bp.route('/resources', methods=['GET'], endpoint='get_resources') def resources(): return get_resources() @bp.route('/resources', methods=['POST'], endpoint='create_resource') @authenticate def post_resources(): validation_errors = validate_resource(request.get_json()) if validation_errors: return standardize_response(payload=validation_errors, status_code=422) return create_resource(request.get_json(), db)
from prometheus_client import Counter, Summary from app import utils as utils from app.models import Category, Language logger = utils.setup_logger('routes_logger') latency_summary = Summary('request_latency_seconds', 'Length of request') failures_counter = Counter('my_failures', 'Number of exceptions raised') def unauthorized_response(): message = "The email or password you submitted is incorrect " \ "or your account is not allowed api access" payload = {'errors': {"unauthorized": {"message": message}}} return utils.standardize_response(payload=payload, status_code=401) def get_attributes(json): languages_list = Language.query.all() categories_list = Category.query.all() language_dict = {l.key(): l for l in languages_list} category_dict = {c.key(): c for c in categories_list} langs = [] for lang in json.get('languages') or []: language = language_dict.get(lang) if not language: language = Language(name=lang) langs.append(language) categ = category_dict.get(json.get('category'),
import uuid import os from enum import Enum import functools import requests from app import db from app.models import Key from app.utils import setup_logger, standardize_response from flask import g, request from jwt import decode, InvalidSignatureError, ExpiredSignatureError PUBLIC_KEY = os.environ.get('JWT_PUBLIC_KEY', open(".dev/dev-jwt-key.pub").read()) auth_logger = setup_logger('auth_logger') create_logger = setup_logger('create_auth_logger') update_logger = setup_logger('update_auth_logger') class ApiKeyError(Exception): def __init__(self, message, error_code): super().__init__(message) self.message = message self.error_code = error_code class ApiKeyErrorCode(Enum): NOT_FOUND = 1 ALREADY_DENIED = 2 NOT_DENIED = 3
from aiogram import Dispatcher from aiogram.utils import executor from app import utils, config from app.utils import orders from app.loader import dp # The configuration of the modules using import from app import middlewares, filters, handlers async def on_startup(dispatcher: Dispatcher): await utils.setup_default_commands(dispatcher) await utils.notify_admins(config.ADMIN_IDS) if __name__ == '__main__': utils.setup_logger("INFO", ["sqlalchemy.engine", "aiogram.bot.api"]) orders.scheduler.start() executor.start_polling(dp, on_startup=on_startup, skip_updates=config.SKIP_UPDATES)
import requests from flask import request from app.models import Key from app.utils import standardize_response, setup_logger create_logger = setup_logger('create_auth_logger', 'log/create_auth.log') update_logger = setup_logger('update_auth_logger', 'log/update_auth.log') def authenticate(func): def wrapper(*args, **kwargs): apikey = request.headers.get('x-apikey') key = Key.query.filter_by(apikey=apikey).first() if not key: return standardize_response(status_code=401) log_request(request, key) return func(*args, **kwargs) return wrapper def is_user_oc_member(email, password): response = requests.post( 'https://api.operationcode.org/api/v1/sessions', json=dict(user=dict(email=email, password=password))) return bool(response.json().get('token'))
from app import handlers, middlewares, utils from app.loader import dp def at_exit(): logger.warning('\u001b[31;1m Stop program \u001b[0m') async def on_startup(dispatcher: Dispatcher): handlers.setup(dispatcher) middlewares.setup(dispatcher) await utils.setup_bot_commands(dispatcher) await utils.on_startup_notify(dispatcher) logger.warning('\033[1;34m Bot is successfully configured \033[0m') async def on_shutdown(dispatcher: Dispatcher): await utils.on_shutdown_notify(dispatcher) at_exit() if __name__ == '__main__': utils.setup_logger("INFO", ["aiogram.bot.api"]) executor.start_polling(dp, skip_updates=True, on_startup=on_startup, on_shutdown=on_shutdown) atexit.register(at_exit)
# for local testing, when running in prod will use app.wsgi from app import create_app from app.utils import setup_logger import logging, sys logger = setup_logger(logging.getLogger("app"), stdout=True, quiet=True) def get_args(): # get command line arguments import argparse parser = argparse.ArgumentParser() parser.add_argument("-p", action="store", dest="port", type=int, default=80, help="start flask debug web server") parser.add_argument("-d", action="store", dest="debug", default="debug", help="debugging level", choices=["debug", "info", "warn", "error"]) args = parser.parse_args() # set debug level args.debug = args.debug.upper() if args.debug == "DEBUG": logger.setLevel(logging.DEBUG) if args.debug == "INFO": logger.setLevel(logging.INFO)