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')
