python-in-underwear 0.5.0__py3-none-any.whl

piu/templating.py

@@ -0,0 +1,30 @@
+try:
+    from jinja2 import Environment, FileSystemLoader, select_autoescape
+    JINJA2_AVAILABLE = True
+except ImportError:
+    JINJA2_AVAILABLE = False
+
+
+class TemplateEngine:
+    def __init__(self, template_dir: str = "templates"):
+        if not JINJA2_AVAILABLE:
+            raise RuntimeError(
+                "Jinja2 is required for template rendering.\n"
+                "Install it with: pip install jinja2"
+            )
+        self.env = Environment(
+            loader=FileSystemLoader(template_dir),
+            autoescape=select_autoescape(["html", "xml"])
+        )
+
+    def render(self, template_name: str, **context) -> str:
+        tmpl = self.env.get_template(template_name)
+        return tmpl.render(**context)
+
+    def render_string(self, source: str, **context) -> str:
+        """Render a raw template string instead of a file."""
+        tmpl = self.env.from_string(source)
+        return tmpl.render(**context)
+
+    def __repr__(self):
+        return f"<TemplateEngine dir={self.env.loader.searchpath}>"

piu/testing.py

@@ -0,0 +1,111 @@
+import asyncio
+import json as _json
+from urllib.parse import urlencode
+
+from .wrappers import Request, Response
+
+
+class TestClient:
+    def __init__(self, app):
+        self._app = app
+        self._cookies: dict[str, str] = {}
+
+    def _extract_cookies(self, response: Response):
+        for key, val in response.headers.items():
+            if key.lower() == "set-cookie":
+                for cookie_str in val.split("\n"):
+                    parts = [p.strip() for p in cookie_str.split(";")]
+                    if not parts:
+                        continue
+                    name, _, value = parts[0].partition("=")
+                    max_age = None
+                    for part in parts[1:]:
+                        if part.lower().startswith("max-age="):
+                            try:
+                                max_age = int(part.split("=", 1)[1])
+                            except ValueError:
+                                pass
+                    if max_age == 0:
+                        self._cookies.pop(name.strip(), None)
+                    else:
+                        self._cookies[name.strip()] = value.strip()
+
+    def _cookie_header(self) -> str:
+        return "; ".join(f"{k}={v}" for k, v in self._cookies.items())
+
+    def _request(self, method: str, path: str,
+                 headers: dict = None,
+                 body: bytes = b"",
+                 query: dict = None) -> "TestResponse":
+        hdrs = dict(headers or {})
+        if self._cookies:
+            hdrs.setdefault("Cookie", self._cookie_header())
+
+        req = Request(
+            method=method,
+            path=path,
+            headers=hdrs,
+            body=body,
+            query_params=query or {},
+        )
+
+        loop = asyncio.new_event_loop()
+        try:
+            raw: Response = loop.run_until_complete(self._app._dispatch(req))
+        finally:
+            loop.close()
+
+        raw = self._app._finalize(raw)
+        self._extract_cookies(raw)
+        return TestResponse(raw)
+
+    def get(self, path: str, query: dict = None, headers: dict = None) -> "TestResponse":
+        return self._request("GET", path, headers=headers, query=query)
+
+    def post(self, path: str, json=None, data: dict = None,
+             body: bytes = b"", headers: dict = None) -> "TestResponse":
+        hdrs = dict(headers or {})
+        if json is not None:
+            body = _json.dumps(json).encode()
+            hdrs["Content-Type"] = "application/json"
+        elif data is not None:
+            body = urlencode(data).encode()
+            hdrs["Content-Type"] = "application/x-www-form-urlencoded"
+        return self._request("POST", path, headers=hdrs, body=body)
+
+    def put(self, path: str, json=None, body: bytes = b"",
+            headers: dict = None) -> "TestResponse":
+        hdrs = dict(headers or {})
+        if json is not None:
+            body = _json.dumps(json).encode()
+            hdrs["Content-Type"] = "application/json"
+        return self._request("PUT", path, headers=hdrs, body=body)
+
+    def patch(self, path: str, json=None, body: bytes = b"",
+              headers: dict = None) -> "TestResponse":
+        hdrs = dict(headers or {})
+        if json is not None:
+            body = _json.dumps(json).encode()
+            hdrs["Content-Type"] = "application/json"
+        return self._request("PATCH", path, headers=hdrs, body=body)
+
+    def delete(self, path: str, headers: dict = None) -> "TestResponse":
+        return self._request("DELETE", path, headers=headers)
+
+
+class TestResponse:
+    def __init__(self, response: Response):
+        self._raw = response
+        self.status = response.status
+        self.headers = response.headers
+        self.content_type = response.content_type
+        self.body = response.body
+
+    def text(self) -> str:
+        return self.body.decode("utf-8")
+
+    def json(self):
+        return _json.loads(self.body)
+
+    def __repr__(self):
+        return f"<TestResponse {self.status}>"

piu/websocket.py

@@ -0,0 +1,67 @@
+import inspect
+from typing import Callable
+
+
+class WebSocket:
+    def __init__(self, scope: dict, receive: Callable, send: Callable):
+        self._scope = scope
+        self._receive = receive
+        self._send = send
+        self.path = scope.get("path", "/")
+        self.headers = {k.decode(): v.decode() for k, v in scope.get("headers", [])}
+        self.query_params = scope.get("query_string", b"").decode()
+
+    async def accept(self):
+        await self._send({"type": "websocket.accept"})
+
+    async def send_text(self, data: str):
+        await self._send({"type": "websocket.send", "text": data})
+
+    async def send_bytes(self, data: bytes):
+        await self._send({"type": "websocket.send", "bytes": data})
+
+    async def receive_text(self) -> str | None:
+        event = await self._receive()
+        if event["type"] == "websocket.disconnect":
+            return None
+        return event.get("text", "")
+
+    async def receive_bytes(self) -> bytes | None:
+        event = await self._receive()
+        if event["type"] == "websocket.disconnect":
+            return None
+        return event.get("bytes", b"")
+
+    async def close(self, code: int = 1000):
+        await self._send({"type": "websocket.close", "code": code})
+
+    def __repr__(self):
+        return f"<WebSocket {self.path}>"
+
+
+class WebSocketRoute:
+    def __init__(self, path: str, handler: Callable):
+        import re
+        self.path = path
+        self.handler = handler
+        regex = re.sub(r"<(\w+)>", r"(?P<\1>[^/]+)", path)
+        self.regex = re.compile(f"^{regex}$")
+
+    def match(self, path: str) -> dict | None:
+        m = self.regex.match(path)
+        return m.groupdict() if m else None
+
+
+class WebSocketRouter:
+    def __init__(self):
+        self._routes: list[WebSocketRoute] = []
+
+    def add(self, path: str, handler: Callable):
+        self._routes.append(WebSocketRoute(path, handler))
+
+    def resolve(self, path: str) -> tuple[Callable | None, dict]:
+        for route in self._routes:
+            params = route.match(path)
+            if params is not None:
+                return route.handler, params
+        return None, {}

piu/wrappers.py

@@ -0,0 +1,86 @@
+import json
+from http.cookies import SimpleCookie
+from typing import Any
+from urllib.parse import parse_qs
+
+
+class Request:
+    def __init__(self, method: str, path: str, headers: dict,
+                 body: bytes = b"", query_params: dict = None):
+        self.method = method.upper()
+        self.path = path
+        self.headers = headers
+        self.body = body
+        self.query_params = query_params or {}
+        self._json = None
+        self._cookies = None
+
+    def json(self) -> Any:
+        if self._json is None:
+            self._json = json.loads(self.body.decode("utf-8"))
+        return self._json
+
+    def form(self) -> dict:
+        return parse_qs(self.body.decode("utf-8"))
+
+    @property
+    def cookies(self) -> dict:
+        if self._cookies is None:
+            raw = self.headers.get("Cookie", self.headers.get("cookie", ""))
+            sc = SimpleCookie()
+            sc.load(raw)
+            self._cookies = {k: v.value for k, v in sc.items()}
+        return self._cookies
+
+    def __repr__(self):
+        return f"<Request {self.method} {self.path}>"
+
+
+class Response:
+    def __init__(self, body: Any = "", status: int = 200,
+                 content_type: str = "text/html", headers: dict = None):
+        self.status = status
+        self.headers = headers or {}
+        self.content_type = content_type
+        self._cookies = SimpleCookie()
+
+        if isinstance(body, (dict, list)):
+            self.body = json.dumps(body).encode("utf-8")
+            self.content_type = "application/json"
+        elif isinstance(body, str):
+            self.body = body.encode("utf-8")
+        elif isinstance(body, bytes):
+            self.body = body
+        else:
+            self.body = str(body).encode("utf-8")
+
+    @classmethod
+    def json(cls, data: Any, status: int = 200) -> "Response":
+        return cls(body=data, status=status, content_type="application/json")
+
+    @classmethod
+    def redirect(cls, location: str, status: int = 302) -> "Response":
+        r = cls(body="", status=status)
+        r.headers["Location"] = location
+        return r
+
+    def set_cookie(self, key: str, value: str, max_age: int = None,
+                   path: str = "/", httponly: bool = True,
+                   secure: bool = False, samesite: str = "Lax"):
+        self._cookies[key] = value
+        m = self._cookies[key]
+        if max_age is not None:
+            m["max-age"] = max_age
+        m["path"] = path
+        m["httponly"] = httponly
+        m["secure"] = secure
+        m["samesite"] = samesite
+
+    def delete_cookie(self, key: str, path: str = "/"):
+        self.set_cookie(key, "", max_age=0, path=path)
+
+    def _cookie_headers(self) -> list[tuple]:
+        return [("Set-Cookie", m.OutputString()) for m in self._cookies.values()]
+
+    def __repr__(self):
+        return f"<Response {self.status}>"