Nexom 0.1.3__py3-none-any.whl → 1.0.1__py3-none-any.whl

nexom/app/path.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import os
+import re
+from mimetypes import guess_type
+from pathlib import Path as _Path
+from typing import Optional
+
+from ..core.error import (
+    PathNotFoundError,
+    PathlibTypeError,
+    PathInvalidHandlerTypeError,
+    PathHandlerMissingArgError,
+)
+from .request import Request
+from .response import Response, JsonResponse
+from .middleware import Middleware, MiddlewareChain, Handler
+
+
+# ====================
+# Path (base)
+# ====================
+
+class Path:
+    """Represents a route with optional path arguments and its handler."""
+
+    def __init__(
+        self,
+        path: str,
+        handler: Handler,
+        name: str,
+        *,
+        methods: set[str] | None = None,   # None = any method
+    ):
+        self.handler = handler
+        self.name: str = name
+        self.methods: set[str] | None = {m.upper() for m in methods} if methods else None
+
+        path_segments = path.strip("/").split("/") if path.strip("/") else [""]
+        self.path_args: dict[int, str] = {}
+
+        detection_index = 0
+        for idx, segment in enumerate(path_segments):
+            m = re.match(r"{(.*?)}", segment)
+            if m:
+                if detection_index == 0:
+                    detection_index = idx
+                self.path_args[idx] = m.group(1)
+
+        if detection_index == 0:
+            detection_index = len(path_segments)
+
+        self.path: str = "/".join(path_segments[:detection_index])
+        self.detection_range: int = detection_index
+
+    def _read_args(self, request_path: str) -> dict[str, Optional[str]]:
+        """Build args for this request. (No shared state)"""
+        args: dict[str, Optional[str]] = {}
+        segments = request_path.strip("/").split("/") if request_path.strip("/") else [""]
+        for idx, arg_name in self.path_args.items():
+            args[arg_name] = segments[idx] if idx < len(segments) else None
+        return args
+
+    def call_handler(
+        self,
+        request: Request,
+        middlewares: tuple[Middleware, ...] = (),
+    ) -> Response:
+        try:
+            args = self._read_args(request.path)
+
+            handler = self.handler
+            if middlewares:
+                handler = MiddlewareChain(middlewares).wrap(handler)
+
+            res = handler(request, args)
+
+            if isinstance(res, dict):
+                return JsonResponse(res)
+
+            if not isinstance(res, Response):
+                raise PathInvalidHandlerTypeError(self.handler)
+
+            return res
+
+        except TypeError as e:
+            # handler の引数不足だけは明示的に
+            if re.search(r"takes \d+ positional arguments? but \d+ were given", str(e)):
+                raise PathHandlerMissingArgError()
+            raise
+
+
+# ====================
+# Method specific paths
+# ====================
+
+class Get(Path):
+    def __init__(self, path: str, handler: Handler, name: str):
+        super().__init__(path, handler, name, methods={"GET"})
+
+
+class Post(Path):
+    def __init__(self, path: str, handler: Handler, name: str):
+        super().__init__(path, handler, name, methods={"POST"})
+
+
+# ====================
+# Static files
+# ====================
+
+class Static(Path):
+    """Represents a static file route."""
+
+    def __init__(self, path: str, static_directory: str, name: str) -> None:
+        self._root = _Path(static_directory).resolve()
+        super().__init__(path, self._access, name)
+
+    def _access(self, request: Request, args: dict[str, Optional[str]]) -> Response:
+        segments = request.path.strip("/").split("/") if request.path.strip("/") else [""]
+        relative_parts = segments[self.detection_range :] if len(segments) > self.detection_range else []
+        rel = _Path(*relative_parts) if relative_parts else _Path("")
+
+        try:
+            target = (self._root / rel).resolve()
+        except Exception:
+            raise PathNotFoundError(request.path)
+
+        if not str(target).startswith(str(self._root) + os.sep) and target != self._root:
+            raise PathNotFoundError(request.path)
+
+        if target.is_dir():
+            target = (target / "index.html").resolve()
+
+        if not target.exists() or not target.is_file():
+            raise PathNotFoundError(request.path)
+
+        data = target.read_bytes()
+        mime_type, _ = guess_type(str(target))
+
+        headers = [
+            ("Content-Type", mime_type or "application/octet-stream"),
+            ("Content-Length", str(len(data))),
+        ]
+        return Response(data, headers=headers)
+
+
+# ====================
+# Pathlib
+# ====================
+
+class Pathlib(list[Path]):
+    """Collection of Path objects with middleware support."""
+
+    def __init__(self, *paths: Path) -> None:
+        for p in paths:
+            self._check(p)
+        super().__init__(paths)
+
+        self.raise_if_not_exist: bool = True
+        self.middlewares: list[Middleware] = []
+
+    def _check(self, arg: object) -> None:
+        if not isinstance(arg, Path):
+            raise PathlibTypeError
+
+    def add_middleware(self, *middlewares: Middleware) -> None:
+        self.middlewares.extend(middlewares)
+
+    def get(self, request_path: str, *, method: str | None = None) -> Path | None:
+        segments = request_path.rstrip("/").split("/")
+        method_u = method.upper() if method else None
+
+        fallback: Path | None = None
+
+        for p in self:
+            detection_path = "/".join(segments[: p.detection_range])
+            if detection_path != p.path:
+                continue
+
+            # Method-specific Path has priority
+            if method_u and p.methods is not None:
+                if method_u in p.methods:
+                    return p
+                continue
+
+            # Method-agnostic Path as fallback
+            if fallback is None:
+                fallback = p
+
+        if fallback is not None:
+            return fallback
+
+        if self.raise_if_not_exist:
+            raise PathNotFoundError(request_path)
+        return None

nexom/app/request.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+from http.cookies import SimpleCookie
+from urllib.parse import parse_qs
+import json
+
+from .cookie import RequestCookies
+
+
+WSGIEnviron = Mapping[str, Any]
+
+
+class Request:
+    """
+    Represents an HTTP request constructed from a WSGI environ.
+
+    Notes:
+    - headers keys are normalized to lower-case
+    - wsgi.input is readable only once; this class caches parsed body per request
+    - .json() / .form() use cached raw body (bytes)
+    - .files() parses multipart/form-data using python-multipart (external dependency)
+        and cannot be used together with .read_body()/.json()/.form() after reading the stream
+    """
+
+    def __init__(self, environ: WSGIEnviron) -> None:
+        self.environ: WSGIEnviron = environ
+
+        self.method: str = str(environ.get("REQUEST_METHOD", "GET")).upper()
+        self.path: str = str(environ.get("PATH_INFO", "")).lstrip("/")
+        self.query: dict[str, list[str]] = parse_qs(str(environ.get("QUERY_STRING", "")))
+
+        # normalize header keys to lower-case
+        self.headers: dict[str, str] = {
+            k[5:].replace("_", "-").lower(): v
+            for k, v in environ.items()
+            if k.startswith("HTTP_") and isinstance(v, str)
+        }
+        ct = environ.get("CONTENT_TYPE")
+        if isinstance(ct, str) and ct:
+            self.headers["content-type"] = ct
+        cl = environ.get("CONTENT_LENGTH")
+        if isinstance(cl, str) and cl:
+            self.headers["content-length"] = cl
+
+        self.cookie: RequestCookies | None = self._parse_cookies()
+
+        self._body: bytes | None = None
+        self._json_cache: Any | None = None
+        self._form_cache: dict[str, list[str]] | None = None
+        self._files_cache: dict[str, Any] | None = None
+        self._multipart_consumed: bool = False
+
+    # -------------------------
+    # basic helpers
+    # -------------------------
+
+    def _parse_cookies(self) -> RequestCookies | None:
+        cookie_header = self.environ.get("HTTP_COOKIE")
+        if not cookie_header:
+            return None
+
+        simple_cookie = SimpleCookie()
+        simple_cookie.load(cookie_header)
+
+        cookies = {key: morsel.value for key, morsel in simple_cookie.items()}
+        return RequestCookies(**cookies)
+
+    @property
+    def content_type(self) -> str:
+        """
+        Lower-cased mime type without parameters (no charset/boundary).
+        Example:
+            "application/json; charset=utf-8" -> "application/json"
+        """
+        return (self.headers.get("content-type") or "").split(";", 1)[0].strip().lower()
+
+    def _content_length(self) -> int:
+        raw = self.environ.get("CONTENT_LENGTH")
+        try:
+            return int(raw) if raw else 0
+        except (TypeError, ValueError):
+            return 0
+
+    # -------------------------
+    # body
+    # -------------------------
+
+    def read_body(self) -> bytes:
+        """
+        Read and cache request body bytes.
+
+        WARNING:
+        - If multipart parsing (.files()) already consumed the stream, body will be empty.
+        """
+        if self._body is not None:
+            return self._body
+
+        if self._multipart_consumed:
+            self._body = b""
+            return self._body
+
+        length = self._content_length()
+        if length <= 0:
+            self._body = b""
+            return self._body
+
+        self._body = self.environ["wsgi.input"].read(length)
+        return self._body
+
+    @property
+    def body(self) -> bytes:
+        return self.read_body()
+
+    # -------------------------
+    # POST parsers
+    # -------------------------
+
+    def json(self) -> Any | None:
+        """
+        Parse application/json body.
+
+        Returns:
+            Parsed JSON (dict/list/...) or None if not JSON or empty body.
+
+        Raises:
+            json.JSONDecodeError: If Content-Type is JSON but body is invalid.
+        """
+        if self._json_cache is not None:
+            return self._json_cache
+
+        if self.content_type != "application/json":
+            return None
+
+        raw = self.body
+        if not raw:
+            self._json_cache = None
+            return None
+
+        self._json_cache = json.loads(raw.decode("utf-8"))
+        return self._json_cache
+
+    def form(self) -> dict[str, list[str]] | None:
+        """
+        Parse application/x-www-form-urlencoded body.
+
+        Returns:
+            dict[str, list[str]] or None if not urlencoded form.
+        """
+        if self._form_cache is not None:
+            return self._form_cache
+
+        if self.content_type != "application/x-www-form-urlencoded":
+            return None
+
+        raw = self.body
+        if not raw:
+            self._form_cache = {}
+            return self._form_cache
+
+        self._form_cache = parse_qs(raw.decode("utf-8"))
+        return self._form_cache
+
+    def files(self) -> dict[str, Any] | None:
+        """
+        Parse multipart/form-data using python-multipart.
+
+        Returns:
+            dict[str, Any] mapping field name to either:
+              - str for normal form fields
+              - dict for file fields:
+                    {
+                        "filename": str,
+                        "content_type": str | None,
+                        "size": int | None,
+                        "file": <file-like object or bytes depending on backend>
+                    }
+
+        Raises:
+            ModuleNotFoundError: if python-multipart is not installed.
+            ValueError: if Content-Type is multipart but parsing fails.
+
+        IMPORTANT:
+            multipart parsing consumes wsgi.input. Do not call .read_body()/.json()/.form()
+            after calling this method.
+        """
+        if self._files_cache is not None:
+            return self._files_cache
+
+        if self.content_type != "multipart/form-data":
+            return None
+
+        # Lazy import (optional dependency)
+        # python-multipart package provides "multipart" module.
+        try:
+            from multipart import MultipartParser  # type: ignore
+        except Exception as e:
+            raise ModuleNotFoundError(
+                "python-multipart is required for multipart/form-data parsing. "
+                "Install with: pip install python-multipart"
+            ) from e
+
+        # Prevent mixing with body-based parsing
+        if self._body is not None and self._body != b"":
+            raise ValueError("Body was already read. multipart parsing must be done first.")
+
+        self._multipart_consumed = True
+
+        # Extract boundary from Content-Type header
+        ctype_full = self.headers.get("content-type", "")
+        boundary = None
+        for part in ctype_full.split(";")[1:]:
+            part = part.strip()
+            if part.startswith("boundary="):
+                boundary = part.split("=", 1)[1].strip().strip('"')
+                break
+        if not boundary:
+            raise ValueError("multipart/form-data boundary not found")
+
+        # Parse stream
+        stream = self.environ["wsgi.input"]
+
+        parser = MultipartParser(stream, boundary.encode("utf-8"))
+
+        out: dict[str, Any] = {}
+
+        # MultipartParser yields parts; API differs slightly by version.
+        # We handle common attributes: name, filename, headers, raw, file.
+        for p in parser:  # type: ignore
+            name = getattr(p, "name", None)
+            if not name:
+                continue
+
+            filename = getattr(p, "filename", None)
+            if filename:
+                # file part
+                content_type = None
+                headers = getattr(p, "headers", None)
+                if isinstance(headers, dict):
+                    # some versions use bytes keys/values
+                    ct = headers.get(b"Content-Type") or headers.get("Content-Type")
+                    if ct:
+                        content_type = ct.decode() if isinstance(ct, (bytes, bytearray)) else str(ct)
+
+                # Try to expose a stream if available, else raw bytes
+                fileobj = getattr(p, "file", None)
+                raw = getattr(p, "raw", None)
+
+                out[name] = {
+                    "filename": filename,
+                    "content_type": content_type,
+                    "size": None,
+                    "file": fileobj if fileobj is not None else raw,
+                }
+            else:
+                # normal field
+                value = getattr(p, "value", None)
+                if value is None:
+                    raw = getattr(p, "raw", b"")
+                    if isinstance(raw, (bytes, bytearray)):
+                        value = raw.decode("utf-8", errors="replace")
+                    else:
+                        value = str(raw)
+                out[name] = value
+
+        self._files_cache = out
+        return self._files_cache

nexom/{web → app}/response.py

@@ -4,6 +4,8 @@ from typing import Iterable, Optional
 from importlib import resources
 import json
 
+from ..core.object_html_render import HTMLDoc, ObjectHTML
+
 from .http_status_codes import http_status_codes
 
 
@@ -49,6 +51,11 @@ class Response:
         if cookie:
             self.headers.append(("Set-Cookie", cookie))
 
+        # ---- auto Content-Length (if not already present) ----
+        has_len = any(k.lower() == "content-length" for k, _ in self.headers)
+        if not has_len and isinstance(self.body, (bytes, bytearray)):
+            self.headers.append(("Content-Length", str(len(self.body))))
+
     def __iter__(self):
         """
         Allow Response to be returned directly from WSGI apps.
@@ -127,6 +134,7 @@ class ErrorResponse(Response):
 
     def __init__(self, status: int, message: str) -> None:
         html = self._render(status, message)
+        
         super().__init__(html, status=status)
 
     @staticmethod
@@ -139,8 +147,10 @@ class ErrorResponse(Response):
             .read_text(encoding="utf-8")
         )
 
+        ohtml = ObjectHTML(HTMLDoc("error_page", template))
+
+        status_str = f"{status} - {http_status_codes.get(status)}"
+
         return (
-            template
-            .replace("__STATUS__", status_text)
-            .replace("__MESSAGE__", message)
+            ohtml.render("error_page", status=status_str, message=message)
         )

nexom/{web → app}/template.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from ..engine.object_html_render import HTMLDoc, HTMLDocLib, ObjectHTML
+from ..core.object_html_render import HTMLDoc, HTMLDocLib, ObjectHTML
 from ..core.error import TemplateNotFoundError, TemplateInvalidNameError, TemplatesNotDirError
 
 _SEG_RE = re.compile(r"^[A-Za-z0-9_]+$")

nexom/app/user.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pathlib as plb
+
+from .db import DatabaseManager
+
+
+# --------------------
+# models
+# --------------------
+
+@dataclass
+class User:
+    uid: str
+    user_id: str
+    public_name: str
+    password_hash: str
+    password_salt: str
+    is_active: int
+
+
+# --------------------
+# UserDatabaseManager
+# --------------------
+
+class UserDatabaseManager(DatabaseManager):
+    def __init__(self, users_dir:str, user: User, auto_commit: bool = True):
+        db_file = str(plb.Path(users_dir) / f"{user.uid}.db")
+        super().__init__(db_file, auto_commit)

nexom/assets/app/config.py

@@ -0,0 +1,28 @@
+"""
+Nexom server settings.
+
+This file is generated by Nexom buildTools.
+"""
+# ======== project ========
+APP_NAME: str = "__app_name__"
+
+PROJECT_DIR: str = "__prj_dir__"
+APP_DIR: str = "__app_dir__"
+TEMPLATES_DIR: str = "__app_dir__/templates"
+
+DATA_DIR: str = "__prj_dir__/data"
+
+# ======== gunicorn ========
+ADDRESS: str = "__g_address__"
+PORT: int = __g_port__
+WORKERS: int = __g_workers__
+RELOAD: bool = __g_reload__
+
+# ======== auth ========
+AUTH_SERVER: str = "http://127.0.0.1:7070"
+
+# ======== logger ========
+INFO_LOG: str = "__prj_dir__/data/log/__app_name__/info.log"
+WARN_LOG: str = "__prj_dir__/data/log/__app_name__/warning.log"
+ERR_LOG: str = "__prj_dir__/data/log/__app_name__/error.log"
+ACES_LOG: str = "__prj_dir__/data/log/__app_name__/access.log"

nexom/assets/app/gunicorn.conf.py

@@ -0,0 +1,5 @@
+from __app_name__.config import ADDRESS, PORT, WORKERS, RELOAD  # noqa: E402
+
+bind = f"{ADDRESS}:{PORT}"
+workers = int(WORKERS)
+reload = bool(RELOAD)

nexom/assets/app/pages/_templates.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from nexom.app.template import ObjectHTMLTemplates
+
+from __app_name__.config import TEMPLATES_DIR
+
+templates = ObjectHTMLTemplates(base_dir=TEMPLATES_DIR)

nexom/assets/{server → app}/pages/default.py

@@ -1,5 +1,5 @@
-from nexom.web.request import Request
-from nexom.web.response import Response
+from nexom.app.request import Request
+from nexom.app.response import Response
 
 from ._templates import templates
 

nexom/assets/{server → app}/pages/document.py

@@ -1,5 +1,5 @@
-from nexom.web.request import Request
-from nexom.web.response import Response
+from nexom.app.request import Request
+from nexom.app.response import Response
 
 from ._templates import templates
 

nexom/assets/app/router.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from nexom.app.path import Get, Static, Pathlib
+
+from .config import APP_DIR
+from .pages import default, document
+
+routing = Pathlib(
+    Get("", default.main, "DefaultPage"),
+    Get("doc/", document.main, "DocumentPage"),
+    Static("static/", APP_DIR + "/static", "StaticFiles"),
+)

nexom/assets/app/wsgi.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Callable, Iterable
+import time
+
+from nexom.app.request import Request
+from nexom.app.response import Response, ErrorResponse
+from nexom.core.error import PathNotFoundError
+from nexom.core.log import AppLogger, AuthLogger
+
+from __app_name__.config import INFO_LOG, WARN_LOG, ERR_LOG, ACES_LOG
+from .router import routing
+
+
+# Logger (global)
+logger = AppLogger(
+    info=INFO_LOG,
+    warn=WARN_LOG,
+    error=ERR_LOG,
+    access=ACES_LOG,
+)
+
+
+def _ip(environ: dict) -> str:
+    xff = environ.get("HTTP_X_FORWARDED_FOR")
+    if isinstance(xff, str) and xff.strip():
+        return xff.split(",")[0].strip()
+    return str(environ.get("REMOTE_ADDR") or "-")
+
+
+def app(environ: dict, start_response: Callable) -> Iterable[bytes]:
+    t0 = time.time()
+
+    req: Request | None = None
+    res: Response
+
+    try:
+        req = Request(environ)
+        path = req.path
+        method = req.method
+
+        p = routing.get(path, method=method)
+        res = p.call_handler(req)
+
+    except PathNotFoundError as e:
+        logger.warn(str(e))
+        res = ErrorResponse(404, "Not Found")
+
+    except Exception as e:
+        logger.error(e)
+        res = ErrorResponse(500, "Internal Server Error")
+
+    try:
+        dt_ms = int((time.time() - t0) * 1000)
+        method = req.method if req else str(environ.get("REQUEST_METHOD") or "-")
+        path = (req.path if req else str(environ.get("PATH_INFO") or "")).lstrip("/")
+        ip = _ip(environ)
+        ua = str(environ.get("HTTP_USER_AGENT") or "-")
+        logger.access(f'{ip} "{method} /{path}" {res.status_code} {dt_ms}ms "{ua}"')
+    except Exception:
+        pass
+
+    start_response(res.status_text, res.headers)
+    return [res.body]