datamuru 0.1.0a0__py3-none-any.whl

datamuru/__init__.py

@@ -0,0 +1,4 @@
+from .api import DataMuru
+
+__all__ = ["DataMuru"]
+__version__ = "0.1.0a0"

datamuru/api.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from datamuru.core.engine import DataMuruEngine
+
+
+class DataMuru:
+    def __init__(self, config_path: str | Path, environment: str | None = None) -> None:
+        self.engine = DataMuruEngine(config_path=config_path, environment=environment)
+
+    def validate(self):
+        return self.engine.validate()
+
+    def plan(self, target: str | None = None):
+        return self.engine.plan(target=target)
+
+    def apply(self, target: str | None = None):
+        return self.engine.apply(target=target)
+
+    def apply_saved_plan(self, plan_path: str | Path):
+        return self.engine.apply_saved_plan(plan_path)
+
+    def destroy(self, target: str | None = None):
+        return self.engine.destroy(target=target)
+
+    def save_plan(self, output_path: str | Path, target: str | None = None):
+        return self.engine.save_plan(output_path=output_path, target=target)
+
+    def edition_summary(self):
+        return self.engine.edition_summary()
+
+    def doctor(self):
+        return self.engine.doctor()
+
+    def import_discover(self, include_system: bool = False):
+        return self.engine.import_discover(include_system=include_system)
+
+    def import_generate(
+        self,
+        *,
+        catalogs: list[str] | None = None,
+        include_groups: bool = False,
+        include_system: bool = False,
+    ):
+        return self.engine.import_generate(
+            catalogs=catalogs,
+            include_groups=include_groups,
+            include_system=include_system,
+        )

datamuru/bootstrap.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path
+
+
+class ProjectScaffolder:
+    def scaffold(
+        self,
+        output_dir: str | Path,
+        *,
+        name: str,
+        provider: str = "databricks",
+        cloud: str = "azure",
+        edition: str = "open-source",
+    ) -> list[Path]:
+        root = Path(output_dir)
+        created: list[Path] = []
+        for relative in [
+            Path("environments"),
+            Path("providers"),
+            Path("workspaces"),
+            Path("governance"),
+        ]:
+            target = root / relative
+            target.mkdir(parents=True, exist_ok=True)
+            created.append(target)
+
+        content = {
+            root / "datamuru.yml": textwrap.dedent(
+                f"""
+                project:
+                  name: {name}
+                  version: "0.1.0"
+                  description: "Bootstrap DataMuru project"
+                  edition: {edition}
+                  provider: {provider}
+
+                environments:
+                  - name: dev
+                    config: ./environments/dev.yml
+
+                default_environment: dev
+
+                features:
+                  governance: true
+                  data_mesh: false
+                  ingestion: false
+                  modeling: false
+                  observability: false
+                  compliance_reporting: false
+                  multi_workspace: false
+                  hosted_control_plane: false
+                  identity_management: false
+
+                state:
+                  backend: local
+                  path: ./.datamuru/state-dev.json
+
+                provider:
+                  name: {provider}
+                  cloud: {cloud}
+                  config: ./providers/{provider}.yml
+                """
+            ).strip() + "\n",
+            root / "environments" / "dev.yml": "environment:\n  name: dev\n",
+            root / "providers" / f"{provider}.yml": textwrap.dedent(
+                f"""
+                provider:
+                  cloud: {cloud}
+                  connect_timeout_seconds: 10
+                  credential_mode: personal-access-token
+                  execution_mode: state-only
+                  auth_type: pat
+                  token_env: DATABRICKS_TOKEN
+                  host: https://adb-placeholder.{cloud}.databricks.example
+                """
+            ).strip() + "\n",
+            root / "workspaces" / "alpha-dev.yml": textwrap.dedent(
+                f"""
+                workspace:
+                  name: alpha-dev
+                  cloud: {cloud}
+                  region: eastus2
+                  catalogs:
+                    - name: alpha_marketing
+                      schemas:
+                        - raw
+                        - bronze
+                        - silver
+                        - gold
+                """
+            ).strip() + "\n",
+            root / "governance" / "taxonomy.yml": textwrap.dedent(
+                """
+                taxonomy:
+                  name: bootstrap
+                  version: "0.1"
+                  categories:
+                    - id: internal
+                      label: Internal
+                      description: "Internal data"
+                      handling:
+                        retention_years: 3
+                        encryption: at_rest
+                """
+            ).strip() + "\n",
+            root / "governance" / "rbac.yml": textwrap.dedent(
+                """
+                rbac:
+                  roles:
+                    - id: data_consumer
+                      name: Data Consumer
+                      permissions:
+                        - resource_type: schema
+                          resource_pattern: "*.gold"
+                          privilege: SELECT
+                  assignments:
+                    - principal: sample-consumers
+                      type: group
+                      roles:
+                        - data_consumer
+                      domains:
+                        - alpha_marketing
+                """
+            ).strip() + "\n",
+            root / "governance" / "masking.yml": textwrap.dedent(
+                """
+                masking:
+                  builtins:
+                    - id: partial_mask
+                      description: Show last four characters for strings.
+                      strategy: partial_mask
+                """
+            ).strip() + "\n",
+        }
+        for path, value in content.items():
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(value, encoding="utf-8")
+            created.append(path)
+        return created

datamuru/cli/__init__.py

@@ -0,0 +1 @@
+

datamuru/cli/commands/__init__.py

@@ -0,0 +1,19 @@
+from .apply import apply_command
+from .destroy import destroy_command
+from .doctor import doctor_command
+from .edition import edition_group
+from .init import init_command
+from .import_ import import_group
+from .plan import plan_command
+from .validate import validate_command
+
+COMMANDS = [
+    init_command,
+    validate_command,
+    plan_command,
+    apply_command,
+    destroy_command,
+    doctor_command,
+    import_group,
+    edition_group,
+]

datamuru/cli/commands/apply.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+
+from datamuru.api import DataMuru
+from datamuru.types import Plan
+
+from ..guard import with_cli_errors
+from ..output import console
+
+
+@click.command("apply")
+@click.option("--config", "config_path", default="datamuru.yml", show_default=True)
+@click.option("--target", default=None)
+@click.option("--plan", "plan_path", default=None)
+@click.option("--auto-approve", is_flag=True, default=False)
+@with_cli_errors
+def apply_command(config_path: str, target: str | None, plan_path: str | None, auto_approve: bool) -> None:
+    if not auto_approve:
+        raise click.ClickException("Alpha bootstrap requires --auto-approve for non-interactive apply.")
+    dm = DataMuru(config_path=config_path)
+    preview_plan: Plan | None = None
+    if plan_path:
+        preview_plan = Plan.from_dict(json.loads(Path(plan_path).read_text(encoding="utf-8")))
+        result = dm.apply_saved_plan(plan_path)
+    else:
+        preview_plan = dm.plan(target=target)
+        if target and not preview_plan.changes:
+            console.print(f"[warning]Target '{target}' matched nothing; apply skipped.[/warning]")
+            return
+        result = dm.apply(target=target)
+    if not result.success:
+        for failure in result.failures:
+            console.print(f"[error]FAILED[/error] {failure.resource}: {failure.reason}")
+        raise SystemExit(1)
+    noop_count = 0
+    if preview_plan is not None:
+        noop_count = sum(1 for change in preview_plan.changes if change.action == "noop")
+    message = f"[success]Applied[/success] {len(result.applied)} changes."
+    if noop_count:
+        message += f" [muted]{noop_count} resources already matched.[/muted]"
+    console.print(message)

datamuru/cli/commands/destroy.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import click
+
+from datamuru.api import DataMuru
+
+from ..guard import with_cli_errors
+from ..output import console
+
+
+@click.command("destroy")
+@click.option("--config", "config_path", default="datamuru.yml", show_default=True)
+@click.option("--target", default=None)
+@click.option("--confirm-destroy", is_flag=True, default=False)
+@with_cli_errors
+def destroy_command(config_path: str, target: str | None, confirm_destroy: bool) -> None:
+    if not confirm_destroy:
+        raise click.ClickException("Destroy requires --confirm-destroy.")
+    dm = DataMuru(config_path=config_path)
+    result = dm.destroy(target=target)
+    if not result.success:
+        raise SystemExit(1)
+    console.print(f"[success]Destroyed[/success] {len(result.applied)} resources.")

datamuru/cli/commands/doctor.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import json
+
+import click
+
+from datamuru.api import DataMuru
+
+from ..guard import with_cli_errors
+from ..output import console
+
+
+@click.command("doctor")
+@click.option("--config", "config_path", default="datamuru.yml", show_default=True)
+@click.option("--output", "output_format", default="text", type=click.Choice(["text", "json"]))
+@with_cli_errors
+def doctor_command(config_path: str, output_format: str) -> None:
+    dm = DataMuru(config_path=config_path)
+    report = dm.doctor()
+    if output_format == "json":
+        console.print_json(json.dumps(report.to_dict(), indent=2))
+        if not report.success:
+            raise SystemExit(1)
+        return
+    console.print(f"[primary]Provider[/primary]: [code]{report.provider}[/code]")
+    console.print(f"[primary]Environment[/primary]: [code]{report.environment}[/code]")
+    for check in report.checks:
+        style = "success" if check.level == "ok" else "warning" if check.level == "warning" else "error"
+        console.print(f"[{style}][{check.level}][/{style}] {check.code}: {check.message}")
+    if not report.success:
+        raise SystemExit(1)

datamuru/cli/commands/edition.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import json
+
+import click
+
+from datamuru.api import DataMuru
+
+from ..guard import with_cli_errors
+from ..output import console
+
+
+@click.group("edition")
+def edition_group() -> None:
+    """Inspect edition-aware product metadata."""
+
+
+@edition_group.command("show")
+@click.option("--config", "config_path", default="datamuru.yml", show_default=True)
+@click.option("--output", "output_format", default="text", type=click.Choice(["text", "json"]))
+@with_cli_errors
+def edition_show(config_path: str, output_format: str) -> None:
+    dm = DataMuru(config_path=config_path)
+    summary = dm.edition_summary()
+    if output_format == "json":
+        console.print_json(json.dumps(summary.to_dict(), indent=2))
+        return
+    console.print(f"[primary]Edition[/primary]: [code]{summary.edition}[/code]")
+    console.print(f"Enabled features: {', '.join(summary.enabled_features) if summary.enabled_features else 'none'}")
+    console.print(
+        f"Restricted features: {', '.join(summary.restricted_features) if summary.restricted_features else 'none'}"
+    )

datamuru/cli/commands/import_.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+
+from datamuru.api import DataMuru
+
+from ..guard import with_cli_errors
+from ..output import console
+
+
+@click.group("import")
+def import_group() -> None:
+    """Discover and generate starter YAML from an existing live workspace."""
+
+
+@import_group.command("discover")
+@click.option("--config", "config_path", default="datamuru.yml", show_default=True)
+@click.option("--include-system", is_flag=True, default=False, help="Include system catalogs, schemas, and groups.")
+@click.option("--output", "output_format", default="text", type=click.Choice(["text", "json"]))
+@with_cli_errors
+def import_discover_command(config_path: str, include_system: bool, output_format: str) -> None:
+    dm = DataMuru(config_path=config_path)
+    report = dm.import_discover(include_system=include_system)
+    if output_format == "json":
+        console.print_json(json.dumps(report.to_dict(), indent=2))
+        return
+
+    console.print(f"[primary]Import Discovery[/primary] - provider: [code]{report.provider}[/code]")
+    console.print(f"[primary]Environment[/primary]: [code]{report.environment}[/code]")
+    console.print(f"[primary]Workspace[/primary]: [code]{report.workspace.name}[/code]")
+    console.print(f"[primary]Cloud[/primary]: [code]{report.workspace.cloud}[/code]")
+    console.print(f"[primary]Region[/primary]: [code]{report.workspace.region}[/code]")
+    if report.workspace.groups:
+        console.print("[primary]Groups[/primary]:")
+        for group_name in report.workspace.groups:
+            console.print(f"  - [code]{group_name}[/code]")
+    if report.workspace.catalogs:
+        console.print("[primary]Catalogs[/primary]:")
+        for catalog in report.workspace.catalogs:
+            console.print(f"  - [code]{catalog.name}[/code]")
+            for schema in catalog.schemas:
+                console.print(f"    - schema [code]{schema.name}[/code]")
+
+
+@import_group.command("generate")
+@click.option("--config", "config_path", default="datamuru.yml", show_default=True)
+@click.option("--catalog", "catalogs", multiple=True, help="Catalog name to include. Repeat to select multiple.")
+@click.option("--include-groups", is_flag=True, default=False, help="Include discovered groups in principals.")
+@click.option("--include-system", is_flag=True, default=False, help="Include system catalogs, schemas, and groups.")
+@click.option("--out", "out_path", default=None, help="Write generated workspace YAML to a file.")
+@click.option("--output", "output_format", default="text", type=click.Choice(["text", "json"]))
+@with_cli_errors
+def import_generate_command(
+    config_path: str,
+    catalogs: tuple[str, ...],
+    include_groups: bool,
+    include_system: bool,
+    out_path: str | None,
+    output_format: str,
+) -> None:
+    dm = DataMuru(config_path=config_path)
+    result = dm.import_generate(
+        catalogs=list(catalogs) or None,
+        include_groups=include_groups,
+        include_system=include_system,
+    )
+    if out_path:
+        resolved = Path(out_path).resolve()
+        resolved.write_text(result.workspace_file_text, encoding="utf-8")
+    if output_format == "json":
+        payload = result.to_dict()
+        if out_path:
+            payload["written_to"] = str(Path(out_path).resolve())
+        console.print_json(json.dumps(payload, indent=2))
+        return
+
+    console.print(f"[primary]Import Generate[/primary] - environment: [code]{result.environment}[/code]")
+    if out_path:
+        console.print(f"[success]Wrote[/success] starter workspace YAML to [code]{Path(out_path).resolve()}[/code]")
+    console.print(result.workspace_file_text)

datamuru/cli/commands/init.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from datamuru.bootstrap import ProjectScaffolder
+
+from ..guard import with_cli_errors
+from ..output import console
+
+
+@click.command("init")
+@click.option("--name", default="datamuru-project", show_default=True)
+@click.option("--provider", default="databricks", show_default=True)
+@click.option("--cloud", default="azure", show_default=True)
+@click.option("--edition", default="open-source", show_default=True)
+@click.option("--output-dir", default=".", show_default=True)
+@with_cli_errors
+def init_command(name: str, provider: str, cloud: str, edition: str, output_dir: str) -> None:
+    scaffolder = ProjectScaffolder()
+    created = scaffolder.scaffold(output_dir, name=name, provider=provider, cloud=cloud, edition=edition)
+    console.print(
+        f"[success]Created[/success] {len(created)} bootstrap artifacts in [code]{Path(output_dir).resolve()}[/code]"
+    )

datamuru/cli/commands/plan.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import json
+
+import click
+
+from datamuru.api import DataMuru
+
+from ..guard import with_cli_errors
+from ..output import console, render_plan_symbol
+
+
+@click.command("plan")
+@click.option("--config", "config_path", default="datamuru.yml", show_default=True)
+@click.option("--target", default=None)
+@click.option("--out", "out_path", default=None)
+@click.option("--output", "output_format", default="text", type=click.Choice(["text", "json"]))
+@with_cli_errors
+def plan_command(config_path: str, target: str | None, out_path: str | None, output_format: str) -> None:
+    dm = DataMuru(config_path=config_path)
+    result = dm.plan(target=target)
+    if out_path:
+        dm.save_plan(output_path=out_path, target=target)
+    if output_format == "json":
+        console.print_json(json.dumps(result.to_dict(), indent=2))
+        return
+    console.print(f"[primary]DataMuru Plan[/primary] - environment: [code]{result.environment}[/code]")
+    if target and not result.changes:
+        console.print(f"[warning]No resources matched target '{target}'.[/warning]")
+        return
+    for change in result.changes:
+        console.print(f"  {render_plan_symbol(change.action)} {change.resource.address} [muted]({change.reason})[/muted]")

datamuru/cli/commands/validate.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import click
+
+from datamuru.api import DataMuru
+
+from ..guard import with_cli_errors
+from ..output import console
+
+
+@click.command("validate")
+@click.option("--config", "config_path", default="datamuru.yml", show_default=True)
+@click.option("--strict", is_flag=True, default=False)
+@with_cli_errors
+def validate_command(config_path: str, strict: bool) -> None:
+    dm = DataMuru(config_path=config_path)
+    issues = dm.validate()
+    errors = [issue for issue in issues if issue.level == "error"]
+    for issue in issues:
+        style = "error" if issue.level == "error" else "warning"
+        console.print(f"[{style}][{issue.level}][/{style}] {issue.path}: {issue.message}")
+    if errors:
+        raise SystemExit(1)
+    if strict and any(issue.level == "warning" for issue in issues):
+        raise SystemExit(1)
+    console.print("[success]Configuration is valid.[/success]")

datamuru/cli/guard.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from functools import wraps
+
+from datamuru.errors import DataMuruError
+
+from .output import render_error
+
+
+def with_cli_errors(fn):
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except DataMuruError as exc:
+            render_error(exc)
+            raise SystemExit(exc.exit_code) from exc
+
+    return wrapper

datamuru/cli/main.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import click
+
+from .commands import COMMANDS
+
+
+@click.group()
+def cli() -> None:
+    """DataMuru alpha CLI."""
+
+
+for command in COMMANDS:
+    cli.add_command(command)
+
+
+def main() -> None:
+    cli()
+
+
+if __name__ == "__main__":
+    main()

datamuru/cli/output.py

@@ -0,0 +1,51 @@
+"""Shared rich console and formatting helpers for the DataMuru CLI."""
+
+from __future__ import annotations
+
+from rich.panel import Panel
+from rich.console import Console
+from rich.theme import Theme
+from rich.traceback import install
+
+from datamuru.errors import DataMuruError
+
+DATAMURU_THEME = Theme(
+    {
+        "primary": "bold #0D7377",
+        "secondary": "bold #14539A",
+        "accent": "#C8962A",
+        "success": "bold green",
+        "warning": "bold yellow",
+        "error": "bold red",
+        "create": "bold green",
+        "update": "bold yellow",
+        "destroy": "bold red",
+        "nochange": "dim",
+        "code": "#9CDCFE",
+        "muted": "dim white",
+    }
+)
+
+console = Console(theme=DATAMURU_THEME)
+install(show_locals=False)
+
+
+def render_plan_symbol(action: str) -> str:
+    """Return the rich-styled symbol for a plan action."""
+
+    mapping = {
+        "create": "[create]+[/create]",
+        "update": "[update]~[/update]",
+        "destroy": "[destroy]-[/destroy]",
+        "noop": "[nochange]=[/nochange]",
+    }
+    return mapping[action]
+
+
+def render_error(error: DataMuruError) -> None:
+    lines = [f"[error]{error.code}[/error] [primary]{error.title}[/primary]", error.description]
+    for key, value in error.context.items():
+        lines.append(f"[muted]{key}[/muted]: {value}")
+    if error.suggestion:
+        lines.append(f"[accent]Suggestion[/accent]: {error.suggestion}")
+    console.print(Panel.fit("\n".join(lines), border_style="error", title="DataMuru"))

datamuru/core/__init__.py

@@ -0,0 +1 @@
+

datamuru/core/apply/__init__.py

@@ -0,0 +1,5 @@
+from .engine import apply_plan
+from .executor import PlanExecutor
+from .models import ApplyFailure, ApplyResult
+
+__all__ = ["ApplyFailure", "ApplyResult", "PlanExecutor", "apply_plan"]

datamuru/core/apply/engine.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from datamuru.core.plan.models import Plan
+
+from .executor import PlanExecutor
+from .models import ApplyResult
+
+
+def apply_plan(plan: Plan, provider, state_backend) -> ApplyResult:
+    return PlanExecutor().execute(plan=plan, provider=provider, state_backend=state_backend)