def create_asgi() -> fastapi.FastAPI: """Function facetory for create a new ASGI object""" setting = FastAPISetting() app = fastapi.FastAPI( title=setting.SERVICE_NAME, debug=setting.DEBUG, ) app.add_middleware( CORSMiddleware, allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) @app.get('/health') async def health(): #pylint:disable=W0612 return fastapi.Response('', 204) app.include_router(v1.api_router, prefix='/v1') @app.on_event('startup') async def startup_event(): #pylint:disable=W0612 await setup_database() # create the pool connection @app.on_event('shutdown') async def shutdown_event(): #pylint:disable=W0612 await db_pool.close() # attemp close all connections return app
def make_app(self, config=None, version=None, environ=None, plugins=None): if plugins is None: plugins = [] app = fastapi.FastAPI() if config is None: config = fastapi_plugins.ControlSettings() @app.on_event('startup') async def on_startup() -> None: for p in plugins: await p.init_app(app, config) await p.init() kwargs = {} if version: kwargs.update(**dict(version=version)) if environ: kwargs.update(**dict(environ=environ)) await fastapi_plugins.control_plugin.init_app( app, config, **kwargs) # noqa E501 await fastapi_plugins.control_plugin.init() @app.on_event('shutdown') async def on_shutdown() -> None: await fastapi_plugins.control_plugin.terminate() for p in plugins: await p.terminate() return app
async def _test(): app = fastapi.FastAPI() config = fastapi_plugins.RedisSettings( redis_url='redis://localhost:6379/1') await fastapi_plugins.redis_plugin.init_app(app=app, config=config) await fastapi_plugins.redis_plugin.init() await fastapi_plugins.redis_plugin.terminate()
async def _test(): app = fastapi.FastAPI() config = fastapi_plugins.RedisSettings( redis_type='sentinel', redis_sentinels='localhost:26379') await fastapi_plugins.redis_plugin.init_app(app=app, config=config) await fastapi_plugins.redis_plugin.init() await fastapi_plugins.redis_plugin.terminate()
async def _test(): app = fastapi.FastAPI() config = fastapi_plugins.SchedulerSettings() await fastapi_plugins.scheduler_plugin.init_app(app=app, config=config ) # noqa E501 await fastapi_plugins.scheduler_plugin.init() try: count = 3 exp = dict([(str(i), str(i)) for i in range(count)]) res = {} async def coro(name, timeout): try: await asyncio.sleep(timeout) res[name] = name except asyncio.CancelledError as e: res[name] = 'cancel' raise e s = await fastapi_plugins.scheduler_plugin() for i in range(count): await s.spawn(coro(str(i), i / 10)) await asyncio.sleep(1) self.assertTrue(d2json(exp) == d2json(res), 'scheduler failed') finally: await fastapi_plugins.scheduler_plugin.terminate()
def api_no_type(event_loop): np = pytest.importorskip("numpy") class ValidationNotSupported(Model[np.ndarray, np.ndarray]): CONFIGURATIONS = {"no_supported_model": {}} def _predict(self, item): return item router = ModelkitAutoAPIRouter( required_models=[ "unvalidated_model", "no_supported_model", "some_model", "some_complex_model", "some_asset", "async_model", ], models=[ ValidationNotSupported, NotValidatedModel, SomeSimpleValidatedModel, SomeComplexValidatedModel, SomeAsset, SomeAsyncModel, ], ) app = fastapi.FastAPI() app.include_router(router) with TestClient(app) as client: yield client
async def _test(): os.environ[ fastapi_plugins. DEFAULT_CONFIG_ENVVAR] = fastapi_plugins.CONFIG_NAME_LOCAL # noqa E501 try: @fastapi_plugins.registered_configuration class MyConfigDocker(fastapi_plugins.PluginSettings): api_name: str = 'docker' @fastapi_plugins.registered_configuration_local class MyConfigLocal(fastapi_plugins.PluginSettings): api_name: str = 'local' app = fastapi.FastAPI() config = fastapi_plugins.get_config() await fastapi_plugins.config_plugin.init_app(app=app, config=config ) # noqa E501 await fastapi_plugins.config_plugin.init() try: c = await fastapi_plugins.config_plugin() exp = d2json(MyConfigLocal().dict()) res = d2json(c.dict()) self.assertTrue(res == exp, 'get configuration failed: %s != %s' % (exp, res)) # noqa E501 finally: await fastapi_plugins.config_plugin.terminate() finally: os.environ.pop(fastapi_plugins.DEFAULT_CONFIG_ENVVAR) fastapi_plugins.reset_config()
async def test_scheduler(): async def coro(name, timeout): try: print('> sleep', name, timeout) await asyncio.sleep(timeout) print('---> sleep done', name, timeout) except asyncio.CancelledError as e: print('coro cancelled', name) raise e print('--- do schedule test') app = fastapi.FastAPI() config = fastapi_plugins.SchedulerSettings() config = None config = AppSettings(aiojobs_limit=100) config = AppSettings() # config = AppSettings(aiojobs_limit=1) await fastapi_plugins.scheduler_plugin.init_app(app=app, config=config) await fastapi_plugins.scheduler_plugin.init() try: print('- play') s = await fastapi_plugins.scheduler_plugin() # import random for i in range(10): await s.spawn(coro(str(i), i / 10)) # await s.spawn(coro(str(i), i/10 + random.choice([0.1, 0.2, 0.3, 0.4, 0.5]))) # nosec B311 # print('----------') print('- sleep', 5) await asyncio.sleep(5.0) print('- terminate') finally: await fastapi_plugins.scheduler_plugin.terminate() print('---test schedule done')
def create_modelkit_app(models=None, required_models=None): """ Creates a modelkit FastAPI app with the specified models and required models. This is meant to be used in conjunction with gunicorn or uvicorn in order to start a server. Run with: ``` export MODELKIT_REQUIRED_MODELS=... # optional export MODELKIT_DEFAULT_PACKAGE=... # mandatory gunicorn --workers 4 \ --preload \ --worker-class=uvicorn.workers.UvicornWorker \ 'modelkit.api.create_modelkit_app()' ``` """ if not (models or os.environ.get("MODELKIT_DEFAULT_PACKAGE")): raise ModelsNotFound( "Please add `your_package` as argument or set the " "`MODELKIT_DEFAULT_PACKAGE=your_package` env variable.") if os.environ.get("MODELKIT_REQUIRED_MODELS") and not required_models: required_models = os.environ.get("MODELKIT_REQUIRED_MODELS").split(":") app = fastapi.FastAPI() router = ModelkitAutoAPIRouter(required_models=required_models, models=models) app.include_router(router) return app
async def _test(): @fastapi_plugins.registered_configuration class MyConfigDocker(fastapi_plugins.PluginSettings): api_name: str = 'docker' @fastapi_plugins.registered_configuration_local class MyConfigLocal(fastapi_plugins.PluginSettings): api_name: str = 'local' app = fastapi.FastAPI() config = fastapi_plugins.get_config() await fastapi_plugins.config_plugin.init_app(app=app, config=config ) # noqa E501 await fastapi_plugins.config_plugin.init() try: c = await fastapi_plugins.config_plugin() exp = d2json(MyConfigDocker().dict()) res = d2json(c.dict()) self.assertTrue(res == exp, 'get configuration failed') finally: await fastapi_plugins.config_plugin.terminate() fastapi_plugins.reset_config()
def create_app(*, plugins=(), template_paths=(), **plugin_kwargs): api = fastapi.FastAPI() api.mount("/static", StaticFiles(directory=ijik_path("static")), name="static") pluginmanager = pluggy.PluginManager("ijik") pluginmanager.add_hookspecs(Hooks) pluginmanager.add_hookspecs(EntityHooks) pluginmanager.add_hookspecs(FormHooks) for p in itertools.chain(core_plugins(**plugin_kwargs), plugins): pluginmanager.register(p) @api.exception_handler(Exception) async def api_error(request, exc): pluginmanager.hook.ijik_uncaught_exception(exc=exc) return PlainTextResponse("Internal Server Error", status_code=500) ijik = Ijik(api=api, templates=Jinja2Templates( directory=[*template_paths, ijik_path("templates")]), pluginmanager=pluginmanager, registry=sa_registry(), sessionmanager=SessionManager(), entitymanager=EntityManager(pluginmanager), mixins=Mixins(), form_renderer=FormRenderer(pluginmanager)) ijik.init() ijik.setup() return api
async def create_asgi_app(self) -> ASGIApplicationType: app = fastapi.FastAPI() @app.get("/") async def root(): return {"message": "Hello World"} return app
def __init__(self, env, allow_origins): self.app = fastapi.FastAPI(version=info.version, title=' '.join(info.name.split('_'))) if env not in ['LOCAL', 'STAGE', 'ISOLATED']: self.app = fastapi.FastAPI( version=info.version, title=' '.join(info.name.split('_')), openapi_url=None, redoc_url=None, docs_url=None, swagger_ui_oauth2_redirect_url=None, ) self.app.add_middleware( cors.CORSMiddleware, allow_origins=allow_origins, allow_credentials=True, allow_methods=["*"], allow_headers=["*"] )
def serve(self, host: str, port: int, is_dev: bool): # 設定設定檔 try: config = OmegaConf.load(self.CONFIG_FILE_PATH) config.merge_with( {'app': { 'config_folder': str(self.CONFIG_FOLDER) }}) except FileNotFoundError: raise NotFoundError(f'設定檔 {self.CONFIG_FILE_PATH} 不存在 ') # 設定環境 logging.basicConfig( level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S', format='[%(asctime)s][%(levelname)s] %(message)s', ) # 設定 Scheduler scheduler = BackgroundScheduler() scheduler.start() app = fastapi.FastAPI() app.state.config = config app.state.logger = logging.getLogger() app.state.scheduler = scheduler # 設定第三方擴充 app.add_middleware( CORSMiddleware, allow_origins=[ r'http://localhost:9002', r'https://jessigod.marco79423.net', r'http://localhost:9003', r'https://jessiclient.marco79423.net', ], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # 設定並啟動服務 if config.services.jessiclient: serv = JessiclientService(app) serv.setup() if config.services.db_backup: serv = DBBackupService(app) serv.setup() if config.services.jessigod: serv = JessigodService(app) serv.setup() uvicorn.run(app, host=host, port=port)
def __init__(self, routers, middleware=None): self.app = fastapi.FastAPI() if not isinstance(routers, (list, tuple)): routers = [routers] self.app.include_router(monitoring_router) for router in routers: self.app.include_router(router) self.middleware = middleware
async def _test(): app = fastapi.FastAPI() config = self.fixture_get_config() await memcached_plugin.init_app(app=app, config=config) await memcached_plugin.init() try: c = await memcached_plugin() r = await c.ping() self.assertTrue(r, 'set failed') finally: await memcached_plugin.terminate()
async def _test(): app = fastapi.FastAPI() config = fastapi_plugins.RedisSettings() await fastapi_plugins.redis_plugin.init_app(app=app, config=config) await fastapi_plugins.redis_plugin.init() try: c = await fastapi_plugins.redis_plugin() r = (await c.ping()).decode() self.assertTrue(r == 'PONG', 'ping-pong failed == %s' % r) finally: await fastapi_plugins.redis_plugin.terminate()
class Application: """ Defines the application as a composition of several fastapi application related attributes including the app itself """ app = fastapi.FastAPI(redoc_url=None) # Initializing our app _html_directory = os.path.join(os.path.dirname(os.path.abspath(__file__)), "html") # Defining our templates directory templates = Jinja2Templates(directory=os.path.join(_html_directory, "templates")) # Mounting our static files app.mount("/static", StaticFiles(directory=os.path.join(_html_directory, "static")), name="static")
def setUp(self): super().setUp() self.app = fastapi.FastAPI() @self.app.get("/foobar") async def _(): return {"message": "hello world"} otel_fastapi.FastAPIInstrumentor().instrument_app(self.app) self.client = TestClient(self.app) self.tracer = self.tracer_provider.get_tracer(__name__)
def _create_fastapi_app(): app = fastapi.FastAPI() @app.get("/foobar") async def _(): return {"message": "hello world"} @app.get("/user/{username}") async def _(username: str): return {"message": username} return app
def build_app(allow_origins): app = fastapi.FastAPI( version=info.version, title=service_name(), docs_url=None, redoc_url=None, openapi_url=None, ) app.add_middleware( cors.CORSMiddleware, allow_origins=allow_origins, allow_credentials=True, allow_methods=["*"], allow_headers=["*"] ) return app
def _create_app(): app = fastapi.FastAPI() @app.get("/foobar") async def _(): headers = { "custom-test-header-1": "test-header-value-1", "custom-test-header-2": "test-header-value-2", } content = {"message": "hello world"} return JSONResponse(content=content, headers=headers) return app
def __init__(self, bot, secret_token: str, host: Optional[str] = "127.0.0.1", port: Optional[int] = 443, ssl_context: Optional[tuple] = None, url_path: Optional[str] = None, debug: Optional[bool] = False) -> None: """ Aynchronous implementation of webhook listener for asynchronous version of telebot. Not supposed to be used manually by user. Use AsyncTeleBot.run_webhooks() instead. :param bot: AsyncTeleBot instance. :type bot: telebot.async_telebot.AsyncTeleBot :param secret_token: Telegram secret token :type secret_token: str :param host: Webhook host :type host: str :param port: Webhook port :type port: int :param ssl_context: SSL context :type ssl_context: tuple :param url_path: Webhook url path :type url_path: str :param debug: Debug mode :type debug: bool :raises ImportError: If FastAPI or uvicorn is not installed. :raises ImportError: If Starlette version is too old. :return: None """ self._check_dependencies() self.app = fastapi.FastAPI() self._secret_token = secret_token self._bot = bot self._port = port self._host = host self._ssl_context = ssl_context self._url_path = url_path self._debug = debug self._prepare_endpoint_urls()
async def _test(): app = fastapi.FastAPI() config = fastapi_plugins.RedisSettings() await fastapi_plugins.redis_plugin.init_app(app=app, config=config) await fastapi_plugins.redis_plugin.init() try: c = await fastapi_plugins.redis_plugin() value = str(uuid.uuid4()) r = await c.set('x', value) self.assertTrue(r, 'set failed') r = await c.get('x', encoding='utf-8') self.assertTrue(r == value, 'get failed') finally: await fastapi_plugins.redis_plugin.terminate()
async def _test(): app = fastapi.FastAPI() config = self.fixture_get_config() await memcached_plugin.init_app(app=app, config=config) await memcached_plugin.init() try: c = await memcached_plugin() value = str(uuid.uuid4()).encode() r = await c.set(b'x', value) self.assertTrue(r, 'set failed') r = await c.get(b'x') self.assertTrue(r == value, 'get failed') finally: await memcached_plugin.terminate()
async def _test(): app = fastapi.FastAPI() config = fastapi_plugins.RedisSettings() await fastapi_plugins.redis_plugin.init_app(app=app, config=config) await fastapi_plugins.redis_plugin.init() try: exp = dict(redis_type=config.redis_type, redis_address=config.get_redis_address(), redis_pong='PONG') res = await fastapi_plugins.redis_plugin.health() self.assertTrue( d2json(exp) == d2json(res), 'health failed: %s != %s' % (exp, res)) finally: await fastapi_plugins.redis_plugin.terminate()
def create_app() -> fastapi.FastAPI: pkg = pkg_resources.get_distribution(__package__) app = fastapi.FastAPI( title=__package__, version=pkg.version, on_startup=(create_scanner,), ) tracker = tracking.Tracker() registry.set_tracker(tracker) app.add_middleware(middleware.RequestStats, track=tracker.track) app.include_router(api.router) return app
async def _test(): app = fastapi.FastAPI() config = self.fixture_get_config() await memcached_plugin.init_app(app=app, config=config) await memcached_plugin.init() try: exp = dict(host=config.memcached_host, port=config.memcached_port, version='1.6.9') res = await memcached_plugin.health() self.assertTrue( d2json(exp) == d2json(res), 'health failed: %s != %s' % (exp, res)) finally: await memcached_plugin.terminate()
def create_app(debug=False): app = fastapi.FastAPI( title=config.PROJECT_NAME, description=config.PROJECT_NAME, version=__version__, debug=debug, ) sio_asgi_app = socketio.ASGIApp(socketio_server=sio, other_asgi_app=app) app.add_route("/socket.io/", route=sio_asgi_app, methods=['GET', 'POST']) app.add_websocket_route("/socket.io/", sio_asgi_app) load_handlers(app) return app
async def test_redis(): print('--- do redis test') app = fastapi.FastAPI() config = fastapi_plugins.RedisSettings() config = None config = AppSettings(redis_host='127.0.0.1') config = AppSettings() await fastapi_plugins.redis_plugin.init_app(app=app, config=config) await fastapi_plugins.redis_plugin.init() c = await fastapi_plugins.redis_plugin() print(await c.get('x')) print(await c.set('x', str(time.time()))) print(await c.get('x')) await fastapi_plugins.redis_plugin.terminate() print('---test redis done')