def create_app(name: str,
psql_uri: str = None,
mongo_uri: str = None,
psql_pool_args: dict = None) -> Pint:
"""
Create the core API app. Supply URIs as necessary
"""
app = Pint(name)
@app.before_serving
async def _startup():
if psql_uri:
import asyncpg
kwargs = {"min_size": 3, "max_size": 8, "command_timeout": 5}
if "localhost" not in psql_uri:
kwargs["ssl"] = SSLContext()
if psql_pool_args:
kwargs.update(psql_pool_args)
app.db = await asyncpg.create_pool(psql_uri, **kwargs)
else:
app.db = None
if mongo_uri:
from motor.motor_asyncio import AsyncIOMotorClient
app.mdb = AsyncIOMotorClient(mongo_uri)
else:
app.mdb = None
app.json_encoder = CustomJSONEncoder
app.after_request(add_cors)
return app
def create_app(config) -> Pint:
load_dotenv(verbose=True)
app = Pint(__name__,
title="BattleShip",
base_model_schema=BASE_MODEL_SCHEMA)
app = cors(app, allow_origin="*")
app.json_encoder = Encoder
app.config.from_envvar("CONFIG_FILE")
app.games = dict()
@app.before_serving
async def init_orm():
await init()
from battlefield.session.data.api.single import session
app.register_blueprint(session)
from battlefield.session.data.api.multi import sessions
app.register_blueprint(sessions)
from battlefield.game.data.websocket import game
app.register_blueprint(game)
@app.cli.command()
def openapi():
print(json.dumps(app.__schema__, indent=4, sort_keys=False))
@app.after_serving
async def close_orm():
await Tortoise.close_connections()
return app
def app():
testapp = Pint('test',
title='App Test',
contact='foo',
contact_email='*****@*****.**',
description='Sample Desc')
return testapp
def __init__(self, **kwargs):
self.init_keys = set()
for k, v in kwargs.items(
): # TODO figure out how to distinguish between Models in Mongo and Postgres
setattr(self, k, v)
self.init_keys.add(k)
for k, v in self.DEFAULT_VALUES.items():
if k not in kwargs:
setattr(self, k, v)
else:
setattr(self, k, kwargs.get(k))
self.logger = Logger(self.NAME)
self.app = Pint(self.NAME)
self.app.config.update(DBSettings.get_mongo_config(**kwargs))
self.app.config.update(DBSettings.get_sqlalchemy_config(**kwargs))
self.orm_mappings = {}
self.odm_mappings = {}
self.default_mongo_settings = {}
self.default_sqlalchemy_settings = {}
self.default_mongo_engine = None
self.default_sqla_engine = None
self.views = []
if isinstance(kwargs.get(VIEWS, list()), list):
for v in kwargs.get(VIEWS, list()):
self.import_add_view(v)
if self.get_using_mongo():
self.default_mongo_settings = DBSettings.get_mongoclient_kargs(
**kwargs)
self.default_mongo_settings[TLS_INSECURE] = True
if self.default_mongo_settings.get(SSL_KEYFILE, None) is None:
self.default_mongo_settings[SSL_KEYFILE] = self.get_key_pem()
if self.default_mongo_settings.get(SSL_CERTFILE, None) is None:
self.default_mongo_settings[SSL_KEYFILE] = self.get_cert_pem()
if self.get_using_postgres():
self.default_sqlalchemy_settings = DBSettings.get_sqlalchemy_config(
**kwargs)
uri = self.pgc.get(SQLALCHEMY_DATABASE_URI)
self.default_sqla_engine = create_engine(uri)
for name, kargs in self.get_sqlalchemy_orms():
classname = kargs.get(ORM_CLASS, None)
tablename = kargs.get(TABLE, None)
if classname is None or tablename is None:
continue
self.import_add_orms(classname, tablename)
self.load_odm_configurations(self.get_odms())
self.load_orm_configurations(self.get_orms())
self.bg_thread = None
def test_base_model_file(tmpdir):
import json
tmp_schema = tmpdir.join('schema.json')
tmp_schema.write_text(json.dumps(TEST_BASE_MODEL_SCHEMA), encoding='utf-8')
app = Pint('test', base_model_schema=str(tmp_schema.realpath()))
assert isinstance(app.base_model, RefResolver)
assert app.base_model.base_uri == 'schema.json'
async def test_no_openapi():
app = Pint('test',
title='App Test',
contact='foo',
contact_email='*****@*****.**',
no_openapi=True)
client = app.test_client()
rv = await client.get('/openapi.json')
assert rv.status_code == HTTPStatus.NOT_FOUND
def create_app(name: str, mongo_uri: str = None) -> Pint:
"""Create the core API app. Supply URIs as necessary"""
app = Pint(name)
@app.before_serving
async def _startup():
app.mdb = AsyncIOMotorClient(mongo_uri) if mongo_uri else None
app.json_encoder = CustomJSONEncoder
app.after_request(add_cors)
return app
async def test_base_model_obj():
app = Pint('test',
title='App Test',
contact='foo',
contact_email='*****@*****.**',
description='Sample Desc',
base_model_schema=TEST_BASE_MODEL_SCHEMA)
@app.route('/testque')
@app.param('test_que', ref='#/components/parameters/test_query')
class TestQue(Resource):
async def get(self):
return request.args['moo']
test_que_ref = app.create_ref_validator('test_query', 'parameters')
@app.route('/testref')
@app.param('test_que_ref', ref=test_que_ref)
class TestRef(Resource):
async def get(self):
return request.args['moo']
@app.route('/testquename')
@app.param('test_que_name', ref='test_query')
class TestQueName(Resource):
async def get(self):
return request.args['moo']
swag = app.__schema__
assert swag['components']['parameters']['test_query']['name'] == 'moo'
swag_testque = swag['paths']['/testque']['get']
swag_testref = swag['paths']['/testref']['get']
swag_testquename = swag['paths']['/testquename']['get']
assert swag_testque['parameters'] == swag_testref['parameters']
assert swag_testque['parameters'] == swag_testquename['parameters']
client = app.test_client()
rv = await client.get('/testque?moo=foo')
assert rv.status_code == HTTPStatus.OK
assert await rv.get_data() == b'foo'
rv = await client.get('/testref?moo=bar')
assert rv.status_code == HTTPStatus.OK
assert await rv.get_data() == b'bar'
rv = await client.get('/testquename?moo=baz')
assert rv.status_code == HTTPStatus.OK
assert await rv.get_data() == b'baz'
async def test_custom_openapi():
app = Pint('test',
title='App Test',
contact='foo',
no_openapi=True,
contact_email='*****@*****.**')
@app.route('/hello')
class Hello(Resource):
async def get(self):
return "OK"
@app.route('/api.json', methods=['GET', 'OPTIONS'])
async def api():
return jsonify(app.__schema__)
client = app.test_client()
rv = await client.get('/api.json')
assert rv.status_code == HTTPStatus.OK
data = await rv.get_json()
assert data == {
'openapi': '3.0.0',
'info': {
'title': 'App Test',
'version': '1.0',
'contact': {
'name': 'foo',
'email': '*****@*****.**'
}
},
'servers': [{
'url': 'http://'
}],
'paths': {
'/hello': {
'get': {
'description': '',
'tags': [],
'responses': {
'200': {
'description': 'Success'
}
},
'operationId': 'get_hello'
}
}
}
}
async def test_required_query():
app = Pint('test', title='App Test', contact='foo',
contact_email='*****@*****.**', description='Sample Desc',
base_model_schema=TEST_BASE_MODEL_SCHEMA)
test_que_ref = app.create_ref_validator('test_query', 'parameters')
@app.param('test_que_ref', _in='query', schema=test_que_ref)
@app.route('/testref')
def testref():
return request.args['moo']
client = app.test_client()
rv = await client.get('/testref')
# will add validation in the future for required query args
assert rv.status_code == HTTPStatus.BAD_REQUEST
def make_app():
app = Pint(__name__, title="Rhasspy")
app = cors(app)
@app.route("/")
class Root(Resource):
async def get(self):
"""Hello World Route
This docstring will show up as the description and short-description
for the openapi docs for this route.
"""
return "hello"
@app.websocket("/ws")
async def ws():
while True:
await websocket.send("hello")
def create_app():
from . import models, resources, schemas, logger, repositories, injection
app = Pint(__name__, title='Magnum Opus')
# This could be used to separate by environment
app.config.from_object('magnumopus.config.Config')
# This helps avoid cyclic dependencies
modules = []
modules += logger.init_app(app)
modules += models.init_app(app)
modules += resources.init_app(app)
modules += repositories.init_app(app)
modules += schemas.init_app(app)
injection.init_app(app, modules)
return app
async def test_post_validation():
app = Pint('test', base_model_schema=TEST_BASE_MODEL_SCHEMA)
test_ref = app.create_ref_validator('User', 'schemas')
@app.route('/testroute')
class TestReq(Resource):
@app.expect(test_ref)
async def post(self):
return jsonify(await request.get_json())
client = app.test_client()
# fail validation, missing required props
rv = await client.post('/testroute', json={})
assert rv.status_code == HTTPStatus.BAD_REQUEST
assert rv.headers['content-type'] == 'application/json'
data = await rv.get_json()
assert data['message'] == 'Request Body failed validation'
assert 'msg' in data['error'] and data['error']['msg']
assert 'value' in data['error']
assert 'schema' in data['error']
# fail validation, have required props, but age is wrong type
rv = await client.post('/testroute', json={'name': 'foobar', 'age': 'baz'})
assert rv.status_code == HTTPStatus.BAD_REQUEST
assert rv.headers['content-type'] == 'application/json'
data = await rv.get_json()
assert data['message'] == 'Request Body failed validation'
assert 'msg' in data['error'] and data['error']['msg']
assert 'value' in data['error']
assert 'schema' in data['error']
# succeed validation
rv = await client.post('/testroute', json={'name': 'foobar', 'age': 10})
assert rv.status_code == HTTPStatus.OK
def create_app(config_class=Development) -> Pint:
app = Pint(__name__)
app.test_client()
DbWrapper.set_url(config_class.SQLALCHEMY_DATABASE_URI)
db = DbWrapper.create_instance()
@app.before_request
async def connect_db() -> None:
# todo: replace Exception with AlreadyConnectedToDbException
try:
await db.connect()
except Exception:
pass
@app.after_request
async def disconnect_db(response) -> None:
await db.disconnect()
return response
app.config.from_object(Development)
register_blueprints(app)
app = cors(app, allow_credentials=True)
return app
def test_base_model_ref_resolve():
base_model = RefResolver.from_schema(TEST_BASE_MODEL_SCHEMA)
app = Pint('test', base_model_schema=base_model)
assert isinstance(app.base_model, RefResolver)
assert app.base_model.base_uri == 'schema.json'
if session_key in session_clients:
return session_clients[session_key]['client']
print('Creating new session client with key ', session_key)
new_client = TelegramClient('api_test_' + session_key, API_ID, API_HASH)
new_client.session.set_dc(2, '149.154.167.40', 443)
session_clients[session_key] = {}
session_clients[session_key]['client'] = new_client
await new_client.connect()
return new_client
# Quart app
app = Pint(__name__, title='apiMiddleware')
app.secret_key = 'Someday this war will end'
app = cors(app, allow_origin='http://localhost:8080', allow_credentials=True)
# VALIDATORS
# After we're done serving (near shutdown), clean up the client
@app.after_serving
async def cleanup():
for client in session_clients.items():
await client[1]['client'].disconnect()
@app.route('/')
class Root(Resource):
from quart import Quart, request, jsonify
from quart_openapi import Pint, Resource
from telethon import TelegramClient
import logging
logging.basicConfig(
format='[%(levelname) 5s/%(asctime)s] %(name)s: %(message)s',
level=logging.WARNING
)
app = Pint(__name__, title='mtproto-proxy')
api_id = 1150044
api_hash = "07a4a593788b5d222f4f3139dca2e0b9"
async def main(client, phone_number):
print('here we go')
response = await client.send_code_request(phone_number, True)
print(response.stringify())
@app.route('/auth.sendCode')
class SendCode(Resource):
async def post(self):
data = await request.get_json()
phone_number = data['phone_number']
print(phone_number)
client = TelegramClient('anon', api_id, api_hash)
await client.connect()
sent = await client.send_code_request(phone_number)
response = {
"""A Quart application module for the rate limiting proxy solution.
Uses REQUEST_COUNT and INTERVAL environment variables to configure the rate for
a root ("/") endpoint.
Replies Hello! to all valid requests. Rejects all rate exceeding requests with
429 statius code.
"""
import os
from quart import Quart, redirect, url_for
from quart_openapi import Pint, Resource
from decorators.rate_limit import rate_limit
REQUEST_COUNT = os.getenv("REQUEST_COUNT", "1")
INTERVAL = os.getenv("INTERVAL", "5")
PROXY = Pint(__name__, title="Rate Limiting Proxy App")
@PROXY.route("/")
class RateLimitProxyRoot(Resource):
"""This route is used to limit the rate of the incoming requests to a
configured REQUEST_COUNT per INTERVAL. The configuration is read from
the environment.
"""
@rate_limit(int(REQUEST_COUNT), int(INTERVAL))
async def get(self):
"""Get request.
"""
return "Hello!"
if __name__ == "__main__":
from os import environ
from quart_openapi import Pint
import service.config as default_config
app = Pint(__name__, no_openapi=True, title='Exact Time Service')
app.config.from_object(default_config)
config_file = environ.get('QUART_CONFIG')
if config_file:
app.config.from_pyfile(config_file)
import service.view
from quart_openapi import Pint, Resource
from quart import jsonify, request
app = Pint(__name__, title='Spectacular Hypercorn Quart Application Skeleton')
expected = app.create_validator('sample_request', {
'type': 'object',
'properties': {
'foobar': {
'type': 'string'
},
'baz': {
'oneOf': [
{ 'type': 'integer' },
{ 'type': 'number', 'format': 'float' }
]
}
}
})
@app.route('/')
class Root(Resource):
async def get(self):
'''Note Route
This docstring will show up as the description and short-description
for the openapi docs for this route.
'''
return jsonify({"Note": "There exists a localhost:9000/openapi.json that can be helpful here"})
@app.expect(expected)
async def post(self):
return action
elif action.metavar == name:
return action
elif action.dest == name:
return action
def error(self, message):
exc = sys.exc_info()[1]
if exc:
exc.argument = self._get_action_from_name(exc.argument_name)
raise exc
# super(SrlArgumentParser, self).error(message)
# small restful API server running locally so my other bots can send messages
app = Pint(__name__, title='Srl Bot API')
@app.route('/api/message')
class Message(Resource):
async def post(self):
data = await request.get_json()
if 'auth' in data and data['auth'] == c.InternalApiToken:
if not client.in_channel(data['channel']):
abort(400, "Bot not in specified channel")
result = await client.message(data['channel'], data['message'])
return jsonify({"success": True})
else:
abort(401)
if __name__ == '__main__':
client = SrlBot(c.SRL_NICK, realname=c.SRL_NICK)
""":mod:'irastretto.web.app'
--- Quart application
Todo:
* Download Queue (Modular Structure).
* Download images from Twitter (Queue Module).
* Caching duplicated reference.
* Extract Zelda.
* User login.
* Accounts Management.
* Download images from Pixiv (Queue Module).
* Library interface.
* Audio/Video Play.
* Share Timeline.
* Finder Extension (Another Project).
"""
from quart_openapi import Pint
from quart_cors import cors
from . import blueprints
from .. import config
app = Pint(__name__, title='Irastretto', template_folder='templates')
app = cors(app)
# app.config.from_object()
app.register_blueprint(blueprints.root.blueprint)
app.register_blueprint(blueprints.tasks.blueprint)
app.register_blueprint(blueprints.users.blueprint)
from quart_openapi import Pint app = Pint(__name__, title='SahasrahBot API')
"""
# stdlib
from datetime import date
from os import environ
# library
from motor.motor_asyncio import AsyncIOMotorClient
from quart import got_request_exception
from quart.json import JSONEncoder
from quart_openapi import Pint
import rollbar
from rollbar.contrib.quart import report_exception
app = Pint(__name__)
class CustomJSONEncoder(JSONEncoder):
# pylint: disable=method-hidden
def default(self, obj):
try:
if isinstance(obj, date):
return obj.isoformat() + "Z"
iterable = iter(obj)
except TypeError:
pass
else:
return list(iterable)
return JSONEncoder.default(self, obj)
dictConfig({
"version": 1,
"loggers": {
"quart.app": {
"level": "DEBUG",
},
"quart.serving": {
"level": "DEBUG"
},
"stocks.stocks": {
"level": "INFO"
},
},
})
app = Pint(__name__, title="Stock Analysis")
app.config["TEMPLATES_AUTO_RELOAD"] = True
app.config["STOCKS_FOLDER"] = os.path.join(app.static_folder, "stocks")
blueprint.stocks_folder = os.path.join(app.static_folder, "stocks")
app.register_blueprint(blueprint)
@app.route("/", methods=["GET", "POST"], provide_automatic_options=False)
class Root(Resource):
async def get(self):
return await render_template("index.html")
status_expected_schema = app.create_validator("status", {
from quart_openapi import Pint
app = Pint("vanguard_api")
