cross-web

0.4.1 · active · verified Sat Apr 11

Cross-web is a Python library (version 0.4.1) providing a unified interface for common web framework operations, allowing developers to write framework-agnostic code for popular Python web frameworks like FastAPI, Flask, and Django. It is actively developed with recent releases addressing bug fixes and framework support, and was last updated in January 2026.

Warnings

breaking The package name and import path changed from `lia-web` to `cross-web` in version 0.4.0. Code using `from lia_web import ...` will need to be updated.
Fix: Update all import statements from `from lia_web import ...` to `from cross_web import ...`. While `lia-web` acts as a shim, direct imports are recommended for future compatibility.
deprecated The `lia-web` package is now deprecated. It acts as a compatibility shim for `cross-web` but should not be used for new projects or ongoing development.
Fix: Install and use `cross-web` directly. Update all imports from `lia_web` to `cross_web`.
gotcha Pydantic was removed as a dependency in version 0.2.2. If your application implicitly relied on Pydantic being a dependency of `cross-web` (e.g., for schema validation outside of `cross-web`'s explicit use), it might break.
Fix: Ensure Pydantic is explicitly listed in your project's dependencies if your code relies on its presence. `cross-web` itself no longer requires it.
gotcha A fix for handling multipart form data in the AioHTTP integration was introduced in version 0.2.1. Older versions might have issues with file uploads or on-demand processing.
Fix: Upgrade to `cross-web` version 0.2.1 or higher to ensure correct multipart form data processing, especially when using the AioHTTP adapter.

Install

pip install cross-web Install latest version

Imports

Response
```
from cross_web import Response
```
The package was renamed from `lia-web` to `cross-web` in version 0.4.0. While `lia-web` acts as a compatibility shim, direct imports from `cross_web` are recommended.
Request
```
from cross_web import Request
```

Quickstart

This quickstart demonstrates the core concept of `cross-web`: defining framework-agnostic `Request` and `Response` objects. In a real application, a specific web framework (like Flask or FastAPI) would use a `cross-web` adapter to convert its native request/response objects to `cross-web`'s types, allowing you to write your business logic using these unified types. This example is runnable and simulates the creation and processing of these objects.

from cross_web import Request, Response

def my_framework_agnostic_handler(request: Request) -> Response:
    # This function represents a handler written using cross-web's abstractions
    name = request.query_params.get('name', 'World')
    body_content = f"Hello, {name}! This is a cross-web response."
    return Response(
        status_code=200,
        headers={'Content-Type': 'text/plain'},
        body=body_content.encode('utf-8')
    )

# --- Example of how a web framework adapter might use it ---
# In a real application, a framework-specific adapter would create
# the Request object and handle the Response object.

# Simulate an incoming request
simulated_request = Request(
    method="GET",
    path="/greeting",
    headers={
        "Host": "example.com",
        "User-Agent": "curl/7.81.0"
    },
    query_params={
        "name": "cross-web user"
    },
    body=b''
)

# Call the framework-agnostic handler
response_obj = my_framework_agnostic_handler(simulated_request)

# Output the response details (what a framework adapter might send back)
print(f"Status: {response_obj.status_code}")
print(f"Headers: {response_obj.headers}")
print(f"Body: {response_obj.body.decode('utf-8')}")

view raw JSON →