weaverstack 0.1.1__py3-none-any.whl

weaver/unbind.py

@@ -0,0 +1,74 @@
+"""Remove catalogue installations for explicitly named physical targets."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .catalogue.reader import read_table
+from .catalogue.reconcile import prune_installation
+from .catalogue.render import InstallationScope
+from .catalogue.tables import INSTALLATION
+from .declaration.model import LAKEHOUSE, WAREHOUSE
+from .targets import ItemRef
+
+
+@dataclass(frozen=True)
+class UnbindResult:
+    targets: tuple[str, ...]
+    logical_items: tuple[str, ...]
+    statements: tuple[str, ...]
+
+    def to_mapping(self) -> dict[str, object]:
+        return {
+            "targets": list(self.targets),
+            "logical_items": list(self.logical_items),
+            "statements": len(self.statements),
+        }
+
+
+def plan_unbind(
+    catalogue,
+    *,
+    lakehouses=(),
+    warehouses=(),
+) -> UnbindResult:
+    """Render complete catalogue deletion without inspecting physical targets."""
+
+    selected = {
+        (LAKEHOUSE, ItemRef.parse(value).name) for value in lakehouses
+    } | {
+        (WAREHOUSE, ItemRef.parse(value).name) for value in warehouses
+    }
+    rows = read_table(catalogue, INSTALLATION)
+    scopes = sorted(
+        {
+            InstallationScope(
+                str(row["item_type"]), str(row["item_name"])
+            )
+            for row in rows
+            if (str(row["item_type"]), str(row["target_name"])) in selected
+        },
+        key=str,
+    )
+    statements = tuple(
+        statement
+        for scope in scopes
+        for statement in prune_installation(scope)
+    )
+    targets = tuple(f"{item_type}/{name}" for item_type, name in sorted(selected))
+    return UnbindResult(
+        targets=targets,
+        logical_items=tuple(map(str, scopes)),
+        statements=statements,
+    )
+
+
+def unbind_targets(catalogue, *, lakehouses=(), warehouses=()) -> UnbindResult:
+    """Execute target-directed catalogue deletion and touch no physical target."""
+
+    result = plan_unbind(
+        catalogue, lakehouses=lakehouses, warehouses=warehouses
+    )
+    for statement in result.statements:
+        catalogue.sql(statement)
+    return result

weaver/workspaces.py

@@ -0,0 +1,175 @@
+"""Workspace configuration and the two execution environments Weaver supports.
+
+A Workspace identifies where resources live.  For Fabric that identity is a
+Microsoft Fabric workspace name; for the local emulator it is the path to the
+folder that stands in for one.  It does not say where Weaver code executes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from types import MappingProxyType
+from typing import Mapping
+
+from .declaration.model import LAKEHOUSE, WAREHOUSE, WeaverItemId
+from .errors import ConfigError
+from .targets import validate_name
+
+WEAVER_ITEMS_AREA = "weaver_items"
+BUILD_BUNDLES_AREA = "build_bundles"
+CLI_AREA = "cli"
+FABRIC = "fabric"
+LOCAL = "local"
+WORKSPACE_TYPES = (FABRIC, LOCAL)
+
+
+@dataclass(frozen=True)
+class ExecutionSettings:
+    """Technical parallelism settings for a Workspace or one physical item."""
+
+    parallel_workers: int | None = None
+
+    def __post_init__(self) -> None:
+        workers = self.parallel_workers
+        if workers is not None and (
+            isinstance(workers, bool) or not isinstance(workers, int) or workers < 1
+        ):
+            raise ConfigError("parallel_workers must be a positive integer")
+
+
+@dataclass(frozen=True)
+class TargetDeclaration:
+    """A configured physical target and its default logical Weaver item."""
+
+    item: WeaverItemId
+    execution: ExecutionSettings = field(default_factory=ExecutionSettings)
+
+
+def _target_declarations(
+    declarations: Mapping[str, TargetDeclaration], *, item_type: str, field_name: str
+) -> Mapping[str, TargetDeclaration]:
+    resolved: dict[str, TargetDeclaration] = {}
+    for physical_name, declaration in dict(declarations).items():
+        name = validate_name(physical_name, what=f"{field_name} key")
+        if not isinstance(declaration, TargetDeclaration):
+            raise ConfigError(f"{field_name}[{name!r}] must be a TargetDeclaration")
+        if declaration.item.item_type != item_type:
+            raise ConfigError(
+                f"{field_name}[{name!r}] must name a {item_type} item, "
+                f"got {declaration.item}"
+            )
+        resolved[name] = declaration
+    return MappingProxyType(resolved)
+
+
+@dataclass(frozen=True, kw_only=True)
+class Workspace:
+    """The common configuration for one Fabric workspace or local emulator."""
+
+    environment: str | None = None
+    weaver_lakehouse: str | None = None
+    execution: ExecutionSettings = field(default_factory=ExecutionSettings)
+    lakehouses: Mapping[str, TargetDeclaration] = field(default_factory=dict)
+    warehouses: Mapping[str, TargetDeclaration] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.environment is not None:
+            object.__setattr__(
+                self,
+                "environment",
+                validate_name(self.environment, what="environment"),
+            )
+        if self.weaver_lakehouse is not None:
+            object.__setattr__(
+                self,
+                "weaver_lakehouse",
+                validate_name(self.weaver_lakehouse, what="weaver_lakehouse"),
+            )
+        if not isinstance(self.execution, ExecutionSettings):
+            raise ConfigError("execution must be ExecutionSettings")
+        object.__setattr__(
+            self,
+            "lakehouses",
+            _target_declarations(
+                self.lakehouses, item_type=LAKEHOUSE, field_name="lakehouses"
+            ),
+        )
+        object.__setattr__(
+            self,
+            "warehouses",
+            _target_declarations(
+                self.warehouses, item_type=WAREHOUSE, field_name="warehouses"
+            ),
+        )
+
+    @property
+    def workspace_type(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def supports_sql(self) -> bool:
+        raise NotImplementedError
+
+    def declaration_for(self, item_type: str, physical_name: str) -> TargetDeclaration:
+        declarations = self.lakehouses if item_type == LAKEHOUSE else self.warehouses
+        try:
+            return declarations[physical_name]
+        except KeyError as exc:
+            plural = "Lakehouses" if item_type == LAKEHOUSE else "Warehouses"
+            raise ConfigError(
+                f"physical target {plural}/{physical_name} is not configured"
+            ) from exc
+
+
+@dataclass(frozen=True, kw_only=True)
+class FabricWorkspace(Workspace):
+    """One Microsoft Fabric workspace."""
+
+    workspace: str
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        object.__setattr__(
+            self, "workspace", validate_name(self.workspace, what="workspace")
+        )
+
+    @property
+    def workspace_type(self) -> str:
+        return FABRIC
+
+    @property
+    def supports_sql(self) -> bool:
+        return True
+
+    def settings_for_warehouse(self, name: str) -> ExecutionSettings:
+        declaration = self.warehouses.get(name)
+        return declaration.execution if declaration else self.execution
+
+
+@dataclass(frozen=True, kw_only=True)
+class LocalWorkspace(Workspace):
+    """A filesystem folder standing in for one Fabric workspace."""
+
+    workspace: Path
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        value = self.workspace
+        if isinstance(value, str):
+            if not value.strip():
+                raise ConfigError("workspace path must not be empty")
+            value = Path(value.strip())
+        elif not isinstance(value, Path):
+            raise ConfigError(
+                f"workspace must be a path, got {type(value).__name__}"
+            )
+        object.__setattr__(self, "workspace", value.expanduser())
+
+    @property
+    def workspace_type(self) -> str:
+        return LOCAL
+
+    @property
+    def supports_sql(self) -> bool:
+        return False

weaver_cli/__init__.py

@@ -0,0 +1,12 @@
+"""The optional desktop CLI — an adapter over :mod:`weaver`.
+
+The dependency direction is one way: this package imports ``weaver``; the core
+never imports this package. The CLI owns argument parsing and presentation
+only. Build, load and catalogue semantics belong to the core.
+"""
+
+from __future__ import annotations
+
+from .main import main
+
+__all__ = ["main"]

weaver_cli/__main__.py

@@ -0,0 +1,7 @@
+"""Allow ``python -m weaver_cli``."""
+
+from __future__ import annotations
+
+from .main import main
+
+raise SystemExit(main())