def simple_client(hello_fake): @path('/test/', MethodType.GET) def operation() -> StrResponse: return StrResponse(body=hello_fake) app = appdaora([operation]) return TestClient(app)
def start(spec: Specification, host: str, port: int, html_params: Dict[str, str]) -> None: controllers = build_yaml_spec_controllers(spec) + [ build_json_spec_controller(spec) ] controllers.extend(build_spec_docs_controllers(spec, html_params)) app = appdaora(controllers) uvicorn.run(app, host=host, port=port)
async def test_should_get_response_with_one_scalar_path_parameter(): @path('/test/{param}', MethodType.GET) def operation(param: int) -> StrResponse: return StrResponse(body=f'{param}: {type(param).__name__}') client = TestClient(appdaora([operation])) response = await client.get('/test/01') assert response.status_code == HTTPStatus.OK.value assert response.content == b'1: int'
async def test_should_get_response_with_one_scalar_path_parameter_and_two_query_parameter(): @path('/test/{param}', MethodType.GET) def operation(param: int, param2: float, param3: str) -> StrResponse: return StrResponse( body=( f'{param}: {type(param).__name__}, ' f'{param2}: {type(param2).__name__}, ' f'{param3}: {type(param3).__name__}' ) ) client = TestClient(appdaora([operation])) response = await client.get('/test/01/?param2=00000.1¶m3=test') assert response.status_code == HTTPStatus.OK.value assert response.content == b'1: int, 0.1: float, test: str'
async def test_should_get_response_with_scalar_parameters_with_one_path_and_one_query_and_one_header(): @path('/test/{param}', MethodType.GET) def operation( param: int, param2: float, param3: header_param(schema=float, name='x-param3'), ) -> StrResponse: return StrResponse( body=( f'{param}: {type(param).__name__}, ' f'{param2}: {type(param2).__name__}, ' f'{param3}: {type(param3).__name__}' ) ) client = TestClient(appdaora([operation])) response = await client.get( '/test/01/?param2=00000.1', headers={'x-param3': '-000.1'} ) assert response.status_code == HTTPStatus.OK.value assert response.content == b'1: int, 0.1: float, -0.1: float'
from dataclasses import dataclass from apidaora import JSONResponse, MethodType, appdaora, path @dataclass class Response(JSONResponse): body: str @path('/hello', MethodType.GET) def controller(name: str) -> Response: message = f'Hello {name}!' return Response(body=message) app = appdaora(operations=[controller])
import time from apidaora import appdaora, route @route.background('/hello-single', lock=True) def hello_task(name: str) -> str: time.sleep(1) return f'Hello {name}!' app = appdaora(hello_task)
def make_app() -> ASGIApp: executor = ThreadPoolExecutor(config.workers) chunli = Caller(data_source_target=config.redis_target) executor.submit(wait_for_ditributed_calls_in_background, chunli, config) @route.background('/run', tasks_repository_uri=config.redis_target) async def run( duration: int, rps_per_node: int, body: GzipBody, rampup_time: Optional[int] = None, ) -> Results: calls = (line.strip('\n') for line in body.open()) chunli_run = Caller(data_source_target=config.redis_target) await chunli_run.set_calls(calls) await chunli_run.start_distributed_calls( CallerConfig( duration=duration, rps_per_node=rps_per_node, rampup_time=rampup_time, )) try: results = await chunli_run.get_results(duration) return results except Exception as error: logger.exception(error) return Results( # type: ignore error=Error(name=type(error).__name__, args=error.args)) @route.background('/script', tasks_repository_uri=config.redis_target) async def script( duration: int, rps_per_node: int, body: str, rampup_time: Optional[int] = None, ) -> Results: chunli_run = Caller(data_source_target=config.redis_target) await chunli_run.set_script(body) await chunli_run.start_distributed_calls( CallerConfig( duration=duration, rps_per_node=rps_per_node, rampup_time=rampup_time, )) try: results = await chunli_run.get_results(duration) return results except Exception as error: logger.exception(error) return Results( # type: ignore error=Error(name=type(error).__name__, args=error.args)) @route.get('/status') async def status() -> Status: return Status(chunli=random.choice(_CHUN_LI_ATTACKS)) return appdaora([run, status, script])
) async def pre_execution_middleware_controller(body: PreExecutionBody) -> str: return hello(body.name) class PostExecutionHeader(Header, type=int, http_name='x-name-len'): ... @route.get( '/hello-post-execution', middlewares=Middlewares(post_execution=[post_execution_middleware]), ) async def post_execution_middleware_controller(name: str) -> Response: return text(body=hello(name)) def hello(name: str) -> str: return f'Hello {name}!' app = appdaora( [ post_routing_middleware_controller, pre_execution_middleware_controller, post_execution_middleware_controller, ], middlewares=Middlewares( post_execution=[CorsMiddleware(servers_all='my-server.domain')]), )
class ReqBody(TypedDict): last_name: str @jsondaora class HelloOutput(TypedDict): hello_message: str about_you: You @route.put('/hello/{name}') async def hello_controller( name: str, location: String, age: Age, body: ReqBody ) -> HelloOutput: you = You( name=name, location=location.value, age=age.value.value, last_name=body['last_name'], ) return HelloOutput( hello_message=await hello_message(name, location.value), about_you=you ) async def hello_message(name: str, location: str) -> str: return f'Hello {name}! Welcome to {location}!' app = appdaora(hello_controller)
from typing import TypedDict from apidaora import appdaora, route from jsondaora import jsondaora @route.get('/hello') def hello() -> str: return 'Hello World!' @jsondaora class Body(TypedDict): name: str @route.post('/hello-body') def hello_body(body: Body) -> str: return f"Hello {body['name']}!" app = appdaora([hello, hello_body])
from apidaora import appdaora, route @route.get('/app-options') async def app_options() -> str: return 'Options' @route.get('/route-options', options=True) async def route_options() -> str: return 'Options' app = appdaora([app_options, route_options], options=True)
@route.get('/updates') async def database_updates(queries: Optional[str] = None): worlds = [] updates = set() async with connection_pool.acquire() as connection: statement = await connection.prepare(READ_ROW_SQL_TO_UPDATE) for _ in range(get_num_queries(queries)): record = await statement.fetchrow(randint(1, 10000)) world = DatabaseObject(id=record['id'], randomNumber=record['randomnumber']) world['randomNumber'] = randint(1, 10000) worlds.append(world) updates.add((world['id'], world['randomNumber'])) await connection.executemany(WRITE_ROW_SQL, updates) return worlds @route.get('/plaintext') async def plaintext(): return text('Hello, world!') app = appdaora([ json_serialization, single_database_query, multiple_database_queries, fortunes, database_updates, plaintext ])
class YouWereNotFoundError(DBError): name = 'you-were-not-found' # Application layer, here are the http related definitions # See: https://dutrdda.github.io/apidaora/tutorial/headers/ class ReqID(Header, type=str, http_name='http_req_id'): ... @route.post('/you/') async def add_you_controller(req_id: ReqID, body: You) -> Response: try: add_you(body) except YouAlreadyBeenAddedError as error: raise BadRequestError(name=error.name, info=error.info) from error return json(body, HTTPStatus.CREATED, headers=(req_id,)) @route.get('/you/{name}') async def get_you_controller(name: str, req_id: ReqID) -> Response: try: return json(get_you(name), headers=(req_id,)) except YouWereNotFoundError as error: raise BadRequestError(name=error.name, info=error.info) from error app = appdaora([add_you_controller, get_you_controller])
from typing import List from apidaora import LockRequestMiddleware, Middlewares, appdaora, route prevent_request_middleware = LockRequestMiddleware() @route.post( '/lock-request', middlewares=Middlewares( post_routing=[prevent_request_middleware.lock], pre_execution=[prevent_request_middleware.unlock_pre_execution], ), ) async def lock_controller(body: List[int]) -> int: return len(body) @route.post( '/lock-request-post', middlewares=Middlewares( post_routing=[prevent_request_middleware.lock], post_execution=[prevent_request_middleware.unlock_post_execution], ), ) async def lock_post_controller(body: List[int]) -> int: return len(body) app = appdaora([lock_controller, lock_post_controller])
from apidaora import ( BackgroundTaskMiddleware, Middlewares, Response, appdaora, route, text, ) class HelloCounter: counter = 1 @classmethod async def count(cls) -> None: cls.counter += 1 @route.get('/background-tasks') async def background_tasks_controller(name: str) -> Response: return text( f'Hello {name}!\n{name} are the #{HelloCounter.counter}!', background_tasks=HelloCounter.count, ) app = appdaora( background_tasks_controller, middlewares=Middlewares(post_execution=BackgroundTaskMiddleware()), )
from apidaora import Middlewares, Request, Response, appdaora, route, text def request_extra_args(request: Request) -> None: request.ctx['extra'] = 'You' def response_extra_args(request: Request, response: Response) -> None: if request.ctx and response.ctx: response.body = response.body.replace( 'You', f"{request.ctx['extra']} and {response.ctx['name']}" ) @route.get( '/middlewares-ctx', middlewares=Middlewares( pre_execution=request_extra_args, post_execution=response_extra_args, ), ) async def extra_args_controller(name: str, **kwargs: Any) -> Response: return text(hello(kwargs['extra']), name=name) def hello(name: str) -> str: return f'Hello {name}!' app = appdaora(extra_args_controller)
from apidaora import GZipFactory, appdaora, route class GzipBody(GZipFactory): mode = 'rt' @route.post('/hello') def gzip_hello(body: GzipBody) -> str: with body.open() as file: return file.read() app = appdaora(gzip_hello)