aiohtt-api 0.0.1
Asynchronous web framework for building powerful web APIs and applications with Python
Requires Python: >=3.8

Certainly! Here's the full README.md file incorporating all the detailed explanations and examples:

```markdown
# aiohttp-api

aiohttp-api is an asynchronous web framework for building powerful and efficient web APIs and applications with Python. It leverages the asyncio and aiohttp libraries to provide a seamless development experience for building high-performance web applications.

## Key Features

- Asynchronous by design: Built on top of asyncio and aiohttp, aiohttp-api allows you to write highly concurrent and efficient web applications.
- Simple and intuitive API: With minimal boilerplate and sensible defaults, aiohttp-api provides a clean and intuitive API for defining routes and handling requests.
- Error handling made easy: aiohttp-api simplifies error handling with support for both simple and class-based error responses, making it straightforward to handle exceptions and provide meaningful feedback to clients.
- Schema validation with SchemaModel: aiohttp-api makes form validation easy with the SchemaModel class, allowing you to validate incoming request data against defined schemas effortlessly.
- Template rendering with Jinja2Template: aiohttp-api includes built-in support for Jinja2Template, allowing you to render HTML templates seamlessly.

## Installation

You can install aiohttp-api via pip:


pip install aiohttp-api
```

## Quick Start

```python
from src import AioAPI, Request
from src.exceptions import APIError, ClassBaseError
from src.schemas import SchemaModel
from src.templating import Jinja2Template

app = AioAPI()
render = Jinja2Template('templates')

# Define routes and handlers
@app.get("/")
async def hello():
    return "Hello, aiohttp-api!"

# Run the aiohttp-api application
app.run()
```

## Advanced Features and Best Practices

In addition to the basic setup and usage, aiohttp-api offers advanced features and best practices for building robust web applications.

### Advanced Routing Techniques

#### Route Parameters

In aiohttp-api, you can define routes with parameters that capture dynamic values from the URL. For example:

```python
@app.get("/users/{user_id}")
async def get_user(request: Request, user_id: int):
    # Retrieve user data based on user_id
    return {'user_id': user_id}
```

#### Query Parameters

You can also handle query parameters in aiohttp-api routes. For example:

```python
@app.get("/search")
async def search_users(request: Request):
    query = request.query.get('q')
    # Perform search based on query parameter
    return {'query': query}
```

### Middleware

Middleware in aiohttp-api allows you to intercept and modify requests and responses before they reach the handler. You can use middleware for tasks such as authentication, logging, and request/response manipulation.

```python
async def logger_middleware(request: Request, handler, **kwargs):
    # Log request information
    print(f"Received {request.method} request to {request.path}")
    
    # Call the next middleware/handler in the chain
    response = await handler(request, **kwargs)
    
    # Log response information
    print(f"Responded with {response.status}")
    
    return response

# Register middleware with the aiohttp-api app
app.add_middleware(logger_middleware)
```

### Static Files and Asset Handling

AioAPI allows you to serve static files such as CSS, JavaScript, and images alongside your dynamic content. You can use the `StaticFiles` class to define a route for serving static files from a directory:

```python
from src.static import StaticFiles

# Define a route for serving static files
app.add_static('/static', path='static')
```

### Testing

Testing is an essential part of the development process. AioAPI provides utilities for testing your web applications, including the ability to simulate HTTP requests and responses.

```python
from src.testing import AioAPITestClient

async with AioAPITestClient(app) as client:
    response = await client.get('/hello')
    assert response.status == 200
    assert await response.text() == 'Hello, aiohttp-api!'
```