pyrith 0.1.0__py3-none-any.whl

pyrith/__init__.py

@@ -0,0 +1,18 @@
+"""Pyrith — Pure-Python full-stack web framework."""
+
+from .app import Pyrith
+from .request import Request
+from .response import Response, HTMLResponse, JSONResponse, RedirectResponse, StreamResponse
+from .router import Router, RouteGroup
+from . import ui
+from . import style
+from . import orm
+from . import auth
+from . import forms
+
+__version__ = "0.1.0"
+__all__ = [
+    "Pyrith", "Request", "Response", "HTMLResponse", "JSONResponse",
+    "RedirectResponse", "StreamResponse", "Router", "RouteGroup",
+    "ui", "style", "orm", "auth", "forms",
+]

pyrith/app.py

@@ -0,0 +1,165 @@
+"""Pyrith application — HTTP server, routing, middleware pipeline."""
+from __future__ import annotations
+import http.server
+import urllib.parse
+import traceback
+from typing import Callable, Dict, List, Optional
+
+from .request import Request
+from .response import Response, HTMLResponse, JSONResponse
+from .router import Router, RouteGroup
+from .middleware import Middleware
+from .websocket import WebSocketHandler
+
+
+class Pyrith:
+    """The core Pyrith application."""
+
+    def __init__(self, name: Optional[str] = None) -> None:
+        self.name = name or "pyrith"
+        self._router = Router()
+        self._middlewares: List[Middleware] = []
+        self._error_handlers: Dict[int, Callable] = {}
+        self._ws_routes: Dict[str, Callable] = {}
+
+    # ── Routing ──────────────────────────────────────────────
+
+    def route(self, path: str, methods: Optional[List[str]] = None):
+        return self._router.route(path, methods or ["GET"])
+
+    def get(self, path: str):
+        return self._router.get(path)
+
+    def post(self, path: str):
+        return self._router.post(path)
+
+    def put(self, path: str):
+        return self._router.put(path)
+
+    def delete(self, path: str):
+        return self._router.delete(path)
+
+    def patch(self, path: str):
+        return self._router.patch(path)
+
+    def websocket(self, path: str):
+        def decorator(fn: Callable) -> Callable:
+            self._ws_routes[path] = fn
+            return fn
+        return decorator
+
+    def group(self, prefix: str) -> RouteGroup:
+        return RouteGroup(prefix, self)
+
+    # ── Middleware ───────────────────────────────────────────
+
+    def use(self, middleware: Middleware) -> None:
+        self._middlewares.append(middleware)
+
+    # ── Error handling ───────────────────────────────────────
+
+    def error_handler(self, status_code: int):
+        def decorator(fn: Callable) -> Callable:
+            self._error_handlers[status_code] = fn
+            return fn
+        return decorator
+
+    # ── Request handling ─────────────────────────────────────
+
+    def handle(self, request: Request) -> Response:
+        # Run before_request middlewares
+        for mw in self._middlewares:
+            early = mw.before_request(request)
+            if early is not None:
+                return self._run_after(request, early)
+
+        # Resolve route
+        handler, params = self._router.resolve(request.path, request.method)
+        request.params = params
+
+        if handler is None:
+            response = self._make_error(404, request, "Not Found")
+        else:
+            try:
+                result = handler(request)
+                response = self._coerce(result)
+            except Exception as exc:
+                traceback.print_exc()
+                response = self._make_error(500, request, f"Internal Server Error: {exc}")
+
+        return self._run_after(request, response)
+
+    def _run_after(self, request: Request, response: Response) -> Response:
+        for mw in reversed(self._middlewares):
+            response = mw.after_request(request, response)
+        return response
+
+    def _coerce(self, result) -> Response:
+        if isinstance(result, Response):
+            return result
+        if isinstance(result, dict) or isinstance(result, list):
+            return JSONResponse(result)
+        if isinstance(result, str):
+            if result.lstrip().startswith("<"):
+                return HTMLResponse(result)
+            return Response(result, content_type="text/plain; charset=utf-8")
+        return Response(str(result))
+
+    def _make_error(self, status: int, request: Request, message: str) -> Response:
+        if status in self._error_handlers:
+            try:
+                result = self._error_handlers[status](request)
+                return self._coerce(result)
+            except Exception:
+                pass
+        return Response(message, status=status)
+
+    # ── Server ───────────────────────────────────────────────
+
+    def run(self, host: str = "127.0.0.1", port: int = 8080, debug: bool = False) -> None:
+        app = self
+
+        class _Handler(http.server.BaseHTTPRequestHandler):
+            def log_message(self, fmt, *args):
+                if debug:
+                    super().log_message(fmt, *args)
+
+            def _handle(self):
+                parsed = urllib.parse.urlparse(self.path)
+                path = parsed.path or "/"
+                query_string = parsed.query or ""
+                length = int(self.headers.get("Content-Length", 0))
+                body = self.rfile.read(length) if length else b""
+                headers = dict(self.headers)
+                request = Request(
+                    method=self.command,
+                    path=path,
+                    headers=headers,
+                    body=body,
+                    query_string=query_string,
+                )
+                response = app.handle(request)
+                body_bytes = response.body_bytes()
+                self.send_response(response.status)
+                for k, v in response.all_headers().items():
+                    self.send_header(k, v)
+                for cookie in response._cookies:
+                    self.send_header("Set-Cookie", cookie)
+                self.end_headers()
+                self.wfile.write(body_bytes)
+
+            def do_GET(self):    self._handle()
+            def do_POST(self):   self._handle()
+            def do_PUT(self):    self._handle()
+            def do_DELETE(self): self._handle()
+            def do_PATCH(self):  self._handle()
+            def do_OPTIONS(self): self._handle()
+            def do_HEAD(self):   self._handle()
+
+        server = http.server.ThreadingHTTPServer((host, port), _Handler)
+        print(f"[Pyrith] Running on http://{host}:{port}  (debug={debug})")
+        try:
+            server.serve_forever()
+        except KeyboardInterrupt:
+            print("\n[Pyrith] Stopped.")
+            server.shutdown()

pyrith/auth/__init__.py

@@ -0,0 +1,5 @@
+"""Pyrith Auth — session management and route protection."""
+from .session import SessionStore, Session
+from .decorators import login_required, role_required
+
+__all__ = ["SessionStore", "Session", "login_required", "role_required"]

pyrith/auth/decorators.py

@@ -0,0 +1,46 @@
+"""Pyrith Auth — route guard decorators."""
+from __future__ import annotations
+from typing import Callable, Optional
+from ..response import RedirectResponse
+
+
+def login_required(redirect_to: str = "/login"):
+    """
+    Redirect unauthenticated requests.
+
+    Expects ``request.session`` to be set (by SessionStore middleware)
+    and ``request.session.get("user_id")`` to be non-None when authenticated.
+
+    Usage::
+
+        @app.get("/dashboard")
+        @login_required()
+        def dashboard(request):
+            ...
+    """
+    def decorator(fn: Callable) -> Callable:
+        def wrapper(request):
+            session = getattr(request, "session", None)
+            if session is None or session.get("user_id") is None:
+                return RedirectResponse(redirect_to)
+            return fn(request)
+        wrapper.__name__ = fn.__name__
+        return wrapper
+    return decorator
+
+
+def role_required(role: str, redirect_to: str = "/forbidden"):
+    """
+    Guard a route to users with a specific role stored in the session.
+
+    Expects ``request.session.get("role")`` to equal *role*.
+    """
+    def decorator(fn: Callable) -> Callable:
+        def wrapper(request):
+            session = getattr(request, "session", None)
+            if session is None or session.get("role") != role:
+                return RedirectResponse(redirect_to)
+            return fn(request)
+        wrapper.__name__ = fn.__name__
+        return wrapper
+    return decorator

pyrith/auth/session.py

@@ -0,0 +1,124 @@
+"""Pyrith Auth — session store (in-memory + cookie-based)."""
+from __future__ import annotations
+import hashlib
+import os
+import time
+from typing import Any, Dict, Optional
+
+
+class Session:
+    def __init__(self, session_id: str) -> None:
+        self.id = session_id
+        self._data: Dict[str, Any] = {}
+        self.created_at = time.time()
+        self.last_accessed = time.time()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._data[key] = value
+        self.last_accessed = time.time()
+
+    def delete(self, key: str) -> None:
+        self._data.pop(key, None)
+
+    def clear(self) -> None:
+        self._data.clear()
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._data
+
+    def __repr__(self) -> str:
+        return f"<Session {self.id[:8]}...>"
+
+
+class SessionStore:
+    """
+    Thread-safe in-memory session store with HMAC-signed cookie tokens.
+
+    Usage::
+
+        store = SessionStore(secret="change-me", max_age=3600)
+        app.use(store.middleware())
+
+        @app.get("/login")
+        def login(request):
+            session = store.get_or_create(request)
+            session.set("user_id", 42)
+            response = RedirectResponse("/dashboard")
+            store.save(session, response)
+            return response
+    """
+
+    COOKIE_NAME = "pyrith_session"
+
+    def __init__(self, secret: str, max_age: int = 86400) -> None:
+        self._secret = secret.encode()
+        self._max_age = max_age
+        self._sessions: Dict[str, Session] = {}
+
+    def _sign(self, session_id: str) -> str:
+        import hmac
+        sig = hmac.new(self._secret, session_id.encode(), hashlib.sha256).hexdigest()
+        return f"{session_id}.{sig}"
+
+    def _verify(self, token: str) -> Optional[str]:
+        import hmac
+        parts = token.rsplit(".", 1)
+        if len(parts) != 2:
+            return None
+        session_id, sig = parts
+        expected = hmac.new(self._secret, session_id.encode(), hashlib.sha256).hexdigest()
+        if hmac.compare_digest(sig, expected):
+            return session_id
+        return None
+
+    def _new_id(self) -> str:
+        return hashlib.sha256(os.urandom(32)).hexdigest()
+
+    def get_or_create(self, request) -> Session:
+        cookies = request.cookies() if callable(request.cookies) else {}
+        token = cookies.get(self.COOKIE_NAME, "")
+        session_id = self._verify(token) if token else None
+        if session_id and session_id in self._sessions:
+            session = self._sessions[session_id]
+            if time.time() - session.last_accessed < self._max_age:
+                session.last_accessed = time.time()
+                return session
+        session_id = self._new_id()
+        session = Session(session_id)
+        self._sessions[session_id] = session
+        return session
+
+    def save(self, session: Session, response) -> None:
+        token = self._sign(session.id)
+        response.set_cookie(
+            self.COOKIE_NAME,
+            token,
+            max_age=self._max_age,
+            http_only=True,
+            same_site="Lax",
+        )
+
+    def destroy(self, session: Session, response) -> None:
+        self._sessions.pop(session.id, None)
+        response.delete_cookie(self.COOKIE_NAME)
+
+    def middleware(self):
+        """Return a Pyrith Middleware that attaches a session to every request."""
+        from ..middleware import Middleware
+
+        store = self
+
+        class _SessionMiddleware(Middleware):
+            def before_request(self, request):
+                request.session = store.get_or_create(request)
+                return None
+
+            def after_request(self, request, response):
+                if hasattr(request, "session"):
+                    store.save(request.session, response)
+                return response
+
+        return _SessionMiddleware()

pyrith/cli/__init__.py

@@ -0,0 +1,4 @@
+"""Pyrith CLI — project scaffolding and dev-server launcher."""
+from .commands import main
+
+__all__ = ["main"]

pyrith/cli/commands.py

@@ -0,0 +1,95 @@
+"""Pyrith CLI commands."""
+from __future__ import annotations
+import sys
+import os
+
+
+_HELP = """\
+Pyrith — pure-Python full-stack web framework
+
+Usage:
+  pyrith new <project>     Scaffold a new Pyrith project
+  pyrith run [file]        Run an app file (default: app.py)
+  pyrith version           Show Pyrith version
+
+Examples:
+  pyrith new myapp
+  pyrith run app.py
+"""
+
+_APP_TEMPLATE = '''\
+from pyrith import Pyrith
+from pyrith import ui, style
+
+app = Pyrith(__name__)
+
+
+@app.get("/")
+def index(request):
+    page = ui.Page(title="Welcome to Pyrith")
+    page.head_add(f"<style>{style.TailwindSheet().add('flex','items-center','justify-center','min-h-100vh')}</style>")
+    page.body_add(
+        ui.div(
+            ui.h1("Hello from Pyrith", class_="text-4xl font-bold"),
+            ui.p("Edit app.py to get started.", class_="text-gray-500 mt-4"),
+            class_="flex flex-col items-center justify-center min-h-100vh",
+        )
+    )
+    from pyrith.response import HTMLResponse
+    return HTMLResponse(page.to_html())
+
+
+if __name__ == "__main__":
+    app.run(debug=True)
+'''
+
+
+def _new_project(name: str) -> None:
+    if os.path.exists(name):
+        print(f"Error: '{name}' already exists.", file=sys.stderr)
+        sys.exit(1)
+    os.makedirs(name)
+    with open(os.path.join(name, "app.py"), "w") as f:
+        f.write(_APP_TEMPLATE)
+    with open(os.path.join(name, "requirements.txt"), "w") as f:
+        f.write("pyrith\n")
+    print(f"Created project '{name}'.")
+    print(f"  cd {name}")
+    print("  python app.py")
+
+
+def _run_app(file: str) -> None:
+    if not os.path.exists(file):
+        print(f"Error: '{file}' not found.", file=sys.stderr)
+        sys.exit(1)
+    import importlib.util
+    spec = importlib.util.spec_from_file_location("__pyrith_app__", file)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    if hasattr(mod, "app"):
+        mod.app.run(debug=True)
+    else:
+        print("Error: no 'app' variable found in module.", file=sys.stderr)
+        sys.exit(1)
+
+
+def main() -> None:
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help", "help"):
+        print(_HELP)
+        return
+    cmd = args[0]
+    if cmd == "new":
+        if len(args) < 2:
+            print("Usage: pyrith new <project>", file=sys.stderr)
+            sys.exit(1)
+        _new_project(args[1])
+    elif cmd == "run":
+        file = args[1] if len(args) > 1 else "app.py"
+        _run_app(file)
+    elif cmd == "version":
+        from pyrith import __version__
+        print(f"Pyrith {__version__}")
+    else:
+        print(f"Unknown command: {cmd}\n{_HELP}", file=sys.stderr)
+        sys.exit(1)

pyrith/forms/__init__.py

@@ -0,0 +1,4 @@
+"""Pyrith Forms — Python-native HTML form validation."""
+from .form import Form, FormField, StringField, IntegerField, EmailField, BooleanField
+
+__all__ = ["Form", "FormField", "StringField", "IntegerField", "EmailField", "BooleanField"]

pyrith/forms/form.py

@@ -0,0 +1,195 @@
+"""Pyrith Forms — form validation and HTML rendering."""
+from __future__ import annotations
+import re
+from typing import Any, Dict, List, Optional
+
+
+class FormField:
+    def __init__(
+        self,
+        label: str = "",
+        required: bool = False,
+        default: Any = None,
+        validators: Optional[List] = None,
+    ) -> None:
+        self.label = label
+        self.required = required
+        self.default = default
+        self.validators = validators or []
+        self._name: str = ""
+
+    def __set_name__(self, owner, name: str) -> None:
+        self._name = name
+        if not self.label:
+            self.label = name.replace("_", " ").title()
+
+    def coerce(self, value: str) -> Any:
+        return value
+
+    def validate(self, value: Any) -> List[str]:
+        errors = []
+        if self.required and (value is None or value == ""):
+            errors.append(f"{self.label} is required.")
+        for validator in self.validators:
+            err = validator(value)
+            if err:
+                errors.append(err)
+        return errors
+
+    def render(self, value: Any = "") -> str:
+        return (
+            f'<label for="{self._name}">{self.label}</label>'
+            f'<input type="text" id="{self._name}" name="{self._name}" value="{value}">'
+        )
+
+
+class StringField(FormField):
+    def __init__(self, min_length: int = 0, max_length: Optional[int] = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.min_length = min_length
+        self.max_length = max_length
+
+    def validate(self, value: Any) -> List[str]:
+        errors = super().validate(value)
+        if value and len(str(value)) < self.min_length:
+            errors.append(f"{self.label} must be at least {self.min_length} characters.")
+        if value and self.max_length and len(str(value)) > self.max_length:
+            errors.append(f"{self.label} must be at most {self.max_length} characters.")
+        return errors
+
+
+class IntegerField(FormField):
+    def __init__(self, min_val: Optional[int] = None, max_val: Optional[int] = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.min_val = min_val
+        self.max_val = max_val
+
+    def coerce(self, value: str) -> Optional[int]:
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return None
+
+    def validate(self, value: Any) -> List[str]:
+        errors = super().validate(value)
+        if value is not None and value != "":
+            try:
+                n = int(value)
+                if self.min_val is not None and n < self.min_val:
+                    errors.append(f"{self.label} must be at least {self.min_val}.")
+                if self.max_val is not None and n > self.max_val:
+                    errors.append(f"{self.label} must be at most {self.max_val}.")
+            except (ValueError, TypeError):
+                errors.append(f"{self.label} must be an integer.")
+        return errors
+
+    def render(self, value: Any = "") -> str:
+        return (
+            f'<label for="{self._name}">{self.label}</label>'
+            f'<input type="number" id="{self._name}" name="{self._name}" value="{value}">'
+        )
+
+
+class EmailField(StringField):
+    _EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+
+    def validate(self, value: Any) -> List[str]:
+        errors = super().validate(value)
+        if value and not self._EMAIL_RE.match(str(value)):
+            errors.append(f"{self.label} must be a valid email address.")
+        return errors
+
+    def render(self, value: Any = "") -> str:
+        return (
+            f'<label for="{self._name}">{self.label}</label>'
+            f'<input type="email" id="{self._name}" name="{self._name}" value="{value}">'
+        )
+
+
+class BooleanField(FormField):
+    def coerce(self, value: str) -> bool:
+        return value in ("1", "true", "on", "yes")
+
+    def render(self, value: Any = False) -> str:
+        checked = ' checked' if value else ''
+        return (
+            f'<label><input type="checkbox" id="{self._name}" name="{self._name}"'
+            f'{checked}> {self.label}</label>'
+        )
+
+
+class FormMeta(type):
+    def __new__(mcs, name, bases, namespace):
+        fields: Dict[str, FormField] = {}
+        for base in bases:
+            if hasattr(base, "_form_fields"):
+                fields.update(base._form_fields)
+        for k, v in namespace.items():
+            if isinstance(v, FormField):
+                v._name = k
+                if not v.label:
+                    v.label = k.replace("_", " ").title()
+                fields[k] = v
+        namespace["_form_fields"] = fields
+        return super().__new__(mcs, name, bases, namespace)
+
+
+class Form(metaclass=FormMeta):
+    """
+    Declarative form with validation and HTML rendering.
+
+    Usage::
+
+        class LoginForm(Form):
+            username = StringField(required=True, min_length=3)
+            password = StringField(required=True, min_length=8)
+
+        @app.post("/login")
+        def login(request):
+            form = LoginForm(request.form())
+            if form.is_valid():
+                ...
+            return HTMLResponse(form.render())
+    """
+
+    _form_fields: Dict[str, FormField] = {}
+
+    def __init__(self, data: Optional[Dict[str, str]] = None) -> None:
+        self._data = data or {}
+        self._errors: Dict[str, List[str]] = {}
+        self._cleaned: Dict[str, Any] = {}
+
+    def is_valid(self) -> bool:
+        self._errors = {}
+        self._cleaned = {}
+        for name, field in self._form_fields.items():
+            raw = self._data.get(name, "")
+            value = field.coerce(raw)
+            errors = field.validate(value)
+            if errors:
+                self._errors[name] = errors
+            else:
+                self._cleaned[name] = value
+        return len(self._errors) == 0
+
+    @property
+    def errors(self) -> Dict[str, List[str]]:
+        return self._errors
+
+    @property
+    def cleaned_data(self) -> Dict[str, Any]:
+        return self._cleaned
+
+    def render(self, action: str = "", method: str = "post") -> str:
+        lines = [f'<form action="{action}" method="{method}">']
+        for name, field in self._form_fields.items():
+            value = self._data.get(name, field.default or "")
+            lines.append(f'  <div class="form-field">')
+            lines.append(f"    {field.render(value)}")
+            if name in self._errors:
+                for err in self._errors[name]:
+                    lines.append(f'    <span class="form-error">{err}</span>')
+            lines.append("  </div>")
+        lines.append('  <button type="submit">Submit</button>')
+        lines.append("</form>")
+        return "\n".join(lines)