nercone-aki 0.1.0__tar.gz

nercone_aki-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.3
+Name: nercone-aki
+Version: 0.1.0
+Summary: FastAPI-inspired Web Application Framework
+Author: Nercone
+Author-email: Nercone <nercone@nercone.dev>
+License: MIT
+Requires-Dist: nercone-kaede
+Requires-Python: >=3.10
+Project-URL: GitHub, https://github.com/nercone-aki/aki/
+Description-Content-Type: text/markdown
+
+![](assets/aki.png)
+
+# Aki
+FastAPI-inspired Web Application Framework

nercone_aki-0.1.0/README.md

@@ -0,0 +1,4 @@
+![](assets/aki.png)
+
+# Aki
+FastAPI-inspired Web Application Framework

nercone_aki-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["uv_build>=0.9.5,<0.10.0"]
+build-backend = "uv_build"
+
+[project]
+name = "nercone-aki"
+version = "0.1.0"
+description = "FastAPI-inspired Web Application Framework"
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [ { name = "Nercone", email = "nercone@nercone.dev" } ]
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = [
+    "nercone-kaede"
+]
+
+[project.urls]
+GitHub = "https://github.com/nercone-aki/aki/"
+
+[tool.uv.build-backend]
+module-name = "aki"

nercone_aki-0.1.0/src/aki/__init__.py

@@ -0,0 +1,6 @@
+from .app import Aki
+from .responses import PlainTextResponse, HTMLResponse, JSONResponse, FileResponse, RedirectResponse
+
+from kaede import Request, Response, Listener, Callback, Headers, TLS, TLSInfo, TLSServerConfig as TLSConfig, Server, ServerConfig as Config, ServerHandler as Handler, WebSocket
+
+__all__ = ["Aki", "PlainTextResponse", "HTMLResponse", "JSONResponse", "FileResponse", "RedirectResponse", "Request", "Response", "Listener", "Callback", "Headers", "TLS", "TLSInfo", "TLSConfig", "Server", "Config", "Handler", "WebSocket"]

nercone_aki-0.1.0/src/aki/app.py

@@ -0,0 +1,20 @@
+from kaede import Request, Response, WebSocket, Callback
+from typing import Literal, Callable
+from .routing import Router
+
+class Aki(Callback):
+    def __init__(self):
+        super().__init__()
+        self.router = Router()
+
+    async def on_request(self, request: Request) -> Response:
+        return await self.router.dispatch(request, ws=None)
+
+    async def on_websocket(self, request: Request, ws: WebSocket):
+        await self.router.dispatch(request, ws=ws)
+
+    def add_route(self, path: str, *, methods: list[Literal["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"]] | None = None, callback: Callable) -> Callable:
+        return self.router.add_route(path, methods=methods, callback=callback)
+
+    def route(self, path: str, *, methods: list[Literal["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"]] | None = None) -> Callable:
+        return self.router.route(path, methods=methods)

nercone_aki-0.1.0/src/aki/responses.py

@@ -0,0 +1,56 @@
+import os
+import json
+from kaede import Response, Headers
+from pathlib import Path
+
+class PlainTextResponse(Response):
+    def __init__(self, content: str, *, status_code: int = 200, headers: Headers | None = None, compression: bool = True, file_range: tuple[int, int] | None = None):
+        self.body = content.encode()
+        self.status_code = status_code
+        self.headers = headers or Headers({})
+        self.content_type = "text/plain"
+        self.compression = compression
+        self.minification = False
+        self.file_range = file_range
+
+class HTMLResponse(Response):
+    def __init__(self, content: str, *, status_code: int = 200, headers: Headers | None = None, compression: bool = True, minification: bool = False, file_range: tuple[int, int] | None = None):
+        self.body = content.encode()
+        self.status_code = status_code
+        self.headers = headers or Headers({})
+        self.content_type = "text/html"
+        self.compression = compression
+        self.minification = minification
+        self.file_range = file_range
+
+class JSONResponse(Response):
+    def __init__(self, content: list | dict, *, status_code: int = 200, headers: Headers | None = None, compression: bool = True, file_range: tuple[int, int] | None = None):
+        self.body = json.dumps(content).encode()
+        self.status_code = status_code
+        self.headers = headers or Headers({})
+        self.content_type = "application/json"
+        self.compression = compression
+        self.minification = False
+        self.file_range = file_range
+
+class FileResponse(Response):
+    def __init__(self, path: os.PathLike | Path, *, status_code: int = 200, headers: Headers | None = None, content_type: str | None = None, compression: bool = True, minification: bool = False, file_range: tuple[int, int] | None = None):
+        self.body = path
+        self.status_code = status_code
+        self.headers = headers or Headers({})
+        self.content_type = content_type
+        self.compression = compression
+        self.minification = minification
+        self.file_range = file_range
+
+class RedirectResponse(Response):
+    def __init__(self, url: str, *, status_code: int = 307, headers: Headers | None = None):
+        self.body = None
+        self.status_code = status_code
+        self.headers = headers or Headers({})
+        self.content_type = None
+        self.compression = False
+        self.minification = False
+        self.file_range = None
+
+        self.headers.set("Location", url)

nercone_aki-0.1.0/src/aki/routing.py

@@ -0,0 +1,70 @@
+import re
+import inspect
+from typing import Callable, Literal
+from kaede import Request, Response, WebSocket
+from .responses import PlainTextResponse
+
+PARAM_RE = re.compile(r'\{(\w+)\}')
+
+def compile_path(path: str) -> re.Pattern:
+    parts = PARAM_RE.split(path)
+    regex_parts = []
+    for i, part in enumerate(parts):
+        if i % 2 == 0:
+            regex_parts.append(re.escape(part))
+        else:
+            regex_parts.append(f'(?P<{part}>[^/]+)')
+    return re.compile(''.join(regex_parts))
+
+class RouteEntry:
+    __slots__ = ('path', 'regex', 'methods', 'callback')
+
+    def __init__(self, path: str, methods: frozenset[str] | None, callback: Callable):
+        self.path = path
+        self.methods = methods
+        self.callback = callback
+        self.regex = compile_path(path)
+
+class Router:
+    def __init__(self):
+        self.routes: list[RouteEntry] = []
+
+    def add_route(self, path: str, *, methods: list[Literal["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"]] | None = None, callback: Callable) -> Callable:
+        normalized = frozenset(m.upper() for m in methods) if methods else None
+        self.routes.append(RouteEntry(path, normalized, callback))
+        return callback
+
+    def route(self, path: str, *, methods: list[Literal["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"]] | None = None) -> Callable:
+        def decorator(func: Callable) -> Callable:
+            self.add_route(path, methods=methods, callback=func)
+            return func
+        return decorator
+
+    async def dispatch(self, request: Request, ws: WebSocket | None) -> Response | None:
+        path = request.target.split('?', 1)[0]
+        method = request.method.upper()
+
+        allowed: set[str] = set()
+        path_matched = False
+
+        for entry in self.routes:
+            match = entry.regex.fullmatch(path)
+            if match is None:
+                continue
+            path_matched = True
+
+            if entry.methods is not None and method not in entry.methods:
+                allowed.update(entry.methods)
+                continue
+
+            result = entry.callback(request, ws, **match.groupdict())
+            if inspect.isawaitable(result):
+                result = await result
+            return result
+
+        if path_matched:
+            response = PlainTextResponse("Method Not Allowed", status_code=405)
+            response.headers.set("Allow", ", ".join(sorted(allowed)))
+            return response
+
+        return PlainTextResponse("Not Found", status_code=404)