trellis-datamodel 0.3.3__py3-none-any.whl

trellis_datamodel/cli.py

@@ -0,0 +1,292 @@
+"""
+Trellis CLI
+
+Command-line interface for Trellis - visual data model editor for dbt projects.
+"""
+
+import typer
+import uvicorn
+import webbrowser
+from pathlib import Path
+from typing import Optional
+
+from trellis_datamodel import __version__
+from trellis_datamodel import config as cfg
+from trellis_datamodel.config import (
+    load_config,
+    find_config_file,
+    print_config,
+)
+
+app = typer.Typer(
+    name="trellis",
+    help="Trellis - Visual data model editor for dbt projects",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", help="Show version and exit"),
+):
+    """Trellis - Visual data model editor for dbt projects."""
+    if version:
+        typer.echo(__version__)
+        raise typer.Exit()
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+@app.command()
+def run(
+    port: int = typer.Option(8089, "--port", "-p", help="Port to run the server on"),
+    config: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to config file (trellis.yml or config.yml)"
+    ),
+    no_browser: bool = typer.Option(
+        False, "--no-browser", help="Don't open browser automatically"
+    ),
+):
+    """
+    Start the Trellis server.
+
+    Looks for trellis.yml or config.yml in the current directory.
+    """
+    # Load configuration
+    import os
+
+    # Allow running without config file if test environment variables are set
+    is_test_mode = bool(
+        os.environ.get("DATAMODEL_DATA_MODEL_PATH")
+        or os.environ.get("DATAMODEL_TEST_DIR")
+    )
+
+    config_path = config
+    if not config_path:
+        found_config = find_config_file()
+        if not found_config:
+            if is_test_mode:
+                # Test mode: allow running without config file
+                config_path = None
+            else:
+                cwd = os.getcwd()
+                expected_path = os.path.join(cwd, "trellis.yml")
+                typer.echo(
+                    typer.style(
+                        "Error: No config file found.",
+                        fg=typer.colors.RED,
+                    )
+                )
+                typer.echo(f"   Expected location: {expected_path}")
+                typer.echo()
+                typer.echo("   Run 'trellis init' to create a starter config file.")
+                raise typer.Exit(1)
+        else:
+            config_path = found_config
+
+    if config_path:
+        load_config(config_path)
+    elif is_test_mode:
+        # Test mode: config will be loaded from environment variables
+        load_config(None)
+
+    # Print startup info
+    typer.echo(
+        typer.style(f"🌿 Trellis Data v{__version__}", fg=typer.colors.GREEN, bold=True)
+    )
+    typer.echo(f"   Loading config from {config_path}")
+    print_config()
+    typer.echo()
+
+    # Start server
+    url = f"http://localhost:{port}"
+    typer.echo(typer.style(f"   Server running at {url}", fg=typer.colors.CYAN))
+    typer.echo("   Press Ctrl+C to stop")
+    typer.echo()
+
+    # Open browser
+    if not no_browser:
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass  # Ignore browser errors
+
+    # Run server
+    uvicorn.run(
+        "trellis_datamodel.server:app",
+        host="0.0.0.0",
+        port=port,
+        reload=False,  # Disable reload in production
+        log_level="info",
+    )
+
+
+@app.command(name="serve")
+def serve(
+    port: int = typer.Option(8089, "--port", "-p", help="Port to run the server on"),
+    config: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to config file (trellis.yml or config.yml)"
+    ),
+    no_browser: bool = typer.Option(
+        False, "--no-browser", help="Don't open browser automatically"
+    ),
+):
+    """
+    Start the Trellis server (alias for 'run').
+
+    Looks for trellis.yml or config.yml in the current directory.
+    """
+    # Delegate to run function
+    run(port=port, config=config, no_browser=no_browser)
+
+
+@app.command()
+def init():
+    """
+    Initialize a new trellis.yml config file in the current directory.
+    """
+    config_file = Path("trellis.yml")
+    if config_file.exists():
+        typer.echo(
+            typer.style(
+                "trellis.yml already exists in this directory.", fg=typer.colors.YELLOW
+            )
+        )
+        raise typer.Exit(1)
+
+    default_config = """\
+# Trellis configuration
+framework: dbt-core
+dbt_project_path: "."
+dbt_manifest_path: "target/manifest.json"
+dbt_catalog_path: "target/catalog.json"
+data_model_file: "data_model.yml"
+dbt_model_paths: []  # Empty = include all models
+"""
+    config_file.write_text(default_config)
+    typer.echo(typer.style("✓ Created trellis.yml", fg=typer.colors.GREEN))
+    typer.echo("  Edit the file to configure your dbt project paths, then run:")
+    typer.echo(typer.style("  trellis run", fg=typer.colors.CYAN))
+
+
+@app.command(name="generate-company-data")
+def generate_company_data(
+    config: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to config file (trellis.yml or config.yml)"
+    ),
+):
+    """
+    Generate mock commercial company data for modeling exercises.
+
+    Creates CSV files in dbt_company_dummy/data/ directory with realistic
+    commercial company data including departments, employees, leads, customers,
+    products, orders, and order items.
+
+    The path to the dbt company dummy project can be configured in trellis.yml
+    via the 'dbt_company_dummy_path' option (defaults to './dbt_company_dummy').
+    """
+    import sys
+    import importlib.util
+
+    # Load config to get dbt_company_dummy_path
+    config_path = config
+    if not config_path:
+        found_config = find_config_file()
+        if found_config:
+            config_path = found_config
+
+    if config_path:
+        load_config(config_path)
+
+    # Use configured path or fallback to default relative to current working directory
+    import os
+
+    if cfg.DBT_COMPANY_DUMMY_PATH:
+        generator_path = Path(cfg.DBT_COMPANY_DUMMY_PATH) / "generate_data.py"
+    else:
+        # Fallback: check current working directory first (for installed packages)
+        # This is the most common case when running from repo root
+        cwd_dummy_path = Path(os.getcwd()) / "dbt_company_dummy" / "generate_data.py"
+        if cwd_dummy_path.exists():
+            generator_path = cwd_dummy_path
+        else:
+            # Try repo root (for development when running from source)
+            project_root = Path(__file__).parent.parent
+            repo_dummy_path = project_root / "dbt_company_dummy" / "generate_data.py"
+            if repo_dummy_path.exists():
+                generator_path = repo_dummy_path
+            else:
+                # Last resort: use current working directory even if it doesn't exist yet
+                # (will show helpful error message)
+                generator_path = cwd_dummy_path
+
+    if not generator_path.exists():
+        import os
+
+        typer.echo(
+            typer.style(
+                f"Error: Generator script not found at {generator_path}",
+                fg=typer.colors.RED,
+            )
+        )
+        typer.echo()
+        typer.echo("The generator script should be located at:")
+        if cfg.DBT_COMPANY_DUMMY_PATH:
+            typer.echo(f"  {cfg.DBT_COMPANY_DUMMY_PATH}/generate_data.py")
+            typer.echo()
+            typer.echo("This path is configured in your trellis.yml file.")
+        else:
+            typer.echo(f"  {os.getcwd()}/dbt_company_dummy/generate_data.py")
+            typer.echo()
+            typer.echo(
+                "Make sure you're running this command from the repository root,"
+            )
+            typer.echo(
+                "or configure 'dbt_company_dummy_path' in your trellis.yml file."
+            )
+        raise typer.Exit(1)
+
+    # Load and run the generator module
+    try:
+        spec = importlib.util.spec_from_file_location("generate_data", generator_path)
+        generator_module = importlib.util.module_from_spec(spec)
+        sys.modules["generate_data"] = generator_module
+        spec.loader.exec_module(generator_module)
+
+        # Call the main function
+        generator_module.main()
+
+        typer.echo()
+        typer.echo(
+            typer.style(
+                "✓ Company dummy data generation completed successfully!",
+                fg=typer.colors.GREEN,
+            )
+        )
+    except ImportError as e:
+        typer.echo(
+            typer.style(
+                f"Error: Missing dependency - {e}",
+                fg=typer.colors.RED,
+            )
+        )
+        typer.echo(
+            "  Install required dependencies with: pip install trellis-datamodel[dbt-example]"
+        )
+        typer.echo("  Or install directly: pip install pandas faker")
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.echo(
+            typer.style(
+                f"Error generating data: {e}",
+                fg=typer.colors.RED,
+            )
+        )
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

trellis_datamodel/config.py

@@ -0,0 +1,239 @@
+"""
+Configuration loading for Trellis Data.
+Centralizes all path resolution logic.
+
+For testing, set environment variable DATAMODEL_TEST_DIR to a temp directory path.
+This will override all paths to use that directory.
+"""
+
+import os
+import yaml
+from pathlib import Path
+from typing import Optional
+
+# Check for test mode - allows overriding config via environment
+_TEST_DIR = os.environ.get("DATAMODEL_TEST_DIR", "")
+
+if _TEST_DIR:
+    # Test mode: use temp directory paths
+    CONFIG_PATH = os.path.join(_TEST_DIR, "config.yml")
+    FRAMEWORK: str = os.environ.get("DATAMODEL_FRAMEWORK", "dbt-core")
+    MANIFEST_PATH: str = os.environ.get(
+        "DATAMODEL_MANIFEST_PATH", os.path.join(_TEST_DIR, "manifest.json")
+    )
+    CATALOG_PATH: str = os.environ.get(
+        "DATAMODEL_CATALOG_PATH", os.path.join(_TEST_DIR, "catalog.json")
+    )
+    DATA_MODEL_PATH: str = os.environ.get(
+        "DATAMODEL_DATA_MODEL_PATH", os.path.join(_TEST_DIR, "data_model.yml")
+    )
+    CANVAS_LAYOUT_PATH: str = os.environ.get(
+        "DATAMODEL_CANVAS_LAYOUT_PATH", os.path.join(_TEST_DIR, "canvas_layout.yml")
+    )
+    CANVAS_LAYOUT_VERSION_CONTROL: bool = (
+        os.environ.get("DATAMODEL_CANVAS_LAYOUT_VERSION_CONTROL", "true").lower()
+        == "true"
+    )
+    DBT_PROJECT_PATH: str = _TEST_DIR
+    DBT_MODEL_PATHS: list[str] = ["3_core"]
+    FRONTEND_BUILD_DIR: str = os.path.join(_TEST_DIR, "frontend/build")
+    DBT_COMPANY_DUMMY_PATH: str = os.path.join(_TEST_DIR, "dbt_company_dummy")
+else:
+    # Production mode: will be set by load_config()
+    CONFIG_PATH: str = ""
+    FRAMEWORK: str = "dbt-core"
+    MANIFEST_PATH: str = ""
+    CATALOG_PATH: str = ""
+    DATA_MODEL_PATH: str = ""
+    CANVAS_LAYOUT_PATH: str = ""
+    CANVAS_LAYOUT_VERSION_CONTROL: bool = True
+    DBT_PROJECT_PATH: str = ""
+    DBT_MODEL_PATHS: list[str] = []
+    FRONTEND_BUILD_DIR: str = ""
+    DBT_COMPANY_DUMMY_PATH: str = ""
+
+
+def find_config_file(config_override: Optional[str] = None) -> Optional[str]:
+    """
+    Find config file in order of priority:
+    1. CLI override (--config)
+    2. trellis.yml in current directory
+    3. config.yml in current directory (fallback)
+
+    Returns:
+        Path to config file or None if not found
+    """
+    if config_override:
+        if os.path.exists(config_override):
+            return os.path.abspath(config_override)
+        return None
+
+    cwd = os.getcwd()
+
+    # Try trellis.yml first
+    trellis_yml = os.path.join(cwd, "trellis.yml")
+    if os.path.exists(trellis_yml):
+        return os.path.abspath(trellis_yml)
+
+    # Fallback to config.yml
+    config_yml = os.path.join(cwd, "config.yml")
+    if os.path.exists(config_yml):
+        return os.path.abspath(config_yml)
+
+    return None
+
+
+def load_config(config_path: Optional[str] = None) -> None:
+    """Load and resolve all paths from config file."""
+    global FRAMEWORK, MANIFEST_PATH, DATA_MODEL_PATH, DBT_MODEL_PATHS, CATALOG_PATH, DBT_PROJECT_PATH, CANVAS_LAYOUT_PATH, CANVAS_LAYOUT_VERSION_CONTROL, CONFIG_PATH, FRONTEND_BUILD_DIR, DBT_COMPANY_DUMMY_PATH
+
+    # Skip loading config file in test mode (paths already set via environment)
+    if _TEST_DIR:
+        return
+
+    # Find config file
+    if config_path:
+        CONFIG_PATH = config_path
+    else:
+        found_config = find_config_file()
+        if not found_config:
+            # No config found - use defaults
+            CONFIG_PATH = ""
+            return
+        CONFIG_PATH = found_config
+
+    if not os.path.exists(CONFIG_PATH):
+        return
+
+    try:
+        with open(CONFIG_PATH, "r") as f:
+            config = yaml.safe_load(f) or {}
+
+        # 0. Get framework (defaults to dbt-core)
+        FRAMEWORK = config.get("framework", "dbt-core")
+
+        # 1. Get dbt_project_path (Required for resolving other paths)
+        if "dbt_project_path" in config:
+            p = config["dbt_project_path"]
+            if not os.path.isabs(p):
+                # Resolve relative to config file location
+                DBT_PROJECT_PATH = os.path.abspath(
+                    os.path.join(os.path.dirname(CONFIG_PATH), p)
+                )
+            else:
+                DBT_PROJECT_PATH = p
+        else:
+            DBT_PROJECT_PATH = ""
+
+        # 2. Resolve Manifest
+        if "dbt_manifest_path" in config:
+            p = config["dbt_manifest_path"]
+            if not os.path.isabs(p) and DBT_PROJECT_PATH:
+                MANIFEST_PATH = os.path.abspath(os.path.join(DBT_PROJECT_PATH, p))
+            elif os.path.isabs(p):
+                MANIFEST_PATH = p
+            else:
+                MANIFEST_PATH = os.path.abspath(
+                    os.path.join(os.path.dirname(CONFIG_PATH), p)
+                )
+
+        # 3. Resolve Catalog
+        if "dbt_catalog_path" in config:
+            p = config["dbt_catalog_path"]
+            if not os.path.isabs(p) and DBT_PROJECT_PATH:
+                CATALOG_PATH = os.path.abspath(os.path.join(DBT_PROJECT_PATH, p))
+            elif os.path.isabs(p):
+                CATALOG_PATH = p
+            else:
+                CATALOG_PATH = os.path.abspath(
+                    os.path.join(os.path.dirname(CONFIG_PATH), p)
+                )
+
+        # 4. Resolve Data Model (env var takes precedence)
+        if (
+            "DATAMODEL_DATA_MODEL_PATH" not in os.environ
+            and "data_model_file" in config
+        ):
+            p = config["data_model_file"]
+            if not os.path.isabs(p):
+                base_path = DBT_PROJECT_PATH or os.path.dirname(CONFIG_PATH)
+                DATA_MODEL_PATH = os.path.abspath(os.path.join(base_path, p))
+            else:
+                DATA_MODEL_PATH = p
+
+        # 5. Model path filters
+        if "dbt_model_paths" in config:
+            DBT_MODEL_PATHS = config["dbt_model_paths"]
+
+        # 6. Resolve Canvas Layout (defaults to canvas_layout.yml next to data model)
+        if "canvas_layout_file" in config:
+            p = config["canvas_layout_file"]
+            if not os.path.isabs(p):
+                base_path = DBT_PROJECT_PATH or os.path.dirname(CONFIG_PATH)
+                CANVAS_LAYOUT_PATH = os.path.abspath(os.path.join(base_path, p))
+            else:
+                CANVAS_LAYOUT_PATH = p
+        else:
+            # Default: canvas_layout.yml next to data_model.yml
+            if DATA_MODEL_PATH:
+                data_model_dir = os.path.dirname(DATA_MODEL_PATH)
+                CANVAS_LAYOUT_PATH = os.path.abspath(
+                    os.path.join(data_model_dir, "canvas_layout.yml")
+                )
+            else:
+                CANVAS_LAYOUT_PATH = os.path.abspath(
+                    os.path.join(os.path.dirname(CONFIG_PATH), "canvas_layout.yml")
+                )
+
+        # 7. Canvas layout version control setting
+        if "canvas_layout_version_control" in config:
+            CANVAS_LAYOUT_VERSION_CONTROL = config["canvas_layout_version_control"]
+
+        # 8. Frontend build directory
+        fe_env = os.environ.get("DATAMODEL_FRONTEND_BUILD_DIR")
+        if fe_env:
+            FRONTEND_BUILD_DIR = fe_env
+        elif "frontend_build_dir" in config:
+            p = config["frontend_build_dir"]
+            if not os.path.isabs(p):
+                FRONTEND_BUILD_DIR = os.path.abspath(
+                    os.path.join(os.path.dirname(CONFIG_PATH), p)
+                )
+            else:
+                FRONTEND_BUILD_DIR = p
+        else:
+            # Default: frontend/build next to config file (repo root)
+            FRONTEND_BUILD_DIR = os.path.abspath(
+                os.path.join(os.path.dirname(CONFIG_PATH), "frontend", "build")
+            )
+
+        # 9. Resolve dbt company dummy path (only if explicitly configured)
+        # If not configured, leave empty so CLI can use smart fallback logic
+        if "dbt_company_dummy_path" in config:
+            p = config["dbt_company_dummy_path"]
+            if not os.path.isabs(p):
+                DBT_COMPANY_DUMMY_PATH = os.path.abspath(
+                    os.path.join(os.path.dirname(CONFIG_PATH), p)
+                )
+            else:
+                DBT_COMPANY_DUMMY_PATH = p
+        # Note: No default set here - CLI handles fallback to cwd/dbt_company_dummy
+
+    except Exception as e:
+        print(f"Error loading config: {e}")
+
+
+def print_config() -> None:
+    """Print current configuration for debugging."""
+    print(f"Using Config: {CONFIG_PATH}")
+    print(f"Framework: {FRAMEWORK}")
+    print(f"Project Path: {DBT_PROJECT_PATH}")
+    print(f"Frontend build dir: {FRONTEND_BUILD_DIR}")
+    print(f"Looking for manifest at: {MANIFEST_PATH}")
+    print(f"Looking for catalog at: {CATALOG_PATH}")
+    print(f"Looking for data model at: {DATA_MODEL_PATH}")
+    print(f"Looking for canvas layout at: {CANVAS_LAYOUT_PATH}")
+    print(f"Canvas layout version control: {CANVAS_LAYOUT_VERSION_CONTROL}")
+    print(f"Filtering models by paths: {DBT_MODEL_PATHS}")
+    if DBT_COMPANY_DUMMY_PATH:
+        print(f"dbt company dummy path: {DBT_COMPANY_DUMMY_PATH}")

trellis_datamodel/models/__init__.py

@@ -0,0 +1,13 @@
+"""Pydantic models for API request/response schemas."""
+from .schemas import (
+    DataModelUpdate,
+    DbtSchemaRequest,
+    ModelSchemaRequest,
+)
+
+__all__ = [
+    "DataModelUpdate",
+    "DbtSchemaRequest",
+    "ModelSchemaRequest",
+]
+

trellis_datamodel/models/schemas.py

@@ -0,0 +1,28 @@
+"""Pydantic models for API request/response schemas."""
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+
+
+class DataModelUpdate(BaseModel):
+    """Schema for updating the data model."""
+    version: float = 0.1
+    entities: List[Dict[str, Any]]
+    relationships: List[Dict[str, Any]]
+
+
+class DbtSchemaRequest(BaseModel):
+    """Schema for creating a new dbt schema file."""
+    entity_id: str
+    model_name: str
+    fields: List[Dict[str, str]]
+    description: Optional[str] = None
+    tags: Optional[List[str]] = None
+
+
+class ModelSchemaRequest(BaseModel):
+    """Schema for updating model columns and metadata."""
+    columns: List[Dict[str, Any]]
+    description: Optional[str] = None
+    tags: Optional[List[str]] = None
+    version: Optional[int] = None
+

trellis_datamodel/routes/__init__.py

@@ -0,0 +1,11 @@
+"""API route modules."""
+from .manifest import router as manifest_router
+from .data_model import router as data_model_router
+from .schema import router as schema_router
+
+__all__ = [
+    "manifest_router",
+    "data_model_router",
+    "schema_router",
+]
+