dpmcore 0.0.1__py3-none-any.whl

dpmcore/__init__.py

@@ -0,0 +1,7 @@
+"""Your opinionated Python DPM library."""
+
+__version__ = "1.0.0"
+
+from dpmcore.connection import DpmConnection, connect
+
+__all__ = ["__version__", "connect", "DpmConnection"]

dpmcore/cli/__init__.py

@@ -0,0 +1 @@
+"""Command-line interface for dpmcore."""

dpmcore/cli/main.py

@@ -0,0 +1,111 @@
+"""CLI entry point for dpmcore.
+
+Usage::
+
+    dpmcore migrate --source /path/to/file.accdb --database sqlite:///dpm.db
+    dpmcore serve --database sqlite:///dpm.db
+    dpmcore --version
+"""
+
+from __future__ import annotations
+
+import sys
+
+import click
+
+from dpmcore import __version__
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="dpmcore")
+def main() -> None:
+    """Dpmcore — Data Point Model toolkit."""
+
+
+@main.command()
+@click.option(
+    "--source",
+    required=True,
+    type=click.Path(exists=True),
+    help="Path to Access .accdb / .mdb file.",
+)
+@click.option(
+    "--database",
+    required=True,
+    help="SQLAlchemy database URL (e.g. sqlite:///dpm.db).",
+)
+def migrate(source: str, database: str) -> None:
+    """Migrate an Access database into a SQL database."""
+    try:
+        from rich.console import Console
+        from rich.table import Table
+    except ImportError:
+        click.echo(
+            "Install 'rich' for pretty output: "
+            "pip install dpmcore[cli]",
+            err=True,
+        )
+        sys.exit(1)
+
+    from sqlalchemy import create_engine
+
+    from dpmcore.services.migration import (
+        MigrationError,
+        MigrationService,
+    )
+
+    console = Console()
+
+    engine = create_engine(database)
+    service = MigrationService(engine)
+
+    try:
+        result = service.migrate_from_access(source)
+    except MigrationError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        sys.exit(1)
+
+    # Display results.
+    table = Table(title="Migration Results")
+    table.add_column("Table", style="cyan")
+    table.add_column("Rows", justify="right", style="green")
+
+    for name, rows in result.table_details.items():
+        table.add_row(name, str(rows))
+
+    console.print(table)
+    console.print(
+        f"\n[bold]Total:[/bold] {result.tables_migrated} tables, "
+        f"{result.total_rows} rows "
+        f"(backend: {result.backend_used})"
+    )
+
+    for warning in result.warnings:
+        console.print(f"[yellow]Warning:[/yellow] {warning}")
+
+
+@main.command()
+@click.option(
+    "--database",
+    required=True,
+    help="SQLAlchemy database URL.",
+)
+@click.option("--host", default="127.0.0.1", help="Bind host.")
+@click.option("--port", default=8000, type=int, help="Bind port.")
+def serve(database: str, host: str, port: int) -> None:
+    """Start the dpmcore REST API server."""
+    try:
+        import uvicorn  # type: ignore[import-untyped]
+    except ImportError:
+        click.echo(
+            "Server dependencies not installed. Run:\n"
+            "  pip install dpmcore[server]",
+            err=True,
+        )
+        sys.exit(1)
+
+    # Import here so the server module is only loaded when needed.
+    from dpmcore.server.app import create_app  # type: ignore[import-not-found]
+
+    app = create_app(database)
+    uvicorn.run(app, host=host, port=port)

dpmcore/connection.py

@@ -0,0 +1,207 @@
+"""Connection management for standalone library usage (Mode 1).
+
+Usage::
+
+    from dpmcore import connect
+
+    db = connect("sqlite:///path/to/dpm.db")
+    result = db.services.dpm_xl.validate_syntax("v1 = v2")
+    db.close()
+
+Or as a context manager::
+
+    with connect("sqlite:///path/to/dpm.db") as db:
+        result = db.services.dpm_xl.validate_syntax("v1 = v2")
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from sqlalchemy import Engine, create_engine
+from sqlalchemy.orm import Session, sessionmaker
+
+# Ensure all ORM modules are imported so relationships resolve.
+import dpmcore.orm  # noqa: F401
+
+
+class _ServiceAccessor:
+    """Lazy container that instantiates services on first access."""
+
+    def __init__(self, session: Session, engine: Engine) -> None:
+        self._session = session
+        self._engine = engine
+        self._cache: Dict[str, Any] = {}
+
+    # ------------------------------------------------------------------ #
+    # DPM-XL services
+    # ------------------------------------------------------------------ #
+
+    @property
+    def dpm_xl(self):
+        from dpmcore.services.dpm_xl import DpmXlService
+
+        if "dpm_xl" not in self._cache:
+            self._cache["dpm_xl"] = DpmXlService(self._session)
+        return self._cache["dpm_xl"]
+
+    @property
+    def syntax(self):
+        from dpmcore.services.syntax import SyntaxService
+
+        if "syntax" not in self._cache:
+            self._cache["syntax"] = SyntaxService()
+        return self._cache["syntax"]
+
+    @property
+    def semantic(self):
+        from dpmcore.services.semantic import SemanticService
+
+        if "semantic" not in self._cache:
+            self._cache["semantic"] = SemanticService(self._session)
+        return self._cache["semantic"]
+
+    @property
+    def ast_generator(self):
+        from dpmcore.services.ast_generator import ASTGeneratorService
+
+        if "ast_generator" not in self._cache:
+            self._cache["ast_generator"] = ASTGeneratorService(self._session)
+        return self._cache["ast_generator"]
+
+    @property
+    def scope_calculator(self):
+        from dpmcore.services.scope_calculator import ScopeCalculatorService
+
+        if "scope_calculator" not in self._cache:
+            self._cache["scope_calculator"] = ScopeCalculatorService(
+                self._session,
+            )
+        return self._cache["scope_calculator"]
+
+    # ------------------------------------------------------------------ #
+    # Data dictionary / explorer / hierarchy
+    # ------------------------------------------------------------------ #
+
+    @property
+    def data_dictionary(self):
+        from dpmcore.services.data_dictionary import DataDictionaryService
+
+        if "data_dictionary" not in self._cache:
+            self._cache["data_dictionary"] = DataDictionaryService(
+                self._session,
+            )
+        return self._cache["data_dictionary"]
+
+    @property
+    def explorer(self):
+        from dpmcore.services.explorer import ExplorerService
+
+        if "explorer" not in self._cache:
+            self._cache["explorer"] = ExplorerService(self._session)
+        return self._cache["explorer"]
+
+    @property
+    def hierarchy(self):
+        from dpmcore.services.hierarchy import HierarchyService
+
+        if "hierarchy" not in self._cache:
+            self._cache["hierarchy"] = HierarchyService(self._session)
+        return self._cache["hierarchy"]
+
+    # ------------------------------------------------------------------ #
+    # Structure service
+    # ------------------------------------------------------------------ #
+
+    @property
+    def structure(self):
+        from dpmcore.services.structure import StructureService
+
+        if "structure" not in self._cache:
+            self._cache["structure"] = StructureService(self._session)
+        return self._cache["structure"]
+
+    # ------------------------------------------------------------------ #
+    # Migration (requires Engine, not Session)
+    # ------------------------------------------------------------------ #
+
+    @property
+    def migration(self):
+        from dpmcore.services.migration import MigrationService
+
+        if "migration" not in self._cache:
+            self._cache["migration"] = MigrationService(self._engine)
+        return self._cache["migration"]
+
+
+class DpmConnection:
+    """A connection to a DPM database.
+
+    Holds a SQLAlchemy engine + session and exposes services through
+    the :attr:`services` accessor.
+
+    Args:
+        url: SQLAlchemy connection URL.
+        pool_config: Optional engine keyword arguments (pool_size,
+            max_overflow, etc.).
+    """
+
+    def __init__(
+        self,
+        url: str,
+        pool_config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        engine_kwargs: Dict[str, Any] = {"pool_pre_ping": True}
+        if pool_config:
+            engine_kwargs.update(pool_config)
+
+        self.engine = create_engine(url, **engine_kwargs)
+        self._session_factory = sessionmaker(bind=self.engine)
+        self.session: Session = self._session_factory()
+        self.services = _ServiceAccessor(self.session, self.engine)
+
+    # ------------------------------------------------------------------ #
+    # ORM access
+    # ------------------------------------------------------------------ #
+
+    @property
+    def orm(self):
+        """Direct access to the SQLAlchemy session for advanced ORM
+        queries."""
+        return self.session
+
+    # ------------------------------------------------------------------ #
+    # Lifecycle
+    # ------------------------------------------------------------------ #
+
+    def close(self) -> None:
+        """Close the session and dispose the engine."""
+        self.session.close()
+        self.engine.dispose()
+
+    def __enter__(self) -> "DpmConnection":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"<DpmConnection url={self.engine.url!r}>"
+
+
+def connect(
+    url: str,
+    pool_config: Optional[Dict[str, Any]] = None,
+) -> DpmConnection:
+    """Open a connection to a DPM database.
+
+    Args:
+        url: A SQLAlchemy connection URL, e.g.
+            ``"sqlite:///path/to/dpm.db"`` or
+            ``"postgresql://user:pass@host:5432/db"``.
+        pool_config: Optional engine keyword arguments.
+
+    Returns:
+        A :class:`DpmConnection` instance.
+    """
+    return DpmConnection(url, pool_config=pool_config)

dpmcore/django/__init__.py

@@ -0,0 +1,15 @@
+"""Django integration for dpmcore (Mode 3).
+
+Add ``"dpmcore.django"`` to ``INSTALLED_APPS`` to expose
+read-only Django ORM models backed by the DPM database.
+
+Requires Django 5.2+.
+"""
+
+try:
+    import django  # noqa: F401
+except ImportError as exc:
+    raise ImportError(
+        "Django is required for dpmcore.django. "
+        "Install it with: pip install dpmcore[django]"
+    ) from exc