xitzin 0.1.2__tar.gz → 0.2.0__tar.gz

{xitzin-0.1.2 → xitzin-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xitzin
-Version: 0.1.2
+Version: 0.2.0
 Summary: A Gemini Application Framework
 Keywords: gemini,protocol,framework,async,geminispace
 Author: Alan Velasco
@@ -21,12 +21,14 @@ Requires-Dist: jinja2>=3.1.0
 Requires-Dist: nauyaca>=0.3.2
 Requires-Dist: rich>=14.2.0
 Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: sqlmodel>=0.0.22 ; extra == 'sqlmodel'
 Requires-Python: >=3.10
 Project-URL: Changelog, https://xitzin.readthedocs.io/changelog/
 Project-URL: Documentation, https://xitzin.readthedocs.io
 Project-URL: Homepage, https://github.com/alanbato/xitzin
 Project-URL: Issues, https://github.com/alanbato/xitzin/issues
 Project-URL: Repository, https://github.com/alanbato/xitzin.git
+Provides-Extra: sqlmodel
 Description-Content-Type: text/markdown
 
 # Xitzin

{xitzin-0.1.2 → xitzin-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xitzin"
-version = "0.1.2"
+version = "0.2.0"
 description = "A Gemini Application Framework"
 readme = "README.md"
 license = { text = "MIT" }
@@ -29,6 +29,11 @@ dependencies = [
     "typing-extensions>=4.15.0",
 ]
 
+[project.optional-dependencies]
+sqlmodel = [
+    "sqlmodel>=0.0.22",
+]
+
 [project.urls]
 Homepage = "https://github.com/alanbato/xitzin"
 Documentation = "https://xitzin.readthedocs.io"
@@ -47,6 +52,7 @@ dev = [
     "pytest-asyncio>=0.24.0",
     "pytest-cov>=7.0.0",
     "ruff>=0.14.10",
+    "sqlmodel>=0.0.31",
     "ty>=0.0.8",
 ]
 docs = [

xitzin-0.2.0/src/xitzin/sqlmodel.py

@@ -0,0 +1,172 @@
+"""SQLModel integration for Xitzin.
+
+This module provides database session management through middleware
+and helper functions. Requires the 'sqlmodel' optional dependency.
+
+Install with: pip install xitzin[sqlmodel]
+
+Example:
+    from sqlmodel import Field, select
+    from xitzin import Xitzin, Request
+    from xitzin.sqlmodel import (
+        SQLModel,
+        create_engine,
+        SessionMiddleware,
+        get_session,
+        init_db,
+    )
+
+    # Define models
+    class Entry(SQLModel, table=True):
+        id: int | None = Field(default=None, primary_key=True)
+        content: str
+
+    # Setup app
+    app = Xitzin()
+    engine = create_engine("sqlite:///./database.db")
+
+    # Initialize database and add middleware
+    init_db(app, engine)
+    app.middleware(SessionMiddleware(engine))
+
+    # Use in routes
+    @app.gemini("/entries")
+    def list_entries(request: Request):
+        session = get_session(request)
+        entries = session.exec(select(Entry)).all()
+        return render_entries(entries)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Awaitable, Callable
+
+from sqlalchemy import Engine
+from sqlmodel import Session, SQLModel, create_engine
+
+if TYPE_CHECKING:
+    from nauyaca.protocol.response import GeminiResponse
+
+    from xitzin.application import Xitzin
+    from xitzin.requests import Request
+
+__all__ = [
+    "SQLModel",
+    "Session",
+    "create_engine",
+    "SessionMiddleware",
+    "get_session",
+    "init_db",
+]
+
+
+def SessionMiddleware(
+    engine: Engine,
+    *,
+    autoflush: bool = True,
+) -> Callable[
+    ["Request", Callable[["Request"], Awaitable["GeminiResponse"]]],
+    Awaitable["GeminiResponse"],
+]:
+    """Create a middleware that manages database sessions per request.
+
+    The session is stored in request.state.db and automatically committed
+    on success or rolled back on error.
+
+    Args:
+        engine: SQLAlchemy engine instance.
+        autoflush: If True, flush before queries. Defaults to True.
+
+    Returns:
+        Middleware function compatible with @app.middleware.
+
+    Example:
+        engine = create_engine("sqlite:///./database.db")
+        app.middleware(SessionMiddleware(engine))
+    """
+
+    async def middleware(
+        request: "Request",
+        call_next: Callable[["Request"], Awaitable["GeminiResponse"]],
+    ) -> "GeminiResponse":
+        session = Session(engine, autoflush=autoflush)
+        request.state.db = session
+
+        try:
+            response = await call_next(request)
+            session.commit()
+            return response
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    return middleware
+
+
+def get_session(request: "Request") -> Session:
+    """Get the database session from the current request.
+
+    This helper retrieves the session created by SessionMiddleware.
+
+    Args:
+        request: The current Xitzin request object.
+
+    Returns:
+        SQLModel Session instance.
+
+    Raises:
+        AttributeError: If SessionMiddleware is not configured.
+
+    Example:
+        @app.gemini("/users/{user_id}")
+        def get_user(request: Request, user_id: int):
+            session = get_session(request)
+            user = session.get(User, user_id)
+            return f"# {user.name}"
+    """
+    if not hasattr(request.state, "db"):
+        raise AttributeError(
+            "No database session found. Did you add SessionMiddleware?"
+        )
+    return request.state.db
+
+
+def init_db(
+    app: "Xitzin",
+    engine: Engine,
+    *,
+    create_tables: bool = True,
+    drop_all: bool = False,
+) -> None:
+    """Initialize database with lifecycle hooks.
+
+    This helper registers startup/shutdown hooks to manage table creation
+    and engine cleanup.
+
+    Args:
+        app: Xitzin application instance.
+        engine: SQLAlchemy engine instance.
+        create_tables: Create all tables on startup. Defaults to True.
+        drop_all: Drop all tables before creating. Defaults to False.
+
+    Warning:
+        Setting drop_all=True will DELETE ALL DATA on startup!
+
+    Example:
+        app = Xitzin()
+        engine = create_engine("sqlite:///./database.db")
+        init_db(app, engine)
+    """
+
+    @app.on_startup
+    def create_db_tables() -> None:
+        if drop_all:
+            SQLModel.metadata.drop_all(engine)
+        if create_tables:
+            SQLModel.metadata.create_all(engine)
+
+    @app.on_shutdown
+    def dispose_engine() -> None:
+        engine.dispose()