lenapi 0.1.0__py3-none-any.whl

lenapi/request.py

@@ -0,0 +1,177 @@
+"""Convenient access to an incoming ASGI request."""
+
+import asyncio
+import json
+from email import policy
+from email.parser import BytesParser
+from http.cookies import SimpleCookie
+from pathlib import Path
+import time
+import uuid
+from urllib.parse import parse_qs
+
+from .response import HTTPException
+
+
+class UploadFile:
+    """An uploaded multipart file held in memory for a bounded request."""
+
+    def __init__(self, filename: str, content_type: str, data: bytes) -> None:
+        self.filename = Path(filename).name
+        self.content_type = content_type
+        self.size = len(data)
+        self._data = data
+
+    async def read(self) -> bytes:
+        return self._data
+
+    async def save_image(self, directory: str | Path, *, filename: str | None = None) -> str:
+        """Validate common image signatures and save safely; return the filename."""
+        image_types = (
+            (self._data.startswith(b"\xff\xd8\xff"), ".jpg", {"image/jpeg", "image/jpg"}),
+            (self._data.startswith(b"\x89PNG\r\n\x1a\n"), ".png", {"image/png"}),
+            (self._data.startswith((b"GIF87a", b"GIF89a")), ".gif", {"image/gif"}),
+            (self._data.startswith(b"RIFF") and self._data[8:12] == b"WEBP", ".webp", {"image/webp"}),
+            (self._data.startswith(b"BM"), ".bmp", {"image/bmp", "image/x-ms-bmp"}),
+        )
+        detected = next((extension for matches, extension, _types in image_types if matches), None)
+        allowed_types = next((types for matches, _extension, types in image_types if matches), set())
+        if detected is None or self.content_type.lower() not in allowed_types:
+            raise ValueError("Uploaded file is not a supported image or its content type does not match")
+        if filename:
+            requested = Path(filename).name
+            suffix = Path(requested).suffix.lower()
+            valid_suffixes = {".jpeg", ".jpg"} if detected == ".jpg" else {detected}
+            if suffix not in valid_suffixes:
+                raise ValueError("Image filename extension does not match its image content")
+            safe_name = requested
+        else:
+            safe_name = f"{uuid.uuid4().hex}{detected}"
+        if not safe_name or safe_name in {".", ".."}:
+            raise ValueError("Invalid image filename")
+        root = Path(directory).expanduser().resolve()
+        root.mkdir(parents=True, exist_ok=True)
+        destination = (root / safe_name).resolve()
+        if not destination.is_relative_to(root):
+            raise ValueError("Image destination must stay inside its upload directory")
+        await asyncio.to_thread(destination.write_bytes, self._data)
+        return safe_name
+
+
+class Request:
+    def __init__(self, scope: dict, receive, *, max_body_size: int | None = 10 * 1024 * 1024,
+                 body_timeout: float | None = 30.0) -> None:
+        self.scope = scope
+        self._receive = receive
+        self.max_body_size = max_body_size
+        self.body_timeout = body_timeout
+        self._body: bytes | None = None
+
+    @property
+    def method(self) -> str:
+        return self.scope["method"]
+
+    @property
+    def path(self) -> str:
+        return self.scope["path"]
+
+    @property
+    def client_ip(self) -> str | None:
+        """Client address from the ASGI connection; proxy headers are not trusted."""
+        client = self.scope.get("client")
+        return client[0] if client else None
+
+    @property
+    def path_params(self) -> dict[str, object]:
+        return self.scope.get("path_params", {})
+
+    @property
+    def headers(self) -> dict[str, str]:
+        """Request headers keyed by lowercase names."""
+        return {
+            name.decode("latin-1").lower(): value.decode("latin-1")
+            for name, value in self.scope.get("headers", [])
+        }
+
+    @property
+    def cookies(self) -> dict[str, str]:
+        """Incoming cookies parsed from the Cookie request header."""
+        cookie = SimpleCookie()
+        cookie.load(self.headers.get("cookie", ""))
+        return {name: morsel.value for name, morsel in cookie.items()}
+
+    @property
+    def query_params(self) -> dict[str, str | list[str]]:
+        parsed = parse_qs(self.scope.get("query_string", b"").decode("latin-1"), keep_blank_values=True)
+        return {key: values[0] if len(values) == 1 else values for key, values in parsed.items()}
+
+    async def body(self) -> bytes:
+        if self._body is None:
+            chunks = []
+            size = 0
+            deadline = time.monotonic() + self.body_timeout if self.body_timeout is not None else None
+            while True:
+                try:
+                    if deadline is None:
+                        message = await self._receive()
+                    else:
+                        remaining = deadline - time.monotonic()
+                        if remaining <= 0:
+                            raise asyncio.TimeoutError
+                        message = await asyncio.wait_for(self._receive(), timeout=remaining)
+                except asyncio.TimeoutError as exc:
+                    raise HTTPException(408, "Request body timed out") from exc
+                if message["type"] == "http.disconnect":
+                    break
+                chunk = message.get("body", b"")
+                size += len(chunk)
+                if self.max_body_size is not None and size > self.max_body_size:
+                    raise HTTPException(413, "Request body too large")
+                chunks.append(chunk)
+                if not message.get("more_body", False):
+                    break
+            self._body = b"".join(chunks)
+        return self._body
+
+    async def json(self):
+        return json.loads((await self.body()).decode("utf-8"))
+
+    async def form(self) -> dict[str, str | UploadFile | list[str | UploadFile]]:
+        """Parse URL-encoded or multipart form data, including file uploads."""
+        content_type = self.headers.get("content-type", "")
+        if content_type.lower().startswith("application/x-www-form-urlencoded"):
+            parsed = parse_qs((await self.body()).decode("utf-8"), keep_blank_values=True)
+            return {key: values[0] if len(values) == 1 else values for key, values in parsed.items()}
+        if not content_type.lower().startswith("multipart/form-data"):
+            raise HTTPException(415, "Expected form data")
+        raw = await self.body()
+        message = BytesParser(policy=policy.default).parsebytes(
+            f"Content-Type: {content_type}\r\nMIME-Version: 1.0\r\n\r\n".encode("latin-1") + raw
+        )
+        if not message.is_multipart():
+            raise HTTPException(400, "Invalid multipart form data")
+        values: dict[str, str | UploadFile | list[str | UploadFile]] = {}
+        for part in message.iter_parts():
+            name = part.get_param("name", header="content-disposition")
+            if not name:
+                continue
+            data = part.get_payload(decode=True) or b""
+            filename = part.get_filename()
+            value: str | UploadFile
+            if filename is not None:
+                value = UploadFile(filename, part.get_content_type(), data)
+            else:
+                charset = part.get_content_charset() or "utf-8"
+                try:
+                    value = data.decode(charset)
+                except (LookupError, UnicodeDecodeError) as exc:
+                    raise HTTPException(400, "Invalid form field encoding") from exc
+            if name in values:
+                existing = values[name]
+                if not isinstance(existing, list):
+                    values[name] = [existing, value]
+                else:
+                    existing.append(value)
+            else:
+                values[name] = value
+        return values

lenapi/response.py

@@ -0,0 +1,91 @@
+"""HTTP response types."""
+
+import json
+from collections.abc import Mapping
+from http.cookies import SimpleCookie
+from typing import Any
+import uuid
+
+
+def _json_default(value: Any):
+    if isinstance(value, uuid.UUID):
+        return str(value)
+    raise TypeError(f"Object of type {type(value).__name__} is not JSON serializable")
+
+
+class Response:
+    def __init__(
+        self,
+        content: bytes | str = b"",
+        *,
+        status_code: int = 200,
+        headers: Mapping[str, str] | None = None,
+        media_type: str = "text/plain; charset=utf-8",
+    ) -> None:
+        self.body = content.encode("utf-8") if isinstance(content, str) else content
+        self.status_code = status_code
+        self.headers = {"content-type": media_type, **(headers or {})}
+        self._cookies: list[str] = []
+
+    def set_cookie(
+        self,
+        key: str,
+        value: str,
+        *,
+        max_age: int | None = None,
+        expires: str | None = None,
+        path: str = "/",
+        domain: str | None = None,
+        secure: bool = False,
+        httponly: bool = False,
+        samesite: str | None = "lax",
+    ) -> None:
+        """Add a Set-Cookie header to this response."""
+        if not key or any(char in key for char in "=;, \t\r\n"):
+            raise ValueError("Invalid cookie name")
+        if samesite is not None and samesite.lower() not in {"lax", "strict", "none"}:
+            raise ValueError("samesite must be 'lax', 'strict', 'none', or None")
+        cookie = SimpleCookie()
+        cookie[key] = value
+        morsel = cookie[key]
+        morsel["path"] = path
+        if domain is not None:
+            morsel["domain"] = domain
+        if max_age is not None:
+            morsel["max-age"] = str(max_age)
+        if expires is not None:
+            morsel["expires"] = expires
+        if secure:
+            morsel["secure"] = True
+        if httponly:
+            morsel["httponly"] = True
+        if samesite is not None:
+            morsel["samesite"] = samesite.capitalize()
+        self._cookies.append(morsel.OutputString())
+
+    def delete_cookie(self, key: str, *, path: str = "/", domain: str | None = None) -> None:
+        """Expire a cookie by adding a matching deletion cookie."""
+        self.set_cookie(key, "", max_age=0, expires="Thu, 01 Jan 1970 00:00:00 GMT", path=path, domain=domain)
+
+    async def __call__(self, scope: dict, receive, send) -> None:
+        headers = [(k.lower().encode("latin-1"), v.encode("latin-1")) for k, v in self.headers.items()]
+        headers.extend((b"set-cookie", value.encode("latin-1")) for value in self._cookies)
+        headers.append((b"content-length", str(len(self.body)).encode("ascii")))
+        await send({"type": "http.response.start", "status": self.status_code, "headers": headers})
+        await send({"type": "http.response.body", "body": self.body})
+
+
+class JSONResponse(Response):
+    def __init__(self, content: Any, *, status_code: int = 200, headers: Mapping[str, str] | None = None) -> None:
+        body = json.dumps(content, ensure_ascii=False, separators=(",", ":"), default=_json_default).encode("utf-8")
+        super().__init__(body, status_code=status_code, headers=headers, media_type="application/json")
+
+
+class HTTPException(Exception):
+    """Raise an HTTP error from a route or framework helper."""
+
+    def __init__(self, status_code: int, detail: str, *, headers: Mapping[str, str] | None = None) -> None:
+        super().__init__(detail)
+        self.status_code = status_code
+        self.detail = detail
+        self.headers = headers or {}