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)
