cross-web 0.2.3__py3-none-any.whl

cross/__init__.py

@@ -0,0 +1,36 @@
+from .exceptions import HTTPException
+from .protocols import BaseRequestProtocol
+from .request import AsyncHTTPRequest
+from .request._aiohttp import AiohttpHTTPRequestAdapter
+from .request._base import AsyncHTTPRequestAdapter, FormData, SyncHTTPRequestAdapter
+from .request._chalice import ChaliceHTTPRequestAdapter
+from .request._django import AsyncDjangoHTTPRequestAdapter, DjangoHTTPRequestAdapter
+from .request._flask import AsyncFlaskHTTPRequestAdapter, FlaskHTTPRequestAdapter
+from .request._litestar import LitestarRequestAdapter
+from .request._quart import QuartHTTPRequestAdapter
+from .request._sanic import SanicHTTPRequestAdapter
+from .request._starlette import StarletteRequestAdapter
+from .request._testing import TestingRequestAdapter
+from .response import Cookie, Response
+
+__all__ = [
+    "AiohttpHTTPRequestAdapter",
+    "AsyncDjangoHTTPRequestAdapter",
+    "AsyncFlaskHTTPRequestAdapter",
+    "AsyncHTTPRequest",
+    "AsyncHTTPRequestAdapter",
+    "BaseRequestProtocol",
+    "ChaliceHTTPRequestAdapter",
+    "Cookie",
+    "DjangoHTTPRequestAdapter",
+    "FlaskHTTPRequestAdapter",
+    "FormData",
+    "HTTPException",
+    "LitestarRequestAdapter",
+    "QuartHTTPRequestAdapter",
+    "Response",
+    "SanicHTTPRequestAdapter",
+    "StarletteRequestAdapter",
+    "SyncHTTPRequestAdapter",
+    "TestingRequestAdapter",
+]

cross/exceptions.py

@@ -0,0 +1,8 @@
+class HTTPException(Exception):
+    def __init__(self, status_code: int, reason: str) -> None:
+        self.status_code = status_code
+        self.reason = reason
+        super().__init__(reason)
+
+
+__all__ = ["HTTPException"]

cross/protocols.py

@@ -0,0 +1,20 @@
+from collections.abc import Mapping
+from typing import Optional, Protocol, Union
+
+from .request._base import HTTPMethod
+
+
+class BaseRequestProtocol(Protocol):
+    """Protocol defining the minimal interface for HTTP requests."""
+
+    @property
+    def query_params(self) -> Mapping[str, Optional[Union[str, list[str]]]]: ...
+
+    @property
+    def method(self) -> HTTPMethod: ...
+
+    @property
+    def headers(self) -> Mapping[str, str]: ...
+
+
+__all__ = ["BaseRequestProtocol"]

cross/request/__init__.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Mapping, Optional, Any
+
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from starlette.requests import Request as StarletteRequest
+
+from ._base import AsyncHTTPRequestAdapter, FormData, HTTPMethod, QueryParams
+from ._starlette import StarletteRequestAdapter
+from ._testing import TestingRequestAdapter
+
+
+class AsyncHTTPRequest:
+    def __init__(self, adapter: AsyncHTTPRequestAdapter) -> None:
+        self._adapter = adapter
+
+    @classmethod
+    def from_starlette(cls, request: StarletteRequest) -> Self:
+        adapter = StarletteRequestAdapter(request)
+
+        return cls(adapter)
+
+    @classmethod
+    def from_fastapi(cls, request: StarletteRequest) -> Self:
+        return cls.from_starlette(request)
+
+    @classmethod
+    def from_django(cls, request: Any) -> Self:
+        # Import here to avoid circular imports and optional Django dependency
+        from ._django import AsyncDjangoHTTPRequestAdapter
+
+        adapter = AsyncDjangoHTTPRequestAdapter(request)
+        return cls(adapter)
+
+    @classmethod
+    def from_flask(cls, request: Any) -> Self:
+        # Import here to avoid circular imports and optional Flask dependency
+        from ._flask import AsyncFlaskHTTPRequestAdapter
+
+        adapter = AsyncFlaskHTTPRequestAdapter(request)
+        return cls(adapter)
+
+    @classmethod
+    def from_sanic(cls, request: Any) -> Self:
+        # Import here to avoid circular imports and optional Sanic dependency
+        from ._sanic import SanicHTTPRequestAdapter
+
+        adapter = SanicHTTPRequestAdapter(request)
+        return cls(adapter)
+
+    @classmethod
+    def from_aiohttp(cls, request: Any) -> Self:
+        # Import here to avoid circular imports and optional aiohttp dependency
+        from ._aiohttp import AiohttpHTTPRequestAdapter
+
+        adapter = AiohttpHTTPRequestAdapter(request)
+        return cls(adapter)
+
+    @classmethod
+    def from_quart(cls, request: Any) -> Self:
+        # Import here to avoid circular imports and optional Quart dependency
+        from ._quart import QuartHTTPRequestAdapter
+
+        adapter = QuartHTTPRequestAdapter(request)
+        return cls(adapter)
+
+    @classmethod
+    def from_litestar(cls, request: Any) -> Self:
+        # Import here to avoid circular imports and optional Litestar dependency
+        from ._litestar import LitestarRequestAdapter
+
+        adapter = LitestarRequestAdapter(request)
+        return cls(adapter)
+
+    @classmethod
+    def from_form_data(cls, data: Mapping[str, str]) -> Self:
+        adapter = TestingRequestAdapter(
+            form_data=FormData(files={}, form=data),
+            content_type="application/x-www-form-urlencoded",
+        )
+        return cls(adapter)
+
+    @property
+    def method(self) -> HTTPMethod:
+        """The HTTP method of the request."""
+        return self._adapter.method
+
+    @property
+    def query_params(self) -> QueryParams:
+        """The query parameters of the request."""
+        return self._adapter.query_params
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        """The request headers (case-insensitive keys recommended)."""
+        return self._adapter.headers
+
+    @property
+    def content_type(self) -> Optional[str]:
+        """The 'Content-Type' header value, if present."""
+        return self._adapter.content_type
+
+    @property
+    def url(self) -> str:
+        """The URL of the request."""
+        return self._adapter.url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        """The request cookies."""
+        return self._adapter.cookies
+
+    async def get_body(self) -> bytes:
+        """Return the raw request body as bytes."""
+        return await self._adapter.get_body()
+
+    async def get_form_data(self) -> FormData:
+        """
+        Return parsed form data (multipart/form-data or application/x-www-form-urlencoded).
+        """
+        return await self._adapter.get_form_data()

cross/request/_aiohttp.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from io import BytesIO
+from typing import TYPE_CHECKING, Any, Mapping, Optional, cast
+
+from ._base import AsyncHTTPRequestAdapter, FormData, HTTPMethod, QueryParams
+
+if TYPE_CHECKING:
+    from aiohttp import web
+
+
+class AiohttpHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(
+        self,
+        request: web.Request,
+        body: Optional[bytes] = None,
+        form_data: Optional[FormData] = None,
+    ) -> None:
+        self.request = request
+        self._body = body
+        self._form_data = form_data
+
+    @classmethod
+    async def create(cls, request: web.Request) -> "AiohttpHTTPRequestAdapter":
+        """Create an adapter and pre-read the body to avoid PayloadAccessError"""
+        content_type = request.headers.get("content-type", "")
+        form_data = None
+        body = None
+
+        if content_type.startswith("multipart/form-data"):
+            # Pre-process multipart data
+            reader = await request.multipart()
+            data: dict[str, Any] = {}
+            files: dict[str, Any] = {}
+
+            while field := await reader.next():
+                from aiohttp.multipart import BodyPartReader
+
+                assert isinstance(field, BodyPartReader)
+                assert field.name
+
+                if field.filename:
+                    files[field.name] = BytesIO(await field.read(decode=False))
+                else:
+                    data[field.name] = await field.text()
+
+            form_data = FormData(files=files, form=data)
+        else:
+            # For non-multipart requests, read the body
+            body = await request.read()
+
+        return cls(request, body, form_data)
+
+    @property
+    def query_params(self) -> QueryParams:
+        return cast(QueryParams, self.request.query.copy())  # type: ignore[attr-defined]
+
+    async def get_body(self) -> bytes:
+        if self._form_data is not None:
+            return b""
+        if self._body is None:
+            self._body = await self.request.read()
+        return self._body
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers
+
+    async def get_form_data(self) -> FormData:
+        if self._form_data is not None:
+            return self._form_data
+
+        if self.content_type and self.content_type.startswith("multipart/form-data"):
+            # Process multipart data
+            reader = await self.request.multipart()
+            data: dict[str, Any] = {}
+            files: dict[str, Any] = {}
+
+            while field := await reader.next():
+                from aiohttp.multipart import BodyPartReader
+
+                assert isinstance(field, BodyPartReader)
+                assert field.name
+
+                if field.filename:
+                    files[field.name] = BytesIO(await field.read(decode=False))
+                else:
+                    data[field.name] = await field.text()
+
+            self._form_data = FormData(files=files, form=data)
+            return self._form_data
+        else:
+            # For URL-encoded form data
+            post_data = await self.request.post()
+            return FormData(files={}, form=dict(post_data))
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.headers.get("content-type")
+
+    @property
+    def url(self) -> str:
+        return str(self.request.url)
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return self.request.cookies

cross/request/_base.py

@@ -0,0 +1,148 @@
+import abc
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Literal, Optional, Union
+
+HTTPMethod = Literal[
+    "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "TRACE"
+]
+
+QueryParams = Mapping[str, Optional[str]]
+
+
+@dataclass
+class FormData:
+    files: Mapping[str, Any]
+    form: Mapping[str, Any]
+
+    def get(self, key: str) -> Any:
+        return self.form.get(key)
+
+
+class SyncHTTPRequestAdapter(abc.ABC):
+    """
+    Abstract Base Class defining the interface for accessing HTTP request data
+    in a framework-agnostic way for synchronous operations.
+    """
+
+    @property
+    @abc.abstractmethod
+    def method(self) -> HTTPMethod:
+        """The HTTP method of the request (e.g., 'GET', 'POST')."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def query_params(self) -> QueryParams:
+        """The query parameters of the request."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def headers(self) -> Mapping[str, str]:
+        """The request headers. Header names should ideally be case-insensitive."""
+        # Note: Real implementations might need to handle case-insensitivity
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def content_type(self) -> Optional[str]:
+        """The 'Content-Type' header value, if present."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def body(self) -> Union[str, bytes]:
+        """Return the raw request body as bytes or string."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def post_data(self) -> Mapping[str, Union[str, bytes]]:
+        """Return the parsed POST data as a mapping of field names to values."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def files(self) -> Mapping[str, Any]:
+        """Return uploaded files from the request."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_form_data(self) -> FormData:
+        """
+        Return parsed form data (multipart/form-data or application/x-www-form-urlencoded).
+        Returns an empty FormData object if the content type is not form data
+        or if parsing fails.
+        """
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def url(self) -> str:
+        """The URL of the request."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def cookies(self) -> Mapping[str, str]:
+        """The request cookies."""
+        raise NotImplementedError
+
+
+class AsyncHTTPRequestAdapter(abc.ABC):
+    """
+    Abstract Base Class defining the interface for accessing HTTP request data
+    in a framework-agnostic way.
+    """
+
+    @property
+    @abc.abstractmethod
+    def method(self) -> HTTPMethod:
+        """The HTTP method of the request (e.g., 'GET', 'POST')."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def query_params(self) -> QueryParams:
+        """The query parameters of the request."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def headers(self) -> Mapping[str, str]:
+        """The request headers. Header names should ideally be case-insensitive."""
+        # Note: Real implementations might need to handle case-insensitivity
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def content_type(self) -> Optional[str]:
+        """The 'Content-Type' header value, if present."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def get_body(self) -> bytes:
+        """Return the raw request body as bytes."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def get_form_data(self) -> FormData:
+        """
+        Return parsed form data (multipart/form-data or application/x-www-form-urlencoded).
+        Returns an empty FormData object if the content type is not form data
+        or if parsing fails.
+        """
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def url(self) -> str:
+        """The URL of the request."""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def cookies(self) -> Mapping[str, str]:
+        """The request cookies."""
+        raise NotImplementedError

cross/request/_chalice.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, Optional, Union, cast
+
+from ._base import FormData, HTTPMethod, QueryParams, SyncHTTPRequestAdapter
+
+if TYPE_CHECKING:
+    from chalice.app import Request
+
+
+class ChaliceHTTPRequestAdapter(SyncHTTPRequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.query_params or {}
+
+    @property
+    def body(self) -> Union[str, bytes]:
+        return self.request.raw_body
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers
+
+    @property
+    def post_data(self) -> Mapping[str, Union[str, bytes]]:
+        # Chalice doesn't support traditional form data
+        raise NotImplementedError("Chalice does not support form data")
+
+    @property
+    def files(self) -> Mapping[str, Any]:
+        # Chalice doesn't support file uploads out of the box
+        raise NotImplementedError("Chalice does not support file uploads")
+
+    def get_form_data(self) -> FormData:
+        # Chalice doesn't support form data
+        raise NotImplementedError("Chalice does not support form data")
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.headers.get("Content-Type", None)
+
+    @property
+    def url(self) -> str:
+        # Construct URL from context
+        context = self.request.context
+        stage = context.get("stage", "")
+        domain = context.get("domainName", "")
+        path = context.get("path", "")
+
+        # Build the URL
+        protocol = "https"  # API Gateway typically uses HTTPS
+        if stage and stage != "prod":
+            url = f"{protocol}://{domain}/{stage}{path}"
+        else:
+            url = f"{protocol}://{domain}{path}"
+
+        # Add query string if present
+        if self.request.query_params:
+            from urllib.parse import urlencode
+
+            query_string = urlencode(self.request.query_params)
+            url = f"{url}?{query_string}"
+
+        return url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        # Chalice doesn't have direct cookie support
+        # Cookies would come in the Cookie header
+        cookie_header = self.request.headers.get("Cookie", "")
+        if not cookie_header:
+            return {}
+
+        cookies = {}
+        for cookie in cookie_header.split(";"):
+            cookie = cookie.strip()
+            if "=" in cookie:
+                name, value = cookie.split("=", 1)
+                cookies[name] = value
+
+        return cookies

cross/request/_django.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, Optional, Union, cast
+
+from ._base import (
+    AsyncHTTPRequestAdapter,
+    FormData,
+    HTTPMethod,
+    QueryParams,
+    SyncHTTPRequestAdapter,
+)
+
+if TYPE_CHECKING:
+    from django.http import HttpRequest
+
+
+class DjangoHTTPRequestAdapter(SyncHTTPRequestAdapter):
+    def __init__(self, request: HttpRequest) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return cast(QueryParams, self.request.GET.dict())
+
+    @property
+    def body(self) -> Union[str, bytes]:
+        return cast(Union[str, bytes], self.request.body.decode())
+
+    @property
+    def method(self) -> HTTPMethod:
+        assert self.request.method is not None
+
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return cast(Mapping[str, str], self.request.headers)
+
+    @property
+    def post_data(self) -> Mapping[str, Union[str, bytes]]:
+        return cast(Mapping[str, Union[str, bytes]], self.request.POST)
+
+    @property
+    def files(self) -> Mapping[str, Any]:
+        return cast(Mapping[str, Any], self.request.FILES)
+
+    def get_form_data(self) -> FormData:
+        return FormData(
+            files=cast(Mapping[str, Any], self.request.FILES),
+            form=cast(Mapping[str, Union[str, bytes]], self.request.POST),
+        )
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return cast(Optional[str], self.request.content_type)
+
+    @property
+    def url(self) -> str:
+        return cast(str, self.request.build_absolute_uri())
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return cast(Mapping[str, str], self.request.COOKIES)
+
+
+class AsyncDjangoHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: HttpRequest) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return cast(QueryParams, self.request.GET.dict())
+
+    @property
+    def method(self) -> HTTPMethod:
+        assert self.request.method is not None
+
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return cast(Mapping[str, str], self.request.headers)
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.headers.get("Content-type")
+
+    async def get_body(self) -> bytes:
+        return cast(bytes, self.request.body)
+
+    async def get_form_data(self) -> FormData:
+        return FormData(
+            files=cast(Mapping[str, Any], self.request.FILES),
+            form=cast(Mapping[str, Union[str, bytes]], self.request.POST),
+        )
+
+    @property
+    def url(self) -> str:
+        return cast(str, self.request.build_absolute_uri())
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return cast(Mapping[str, str], self.request.COOKIES)

cross/request/_flask.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, Optional, Union, cast
+
+from ._base import (
+    AsyncHTTPRequestAdapter,
+    FormData,
+    HTTPMethod,
+    QueryParams,
+    SyncHTTPRequestAdapter,
+)
+
+if TYPE_CHECKING:
+    from flask import Request
+
+
+class FlaskHTTPRequestAdapter(SyncHTTPRequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.args.to_dict()
+
+    @property
+    def body(self) -> Union[str, bytes]:
+        return self.request.data.decode()
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers  # type: ignore
+
+    @property
+    def post_data(self) -> Mapping[str, Union[str, bytes]]:
+        return self.request.form
+
+    @property
+    def files(self) -> Mapping[str, Any]:
+        return self.request.files
+
+    def get_form_data(self) -> FormData:
+        return FormData(
+            files=self.request.files,
+            form=self.request.form,
+        )
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
+
+    @property
+    def url(self) -> str:
+        return self.request.url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return self.request.cookies
+
+
+class AsyncFlaskHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.args.to_dict()
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers  # type: ignore
+
+    async def get_body(self) -> bytes:
+        return self.request.data
+
+    async def get_form_data(self) -> FormData:
+        return FormData(
+            files=self.request.files,
+            form=self.request.form,
+        )
+
+    @property
+    def url(self) -> str:
+        return self.request.url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return self.request.cookies

cross/request/_litestar.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, Optional, cast
+
+from ._base import AsyncHTTPRequestAdapter, FormData, HTTPMethod, QueryParams
+
+if TYPE_CHECKING:
+    from litestar import Request
+
+
+class LitestarRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request[Any, Any, Any]) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.query_params
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers
+
+    @property
+    def content_type(self) -> Optional[str]:
+        content_type, params = self.request.content_type
+
+        # combine content type and params
+        if params:
+            content_type += "; " + "; ".join(f"{k}={v}" for k, v in params.items())
+
+        return content_type
+
+    async def get_body(self) -> bytes:
+        return await self.request.body()
+
+    async def get_form_data(self) -> FormData:
+        multipart_data = await self.request.form()
+
+        return FormData(form=multipart_data, files=multipart_data)
+
+    @property
+    def url(self) -> str:
+        return str(self.request.url)
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return self.request.cookies

cross/request/_quart.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Mapping, Optional, cast
+
+from ._base import AsyncHTTPRequestAdapter, FormData, HTTPMethod, QueryParams
+
+if TYPE_CHECKING:
+    from quart import Request
+
+
+class QuartHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.args.to_dict()
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers  # type: ignore
+
+    async def get_body(self) -> bytes:
+        return await self.request.data
+
+    async def get_form_data(self) -> FormData:
+        files = await self.request.files
+        form = await self.request.form
+        return FormData(files=files, form=form)
+
+    @property
+    def url(self) -> str:
+        return self.request.url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return self.request.cookies

cross/request/_sanic.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, Optional, Union, cast
+
+from ._base import AsyncHTTPRequestAdapter, FormData, HTTPMethod, QueryParams
+
+if TYPE_CHECKING:
+    from sanic.request import File, Request
+
+
+def convert_request_to_files_dict(request: Request) -> dict[str, Any]:
+    """Converts the request.files dictionary to a dictionary of sanic Request objects.
+
+    `request.files` has the following format, even if only a single file is uploaded:
+
+    ```python
+    {
+        "textFile": [
+            sanic.request.File(type="text/plain", body=b"strawberry", name="textFile.txt")
+        ]
+    }
+    ```
+
+    Note that the dictionary entries are lists.
+    """
+    request_files = cast("Optional[dict[str, list[File]]]", request.files)
+
+    if not request_files:
+        return {}
+
+    files_dict: dict[str, Union[File, list[File]]] = {}
+
+    for field_name, file_list in request_files.items():
+        assert len(file_list) == 1
+
+        files_dict[field_name] = file_list[0]
+
+    return files_dict
+
+
+class SanicHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        # Just a heads up, Sanic's request.args uses urllib.parse.parse_qs
+        # to parse query string parameters. This returns a dictionary where
+        # the keys are the unique variable names and the values are lists
+        # of values for each variable name. To ensure consistency, we're
+        # enforcing the use of the first value in each list.
+        args = self.request.get_args(keep_blank_values=True)
+        return {k: args.get(k, None) for k in args}
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
+
+    async def get_body(self) -> bytes:
+        return self.request.body
+
+    async def get_form_data(self) -> FormData:
+        assert self.request.form is not None
+
+        files = convert_request_to_files_dict(self.request)
+
+        return FormData(form=self.request.form, files=files)
+
+    @property
+    def url(self) -> str:
+        return self.request.url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return self.request.cookies

cross/request/_starlette.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Mapping, Optional, cast
+
+from ._base import AsyncHTTPRequestAdapter, FormData, HTTPMethod, QueryParams
+
+if TYPE_CHECKING:
+    from starlette.requests import Request
+
+
+class StarletteRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self._request = request
+        # Starlette Headers are case-insensitive Mapping
+        self._headers: Optional[Mapping[str, str]] = None
+
+    @property
+    def method(self) -> HTTPMethod:
+        # Starlette method is already uppercase string
+        return cast(HTTPMethod, self._request.method)
+
+    @property
+    def query_params(self) -> QueryParams:
+        # Starlette QueryParams behaves like a MultiDict Mapping
+        return cast(QueryParams, self._request.query_params)
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        # Cache the immutable headers object for direct access
+        # Starlette Headers are case-insensitive
+        if self._headers is None:
+            self._headers = self._request.headers
+
+        return self._headers
+
+    @property
+    def content_type(self) -> Optional[str]:
+        # Access directly via headers property for consistency
+        return self.headers.get("content-type")
+
+    async def get_body(self) -> bytes:
+        return await self._request.body()
+
+    async def get_form_data(self) -> FormData:
+        multipart_data = await self._request.form()
+
+        return FormData(
+            files=multipart_data,
+            form=multipart_data,
+        )
+
+    @property
+    def url(self) -> str:
+        return str(self._request.url)
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return cast(Mapping[str, str], self._request.cookies)

cross/request/_testing.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Mapping, Optional
+
+from ._base import AsyncHTTPRequestAdapter, FormData, HTTPMethod, QueryParams
+
+
+class TestingRequestAdapter(AsyncHTTPRequestAdapter):
+    __test__ = False
+
+    def __init__(
+        self,
+        *,
+        method: HTTPMethod = "POST",
+        query_params: QueryParams | None = None,
+        headers: Mapping[str, str] | None = None,
+        content_type: str | None = None,
+        url: str = "http://testserver/",
+        cookies: Mapping[str, str] | None = None,
+        form_data: FormData | None = None,
+        json: dict[str, Any] | None = None,
+    ) -> None:
+        self._method = method
+        self._query_params = query_params or {}
+        self._headers = headers or {}
+        self._content_type = content_type
+        self._url = url
+        self._cookies = cookies or {}
+        self._form_data = form_data or FormData(files={}, form={})
+        self._json = json
+
+    @property
+    def method(self) -> HTTPMethod:
+        return self._method
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self._query_params
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self._headers
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self._content_type
+
+    async def get_body(self) -> bytes:
+        if self._json is not None:
+            return json.dumps(self._json).encode("utf-8")
+
+        return b""
+
+    async def get_form_data(self) -> FormData:
+        return self._form_data
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        return self._cookies

cross/response.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal, Mapping, List, Union, cast
+from typing_extensions import Self
+from urllib.parse import urlencode
+
+if TYPE_CHECKING:
+    from fastapi import Response as FastAPIResponse
+
+JsonType = Union[
+    str, int, float, bool, None, Mapping[str, "JsonType"], List["JsonType"]
+]
+
+
+@dataclass
+class Cookie:
+    name: str
+    value: str
+    secure: bool
+    path: str | None = None
+    domain: str | None = None
+    max_age: int | None = None
+    httponly: bool = True
+    samesite: Literal["lax", "strict", "none"] = "lax"
+
+
+@dataclass
+class Response:
+    status_code: int
+    body: str | None = None
+    cookies: list[Cookie] | None = None
+    headers: Mapping[str, str] | None = None
+
+    @classmethod
+    def redirect(
+        cls,
+        url: str,
+        query_params: Mapping[str, str | list[str]] | None = None,
+        headers: Mapping[str, str] | None = None,
+        cookies: list[Cookie] | None = None,
+    ) -> Self:
+        headers = headers or {}
+
+        if query_params:
+            url = url + "?" + urlencode(query_params)
+
+        return cls(
+            status_code=302,
+            headers={"Location": url, **headers},
+            cookies=cookies,
+        )
+
+    def json(self) -> JsonType:
+        if self.body is None:
+            return None
+
+        return cast(JsonType, json.loads(self.body))
+
+    def to_fastapi(self) -> FastAPIResponse:
+        from fastapi import Response as FastAPIResponse
+
+        response = FastAPIResponse(
+            status_code=self.status_code,
+            headers=self.headers,
+            content=self.body,
+        )
+
+        for cookie in self.cookies or []:
+            response.set_cookie(
+                cookie.name,
+                cookie.value,
+                secure=cookie.secure,
+                path=cookie.path,
+                domain=cookie.domain,
+                max_age=cookie.max_age,
+                httponly=cookie.httponly,
+                samesite=cookie.samesite,
+            )
+
+        return response

cross_web-0.2.3.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: cross-web
+Version: 0.2.3
+Summary: A library for working with web frameworks
+Author-email: Patrick Arminio <patrick.arminio@gmail.com>
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: typing-extensions>=4.14.0
+Description-Content-Type: text/markdown
+
+# Cross
+
+**Write once, run everywhere** - A universal web framework adapter for Python that lets you write code once and use it across multiple web frameworks.
+
+## Installation
+
+```bash
+uv add cross-web
+```
+
+## Overview
+
+Cross provides a unified interface for common web framework operations, allowing you to write framework-agnostic code that can be easily adapted to work with FastAPI, Flask, Django, and other popular Python web frameworks.
+
+## Features
+
+This project is in early development!

cross_web-0.2.3.dist-info/RECORD

@@ -0,0 +1,20 @@
+cross/__init__.py,sha256=Lqg9wnEAyU1Kk67dF7dlU_ZmyQvMJt5PisTFCeXBG2Y,1336
+cross/exceptions.py,sha256=uVWXNel6yjRHIEazdtthgFBKCF36mskOU3kmhJR1eXU,226
+cross/protocols.py,sha256=NEItrqqj1LKKUjBOzpNTn3vLCDUWsV9e_yaDlN9rq1I,478
+cross/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cross/response.py,sha256=8kiJjv6OoL2lKKZaay5MBx8BxDxW6poyA1rA6Gca_48,2096
+cross/request/__init__.py,sha256=pgyFbIFYAP3RpZkS947AvUJ8d-2ev4WWhj_9r2E6_d8,3965
+cross/request/_aiohttp.py,sha256=sPRuQnInX64LviaLAKXEsyNQ-sYLVGdPliLIWi4J3sc,3573
+cross/request/_base.py,sha256=kllXikX7S6ZFQWcNs2KYhAbKibEbTsAEtRlp0smoXhg,4330
+cross/request/_chalice.py,sha256=SN62ryIFYOdHO6nJx6lE_4MuluAq_1L5PnQsi-Uwb1c,2730
+cross/request/_django.py,sha256=CMlRlC7m4n_pfclUMuo7r6-TPLki9soF-tu41ac-o6w,2961
+cross/request/_flask.py,sha256=c80Xovg31XSsKO5o9og_RgM4kli1I1NXVe7P8MGYy1k,2433
+cross/request/_litestar.py,sha256=mSPMaqAuR2J-vBDgeB6QN5pFZ1jfuDrWOZnFbkH90FQ,1404
+cross/request/_quart.py,sha256=9ICIpoALCk7Op5ggyIuU7CdHqlLaaowanH5ZNnSdDkQ,1211
+cross/request/_sanic.py,sha256=QfVpXwdj0RF20xkZysq1LuLV6V0r_j0I10ukEtVsiRc,2485
+cross/request/_starlette.py,sha256=bxL4TYkWh-OAjZSht_benXr40TNLDtVj7UaqGBfaXf0,1775
+cross/request/_testing.py,sha256=ja10a1pQSYBzYAN10ce9e5aEpyD9-HBLTWH76hqWK5g,1712
+cross_web-0.2.3.dist-info/METADATA,sha256=uOEg3q9a78xO_XLG4f8ni32dRUB0-LN4JllC3vXSczA,1064
+cross_web-0.2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cross_web-0.2.3.dist-info/licenses/LICENSE,sha256=a-9NtzEY0MYsJLrhMKR7HQsqmfTjYx_A1Mw6dwXer18,1073
+cross_web-0.2.3.dist-info/RECORD,,

cross_web-0.2.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cross_web-0.2.3.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Patrick Arminio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+