tina4-python 3.10.90__tar.gz → 3.10.93__tar.gz

{tina4_python-3.10.90 → tina4_python-3.10.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.10.90
+Version: 3.10.93
 Summary: Tina4 for Python — 54 built-in features, zero dependencies
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/Testing.py

@@ -18,8 +18,8 @@ Usage:
         return a + b
 
 Run all tests:
-    from tina4_python.Testing import run_all_tests
-    run_all_tests()
+    from tina4_python.Testing import run_all
+    run_all()
 """
 
 import sys
@@ -58,7 +58,7 @@ def tests(*assertions):
     """Decorator that attaches inline test assertions to a function.
 
     The decorated function is returned unchanged; the assertions are
-    stored in a global registry and executed by ``run_all_tests()``.
+    stored in a global registry and executed by ``run_all()``.
     """
     def decorator(fn):
         _registry.append({
@@ -73,7 +73,7 @@ def tests(*assertions):
 
 # ── Runner ──────────────────────────────────────────────────────────
 
-def run_all_tests(quiet: bool = False, failfast: bool = False) -> dict:
+def run_all(quiet: bool = False, failfast: bool = False) -> dict:
     """Discover and run every ``@tests``-decorated function.
 
     Returns a dict with keys ``passed``, ``failed``, ``errors``, ``details``.
@@ -171,6 +171,11 @@ def _assertion_label(assertion: dict, fn_name: str) -> str:
     return f"{fn_name} [{atype}]"
 
 
+def reset():
+    """Reset the test registry (useful between test runs)."""
+    _registry.clear()
+
+
 def _print_summary(results: dict, quiet: bool):
     if quiet:
         return

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.10.90"
+__version__ = "3.10.93"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/api/__init__.py

@@ -35,6 +35,7 @@ class Api:
         """Add custom headers to all requests."""
         self._headers.update(headers)
 
+
     def set_basic_auth(self, username: str, password: str):
         """Set Basic authentication."""
         creds = base64.b64encode(f"{username}:{password}".encode()).decode()
@@ -67,7 +68,7 @@ class Api:
         """HTTP DELETE request."""
         return self._request("DELETE", self._url(path), body)
 
-    def send(self, method: str, path: str = "", body=None,
+    def send_request(self, method: str, path: str = "", body=None,
              content_type: str = "application/json") -> dict:
         """Generic request method."""
         return self._request(method.upper(), self._url(path), body, content_type)

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/auth/__init__.py

@@ -69,14 +69,18 @@ class Auth:
     # ── JWT ────────────────────────────────────────────────────────
 
     @_DualMethod
-    def get_token(self, payload: dict, expires_in: int = None) -> str:
+    def get_token(self, payload: dict, expires_in: int = None, secret: str = None) -> str:
         """Create a signed JWT token.
 
         Args:
             expires_in: Lifetime in minutes (default: self.expires_in).
+            secret:     Override signing secret (default: self.secret / SECRET env var).
 
         Returns: header.payload.signature
         """
+        if secret is not None:
+            return Auth(secret=secret, algorithm=self.algorithm,
+                        expires_in=self.expires_in).get_token(payload, expires_in=expires_in)
         exp_minutes = expires_in if expires_in is not None else self.expires_in
         exp_seconds = exp_minutes * 60
 
@@ -193,14 +197,6 @@ class Auth:
         auth = cls(secret=secret)
         return auth.authenticate_request(headers)
 
-    @staticmethod
-    def validate_api_key_static(provided: str, expected: str = None) -> bool:
-        """Validate an API key without instantiating Auth.
-
-        Alias for validate_api_key (already a staticmethod).
-        """
-        return Auth.validate_api_key(provided, expected)
-
     # ── Password Hashing ──────────────────────────────────────────
 
     @staticmethod
@@ -258,9 +254,13 @@ class Auth:
     # ── Request Auth Helper ───────────────────────────────────────
 
     @_DualMethod
-    def authenticate_request(self, headers: dict) -> dict | None:
+    def authenticate_request(self, headers: dict, secret: str = None, algorithm: str = "HS256") -> dict | None:
         """Extract and validate auth from request headers.
 
+        Args:
+            secret:    Override signing secret (default: self.secret / SECRET env var).
+            algorithm: JWT algorithm override (default: "HS256").
+
         Checks: Bearer JWT, Bearer API key, Basic auth.
         Returns payload dict on success, None on failure.
         """
@@ -300,8 +300,10 @@ def _b64url_decode(s: str) -> bytes:
 
 # ── Module-level convenience functions (use static methods) ────
 
-def get_token(payload: dict, expires_in: int = 60) -> str:
+def get_token(payload: dict, expires_in: int = 60, secret: str = None) -> str:
     """Create a JWT — reads SECRET from env. Shortcut for Auth.get_token_static()."""
+    if secret is not None:
+        return Auth(secret=secret).get_token(payload, expires_in=expires_in)
     return Auth.get_token_static(payload, expires_in=expires_in)
 
 
@@ -320,8 +322,10 @@ def refresh_token(token: str, expires_in: int = 60) -> str | None:
     return Auth.refresh_token_static(token, expires_in=expires_in)
 
 
-def authenticate_request(headers: dict) -> dict | None:
+def authenticate_request(headers: dict, secret: str = None, algorithm: str = "HS256") -> dict | None:
     """Validate auth from request headers — reads SECRET from env."""
+    if secret is not None:
+        return Auth(secret=secret).authenticate_request(headers, algorithm=algorithm)
     return Auth.authenticate_request_static(headers)
 
 

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/cache/__init__.py

@@ -591,6 +591,11 @@ class ResponseCache:
                 "backend": self._backend.name(),
             }
 
+    def sweep(self) -> int:
+        """Remove all expired entries. Returns count removed."""
+        self._cleanup_expired()
+        return 0
+
     def clear_cache(self) -> None:
         """Flush all cached entries and reset stats."""
         with self._lock:
@@ -709,6 +714,11 @@ def cache_delete(key: str) -> bool:
     return _get_backend().delete(key)
 
 
+def sweep() -> int:
+    """Remove expired entries from the cache. Returns count removed."""
+    return _get_backend().sweep() if hasattr(_get_backend(), "sweep") else 0
+
+
 def cache_clear():
     """Clear all entries from the cache."""
     _get_backend().clear()

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/cli/__init__.py

@@ -396,12 +396,12 @@ def _migrate(args):
     """Run pending migrations."""
     _load_env()
     from tina4_python.database import Database
-    from tina4_python.migration import migrate
+    from tina4_python.migration import Migration
 
     db_url = os.environ.get("DATABASE_URL", "sqlite:///data/app.db")
     db = Database(db_url)
     mig_dir = args[0] if args else "migrations"
-    ran = migrate(db, mig_dir)
+    ran = Migration(db, mig_dir).migrate()
     if ran:
         for f in ran:
             print(f"  Migrated: {f}")
@@ -426,12 +426,12 @@ def _migrate_rollback(args):
     """Rollback the last migration batch."""
     _load_env()
     from tina4_python.database import Database
-    from tina4_python.migration import rollback
+    from tina4_python.migration import Migration
 
     db_url = os.environ.get("DATABASE_URL", "sqlite:///data/app.db")
     db = Database(db_url)
     mig_dir = args[0] if args else "migrations"
-    rolled = rollback(db, mig_dir)
+    rolled = Migration(db, mig_dir).rollback()
     if rolled:
         for f in rolled:
             print(f"  Rolled back: {f}")
@@ -445,11 +445,11 @@ def _migrate_status(args):
     """Show migration status."""
     _load_env()
     from tina4_python.database import Database
-    from tina4_python.migration import status
+    from tina4_python.migration import Migration
 
     db_url = os.environ.get("DATABASE_URL", "sqlite:///data/app.db")
     db = Database(db_url)
-    result = status(db, args[0] if args else "migrations")
+    result = Migration(db, args[0] if args else "migrations").status()
     completed, pending = result["completed"], result["pending"]
 
     if completed:

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/core/__init__.py

@@ -19,7 +19,7 @@ from tina4_python.core.router import (
 from tina4_python.core.middleware import CorsMiddleware, RateLimiter
 from tina4_python.core.cache import Cache
 from tina4_python.core.events import on, off, emit, emit_async, once, listeners, events, clear as clear_events
-from tina4_python.core.server import run, resolve_config, handle
+from tina4_python.core.server import run, resolve_config, handle, start, stop
 
 __all__ = [
     "Request", "Response", "Router",
@@ -28,5 +28,5 @@ __all__ = [
     "CorsMiddleware", "RateLimiter",
     "Cache",
     "on", "off", "emit", "emit_async", "once", "listeners", "events", "clear_events",
-    "run", "resolve_config", "handle",
+    "run", "resolve_config", "handle", "start", "stop",
 ]

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/core/middleware.py

@@ -1,32 +1,108 @@
-# Tina4 Middleware — CORS, Rate Limiter, CSRF.
+# Tina4 Middleware — orchestrator plus built-in middleware classes.
 """
-Built-in middleware for cross-origin requests, rate limiting, and CSRF protection.
-Zero dependencies — stdlib only.
+Standardized middleware orchestrator and built-in middleware.
+
+Middleware classes follow a simple convention:
+    - Static methods named ``before_*`` run BEFORE the route handler
+    - Static methods named ``after_*`` run AFTER the route handler
+    - Each method receives ``(request, response)`` and returns ``(request, response)``
+    - If a before method sets the response status to >= 400, the chain short-circuits
 
-    from tina4_python.core.middleware import CorsMiddleware, RateLimiter, CsrfMiddleware
+Usage::
 
-CORS is configured via environment variables:
-    TINA4_CORS_ORIGINS=*                    # Allowed origins (* = all)
-    TINA4_CORS_METHODS=GET,POST,PUT,DELETE  # Allowed methods
-    TINA4_CORS_HEADERS=Content-Type,Authorization
-    TINA4_CORS_MAX_AGE=86400               # Preflight cache (seconds)
+    from tina4_python.core.middleware import Middleware, CorsMiddleware
 
-Rate limiter uses a sliding window in memory:
-    TINA4_RATE_LIMIT=100                   # Requests per window
-    TINA4_RATE_WINDOW=60                   # Window in seconds
+    Middleware.use(CorsMiddleware)
+    request, response = Middleware.run_before([CorsMiddleware], request, response)
+    request, response = Middleware.run_after([RequestLoggerMiddleware], request, response)
 
-CSRF protection (off by default):
-    TINA4_CSRF=true                        # Enable CSRF token validation
+Zero dependencies — stdlib only.
 """
 import os
 import time
 import logging
 import threading
 
+from tina4_python.core.rate_limiter import RateLimiter  # noqa: F401 — re-export for backward compat
+
+
+class Middleware:
+    """Standardized middleware orchestrator.
+
+    Registers middleware classes globally and runs their ``before_*`` /
+    ``after_*`` static methods in alphabetical order. Mirrors the PHP,
+    Ruby and Node.js orchestrators.
+    """
+
+    _global_middleware: list = []
+
+    @classmethod
+    def use(cls, middleware_class) -> None:
+        """Register a middleware class to run on every request."""
+        if middleware_class not in cls._global_middleware:
+            cls._global_middleware.append(middleware_class)
+
+    @classmethod
+    def get_global(cls) -> list:
+        """Return the list of globally registered middleware classes."""
+        return list(cls._global_middleware)
+
+    @classmethod
+    def reset(cls) -> None:
+        """Clear all globally registered middleware (primarily for tests)."""
+        cls._global_middleware = []
+
+    @classmethod
+    def run_before(cls, middleware_classes, request, response):
+        """Run every ``before_*`` static method on the given classes.
+
+        Short-circuits if the response status becomes >= 400.
+        Returns ``(request, response)``.
+        """
+        for mw_class in middleware_classes:
+            for method_name in cls._discover_methods(mw_class, "before_"):
+                result = getattr(mw_class, method_name)(request, response)
+                if isinstance(result, tuple) and len(result) >= 2:
+                    request, response = result[0], result[1]
+                status = getattr(response, "status_code", None) or getattr(response, "status", 0)
+                if isinstance(status, int) and status >= 400:
+                    return request, response
+        return request, response
+
+    @classmethod
+    def run_after(cls, middleware_classes, request, response):
+        """Run every ``after_*`` static method on the given classes."""
+        for mw_class in middleware_classes:
+            for method_name in cls._discover_methods(mw_class, "after_"):
+                result = getattr(mw_class, method_name)(request, response)
+                if isinstance(result, tuple) and len(result) >= 2:
+                    request, response = result[0], result[1]
+        return request, response
+
+    @staticmethod
+    def _discover_methods(mw_class, prefix: str) -> list:
+        """Return sorted list of public static method names with ``prefix``."""
+        names = [
+            name
+            for name in dir(mw_class)
+            if name.startswith(prefix) and callable(getattr(mw_class, name, None))
+        ]
+        return sorted(names)
+
 
 class CorsMiddleware:
     """CORS handler — reads config from env, injects headers."""
 
+    @staticmethod
+    def before_cors(request, response):
+        """Inject CORS headers on every request (class-based middleware convention)."""
+        instance = CorsMiddleware()
+        if instance.is_preflight(request):
+            instance.apply(request, response)
+            return request, response
+        instance.apply(request, response)
+        return request, response
+
     def __init__(self):
         self.origins = os.environ.get("TINA4_CORS_ORIGINS", "*")
         self.methods = os.environ.get(
@@ -74,73 +150,44 @@ class CorsMiddleware:
         )
 
 
-class RateLimiter:
-    """Sliding window rate limiter — per-IP, in-memory.
+class RateLimiterMiddleware:
+    """Static rate limiter middleware — tracks requests per IP, returns 429 when exceeded.
 
-    Thread-safe. Automatically cleans up expired entries.
+    Config via env: TINA4_RATE_LIMIT (default 100), TINA4_RATE_WINDOW (default 60s).
+    Delegates to the RateLimiter class for the actual sliding window logic.
     """
 
-    def __init__(self):
-        self.limit = int(os.environ.get("TINA4_RATE_LIMIT", "100"))
-        self.window = int(os.environ.get("TINA4_RATE_WINDOW", "60"))
-        self._requests: dict[str, list[float]] = {}
-        self._lock = threading.Lock()
-        self._last_cleanup = time.monotonic()
+    _limiter = None
+    _lock = threading.Lock()
 
-    def check(self, ip: str) -> tuple[bool, dict]:
-        """Check if request is allowed.
+    @classmethod
+    def _get_limiter(cls):
+        with cls._lock:
+            if cls._limiter is None:
+                cls._limiter = RateLimiter()
+            return cls._limiter
 
-        Returns (allowed, info) where info has remaining/limit/reset fields.
-        """
-        now = time.monotonic()
-
-        with self._lock:
-            # Periodic cleanup every 60 seconds
-            if now - self._last_cleanup > 60:
-                self._cleanup(now)
-                self._last_cleanup = now
-
-            if ip not in self._requests:
-                self._requests[ip] = []
-
-            # Remove expired timestamps
-            cutoff = now - self.window
-            timestamps = self._requests[ip]
-            self._requests[ip] = [t for t in timestamps if t > cutoff]
-            timestamps = self._requests[ip]
-
-            remaining = max(0, self.limit - len(timestamps))
-            reset = int(self.window - (now - timestamps[0])) if timestamps else self.window
-
-            if len(timestamps) >= self.limit:
-                return False, {
-                    "limit": self.limit,
-                    "remaining": 0,
-                    "reset": reset,
-                    "window": self.window,
-                }
-
-            timestamps.append(now)
-            return True, {
-                "limit": self.limit,
-                "remaining": remaining - 1,
-                "reset": self.window,
-                "window": self.window,
-            }
-
-    def _cleanup(self, now: float):
-        """Remove IPs with no recent requests."""
-        cutoff = now - self.window
-        expired = [ip for ip, ts in self._requests.items() if not ts or ts[-1] < cutoff]
-        for ip in expired:
-            del self._requests[ip]
-
-    def apply_headers(self, response, info: dict):
-        """Add rate limit headers to response."""
-        response.header("x-ratelimit-limit", str(info["limit"]))
-        response.header("x-ratelimit-remaining", str(info["remaining"]))
-        response.header("x-ratelimit-reset", str(info["reset"]))
-        return response
+    @staticmethod
+    def before_rate_limit(request, response):
+        """Middleware hook — enforces rate limiting before the route handler."""
+        limiter = RateLimiterMiddleware._get_limiter()
+        ip = getattr(request, "ip", None) or "unknown"
+        allowed, info = limiter.check(ip)
+        limiter.apply_headers(response, info)
+        if not allowed:
+            retry_after = max(1, int(info.get("reset", limiter.window)))
+            response.header("retry-after", str(retry_after))
+            if hasattr(response, "error"):
+                response.error("Too Many Requests", f"Rate limit exceeded. Retry in {retry_after}s.", 429)
+            else:
+                setattr(response, "status_code", 429)
+        return request, response
+
+    @staticmethod
+    def check(ip: str):
+        """Check if an IP is within rate limits. Returns (allowed, info)."""
+        limiter = RateLimiterMiddleware._get_limiter()
+        return limiter.check(ip)
 
 
 class SecurityHeadersMiddleware:
@@ -308,3 +355,37 @@ class CsrfMiddleware:
                 )
 
         return request, response
+
+
+class RequestLoggerMiddleware:
+    """Request logger — stamps start time before the handler and logs elapsed time after.
+
+    Mirrors the PHP, Ruby and Node.js RequestLogger classes.
+    """
+
+    _logger = logging.getLogger("tina4.request")
+    _start_times: dict = {}
+    _lock = threading.Lock()
+
+    @staticmethod
+    def before_log(request, response):
+        """Record the request start time."""
+        key = id(request)
+        with RequestLoggerMiddleware._lock:
+            RequestLoggerMiddleware._start_times[key] = time.monotonic()
+        return request, response
+
+    @staticmethod
+    def after_log(request, response):
+        """Log the request method, path, status code, and elapsed time."""
+        key = id(request)
+        with RequestLoggerMiddleware._lock:
+            start = RequestLoggerMiddleware._start_times.pop(key, None)
+        elapsed_ms = round((time.monotonic() - start) * 1000, 3) if start is not None else 0.0
+        method = getattr(request, "method", "?")
+        path = getattr(request, "url", None) or getattr(request, "path", "/")
+        status = getattr(response, "status_code", None) or getattr(response, "status", 0)
+        RequestLoggerMiddleware._logger.info(
+            "[RequestLogger] %s %s -> %s (%sms)", method, path, status, elapsed_ms
+        )
+        return request, response

tina4_python-3.10.93/tina4_python/core/rate_limiter.py

@@ -0,0 +1,130 @@
+# Tina4 RateLimiter — sliding window per-IP rate limiter.
+"""
+In-memory sliding window rate limiter.
+
+Thread-safe. Automatically cleans up expired entries.
+Reads configuration from environment variables:
+    TINA4_RATE_LIMIT  — max requests per window (default: 100)
+    TINA4_RATE_WINDOW — window duration in seconds (default: 60)
+"""
+import os
+import time
+import threading
+
+
+class RateLimiter:
+    """Sliding window rate limiter — per-IP, in-memory.
+
+    Thread-safe. Automatically cleans up expired entries.
+    """
+
+    _shared_instance = None
+    _shared_lock = threading.Lock()
+
+    @classmethod
+    def _shared(cls) -> "RateLimiter":
+        with cls._shared_lock:
+            if cls._shared_instance is None:
+                cls._shared_instance = cls()
+            return cls._shared_instance
+
+    @staticmethod
+    def before_rate_limit(request, response):
+        """Class-based middleware entry point — enforces the shared rate limit."""
+        limiter = RateLimiter._shared()
+        ip = getattr(request, "ip", None) or "unknown"
+        allowed, info = limiter.check(ip)
+        limiter.apply_headers(response, info)
+        if not allowed:
+            retry_after = max(1, int(info.get("reset", limiter.window)))
+            response.header("retry-after", str(retry_after))
+            if hasattr(response, "error"):
+                response.error("Too Many Requests", f"Rate limit exceeded. Retry in {retry_after}s.", 429)
+            else:
+                setattr(response, "status_code", 429)
+        return request, response
+
+    def __init__(self):
+        self.limit = int(os.environ.get("TINA4_RATE_LIMIT", "100"))
+        self.window = int(os.environ.get("TINA4_RATE_WINDOW", "60"))
+        self._requests: dict[str, list[float]] = {}
+        self._lock = threading.Lock()
+        self._last_cleanup = time.monotonic()
+
+    def check(self, ip: str) -> tuple[bool, dict]:
+        """Check if request is allowed.
+
+        Returns (allowed, info) where info has remaining/limit/reset fields.
+        """
+        now = time.monotonic()
+
+        with self._lock:
+            # Periodic cleanup every 60 seconds
+            if now - self._last_cleanup > 60:
+                self._cleanup(now)
+                self._last_cleanup = now
+
+            if ip not in self._requests:
+                self._requests[ip] = []
+
+            # Remove expired timestamps
+            cutoff = now - self.window
+            timestamps = self._requests[ip]
+            self._requests[ip] = [t for t in timestamps if t > cutoff]
+            timestamps = self._requests[ip]
+
+            remaining = max(0, self.limit - len(timestamps))
+            reset = int(self.window - (now - timestamps[0])) if timestamps else self.window
+
+            if len(timestamps) >= self.limit:
+                return False, {
+                    "limit": self.limit,
+                    "remaining": 0,
+                    "reset": reset,
+                    "window": self.window,
+                }
+
+            timestamps.append(now)
+            return True, {
+                "limit": self.limit,
+                "remaining": remaining - 1,
+                "reset": self.window,
+                "window": self.window,
+            }
+
+    def _cleanup(self, now: float):
+        """Remove IPs with no recent requests."""
+        cutoff = now - self.window
+        expired = [ip for ip, ts in self._requests.items() if not ts or ts[-1] < cutoff]
+        for ip in expired:
+            del self._requests[ip]
+
+    def apply(self, request, response):
+        """Apply rate limiting to a request/response pair.
+
+        Checks the IP, sets headers, and returns 429 if over limit.
+        Returns (request, response).
+        """
+        ip = getattr(request, "ip", None) or "unknown"
+        allowed, info = self.check(ip)
+        self.apply_headers(response, info)
+        if not allowed:
+            retry_after = max(1, int(info.get("reset", self.window)))
+            response.header("retry-after", str(retry_after))
+            if hasattr(response, "error"):
+                response.error("Too Many Requests", f"Rate limit exceeded. Retry in {retry_after}s.", 429)
+            else:
+                setattr(response, "status_code", 429)
+        return request, response
+
+    def reset(self):
+        """Clear all tracked request data."""
+        with self._lock:
+            self._requests.clear()
+
+    def apply_headers(self, response, info: dict):
+        """Add rate limit headers to response."""
+        response.header("x-ratelimit-limit", str(info["limit"]))
+        response.header("x-ratelimit-remaining", str(info["remaining"]))
+        response.header("x-ratelimit-reset", str(info["reset"]))
+        return response

{tina4_python-3.10.90 → tina4_python-3.10.93}/tina4_python/core/request.py

@@ -106,6 +106,20 @@ class Request:
         """Get a route parameter (from URL path). Alias for params[key]."""
         return self.params.get(key, self._route_params.get(key, default))
 
+    def header(self, name: str) -> str | None:
+        """Get a specific header value by name (case-insensitive)."""
+        return self.headers.get(name.lower().replace("-", "_"), self.headers.get(name.lower(), None))
+
+    def bearer_token(self) -> str | None:
+        """Extract the Bearer token from the Authorization header."""
+        auth = self.headers.get("authorization", "")
+        if auth.lower().startswith("bearer "):
+            return auth[7:]
+        return None
+
+    def parse_body(self) -> dict | str | None:
+        """Parse the raw body based on content type. Returns the parsed result."""
+        return _parse_body(self.raw_body, self.content_type)
 
 
 def _extract_ip(scope: dict, headers: dict) -> str: