tigrbl 0.0.1.dev1__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

tigrbl/ddl/__init__.py

@@ -0,0 +1,344 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+from pathlib import Path
+from typing import Any, Dict, Iterable, Mapping, Optional, Sequence
+from types import SimpleNamespace
+
+from ..engine import resolver as _resolver
+
+try:  # pragma: no cover
+    from sqlalchemy import event, text
+    from sqlalchemy.engine import Engine
+    from sqlalchemy.schema import CreateSchema  # type: ignore
+except Exception:  # pragma: no cover
+    event = text = CreateSchema = None  # type: ignore
+    Engine = object  # type: ignore
+
+from ..config.constants import __SAFE_IDENT__
+
+__all__ = [
+    "register_sqlite_attach",
+    "ensure_schemas",
+    "bootstrap_dbschema",
+    "sqlite_default_attach_map",
+    "initialize",
+]
+
+
+# ---------------------------------------------------------------------------
+# SQLite helpers
+# ---------------------------------------------------------------------------
+
+
+def _quote_ident_sqlite(name: str) -> str:
+    if __SAFE_IDENT__.match(name or ""):
+        return name
+    return '"' + (name or "").replace('"', '""') + '"'
+
+
+def _attached_names_sqlite(dbapi_conn: Any) -> set[str]:
+    names: set[str] = set()
+    cur = None
+    try:
+        cur = dbapi_conn.cursor()
+        cur.execute("PRAGMA database_list")
+        for row in cur.fetchall():
+            names.add(str(row[1]))
+    finally:
+        try:
+            cur and cur.close()
+        except Exception:
+            pass
+    return names
+
+
+def _attach_sqlite_dbapi(dbapi_conn: Any, attachments: Mapping[str, str]) -> None:
+    cur = None
+    try:
+        existing = _attached_names_sqlite(dbapi_conn)
+        cur = dbapi_conn.cursor()
+        try:
+            cur.execute("PRAGMA foreign_keys=ON")
+        except Exception:
+            pass
+        for schema, path in (attachments or {}).items():
+            if not path or schema in existing:
+                continue
+            ident = _quote_ident_sqlite(schema)
+            try:
+                cur.execute(f"ATTACH DATABASE ? AS {ident}", (path,))
+            except Exception:
+                cur.execute(f"ATTACH DATABASE '{path}' AS {ident}")  # nosec: application-provided paths
+    finally:
+        try:
+            cur and cur.close()
+        except Exception:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Public helpers
+# ---------------------------------------------------------------------------
+
+
+def sqlite_default_attach_map(engine: Engine, schemas: Iterable[str]) -> Dict[str, str]:
+    """Return a deterministic SQLite ATTACH map for ``schemas``."""
+    db = getattr(getattr(engine, "url", None), "database", None) or ":memory:"
+    if db == ":memory:" or str(db).startswith("file::memory:"):
+        return {s: ":memory:" for s in schemas}
+    p = Path(db)
+    suffix = p.suffix if p.suffix else ".db"
+    return {s: str(p.with_name(f"{p.stem}__{s}{suffix}")) for s in schemas}
+
+
+def register_sqlite_attach(engine: Engine, attachments: Mapping[str, str]) -> Any:
+    if (
+        not hasattr(engine, "dialect")
+        or getattr(engine.dialect, "name", "") != "sqlite"
+    ):
+        return None
+
+    def _connect_listener(dbapi_conn, _):  # type: ignore[override]
+        try:
+            _attach_sqlite_dbapi(dbapi_conn, attachments)
+        except Exception:
+            pass
+
+    event.listen(engine, "connect", _connect_listener)
+    return _connect_listener
+
+
+def ensure_schemas(engine: Engine, schemas: Iterable[str]) -> Sequence[str]:
+    if not schemas:
+        return tuple()
+    if not hasattr(engine, "dialect"):
+        return tuple(schemas)
+
+    dialect = getattr(engine.dialect, "name", "")
+    attempted: list[str] = []
+
+    if dialect == "sqlite":
+        return tuple()
+
+    if text is None:  # pragma: no cover
+        raise RuntimeError("SQLAlchemy is required for ensure_schemas")
+
+    try:
+        with engine.begin() as conn:
+            for name in dict.fromkeys(schemas).keys():
+                if not name:
+                    continue
+                attempted.append(name)
+                try:
+                    conn.execute(CreateSchema(name))  # type: ignore[arg-type]
+                except Exception:
+                    try:
+                        if dialect in ("postgresql", "redshift"):
+                            conn.execute(text(f'CREATE SCHEMA IF NOT EXISTS "{name}"'))
+                        elif dialect in ("mysql", "mariadb"):
+                            conn.execute(text(f"CREATE SCHEMA IF NOT EXISTS `{name}`"))
+                        elif dialect in ("mssql", "sqlserver"):
+                            conn.execute(
+                                text(
+                                    "IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = :n) "
+                                    "EXEC('CREATE SCHEMA ' + QUOTENAME(:n))"
+                                ),
+                                {"n": name},
+                            )
+                        else:
+                            conn.execute(text(f"CREATE SCHEMA IF NOT EXISTS {name}"))
+                    except Exception:
+                        pass
+    except Exception:
+        pass
+
+    return tuple(attempted)
+
+
+def bootstrap_dbschema(
+    engine: Engine,
+    *,
+    schemas: Optional[Iterable[str]] = None,
+    sqlite_attachments: Optional[Mapping[str, str]] = None,
+    immediate: bool = True,
+) -> Dict[str, Any]:
+    attempted = tuple()
+    if schemas:
+        attempted = ensure_schemas(engine, schemas)
+
+    listener = None
+    if sqlite_attachments:
+        listener = register_sqlite_attach(engine, sqlite_attachments)
+        if immediate and getattr(engine.dialect, "name", "") == "sqlite":
+            try:
+                with engine.connect() as conn:
+                    dbapi = getattr(conn, "connection", None)
+                    if dbapi is not None:
+                        _attach_sqlite_dbapi(dbapi, sqlite_attachments)
+            except Exception:
+                pass
+
+    return {
+        "attempted_schemas": attempted,
+        "sqlite_attachments": dict(sqlite_attachments or {}),
+        "listener": listener,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Internal creation helper
+# ---------------------------------------------------------------------------
+
+
+def _create_all_on_bind(
+    bind,
+    *,
+    schemas: Iterable[str] | None = None,
+    sqlite_attachments: Mapping[str, str] | None = None,
+    tables: Iterable[Any] | None = None,
+) -> None:
+    engine = getattr(bind, "engine", bind)
+    tables = list(tables or [])
+
+    schema_names = set(schemas or [])
+    for t in tables:
+        if getattr(t, "schema", None):
+            schema_names.add(t.schema)
+
+    attachments = sqlite_attachments
+    if attachments is None and getattr(engine.dialect, "name", "") == "sqlite":
+        if schema_names:
+            attachments = sqlite_default_attach_map(engine, schema_names)
+
+    if attachments:
+        bootstrap_dbschema(
+            engine,
+            schemas=schema_names,
+            sqlite_attachments=attachments,
+            immediate=True,
+        )
+    else:
+        ensure_schemas(engine, schema_names)
+
+    by_meta: dict[Any, list[Any]] = {}
+    for t in tables:
+        by_meta.setdefault(t.metadata, []).append(t)
+    for md, group in by_meta.items():
+        md.create_all(bind=bind, checkfirst=True, tables=group)
+
+
+# ---------------------------------------------------------------------------
+# Public initialize
+# ---------------------------------------------------------------------------
+
+
+def initialize(
+    obj: Any,
+    *,
+    schemas: Iterable[str] | None = None,
+    sqlite_attachments: Mapping[str, str] | None = None,
+    tables: Iterable[Any] | None = None,
+):
+    if getattr(obj, "_ddl_executed", False):
+        return
+
+    ts = list(tables or [])
+    if not ts:
+        if hasattr(obj, "_collect_tables"):
+            ts = list(obj._collect_tables())  # type: ignore[attr-defined]
+        elif hasattr(obj, "__table__"):
+            ts = [obj.__table__]  # type: ignore[attr-defined]
+
+    kwargs: Dict[str, Any] = {}
+    if hasattr(obj, "_collect_tables"):
+        kwargs["api"] = obj
+    elif hasattr(obj, "__table__"):
+        kwargs["model"] = obj
+
+    prov = _resolver.resolve_provider(**kwargs)
+    if prov is None:
+        raise ValueError("Engine provider is not configured")
+
+    def _bootstrap(db):
+        bind = db.get_bind() if hasattr(db, "get_bind") else db
+        _create_all_on_bind(
+            bind,
+            schemas=schemas,
+            sqlite_attachments=sqlite_attachments,
+            tables=ts,
+        )
+
+        if hasattr(obj, "models"):
+            tables_map = {
+                name: getattr(m, "__table__", None)
+                for name, m in getattr(obj, "models").items()
+                if hasattr(m, "__table__")
+            }
+            existing = getattr(obj, "tables", None)
+            if isinstance(existing, dict):
+                existing.update(tables_map)
+            elif existing is not None:
+                for k, v in tables_map.items():
+                    setattr(existing, k, v)
+            else:
+                setattr(obj, "tables", SimpleNamespace(**tables_map))
+
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        # No running event loop; fall back to fully synchronous bootstrap
+        with next(prov.get_db()) as db:
+            _bootstrap(db)
+        setattr(obj, "_ddl_executed", True)
+        return
+    else:
+        # If we're already inside an event loop but the provider is synchronous
+        # (i.e. ``get_db`` is neither coroutine nor async generator), we can
+        # bootstrap synchronously as well. This mirrors previous "initialize_sync"
+        # behaviour and allows ``initialize()`` to be invoked without ``await``
+        # from async contexts when using sync engines.
+        if not inspect.iscoroutinefunction(
+            prov.get_db
+        ) and not inspect.isasyncgenfunction(prov.get_db):
+            with next(prov.get_db()) as db:
+                _bootstrap(db)
+            setattr(obj, "_ddl_executed", True)
+
+            class _Completed:
+                def __await__(self):  # pragma: no cover - trivial
+                    if False:
+                        yield None
+                    return None
+
+            return _Completed()
+
+        async def _inner():
+            if inspect.isasyncgenfunction(prov.get_db):
+                async for adb in prov.get_db():
+                    await adb.run_sync(_bootstrap)
+                    break
+            else:
+                gen = prov.get_db()
+                db = next(gen)
+                try:
+                    if hasattr(db, "run_sync"):
+                        await db.run_sync(_bootstrap)
+                    else:
+                        bind = db.get_bind()
+                        await asyncio.to_thread(
+                            _create_all_on_bind,
+                            bind,
+                            schemas=schemas,
+                            sqlite_attachments=sqlite_attachments,
+                            tables=ts,
+                        )
+                finally:
+                    try:
+                        next(gen)
+                    except StopIteration:
+                        pass
+            setattr(obj, "_ddl_executed", True)
+
+        return _inner()

tigrbl/decorators.py

@@ -0,0 +1,17 @@
+"""Compatibility layer for decorator imports."""
+
+from __future__ import annotations
+
+from .op.decorators import *  # noqa: F401,F403
+from .hook.decorators import *  # noqa: F401,F403
+from .schema.decorators import schema_ctx
+from .engine.decorators import engine_ctx
+from .op.decorators import __all__ as _op_all
+from .hook.decorators import __all__ as _hook_all
+
+__all__ = [
+    *_op_all,
+    *_hook_all,
+    "schema_ctx",
+    "engine_ctx",
+]

tigrbl/deps/__init__.py

@@ -0,0 +1,20 @@
+# ── Third-party Dependencies Re-exports ─────────────────────────────────
+"""
+Centralized third-party dependency imports for tigrbl.
+
+This module provides a single location for all third-party dependencies,
+making it easier to manage versions and potential replacements.
+"""
+
+# Re-export all SQLAlchemy dependencies
+from .sqlalchemy import relationship  # noqa: F401
+from .sqlalchemy import *  # noqa: F403, F401
+
+# Re-export all Pydantic dependencies
+from .pydantic import *  # noqa: F403, F401
+
+# Re-export all FastAPI dependencies
+from .fastapi import *  # noqa: F403, F401
+
+# Note: starlette.py is reserved for future Starlette-specific imports
+# if we need to import directly from Starlette rather than through FastAPI

tigrbl/deps/fastapi.py

@@ -0,0 +1,45 @@
+# ── FastAPI Imports ─────────────────────────────────────────────────────
+from fastapi import (
+    APIRouter,
+    FastAPI,
+    Security,
+    Depends,
+    Request,
+    Response,
+    Path as FastAPIPath,
+    Body,
+    HTTPException,
+)
+from fastapi.responses import FileResponse
+from pathlib import Path as FilePath
+
+Router = APIRouter
+Path = FastAPIPath
+
+FAVICON_PATH = FilePath(__file__).with_name("favicon.svg")
+
+
+def App(*args, **kwargs):
+    app = FastAPI(*args, **kwargs)
+
+    @app.get("/favicon.ico", include_in_schema=False)
+    async def favicon() -> FileResponse:  # pragma: no cover - simple static route
+        return FileResponse(FAVICON_PATH, media_type="image/svg+xml")
+
+    return app
+
+
+# ── Public Exports ───────────────────────────────────────────────────────
+__all__ = [
+    "APIRouter",
+    "Router",
+    "FastAPI",
+    "Security",
+    "Depends",
+    "Request",
+    "Response",
+    "Path",
+    "Body",
+    "HTTPException",
+    "App",
+]

tigrbl/deps/favicon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" fill="#4f46e5"/>
+  <text x="16" y="21" font-size="18" text-anchor="middle" fill="#fff">A</text>
+</svg>

tigrbl/deps/jinja.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+try:  # pragma: no cover - optional dependency
+    from jinja2 import (
+        Environment,
+        FileSystemLoader,
+        PackageLoader,
+        ChoiceLoader,
+        select_autoescape,
+        TemplateNotFound,
+    )
+except Exception:  # pragma: no cover
+    Environment = None  # type: ignore
+    FileSystemLoader = None  # type: ignore
+    PackageLoader = None  # type: ignore
+    ChoiceLoader = None  # type: ignore
+    select_autoescape = None  # type: ignore
+    TemplateNotFound = None  # type: ignore
+
+__all__ = [
+    "Environment",
+    "FileSystemLoader",
+    "PackageLoader",
+    "ChoiceLoader",
+    "select_autoescape",
+    "TemplateNotFound",
+]

tigrbl/deps/pydantic.py

@@ -0,0 +1,10 @@
+# ── Pydantic Imports ────────────────────────────────────────────────────
+from pydantic import BaseModel, Field, ValidationError
+
+
+# ── Public Exports ───────────────────────────────────────────────────────
+__all__ = [
+    "BaseModel",
+    "Field",
+    "ValidationError",
+]

tigrbl/deps/sqlalchemy.py

@@ -0,0 +1,94 @@
+# ── SQLAlchemy Core ──────────────────────────────────────────────────────
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime as _DateTime,
+    Enum as SAEnum,
+    Text,
+    ForeignKey,
+    Index,
+    Integer,
+    JSON,
+    Numeric,
+    String,
+    LargeBinary,
+    UniqueConstraint,
+    CheckConstraint,
+    create_engine,
+    event,
+)
+
+# ── SQLAlchemy PostgreSQL Dialect ────────────────────────────────────────
+from sqlalchemy.dialects.postgresql import (
+    ARRAY,
+    ENUM as PgEnum,
+    JSONB,
+    UUID as _PgUUID,
+    TSVECTOR,
+)
+
+# ── SQLAlchemy ORM ───────────────────────────────────────────────────────
+from sqlalchemy.orm import (
+    Mapped,
+    declarative_mixin,
+    declared_attr,
+    foreign,
+    mapped_column,
+    relationship,
+    remote,
+    column_property,
+    Session,
+    sessionmaker,
+    InstrumentedAttribute,
+)
+
+from sqlalchemy.pool import StaticPool
+
+# ── SQLAlchemy Extensions ────────────────────────────────────────────────
+from sqlalchemy.ext.mutable import MutableDict, MutableList
+from sqlalchemy.ext.hybrid import hybrid_property
+
+
+# ── Public Exports ───────────────────────────────────────────────────────
+__all__ = [
+    # Core types
+    "Boolean",
+    "Column",
+    "_DateTime",
+    "SAEnum",
+    "Text",
+    "ForeignKey",
+    "Index",
+    "Integer",
+    "JSON",
+    "Numeric",
+    "String",
+    "LargeBinary",
+    "UniqueConstraint",
+    "CheckConstraint",
+    "create_engine",
+    "StaticPool",
+    "event",
+    # PostgreSQL dialect
+    "ARRAY",
+    "PgEnum",
+    "JSONB",
+    "_PgUUID",
+    "TSVECTOR",
+    # ORM
+    "Mapped",
+    "declarative_mixin",
+    "declared_attr",
+    "foreign",
+    "mapped_column",
+    "relationship",
+    "remote",
+    "column_property",
+    "Session",
+    "sessionmaker",
+    "InstrumentedAttribute",
+    # Extensions
+    "MutableDict",
+    "MutableList",
+    "hybrid_property",
+]

tigrbl/deps/starlette.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+try:  # pragma: no cover - optional runtime dependency
+    from starlette.background import BackgroundTask
+    from starlette.requests import Request
+    from starlette.responses import (
+        Response,
+        JSONResponse,
+        HTMLResponse,
+        PlainTextResponse,
+        StreamingResponse,
+        FileResponse,
+        RedirectResponse,
+    )
+except Exception:  # pragma: no cover
+    BackgroundTask = None  # type: ignore
+    Request = None  # type: ignore
+    Response = None  # type: ignore
+    JSONResponse = None  # type: ignore
+    HTMLResponse = None  # type: ignore
+    PlainTextResponse = None  # type: ignore
+    StreamingResponse = None  # type: ignore
+    FileResponse = None  # type: ignore
+    RedirectResponse = None  # type: ignore
+
+__all__ = [
+    "BackgroundTask",
+    "Request",
+    "Response",
+    "JSONResponse",
+    "HTMLResponse",
+    "PlainTextResponse",
+    "StreamingResponse",
+    "FileResponse",
+    "RedirectResponse",
+]

tigrbl/engine/__init__.py

@@ -0,0 +1,26 @@
+"""Engine utilities for collecting and binding database providers."""
+
+from .bind import bind, install_from_objects
+from .collect import collect_engine_config
+from .builders import (
+    async_postgres_engine,
+    async_sqlite_engine,
+    blocking_postgres_engine,
+    blocking_sqlite_engine,
+    HybridSession,
+)
+from ._engine import Engine
+from .shortcuts import engine
+
+__all__ = [
+    "collect_engine_config",
+    "bind",
+    "install_from_objects",
+    "blocking_sqlite_engine",
+    "blocking_postgres_engine",
+    "async_sqlite_engine",
+    "async_postgres_engine",
+    "HybridSession",
+    "Engine",
+    "engine",
+]