apidaora

For complex data structures, use TypedDict annotated with @jsondaora to define request bodies and response shapes. This enables automatic input validation and structured output.

from typing import TypedDict
from jsondaora import jsondaora
from apidaora import route


@jsondaora
class ReqBody(TypedDict):
    last_name: str


@jsondaora
class HelloOutput(TypedDict):
    hello_message: str


@route.put('/hello/{name}')
async def hello_controller(name: str, body: ReqBody) -> HelloOutput:
    return HelloOutput(hello_message=f'Hello {name}!')


app = appdaora(hello_controller)

The Background Task Controller can be implemented using a Redis backend to manage asynchronous tasks. This setup allows you to offload long-running processes and query their status or results later via an API.

To use this, you need a running Redis server and a web server (like uvicorn) to host the application. The workflow involves:

1. Creating a task: Sending a request to the server to initiate a background process.
2. Querying the task: Using the returned task_id to check the current status of the task.
3. Retrieving results: Polling the status until the task is finished to obtain the final output.

# Note: The implementation details are contained in the source file:
# src/redis_background_task_controller/redis_background_task_controller.py

To run an application utilizing the Background Tasks Middleware, use uvicorn. Replace myapp with the name of your Python module and app with your application instance name.

uvicorn myapp:app

To run the application server, ensure a Redis server is active on your system, then use uvicorn to start the app. Replace myapp:app with your actual module and application instance name.

uvicorn myapp:app

To run an application configured to handle gzip request bodies (or any standard apidaora application), use the uvicorn ASGI server. Replace myapp:app with your specific module and application instance.

uvicorn myapp:app

To run a server defined using a ClassController, use uvicorn. Assuming your file is named myapp.py and your application instance is named app, run:

uvicorn myapp:app

Extra Arguments Middlewares allow you to inject additional data or arguments into the request/response lifecycle. This is typically used to augment the context of a request with data derived from headers, query parameters, or other metadata before it reaches the application logic.

# Implementation found in src/middlewares_extra_args/middlewares_extra_args.py

To create a basic API, use the @route decorator to define HTTP methods and paths, and pass the controller function(s) to appdaora() to create the ASGI application instance. The controller function's arguments are automatically mapped from path parameters or query parameters based on type annotations.

from apidaora import appdaora, route


@route.get('/hello')
def hello_controller(name: str) -> str:
    return f'Hello {name}!'


app = appdaora(hello_controller)

The locking mechanism works as follows:

1. Create a task: Send a request to initiate the task. The server will return a task_id.
2. Prevent duplicates: If you attempt to create the same task while the previous one is still active/locked, the server will return an error.
3. Query task status: Use the task_id provided during creation to query the server for the current status of the task.
4. Retrieve results: Once the task status indicates it has finished, you can retrieve the results.
5. Retry task: After the initial task has completed and the lock is released, you can successfully create the task again.