py-data-engine 0.1.0__py3-none-any.whl

data_engine/domain/source_state.py

@@ -0,0 +1,17 @@
+"""Domain models for source-file freshness and change detection."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SourceSignature:
+    """One concrete source file signature used for freshness checks."""
+
+    source_path: str
+    mtime_ns: int
+    size_bytes: int
+
+
+__all__ = ["SourceSignature"]

data_engine/domain/support.py

@@ -0,0 +1,54 @@
+"""Domain models for documentation support state."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class DocumentationSessionState:
+    """Built documentation session state for one operator surface."""
+
+    build_running: bool = False
+    root_dir: Path | None = None
+
+    @classmethod
+    def empty(cls) -> "DocumentationSessionState":
+        """Return the idle documentation state."""
+        return cls()
+
+    @property
+    def available(self) -> bool:
+        """Return whether built documentation is available."""
+        return self.root_dir is not None
+
+    def with_build_running(self, running: bool) -> "DocumentationSessionState":
+        """Return a copy with the build-running flag replaced."""
+        return replace(self, build_running=bool(running))
+
+    def with_root_dir(self, root_dir: Path | None) -> "DocumentationSessionState":
+        """Return a copy with the built-docs root replaced."""
+        return replace(self, root_dir=root_dir)
+
+
+@dataclass(frozen=True)
+class WorkspaceSupportState:
+    """Combined support state for one operator surface."""
+
+    documentation: DocumentationSessionState
+
+    @classmethod
+    def empty(cls) -> "WorkspaceSupportState":
+        """Return the idle workspace-support state."""
+        return cls(documentation=DocumentationSessionState.empty())
+
+    def with_documentation(self, documentation: DocumentationSessionState) -> "WorkspaceSupportState":
+        """Return a copy with documentation state replaced."""
+        return replace(self, documentation=documentation)
+
+
+__all__ = [
+    "DocumentationSessionState",
+    "WorkspaceSupportState",
+]

data_engine/domain/time.py

@@ -0,0 +1,23 @@
+"""Shared UTC timestamp helpers."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+
+def utcnow_text() -> str:
+    """Return the current UTC timestamp in ISO 8601 text form."""
+    return datetime.now(UTC).isoformat()
+
+
+def parse_utc_text(value: str | None) -> datetime | None:
+    """Return a parsed UTC datetime for persisted timestamp text."""
+    if value in {None, ""}:
+        return None
+    parsed = datetime.fromisoformat(value)
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=UTC)
+    return parsed.astimezone(UTC)
+
+
+__all__ = ["parse_utc_text", "utcnow_text"]

data_engine/domain/workspace.py

@@ -0,0 +1,159 @@
+"""Domain models for workspace selection and collection-root state."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterable
+
+if TYPE_CHECKING:
+    from data_engine.platform.workspace_models import WorkspacePaths
+
+
+@dataclass(frozen=True)
+class WorkspaceRootState:
+    """Workspace collection-root state for one operator surface."""
+
+    effective_root: Path | None
+    configured: bool = True
+    override_root: Path | None = None
+
+    @classmethod
+    def from_paths(
+        cls,
+        workspace_paths: "WorkspacePaths",
+        *,
+        override_root: Path | None = None,
+    ) -> "WorkspaceRootState":
+        """Build one root-state value from resolved workspace paths and an override."""
+        configured = bool(getattr(workspace_paths, "workspace_configured", True))
+        return cls(
+            effective_root=workspace_paths.workspace_collection_root if configured else None,
+            configured=configured,
+            override_root=override_root.resolve() if override_root is not None else None,
+        )
+
+    @property
+    def using_override(self) -> bool:
+        """Return whether a machine-local collection-root override is active."""
+        return self.override_root is not None
+
+    @property
+    def input_text(self) -> str:
+        """Return the text that should populate workspace-root controls."""
+        if self.override_root is not None:
+            return str(self.override_root)
+        return str(self.effective_root) if self.effective_root is not None else ""
+
+    @property
+    def status_text(self) -> str:
+        """Return plain-language root-source status text for operator surfaces."""
+        if not self.configured:
+            return "Workspace folder is not configured."
+        return f"Workspace folder: {self.override_root or self.effective_root}"
+
+    def with_override_root(self, override_root: Path | None) -> "WorkspaceRootState":
+        """Return a copy with the override root replaced."""
+        return replace(self, override_root=override_root.resolve() if override_root is not None else None)
+
+
+@dataclass(frozen=True)
+class WorkspaceSelectionState:
+    """Workspace selection/discovery state for one operator surface."""
+
+    current_workspace_id: str
+    discovered_workspace_ids: tuple[str, ...] = ()
+
+    @classmethod
+    def from_paths(
+        cls,
+        workspace_paths: "WorkspacePaths",
+        *,
+        discovered_workspace_ids: Iterable[str] = (),
+    ) -> "WorkspaceSelectionState":
+        """Build one selection state from resolved paths and discovered ids."""
+        return cls(
+            current_workspace_id=workspace_paths.workspace_id,
+            discovered_workspace_ids=tuple(discovered_workspace_ids),
+        )
+
+    @property
+    def selector_enabled(self) -> bool:
+        """Return whether the workspace selector should be interactive."""
+        return bool(self.discovered_workspace_ids)
+
+    @property
+    def selector_options(self) -> tuple[str, ...]:
+        """Return selector option ids in display order."""
+        return self.discovered_workspace_ids
+
+    def with_discovered_workspace_ids(self, workspace_ids: Iterable[str]) -> "WorkspaceSelectionState":
+        """Return a copy with the discovered workspace ids replaced."""
+        return replace(self, discovered_workspace_ids=tuple(workspace_ids))
+
+    def with_current_workspace_id(self, workspace_id: str) -> "WorkspaceSelectionState":
+        """Return a copy with the current selected workspace id replaced."""
+        return replace(self, current_workspace_id=workspace_id)
+
+
+@dataclass(frozen=True)
+class WorkspaceSessionState:
+    """Combined workspace selection and collection-root state."""
+
+    root: WorkspaceRootState
+    selection: WorkspaceSelectionState
+
+    @classmethod
+    def from_paths(
+        cls,
+        workspace_paths: "WorkspacePaths",
+        *,
+        override_root: Path | None = None,
+        discovered_workspace_ids: Iterable[str] = (),
+    ) -> "WorkspaceSessionState":
+        """Build one workspace-session value from resolved paths and discovery state."""
+        return cls(
+            root=WorkspaceRootState.from_paths(workspace_paths, override_root=override_root),
+            selection=WorkspaceSelectionState.from_paths(
+                workspace_paths,
+                discovered_workspace_ids=discovered_workspace_ids,
+            ),
+        )
+
+    @property
+    def workspace_collection_root_override(self) -> Path | None:
+        """Return the active machine-local collection-root override, if any."""
+        return self.root.override_root
+
+    @property
+    def discovered_workspace_ids(self) -> tuple[str, ...]:
+        """Return discovered workspace ids for selector-like surfaces."""
+        return self.selection.discovered_workspace_ids
+
+    @property
+    def current_workspace_id(self) -> str:
+        """Return the currently selected workspace id."""
+        return self.selection.current_workspace_id
+
+    def with_paths(self, workspace_paths: "WorkspacePaths") -> "WorkspaceSessionState":
+        """Return a copy rebound to a new resolved workspace path set."""
+        return type(self).from_paths(
+            workspace_paths,
+            override_root=self.root.override_root,
+            discovered_workspace_ids=self.selection.discovered_workspace_ids,
+        )
+
+    def with_override_root(self, override_root: Path | None) -> "WorkspaceSessionState":
+        """Return a copy with the override root replaced."""
+        return replace(self, root=self.root.with_override_root(override_root))
+
+    def with_discovered_workspace_ids(self, workspace_ids: Iterable[str]) -> "WorkspaceSessionState":
+        """Return a copy with the discovered workspace ids replaced."""
+        return replace(self, selection=self.selection.with_discovered_workspace_ids(workspace_ids))
+
+    def with_current_workspace_id(self, workspace_id: str) -> "WorkspaceSessionState":
+        """Return a copy with the current workspace id replaced."""
+        return replace(self, selection=self.selection.with_current_workspace_id(workspace_id))
+
+
+__all__ = ["WorkspaceRootState", "WorkspaceSelectionState", "WorkspaceSessionState"]

data_engine/flow_modules/__init__.py

@@ -0,0 +1 @@
+"""Flow-module discovery and compilation helpers."""

data_engine/flow_modules/flow_module_compiler.py

@@ -0,0 +1,179 @@
+"""Flow-module compilation and mirroring for Data Engine modules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+import shutil
+
+from data_engine.authoring.model import FlowValidationError
+from data_engine.platform.workspace_models import WORKSPACE_FLOW_HELPERS_DIR_NAME
+from data_engine.platform.workspace_policy import RuntimeLayoutPolicy
+
+
+@dataclass(frozen=True)
+class CompiledFlowModule:
+    """Information about one compiled flow module."""
+
+    name: str
+    source_path: Path
+    module_path: Path
+
+
+def compile_stale_flow_module_notebooks(
+    *,
+    data_root: Path | None = None,
+) -> tuple[CompiledFlowModule, ...]:
+    """Compile notebook flow modules and mirror authored Python modules into compiled output."""
+    flow_modules_dir, modules_dir = resolve_flow_module_paths(
+        data_root=data_root,
+    )
+    modules_dir.mkdir(parents=True, exist_ok=True)
+
+    if not flow_modules_dir.exists():
+        return ()
+
+    notebook_paths = sorted(flow_modules_dir.glob("*.ipynb"))
+    python_paths = sorted(path for path in flow_modules_dir.glob("*.py") if path.name != "__init__.py")
+    _validate_unique_authored_flow_module_stems(notebook_paths, python_paths)
+
+    helper_modules_dir = flow_modules_dir / WORKSPACE_FLOW_HELPERS_DIR_NAME
+    compiled_helper_modules_dir = modules_dir / WORKSPACE_FLOW_HELPERS_DIR_NAME
+    authored_names = {path.stem for path in notebook_paths} | {path.stem for path in python_paths}
+    _remove_orphaned_compiled_modules(modules_dir, authored_names)
+    _mirror_helper_modules(helper_modules_dir, compiled_helper_modules_dir)
+
+    compiled: list[CompiledFlowModule] = []
+    for notebook_path in notebook_paths:
+        module_path = modules_dir / f"{notebook_path.stem}.py"
+        if module_path.exists() and module_path.stat().st_mtime >= notebook_path.stat().st_mtime:
+            continue
+        compile_flow_module_notebook(notebook_path, module_path)
+        compiled.append(CompiledFlowModule(name=notebook_path.stem, source_path=notebook_path, module_path=module_path))
+    for source_path in python_paths:
+        module_path = modules_dir / source_path.name
+        if module_path.exists() and module_path.stat().st_mtime >= source_path.stat().st_mtime:
+            continue
+        mirror_flow_module_python_module(source_path, module_path)
+        compiled.append(CompiledFlowModule(name=source_path.stem, source_path=source_path, module_path=module_path))
+    return tuple(compiled)
+
+
+def resolve_flow_module_paths(
+    *,
+    data_root: Path | None = None,
+) -> tuple[Path, Path]:
+    """Resolve the authored flow-module and compiled output directories."""
+    workspace = RuntimeLayoutPolicy().resolve_paths(data_root=data_root)
+    return workspace.flow_modules_dir, workspace.compiled_flow_modules_dir
+
+
+def compile_flow_module_notebook(notebook_path: Path, module_path: Path) -> None:
+    """Compile one notebook-authored flow module into a Python module."""
+    payload = json.loads(notebook_path.read_text(encoding="utf-8"))
+    cells = payload.get("cells")
+    if not isinstance(cells, list):
+        raise FlowValidationError(f"Notebook cells payload is invalid in {notebook_path}")
+
+    code_blocks: list[str] = []
+    for cell in cells:
+        if not isinstance(cell, dict) or cell.get("cell_type") != "code":
+            continue
+        source = cell.get("source", [])
+        if isinstance(source, str):
+            text = source
+        elif isinstance(source, list) and all(isinstance(line, str) for line in source):
+            text = "".join(source)
+        else:
+            raise FlowValidationError(f"Notebook code cell source is invalid in {notebook_path}")
+        stripped = text.strip()
+        if not stripped:
+            continue
+        for line in stripped.splitlines():
+            if line.lstrip().startswith("%") or line.lstrip().startswith("!"):
+                raise FlowValidationError(f"Notebook magics and shell commands are not allowed in {notebook_path}")
+        code_blocks.append(stripped)
+
+    if not code_blocks:
+        raise FlowValidationError(f"Notebook does not contain any code cells to compile: {notebook_path}")
+
+    rendered = [
+        '"""Auto-compiled flow module. Source notebook is authoritative."""',
+        "",
+        "from __future__ import annotations",
+        "",
+        f"# Source notebook: {notebook_path.as_posix()}",
+        "",
+    ]
+    rendered.append("\n\n".join(code_blocks))
+    rendered.append("")
+
+    module_path.parent.mkdir(parents=True, exist_ok=True)
+    module_path.write_text("\n".join(rendered), encoding="utf-8")
+
+
+def mirror_flow_module_python_module(source_path: Path, module_path: Path) -> None:
+    """Mirror one authored Python flow/helper module into compiled output."""
+    source_text = source_path.read_text(encoding="utf-8")
+    rendered = [
+        f"# Mirrored flow module. Source file is authoritative: {source_path.as_posix()}",
+        "",
+        source_text.rstrip(),
+        "",
+    ]
+    module_path.parent.mkdir(parents=True, exist_ok=True)
+    module_path.write_text("\n".join(rendered), encoding="utf-8")
+
+
+def _mirror_helper_modules(helper_modules_dir: Path, compiled_helper_modules_dir: Path) -> None:
+    """Mirror authored helper modules into compiled output as an importable package."""
+    if compiled_helper_modules_dir.exists():
+        shutil.rmtree(compiled_helper_modules_dir)
+    if not helper_modules_dir.is_dir():
+        return
+    shutil.copytree(helper_modules_dir, compiled_helper_modules_dir)
+    init_path = compiled_helper_modules_dir / "__init__.py"
+    if not init_path.exists():
+        init_path.write_text('"""Authored flow helper modules for flow-module imports."""\n', encoding="utf-8")
+
+
+def _validate_unique_authored_flow_module_stems(notebook_paths: list[Path], python_paths: list[Path]) -> None:
+    """Reject authored flow-module directories that define the same module stem twice."""
+    notebook_stems = {path.stem for path in notebook_paths}
+    python_stems = {path.stem for path in python_paths}
+    overlaps = sorted(notebook_stems & python_stems)
+    if overlaps:
+        names = ", ".join(overlaps)
+        raise FlowValidationError(f"Flow module sources conflict between .ipynb and .py files: {names}")
+
+
+def _remove_orphaned_compiled_modules(modules_dir: Path, authored_names: set[str]) -> None:
+    """Delete generated modules and caches that no longer have a notebook source."""
+    for module_path in modules_dir.glob("*.py"):
+        if module_path.name == "__init__.py" or module_path.stem.startswith("_"):
+            continue
+        if module_path.stem not in authored_names and _is_generated_module(module_path):
+            module_path.unlink()
+
+    pycache_dir = modules_dir / "__pycache__"
+    if pycache_dir.exists():
+        shutil.rmtree(pycache_dir)
+
+
+def _is_generated_module(module_path: Path) -> bool:
+    """Return whether a compiled module was generated or mirrored from authored sources."""
+    try:
+        first_line = module_path.read_text(encoding="utf-8").splitlines()[0]
+    except (FileNotFoundError, IndexError):
+        return False
+    return "Auto-compiled flow module" in first_line or "Mirrored flow module" in first_line
+
+
+__all__ = [
+    "CompiledFlowModule",
+    "compile_flow_module_notebook",
+    "compile_stale_flow_module_notebooks",
+    "mirror_flow_module_python_module",
+    "resolve_flow_module_paths",
+]

data_engine/flow_modules/flow_module_loader.py

@@ -0,0 +1,201 @@
+"""Code-native flow-module discovery and loading for Data Engine flows."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from contextlib import contextmanager
+from contextvars import ContextVar
+from importlib.util import module_from_spec, spec_from_file_location
+import inspect
+from pathlib import Path
+import sys
+from typing import TYPE_CHECKING, Callable
+
+from data_engine.authoring.model import FlowExecutionError, FlowValidationError
+from data_engine.flow_modules.flow_module_compiler import compile_stale_flow_module_notebooks, resolve_flow_module_paths
+from data_engine.platform.workspace_models import APP_INTERNAL_ID
+
+if TYPE_CHECKING:
+    from data_engine.authoring.builder import Flow
+
+
+_COMPILED_FLOW_MODULE_CONTEXT: ContextVar[bool] = ContextVar("compiled_flow_module_context", default=False)
+_COMPILED_FLOW_MODULE_DIR: ContextVar[Path | None] = ContextVar("compiled_flow_module_dir", default=None)
+
+
+@dataclass(frozen=True)
+class FlowModuleDefinition:
+    """Loaded flow-module callable plus optional UI metadata."""
+
+    name: str
+    description: str | None
+    module_path: Path
+    build: Callable[[], "Flow"]
+
+
+def _load_module(name: str, *, data_root: Path | None = None):
+    compile_stale_flow_module_notebooks(data_root=data_root)
+    flow_modules_dir, compiled_flow_modules_dir = resolve_flow_module_paths(data_root=data_root)
+    module_path = compiled_flow_modules_dir / f"{name}.py"
+    if not module_path.exists():
+        source_path = _authored_flow_module_source_path(name, flow_modules_dir=flow_modules_dir)
+        if source_path is not None:
+            raise FlowValidationError(
+                f"Flow module {name!r} could not be compiled from {source_path}. No compiled module was produced."
+            )
+        available = _available_flow_module_names(flow_modules_dir=flow_modules_dir)
+        if available:
+            names_text = ", ".join(available)
+            raise FlowValidationError(
+                f"Flow module {name!r} is not available in {flow_modules_dir}. Available flow modules: {names_text}."
+            )
+        raise FlowValidationError(f"Flow module {name!r} is not available in {flow_modules_dir}.")
+
+    module_name = f"{APP_INTERNAL_ID}_user_flow_module_{name}"
+    try:
+        spec = spec_from_file_location(module_name, module_path)
+        if spec is None or spec.loader is None:
+            raise FlowValidationError(f"Flow module {name!r} could not be loaded from {module_path}.")
+        module = module_from_spec(spec)
+        with compiled_flow_module_context(flow_modules_dir), _compiled_flow_module_import_path(module_path.parent):
+            spec.loader.exec_module(module)
+    except FlowValidationError:
+        raise
+    except Exception as exc:
+        raise FlowExecutionError(
+            flow_name=name,
+            phase="import",
+            detail=f"{type(exc).__name__}: {exc} ({module_path})",
+        ) from exc
+
+    return module, module_path, flow_modules_dir
+
+
+def _authored_flow_module_source_path(name: str, *, flow_modules_dir: Path) -> Path | None:
+    """Return the authored notebook or Python source path for one flow module when present."""
+    for suffix in (".py", ".ipynb"):
+        source_path = flow_modules_dir / f"{name}{suffix}"
+        if source_path.exists():
+            return source_path
+    return None
+
+
+def _available_flow_module_names(*, flow_modules_dir: Path) -> tuple[str, ...]:
+    """Return the authored flow-module names currently present in one workspace."""
+    names = {
+        path.stem
+        for pattern in ("*.py", "*.ipynb")
+        for path in flow_modules_dir.glob(pattern)
+        if path.name != "__init__.py" and not path.stem.startswith("_")
+    }
+    return tuple(sorted(names))
+
+
+@contextmanager
+def _compiled_flow_module_import_path(compiled_flow_modules_dir: Path):
+    """Temporarily expose the compiled flow-module directory for sibling helper imports."""
+    path_text = str(compiled_flow_modules_dir)
+    inserted = False
+    if path_text not in sys.path:
+        sys.path.insert(0, path_text)
+        inserted = True
+    try:
+        yield
+    finally:
+        if inserted:
+            try:
+                sys.path.remove(path_text)
+            except ValueError:
+                pass
+
+
+def load_flow_module_definition(name: str, *, data_root: Path | None = None) -> FlowModuleDefinition:
+    """Load one compiled flow-module definition by module name."""
+    module, module_path, flow_modules_dir = _load_module(name, data_root=data_root)
+
+    build = getattr(module, "build", None)
+    if build is None or not callable(build):
+        raise FlowValidationError(f"Flow module {name!r} does not export a callable build().")
+
+    signature = inspect.signature(build)
+    if len(signature.parameters) != 0:
+        raise FlowValidationError(f"Flow module {name!r} build() must not accept any parameters.")
+
+    description = getattr(module, "DESCRIPTION", None)
+    if description is not None and not isinstance(description, str):
+        raise FlowValidationError(f"Flow module {name!r} DESCRIPTION must be a string.")
+
+    def guarded_build() -> "Flow":
+        with compiled_flow_module_context(flow_modules_dir):
+            from data_engine.authoring.builder import Flow
+
+            try:
+                built = build()
+            except FlowValidationError:
+                raise
+            except Exception as exc:
+                raise FlowExecutionError(
+                    flow_name=name,
+                    phase="build",
+                    function_name=getattr(build, "__name__", "build"),
+                    detail=f"{type(exc).__name__}: {exc}",
+                ) from exc
+        if not isinstance(built, Flow):
+            raise FlowValidationError(f"Flow module {name!r} build() did not return a Flow.")
+        return built._clone(name=name, _workspace_root=flow_modules_dir.parent.resolve())
+
+    return FlowModuleDefinition(
+        name=name,
+        description=description,
+        module_path=module_path,
+        build=guarded_build,
+    )
+
+
+def discover_flow_module_definitions(*, data_root: Path | None = None) -> tuple[FlowModuleDefinition, ...]:
+    """Discover and load all compiled flow-module definitions from the workspace."""
+    compile_stale_flow_module_notebooks(data_root=data_root)
+    flow_modules_dir, compiled_flow_modules_dir = resolve_flow_module_paths(data_root=data_root)
+    if not flow_modules_dir.is_dir():
+        return ()
+    if not compiled_flow_modules_dir.exists():
+        return ()
+
+    discovered: list[FlowModuleDefinition] = []
+    for module_path in sorted(compiled_flow_modules_dir.glob("*.py")):
+        if module_path.name == "__init__.py" or module_path.stem.startswith("_"):
+            continue
+        discovered.append(load_flow_module_definition(module_path.stem, data_root=data_root))
+    return tuple(discovered)
+
+
+def in_compiled_flow_module_context() -> bool:
+    """Return whether execution is currently inside a compiled flow-module context."""
+    return _COMPILED_FLOW_MODULE_CONTEXT.get()
+
+
+def current_compiled_flow_module_dir() -> Path | None:
+    """Return the compiled flow-module directory active for the current import/build context."""
+    return _COMPILED_FLOW_MODULE_DIR.get()
+
+
+@contextmanager
+def compiled_flow_module_context(flow_modules_dir: Path | None = None):
+    """Mark the current execution context as a compiled flow-module import/build."""
+    token = _COMPILED_FLOW_MODULE_CONTEXT.set(True)
+    dir_token = _COMPILED_FLOW_MODULE_DIR.set(flow_modules_dir.resolve() if flow_modules_dir is not None else None)
+    try:
+        yield
+    finally:
+        _COMPILED_FLOW_MODULE_DIR.reset(dir_token)
+        _COMPILED_FLOW_MODULE_CONTEXT.reset(token)
+
+
+__all__ = [
+    "FlowModuleDefinition",
+    "compiled_flow_module_context",
+    "current_compiled_flow_module_dir",
+    "discover_flow_module_definitions",
+    "in_compiled_flow_module_context",
+    "load_flow_module_definition",
+]

data_engine/helpers/__init__.py

@@ -0,0 +1,25 @@
+"""Public authoring helper modules."""
+
+from data_engine.helpers.duckdb import attach_dimension
+from data_engine.helpers.duckdb import build_dimension
+from data_engine.helpers.duckdb import denormalize_columns
+from data_engine.helpers.duckdb import normalize_columns
+from data_engine.helpers.duckdb import read_rows_by_values
+from data_engine.helpers.duckdb import read_sql
+from data_engine.helpers.duckdb import read_table
+from data_engine.helpers.duckdb import replace_rows_by_file
+from data_engine.helpers.duckdb import replace_rows_by_values
+from data_engine.helpers.duckdb import replace_table
+
+__all__ = [
+    "attach_dimension",
+    "build_dimension",
+    "denormalize_columns",
+    "normalize_columns",
+    "read_rows_by_values",
+    "read_sql",
+    "read_table",
+    "replace_rows_by_file",
+    "replace_rows_by_values",
+    "replace_table",
+]