databricks-tellr 0.1.15__tar.gz

databricks_tellr-0.1.15/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: databricks-tellr
+Version: 0.1.15
+Summary: Tellr deployment tooling for Databricks Apps
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: databricks-sdk>=0.20.0
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: pyyaml>=6.0.0
+
+# databricks-tellr
+
+Python deployment tooling for Tellr on Databricks Apps.
+
+## Usage
+
+```python
+import databricks_tellr as tellr
+
+!pip install --upgrade databricks-sdk==0.73.0
+
+result = tellr.setup(
+    lakebase_name="ai-slide-generator-db-dev",
+    schema_name="app_data_dev",
+    app_name="ai-slide-generator-dev",
+    app_file_workspace_path="/Workspace/Users/you@example.com/.apps/dev/ai-slide-generator",
+)
+
+print(result["url"])
+```

databricks_tellr-0.1.15/README.md

@@ -0,0 +1,20 @@
+# databricks-tellr
+
+Python deployment tooling for Tellr on Databricks Apps.
+
+## Usage
+
+```python
+import databricks_tellr as tellr
+
+!pip install --upgrade databricks-sdk==0.73.0
+
+result = tellr.setup(
+    lakebase_name="ai-slide-generator-db-dev",
+    schema_name="app_data_dev",
+    app_name="ai-slide-generator-dev",
+    app_file_workspace_path="/Workspace/Users/you@example.com/.apps/dev/ai-slide-generator",
+)
+
+print(result["url"])
+```

databricks_tellr-0.1.15/databricks_tellr/__init__.py

@@ -0,0 +1,5 @@
+"""Tellr deployment package for Databricks Apps."""
+
+from databricks_tellr.deploy import create, delete, update
+
+__all__ = ["create", "update", "delete"]

databricks_tellr-0.1.15/databricks_tellr/_templates/app.yaml.template

@@ -0,0 +1,23 @@
+# Databricks App Configuration
+name: "tellr"
+description: "Tellr - AI Slide Generator"
+
+command:
+  - "sh"
+  - "-c"
+  - |
+    pip install --upgrade --no-cache-dir -r requirements.txt && \
+    python -c "from databricks_tellr_app.run import init_database; init_database()" && \
+    python -m databricks_tellr_app.run
+
+env:
+  - name: ENVIRONMENT
+    value: "production"
+  - name: LAKEBASE_INSTANCE
+    value: "${LAKEBASE_INSTANCE}"
+  - name: LAKEBASE_SCHEMA
+    value: "${LAKEBASE_SCHEMA}"
+  - name: DATABRICKS_HOST
+    valueFrom: "system.databricks_host"
+  - name: DATABRICKS_TOKEN
+    valueFrom: "system.databricks_token"

databricks_tellr-0.1.15/databricks_tellr/_templates/requirements.txt.template

@@ -0,0 +1,2 @@
+# Generated by databricks-tellr setup
+databricks-tellr-app${APP_VERSION_SUFFIX}

databricks_tellr-0.1.15/databricks_tellr/deploy.py

@@ -0,0 +1,868 @@
+"""Deployment orchestration for Tellr on Databricks Apps.
+
+This module provides the main create/update/delete functions for deploying
+the Tellr AI slide generator to Databricks Apps from a notebook.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import uuid
+from contextlib import contextmanager
+from importlib import metadata, resources
+from pathlib import Path
+from string import Template
+from typing import Any, Iterator, Optional
+
+import yaml
+from databricks.sdk import WorkspaceClient
+from databricks.sdk.service.apps import (
+    App,
+    AppDeployment,
+    AppResource,
+    AppResourceDatabase,
+    AppResourceDatabaseDatabasePermission,
+    ComputeSize,
+)
+from databricks.sdk.service.database import DatabaseInstance
+from databricks.sdk.service.workspace import ImportFormat
+
+logger = logging.getLogger(__name__)
+
+
+class DeploymentError(Exception):
+    """Raised when deployment fails."""
+
+    pass
+
+
+# -----------------------------------------------------------------------------
+# WorkspaceClient Factory
+# -----------------------------------------------------------------------------
+
+
+def _get_workspace_client(
+    client: WorkspaceClient | None = None,
+    profile: str | None = None,
+) -> WorkspaceClient:
+    """Get WorkspaceClient with priority: external > profile > env vars.
+
+    Args:
+        client: Externally created WorkspaceClient (highest priority)
+        profile: Profile name from .databrickscfg file
+
+    Returns:
+        WorkspaceClient configured with the appropriate authentication
+    """
+    if client is not None:
+        return client
+    if profile:
+        return WorkspaceClient(profile=profile)
+    return WorkspaceClient()
+
+
+# -----------------------------------------------------------------------------
+# Public API
+# -----------------------------------------------------------------------------
+
+
+def create(
+    lakebase_name: str | None = None,
+    schema_name: str | None = None,
+    app_name: str | None = None,
+    app_file_workspace_path: str | None = None,
+    lakebase_compute: str = "CU_1",
+    app_compute: str = "MEDIUM",
+    app_version: Optional[str] = None,
+    description: str = "Tellr AI Slide Generator",
+    client: WorkspaceClient | None = None,
+    profile: str | None = None,
+    config_yaml_path: str | None = None,
+) -> dict[str, Any]:
+    """Deploy Tellr to Databricks Apps.
+
+    This function creates all necessary infrastructure and deploys the app:
+    1. Creates/gets Lakebase database instance
+    2. Generates requirements.txt with pinned app version
+    3. Generates app.yaml with environment variables
+    4. Uploads files to workspace
+    5. Creates Databricks App with database resource
+    6. Sets up database schema with permissions
+
+    Authentication priority:
+    1. External WorkspaceClient passed via `client` parameter
+    2. Profile name from .databrickscfg via `profile` parameter
+    3. Environment variables (DATABRICKS_HOST, DATABRICKS_TOKEN, etc.)
+
+    Args:
+        lakebase_name: Name for the Lakebase database instance
+        schema_name: PostgreSQL schema name for app tables
+        app_name: Name for the Databricks App
+        app_file_workspace_path: Workspace path to upload app files
+        lakebase_compute: Lakebase capacity (CU_1, CU_2, CU_4, CU_8)
+        app_compute: App compute size (MEDIUM, LARGE, LIQUID)
+        app_version: Specific databricks-tellr-app version (default: latest)
+        description: App description
+        client: External WorkspaceClient (optional)
+        profile: Databricks CLI profile name (optional)
+        config_yaml_path: Path to deployment config YAML (mutually exclusive with other args)
+
+    Returns:
+        Dictionary with deployment info:
+        - url: App URL
+        - app_name: Created app name
+        - lakebase_name: Database instance name
+        - schema_name: Schema name
+        - status: "created"
+
+    Raises:
+        DeploymentError: If deployment fails
+        ValueError: If required arguments are missing or config_yaml_path used with other args
+    """
+    ws = _get_workspace_client(client, profile)
+
+    # Handle YAML config loading
+    if config_yaml_path:
+        if any([lakebase_name, schema_name, app_name, app_file_workspace_path]):
+            raise ValueError("config_yaml_path cannot be used with other arguments")
+        config = _load_deployment_config(config_yaml_path)
+        lakebase_name = config.get("lakebase_name")
+        schema_name = config.get("schema_name")
+        app_name = config.get("app_name")
+        app_file_workspace_path = config.get("app_file_workspace_path")
+        lakebase_compute = config.get("lakebase_compute", lakebase_compute)
+        app_compute = config.get("app_compute", app_compute)
+
+    # Validate required arguments
+    if not all([lakebase_name, schema_name, app_name, app_file_workspace_path]):
+        raise ValueError(
+            "lakebase_name, schema_name, app_name, and app_file_workspace_path are required"
+        )
+
+    print("Deploying Tellr to Databricks Apps...")
+    print(f"   App name: {app_name}")
+    print(f"   Workspace path: {app_file_workspace_path}")
+    print(f"   Lakebase: {lakebase_name} (capacity: {lakebase_compute})")
+    print(f"   Schema: {schema_name}")
+    print()
+
+    try:
+        # Step 1: Create/get Lakebase instance
+        print("Setting up Lakebase database...")
+        lakebase_result = _get_or_create_lakebase(ws, lakebase_name, lakebase_compute)
+        print(f"   Lakebase: {lakebase_result['name']} ({lakebase_result['status']})")
+        print()
+
+        # Step 2: Generate and upload files
+        print("Preparing deployment files...")
+        with _staging_dir() as staging:
+            _write_requirements(staging, app_version)
+            print("   Generated requirements.txt")
+
+            _write_app_yaml(staging, lakebase_name, schema_name)
+            print("   Generated app.yaml")
+
+            print(f"Uploading to: {app_file_workspace_path}")
+            _upload_files(ws, staging, app_file_workspace_path)
+            print("   Files uploaded")
+        print()
+
+        # Step 3: Create app
+        print(f"Creating Databricks App: {app_name}")
+        app = _create_app(
+            ws,
+            app_name=app_name,
+            description=description,
+            workspace_path=app_file_workspace_path,
+            compute_size=app_compute,
+            lakebase_name=lakebase_name,
+        )
+        print("   App created")
+        if app.url:
+            print(f"   URL: {app.url}")
+        print()
+
+        # Step 4: Set up database schema
+        print("Setting up database schema...")
+        _setup_database_schema(ws, app, lakebase_name, schema_name)
+        print(f"   Schema '{schema_name}' configured")
+        print()
+
+        print("Deployment complete!")
+        return {
+            "url": app.url,
+            "app_name": app_name,
+            "lakebase_name": lakebase_name,
+            "schema_name": schema_name,
+            "status": "created",
+        }
+
+    except Exception as e:
+        raise DeploymentError(f"Deployment failed: {e}") from e
+
+
+def update(
+    app_name: str,
+    app_file_workspace_path: str,
+    lakebase_name: str,
+    schema_name: str,
+    app_version: Optional[str] = None,
+    reset_database: bool = False,
+    client: WorkspaceClient | None = None,
+    profile: str | None = None,
+) -> dict[str, Any]:
+    """Deploy a new version of an existing Tellr app.
+
+    Updates the app files and triggers a new deployment.
+
+    Args:
+        app_name: Name of the existing Databricks App
+        app_file_workspace_path: Workspace path with app files
+        lakebase_name: Lakebase instance name
+        schema_name: Schema name
+        app_version: Specific databricks-tellr-app version (default: latest)
+        reset_database: If True, drop and recreate the schema (tables recreated on app startup)
+        client: External WorkspaceClient (optional)
+        profile: Databricks CLI profile name (optional)
+
+    Returns:
+        Dictionary with deployment info
+
+    Raises:
+        DeploymentError: If update fails
+    """
+    print(f"Updating Tellr app: {app_name}")
+
+    ws = _get_workspace_client(client, profile)
+
+    try:
+        # Reset database if requested
+        if reset_database:
+            print("Resetting database schema...")
+            app = ws.apps.get(name=app_name)
+            _reset_schema(ws, app, lakebase_name, schema_name)
+            print(f"   Schema '{schema_name}' reset (tables will be recreated on app startup)")
+            print()
+
+        # Generate and upload updated files
+        with _staging_dir() as staging:
+            _write_requirements(staging, app_version)
+            _write_app_yaml(staging, lakebase_name, schema_name)
+            _upload_files(ws, staging, app_file_workspace_path)
+            print("   Files updated")
+
+        # Trigger new deployment
+        print("   Deploying...")
+        deployment = AppDeployment(source_code_path=app_file_workspace_path)
+        result = ws.apps.deploy_and_wait(app_name=app_name, app_deployment=deployment)
+        print(f"   Deployment completed: {result.deployment_id}")
+
+        app = ws.apps.get(name=app_name)
+        if app.url:
+            print(f"   URL: {app.url}")
+
+        return {
+            "url": app.url,
+            "app_name": app_name,
+            "deployment_id": result.deployment_id,
+            "status": "updated",
+            "database_reset": reset_database,
+        }
+
+    except Exception as e:
+        raise DeploymentError(f"Update failed: {e}") from e
+
+
+def delete(
+    app_name: str,
+    lakebase_name: str | None = None,
+    schema_name: str | None = None,
+    reset_database: bool = False,
+    client: WorkspaceClient | None = None,
+    profile: str | None = None,
+) -> dict[str, Any]:
+    """Delete a Tellr app.
+
+    Note: This does not delete the Lakebase instance by default.
+
+    Args:
+        app_name: Name of the app to delete
+        lakebase_name: Lakebase instance name (required if reset_database=True)
+        schema_name: Schema name (required if reset_database=True)
+        reset_database: If True, drop the schema before deleting the app
+        client: External WorkspaceClient (optional)
+        profile: Databricks CLI profile name (optional)
+
+    Returns:
+        Dictionary with deletion status
+
+    Raises:
+        DeploymentError: If deletion fails
+        ValueError: If reset_database=True but lakebase_name or schema_name not provided
+    """
+    print(f"Deleting app: {app_name}")
+
+    ws = _get_workspace_client(client, profile)
+
+    try:
+        # Reset database if requested
+        if reset_database:
+            if not lakebase_name or not schema_name:
+                raise ValueError(
+                    "lakebase_name and schema_name are required when reset_database=True"
+                )
+            print("Dropping database schema...")
+            app = ws.apps.get(name=app_name)
+            _reset_schema(ws, app, lakebase_name, schema_name, drop_only=True)
+            print(f"   Schema '{schema_name}' dropped")
+
+        ws.apps.delete(name=app_name)
+        print("   App deleted")
+
+        return {
+            "app_name": app_name,
+            "status": "deleted",
+            "database_reset": reset_database,
+        }
+
+    except Exception as e:
+        raise DeploymentError(f"Deletion failed: {e}") from e
+
+
+# -----------------------------------------------------------------------------
+# Internal functions
+# -----------------------------------------------------------------------------
+
+
+def _load_deployment_config(config_yaml_path: str) -> dict[str, str]:
+    """Load deployment settings from config/deployment.yaml-style files.
+
+    Expected structure (see config/deployment.yaml):
+      environments:
+        development:
+          app_name: ...
+          workspace_path: ...
+          compute_size: ...
+          lakebase:
+            database_name: ...
+            schema: ...
+            capacity: ...
+    """
+    with open(config_yaml_path, "r", encoding="utf-8") as handle:
+        config = yaml.safe_load(handle) or {}
+
+    environments = config.get("environments", {})
+    if not environments:
+        raise ValueError("No environments found in deployment config")
+
+    env_name = os.getenv("ENVIRONMENT", "development")
+    if env_name not in environments:
+        raise ValueError(f"Environment '{env_name}' not found in deployment config")
+
+    env_config = environments[env_name]
+    lakebase_config = env_config.get("lakebase", {})
+
+    return {
+        "app_name": env_config.get("app_name"),
+        "app_file_workspace_path": env_config.get("workspace_path"),
+        "app_compute": env_config.get("compute_size"),
+        "lakebase_name": lakebase_config.get("database_name"),
+        "schema_name": lakebase_config.get("schema"),
+        "lakebase_compute": lakebase_config.get("capacity"),
+    }
+
+
+def _get_or_create_lakebase(
+    ws: WorkspaceClient, database_name: str, capacity: str
+) -> dict[str, Any]:
+    """Get or create a Lakebase database instance."""
+    try:
+        existing = ws.database.get_database_instance(name=database_name)
+        return {
+            "name": existing.name,
+            "status": "exists",
+            "state": existing.state.value if existing.state else "UNKNOWN",
+        }
+    except Exception as e:
+        error_str = str(e).lower()
+        if "not found" not in error_str and "does not exist" not in error_str:
+            raise
+
+    instance = ws.database.create_database_instance_and_wait(
+        DatabaseInstance(name=database_name, capacity=capacity)
+    )
+    return {
+        "name": instance.name,
+        "status": "created",
+        "state": instance.state.value if instance.state else "RUNNING",
+    }
+
+
+def _write_requirements(staging_dir: Path, app_version: Optional[str]) -> None:
+    """Generate requirements.txt with app package."""
+    resolved_version = app_version or _resolve_installed_app_version()
+
+    if resolved_version and not _is_valid_version(resolved_version):
+        raise DeploymentError(
+            f"Invalid app version '{resolved_version}'. Expected a PEP 440 version."
+        )
+
+    if resolved_version:
+        package_line = f"databricks-tellr-app=={resolved_version}"
+    else:
+        package_line = "databricks-tellr-app"
+
+    content = "\n".join(
+        [
+            "# Generated by databricks-tellr create",
+            package_line,
+        ]
+    )
+    (staging_dir / "requirements.txt").write_text(content)
+
+
+def _resolve_installed_app_version() -> str | None:
+    """Try to resolve the installed version of databricks-tellr-app."""
+    try:
+        return metadata.version("databricks-tellr-app")
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def _write_app_yaml(staging_dir: Path, lakebase_name: str, schema_name: str) -> None:
+    """Generate app.yaml with environment variables."""
+    template_content = _load_template("app.yaml.template")
+    content = Template(template_content).substitute(
+        LAKEBASE_INSTANCE=lakebase_name,
+        LAKEBASE_SCHEMA=schema_name,
+    )
+    (staging_dir / "app.yaml").write_text(content)
+
+
+def _load_template(template_name: str) -> str:
+    """Load a template file from package resources."""
+    try:
+        files = resources.files("databricks_tellr") / "_templates" / template_name
+        return files.read_text()
+    except (TypeError, AttributeError):
+        with resources.open_text(
+            "databricks_tellr._templates", template_name
+        ) as f:
+            return f.read()
+
+
+def _is_valid_version(version: str) -> bool:
+    """Check if a version string is valid PEP 440."""
+    try:
+        from packaging.version import Version
+    except ImportError:
+        return True
+    try:
+        Version(version)
+        return True
+    except Exception:
+        return False
+
+
+@contextmanager
+def _staging_dir() -> Iterator[Path]:
+    """Create a temporary staging directory for deployment files."""
+    import tempfile
+
+    staging_dir = Path(tempfile.mkdtemp(prefix="tellr_staging_"))
+    try:
+        yield staging_dir
+    finally:
+        shutil.rmtree(staging_dir, ignore_errors=True)
+
+
+def _upload_files(
+    ws: WorkspaceClient, staging_dir: Path, workspace_path: str
+) -> None:
+    """Upload files from staging directory to workspace."""
+    try:
+        ws.workspace.mkdirs(workspace_path)
+    except Exception:
+        pass  # May already exist
+
+    for file_path in staging_dir.iterdir():
+        if file_path.is_file():
+            workspace_file_path = f"{workspace_path}/{file_path.name}"
+            with open(file_path, "rb") as f:
+                ws.workspace.upload(
+                    workspace_file_path,
+                    f,
+                    format=ImportFormat.AUTO,
+                    overwrite=True,
+                )
+
+
+def _create_app(
+    ws: WorkspaceClient,
+    app_name: str,
+    description: str,
+    workspace_path: str,
+    compute_size: str,
+    lakebase_name: str,
+) -> App:
+    """Create Databricks App with database resource."""
+    compute_size_enum = ComputeSize(compute_size)
+
+    app_resources = [
+        AppResource(
+            name="app_database",
+            database=AppResourceDatabase(
+                instance_name=lakebase_name,
+                database_name="databricks_postgres",
+                permission=AppResourceDatabaseDatabasePermission.CAN_CONNECT_AND_CREATE,
+            ),
+        )
+    ]
+
+    app = App(
+        name=app_name,
+        description=description,
+        compute_size=compute_size_enum,
+        default_source_code_path=workspace_path,
+        resources=app_resources,
+        user_api_scopes=[
+            "sql",
+            "dashboards.genie",
+            "catalog.tables:read",
+            "catalog.schemas:read",
+            "catalog.catalogs:read",
+            "serving.serving-endpoints",
+        ],
+    )
+
+    ws.apps.create_and_wait(app)
+
+    deployment = AppDeployment(source_code_path=workspace_path)
+    ws.apps.deploy_and_wait(app_name=app_name, app_deployment=deployment)
+
+    return ws.apps.get(name=app_name)
+
+
+def _get_app_client_id(app: App) -> str | None:
+    """Extract the service principal client ID from an app."""
+    if hasattr(app, "service_principal_client_id") and app.service_principal_client_id:
+        return app.service_principal_client_id
+    if hasattr(app, "service_principal_id") and app.service_principal_id:
+        return str(app.service_principal_id)
+    return None
+
+
+def _get_lakebase_connection(
+    ws: WorkspaceClient, lakebase_name: str
+) -> tuple[Any, str]:
+    """Get a psycopg2 connection to Lakebase and the current username.
+
+    Returns:
+        Tuple of (connection, username)
+    """
+    try:
+        import psycopg2
+    except ImportError as exc:
+        raise DeploymentError(
+            "psycopg2-binary is required for database operations"
+        ) from exc
+
+    instance = ws.database.get_database_instance(name=lakebase_name)
+    user = ws.current_user.me().user_name
+
+    cred = ws.database.generate_database_credential(
+        request_id=str(uuid.uuid4()),
+        instance_names=[lakebase_name],
+    )
+
+    conn = psycopg2.connect(
+        host=instance.read_write_dns,
+        port=5432,
+        user=user,
+        password=cred.token,
+        dbname="databricks_postgres",
+        sslmode="require",
+    )
+    conn.autocommit = True
+
+    return conn, user
+
+
+def _setup_database_schema(
+    ws: WorkspaceClient, app: App, lakebase_name: str, schema_name: str
+) -> None:
+    """Set up database schema and grant permissions to app."""
+    client_id = _get_app_client_id(app)
+
+    if not client_id:
+        print("   Warning: Could not get app client ID - schema setup skipped")
+        return
+
+    conn, _ = _get_lakebase_connection(ws, lakebase_name)
+
+    try:
+        with conn.cursor() as cur:
+            cur.execute(f'CREATE SCHEMA IF NOT EXISTS "{schema_name}"')
+            _grant_schema_permissions(cur, schema_name, client_id)
+    finally:
+        conn.close()
+
+
+def _reset_schema(
+    ws: WorkspaceClient,
+    app: App,
+    lakebase_name: str,
+    schema_name: str,
+    drop_only: bool = False,
+) -> None:
+    """Drop and recreate schema (tables will be recreated by app on startup).
+
+    Args:
+        ws: WorkspaceClient
+        app: The Databricks App (needed for service principal ID)
+        lakebase_name: Lakebase instance name
+        schema_name: Schema to reset
+        drop_only: If True, only drop the schema without recreating
+    """
+    client_id = _get_app_client_id(app)
+
+    conn, _ = _get_lakebase_connection(ws, lakebase_name)
+
+    try:
+        with conn.cursor() as cur:
+            # Drop schema with CASCADE to remove all objects
+            cur.execute(f'DROP SCHEMA IF EXISTS "{schema_name}" CASCADE')
+
+            if not drop_only:
+                # Recreate schema
+                cur.execute(f'CREATE SCHEMA "{schema_name}"')
+
+                # Re-grant permissions if we have the client ID
+                if client_id:
+                    _grant_schema_permissions(cur, schema_name, client_id)
+    finally:
+        conn.close()
+
+
+def _grant_schema_permissions(cur: Any, schema_name: str, client_id: str) -> None:
+    """Grant schema permissions to an app's service principal."""
+    cur.execute(f'GRANT USAGE ON SCHEMA "{schema_name}" TO "{client_id}"')
+    cur.execute(f'GRANT CREATE ON SCHEMA "{schema_name}" TO "{client_id}"')
+    cur.execute(
+        f'GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA "{schema_name}" TO "{client_id}"'
+    )
+    cur.execute(
+        f'GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA "{schema_name}" TO "{client_id}"'
+    )
+    cur.execute(
+        f'ALTER DEFAULT PRIVILEGES IN SCHEMA "{schema_name}" '
+        f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "{client_id}"'
+    )
+    cur.execute(
+        f'ALTER DEFAULT PRIVILEGES IN SCHEMA "{schema_name}" '
+        f'GRANT USAGE, SELECT ON SEQUENCES TO "{client_id}"'
+    )
+
+
+# -----------------------------------------------------------------------------
+# Internal Functions (not exported, for Databricks internal use only)
+# -----------------------------------------------------------------------------
+
+
+def _seed_internal_content(
+    lakebase_name: str,
+    schema_name: str,
+    client: WorkspaceClient | None = None,
+    profile: str | None = None,
+) -> dict[str, Any]:
+    """Seed Databricks-internal content (prompts and styles).
+    
+    This is an internal function for Databricks use only. It seeds:
+    - Databricks Brand slide style
+    - Consumption Review deck prompt
+    - Use Case Analysis deck prompt
+    
+    This function should be called AFTER the app has been deployed and
+    has already created the base tables and generic content.
+    
+    Args:
+        lakebase_name: Lakebase instance name
+        schema_name: Schema where tables exist
+        client: External WorkspaceClient (optional)
+        profile: Databricks CLI profile name (optional)
+    
+    Returns:
+        Dictionary with seeding results
+    """
+    print("Seeding internal Databricks content...")
+    
+    ws = _get_workspace_client(client, profile)
+    conn, _ = _get_lakebase_connection(ws, lakebase_name)
+    
+    # Internal content definitions
+    internal_styles = [
+        {
+            "name": "Databricks Brand",
+            "description": "Official Databricks brand colors and typography. Navy headers, Lava red accents, clean modern layout.",
+            "category": "Brand",
+            "is_system": False,
+        },
+    ]
+    
+    internal_prompts = [
+        {
+            "name": "Consumption Review",
+            "description": "Template for consumption review meetings. Analyzes usage trends, identifies key drivers, and highlights areas for optimization.",
+            "category": "Review",
+            "prompt_content": """PRESENTATION TYPE: Consumption Review
+
+When creating a consumption review presentation, focus on:
+
+1. EXECUTIVE SUMMARY
+   - Overall consumption trend (increasing/decreasing/stable)
+   - Key highlight metrics (total spend, month-over-month change)
+   - Top 3 insights that require attention
+
+2. USAGE ANALYSIS
+   - Query for consumption data over the past 6-12 months
+   - Break down by major categories (compute, storage, etc.)
+   - Identify the top consumers and their growth patterns
+
+3. TREND IDENTIFICATION
+   - Look for seasonal patterns or anomalies
+   - Compare current period to previous periods
+   - Highlight significant changes (>10% movement)
+
+4. OPTIMIZATION OPPORTUNITIES
+   - Identify underutilized resources
+   - Highlight cost-saving opportunities
+   - Recommend actions based on data
+
+5. FORWARD OUTLOOK
+   - Project future consumption based on trends
+   - Flag any concerns or risks
+   - Provide actionable recommendations
+
+Structure the deck with clear data visualizations showing trends over time.""",
+        },
+        {
+            "name": "Use Case Analysis",
+            "description": "Template for analyzing use case progression and identifying blockers or accelerators.",
+            "category": "Analysis",
+            "prompt_content": """PRESENTATION TYPE: Use Case Analysis
+
+When analyzing use cases, focus on:
+
+1. PORTFOLIO OVERVIEW
+   - Total number of use cases in scope
+   - Distribution by stage/status
+   - Overall health metrics
+
+2. PROGRESSION ANALYSIS
+   - Query for use case movement between stages
+   - Identify velocity patterns
+   - Calculate average time in each stage
+
+3. BLOCKER IDENTIFICATION
+   - Find use cases that are stuck or slowed
+   - Categorize blockers (technical, resource, dependency)
+   - Quantify impact of each blocker type
+
+4. SUCCESS PATTERNS
+   - Identify fast-moving use cases
+   - Find common characteristics of successful progression
+   - Extract best practices
+
+5. RECOMMENDATIONS
+   - Specific actions to unblock stuck use cases
+   - Resource allocation suggestions
+   - Process improvements
+
+Use funnel charts for progression and bar charts for blocker analysis.""",
+        },
+    ]
+    
+    # Default slide style content (same as System Default)
+    default_style_content = """SLIDE VISUAL STYLE:
+
+Typography & Colors:
+- Modern sans-serif font (Inter/SF Pro/Helvetica)
+- H1: 40-52px bold, Navy #102025 | H2: 28-36px, Navy #2B3940 | Body: 16-18px, #5D6D71
+- Primary accent: Lava #EB4A34 | Success: Green #4BA676 | Warning: Yellow #F2AE3D | Info: Blue #3C71AF
+- Background: Oat Light #F9FAFB
+
+Layout & Structure:
+- Fixed slide size: 1280x720px per slide, white background
+- Body: width:1280px; height:720px; margin:0; padding:0; overflow:hidden
+- Use flexbox for layout with appropriate gaps (≥12px)
+- Cards/boxes: padding ≥16px, border-radius 8-12px, shadow: 0 4px 6px rgba(0,0,0,0.1)
+
+Content Per Slide:
+- ONE clear title (≤55 chars) that states the key insight
+- Subtitle for context
+- Body text ≤40 words
+- Maximum 2 data visualizations per slide
+
+Chart Brand Colors:
+['#EB4A34','#4BA676','#3C71AF','#F2AE3D']"""
+    
+    styles_seeded = 0
+    prompts_seeded = 0
+    
+    try:
+        with conn.cursor() as cur:
+            # Set search path
+            cur.execute(f'SET search_path TO "{schema_name}"')
+            
+            # Seed styles
+            for style in internal_styles:
+                cur.execute(
+                    "SELECT id FROM slide_style_library WHERE name = %s",
+                    (style["name"],)
+                )
+                if cur.fetchone():
+                    print(f"   Style '{style['name']}' already exists, skipping")
+                    continue
+                
+                cur.execute(
+                    """INSERT INTO slide_style_library 
+                       (name, description, category, style_content, is_active, is_system, created_by, updated_by, created_at, updated_at)
+                       VALUES (%s, %s, %s, %s, true, %s, 'system', 'system', NOW(), NOW())""",
+                    (style["name"], style["description"], style["category"], 
+                     default_style_content, style["is_system"])
+                )
+                print(f"   Seeded style: {style['name']}")
+                styles_seeded += 1
+            
+            # Seed prompts
+            for prompt in internal_prompts:
+                cur.execute(
+                    "SELECT id FROM slide_deck_prompt_library WHERE name = %s",
+                    (prompt["name"],)
+                )
+                if cur.fetchone():
+                    print(f"   Prompt '{prompt['name']}' already exists, skipping")
+                    continue
+                
+                cur.execute(
+                    """INSERT INTO slide_deck_prompt_library 
+                       (name, description, category, prompt_content, is_active, created_by, updated_by, created_at, updated_at)
+                       VALUES (%s, %s, %s, %s, true, 'system', 'system', NOW(), NOW())""",
+                    (prompt["name"], prompt["description"], prompt["category"], prompt["prompt_content"])
+                )
+                print(f"   Seeded prompt: {prompt['name']}")
+                prompts_seeded += 1
+        
+        print(f"Internal content seeding complete: {styles_seeded} styles, {prompts_seeded} prompts")
+        return {
+            "status": "success",
+            "styles_seeded": styles_seeded,
+            "prompts_seeded": prompts_seeded,
+        }
+        
+    except Exception as e:
+        raise DeploymentError(f"Failed to seed internal content: {e}") from e
+    finally:
+        conn.close()

databricks_tellr-0.1.15/databricks_tellr.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: databricks-tellr
+Version: 0.1.15
+Summary: Tellr deployment tooling for Databricks Apps
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: databricks-sdk>=0.20.0
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: pyyaml>=6.0.0
+
+# databricks-tellr
+
+Python deployment tooling for Tellr on Databricks Apps.
+
+## Usage
+
+```python
+import databricks_tellr as tellr
+
+!pip install --upgrade databricks-sdk==0.73.0
+
+result = tellr.setup(
+    lakebase_name="ai-slide-generator-db-dev",
+    schema_name="app_data_dev",
+    app_name="ai-slide-generator-dev",
+    app_file_workspace_path="/Workspace/Users/you@example.com/.apps/dev/ai-slide-generator",
+)
+
+print(result["url"])
+```

databricks_tellr-0.1.15/databricks_tellr.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+databricks_tellr/__init__.py
+databricks_tellr/deploy.py
+databricks_tellr.egg-info/PKG-INFO
+databricks_tellr.egg-info/SOURCES.txt
+databricks_tellr.egg-info/dependency_links.txt
+databricks_tellr.egg-info/requires.txt
+databricks_tellr.egg-info/top_level.txt
+databricks_tellr/_templates/app.yaml.template
+databricks_tellr/_templates/requirements.txt.template

databricks_tellr-0.1.15/databricks_tellr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

databricks_tellr-0.1.15/databricks_tellr.egg-info/requires.txt

@@ -0,0 +1,3 @@
+databricks-sdk>=0.20.0
+psycopg2-binary>=2.9.0
+pyyaml>=6.0.0

databricks_tellr-0.1.15/databricks_tellr.egg-info/top_level.txt

@@ -0,0 +1 @@
+databricks_tellr

databricks_tellr-0.1.15/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "databricks-tellr"
+version = "0.1.15"
+description = "Tellr deployment tooling for Databricks Apps"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "databricks-sdk>=0.20.0",
+    "psycopg2-binary>=2.9.0",
+    "pyyaml>=6.0.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["databricks_tellr*"]
+
+[tool.setuptools.package-data]
+databricks_tellr = ["_templates/*"]

databricks_tellr-0.1.15/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+