py-data-engine 0.3.10__tar.gz → 0.3.11__tar.gz

{py_data_engine-0.3.10/src/py_data_engine.egg-info → py_data_engine-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-data-engine
-Version: 0.3.10
+Version: 0.3.11
 Summary: GUI orchestrator for python-based dataframe transform pipelines.
 Author: Data Engine contributors
 License-Expression: MIT
@@ -79,7 +79,6 @@ It provides:
 - a workspace-based runtime for authored flows
 - a desktop GUI for operators
 - a terminal UI for headless/local operation
-- an experimental Rust-backed `egui` surface
 - parquet-first inspect/debug tooling for dataframe outputs
 
 Flows are plain Python modules that declare how source files, settings workbooks, schedules, and manual runs should move through Polars, DuckDB, and file outputs.
@@ -153,12 +152,6 @@ Desktop GUI:
 data-engine start gui
 ```
 
-Experimental Rust `egui` surface:
-
-```bash
-data-engine start egui
-```
-
 Terminal UI:
 
 ```bash
@@ -307,6 +300,7 @@ def build():
 - `.watch(mode="schedule", time="HH:MM", source=None, run_as="individual" | "batch")`
 - `.watch(mode="schedule", time=["08:15", "14:45"], source=..., run_as="individual" | "batch")`
 - `.mirror(root=...)`
+- `.date_range_input(name="period", label="Reporting Period")` for manual-only pre-run start/end date selection
 - `.step(fn, use=None, save_as=None, label=None)`
 - `.collect(extensions, root=None, recursive=False, use=None, save_as=None, label=None)`
 - `.map(fn, use=None, save_as=None, label=None)`
@@ -329,6 +323,8 @@ def build():
 - `context.current`
 - `context.objects`
 - `context.metadata`
+- `context.database("analytics.duckdb")`
+- `context.template("reports/base.xlsx")`
 - `context.source_metadata()`
 - `context.debug`
 

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/README.md

@@ -7,7 +7,6 @@ It provides:
 - a workspace-based runtime for authored flows
 - a desktop GUI for operators
 - a terminal UI for headless/local operation
-- an experimental Rust-backed `egui` surface
 - parquet-first inspect/debug tooling for dataframe outputs
 
 Flows are plain Python modules that declare how source files, settings workbooks, schedules, and manual runs should move through Polars, DuckDB, and file outputs.
@@ -81,12 +80,6 @@ Desktop GUI:
 data-engine start gui
 ```
 
-Experimental Rust `egui` surface:
-
-```bash
-data-engine start egui
-```
-
 Terminal UI:
 
 ```bash
@@ -235,6 +228,7 @@ def build():
 - `.watch(mode="schedule", time="HH:MM", source=None, run_as="individual" | "batch")`
 - `.watch(mode="schedule", time=["08:15", "14:45"], source=..., run_as="individual" | "batch")`
 - `.mirror(root=...)`
+- `.date_range_input(name="period", label="Reporting Period")` for manual-only pre-run start/end date selection
 - `.step(fn, use=None, save_as=None, label=None)`
 - `.collect(extensions, root=None, recursive=False, use=None, save_as=None, label=None)`
 - `.map(fn, use=None, save_as=None, label=None)`
@@ -257,6 +251,8 @@ def build():
 - `context.current`
 - `context.objects`
 - `context.metadata`
+- `context.database("analytics.duckdb")`
+- `context.template("reports/base.xlsx")`
 - `context.source_metadata()`
 - `context.debug`
 

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/pyproject.toml

@@ -115,9 +115,6 @@ include = ["data_engine*"]
 [tool.setuptools.package-data]
 data_engine = [
   "ui/gui/icons/*.svg",
-  "ui/egui/*.pyd",
-  "ui/egui/*.so",
-  "ui/egui/*.dylib",
   "docs/sphinx_source/conf.py",
   "docs/sphinx_source/*.rst",
   "docs/sphinx_source/guides/*.md",

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/setup.py

@@ -5,7 +5,6 @@ import sys
 from pathlib import Path
 
 from setuptools import setup
-from setuptools.command.bdist_wheel import bdist_wheel as _bdist_wheel
 from setuptools.command.build_py import build_py as _build_py
 from setuptools.command.sdist import sdist as _sdist
 
@@ -14,14 +13,6 @@ ROOT = Path(__file__).resolve().parent
 DOCS_SOURCE_DIR = ROOT / "src" / "data_engine" / "docs" / "sphinx_source"
 DOCS_OUTPUT_DIR = ROOT / "src" / "data_engine" / "docs" / "html"
 PROJECT_AST_MAP_SCRIPT = ROOT / "src" / "data_engine" / "devtools" / "project_ast_map.py"
-EGUI_PACKAGE_DIR = ROOT / "src" / "data_engine" / "ui" / "egui"
-
-
-def _vendored_native_modules() -> list[Path]:
-    native_modules: list[Path] = []
-    for suffix in (".pyd", ".so", ".dylib"):
-        native_modules.extend(EGUI_PACKAGE_DIR.glob(f"_data_engine_egui*{suffix}"))
-    return sorted(native_modules)
 
 
 def _build_packaged_docs() -> None:
@@ -63,26 +54,4 @@ class sdist(_sdist):
         super().run()
 
 
-class bdist_wheel(_bdist_wheel):
-    def finalize_options(self) -> None:
-        super().finalize_options()
-        if _vendored_native_modules():
-            self.root_is_pure = False
-
-    def get_tag(self) -> tuple[str, str, str]:
-        python_tag, abi_tag, platform_tag = super().get_tag()
-        if _vendored_native_modules():
-            python_tag = f"cp{sys.version_info.major}{sys.version_info.minor}"
-            abi_tag = "abi3"
-        return python_tag, abi_tag, platform_tag
-
-    def run(self) -> None:
-        if sys.platform == "win32" and not _vendored_native_modules():
-            raise RuntimeError(
-                "Windows wheel build requires the vendored egui native module. "
-                "Run scripts/build_egui_native.py first."
-            )
-        super().run()
-
-
-setup(cmdclass={"bdist_wheel": bdist_wheel, "build_py": build_py, "sdist": sdist})
+setup(cmdclass={"build_py": build_py, "sdist": sdist})

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/src/data_engine/application/control.py

@@ -55,6 +55,7 @@ class OperatorControlApplication:
         selected_flow_valid: bool,
         blocked_status_text: str,
         timeout: float = 2.0,
+        inputs: dict[str, object] | None = None,
     ) -> OperatorActionResult:
         """Validate and request one manual run for the selected flow."""
         if not authored_workspace_is_available(paths):
@@ -76,12 +77,14 @@ class OperatorControlApplication:
             return OperatorActionResult(requested=False)
         if not action_context.control_available:
             return OperatorActionResult(requested=False, status_text=blocked_status_text)
-        result = self.runtime_application.run_flow(
-            paths,
-            name=selected_flow_name,
-            wait=False,
-            timeout=timeout,
-        )
+        run_kwargs: dict[str, object] = {
+            "name": selected_flow_name,
+            "wait": False,
+            "timeout": timeout,
+        }
+        if inputs is not None:
+            run_kwargs["inputs"] = inputs
+        result = self.runtime_application.run_flow(paths, **run_kwargs)
         if not result.ok:
             return OperatorActionResult(
                 requested=False,

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/src/data_engine/application/runtime.py

@@ -242,13 +242,21 @@ class RuntimeApplication:
             signature=signature,
         )
 
-    def run_flow(self, paths: WorkspacePaths, *, name: str, wait: bool = False, timeout: float = 2.0) -> DaemonCommandResult:
+    def run_flow(
+        self,
+        paths: WorkspacePaths,
+        *,
+        name: str,
+        wait: bool = False,
+        timeout: float = 2.0,
+        inputs: dict[str, object] | None = None,
+    ) -> DaemonCommandResult:
         """Request one manual flow run through the daemon."""
         if not authored_workspace_is_available(paths):
             return DaemonCommandResult(ok=False, error="Workspace root is no longer available.")
         return self._spawn_and_request(
             paths,
-            {"command": "run_flow", "name": name, "wait": wait},
+            {"command": "run_flow", "name": name, "wait": wait, "inputs": dict(inputs or {})},
             timeout=timeout,
         )
 

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/src/data_engine/authoring/flow.py

@@ -86,6 +86,7 @@ class Flow(_CoreFlow):
     def run_once(
         self,
         *,
+        inputs: dict[str, object] | None = None,
         authoring_services: AuthoringServices | None = None,
         runtime_execution_service: RuntimeExecutionService | None = None,
     ) -> list[FlowContext]:
@@ -95,6 +96,8 @@ class Flow(_CoreFlow):
         ----------
         authoring_services : AuthoringServices | None
             Optional service bundle used by tests or embedded hosts.
+        inputs : dict[str, object] | None
+            Submitted manual-run input values for flows that declare them.
         runtime_execution_service : RuntimeExecutionService | None
             Optional runtime execution service override.
 
@@ -108,7 +111,9 @@ class Flow(_CoreFlow):
             authoring_services=authoring_services,
             runtime_execution_service=runtime_execution_service,
         ).runtime_execution_service
-        return service.run_once(flow)
+        if inputs is None:
+            return service.run_once(flow)
+        return service.run_once(flow, inputs=inputs)
 
     def preview(
         self,

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/src/data_engine/core/flow.py

@@ -19,7 +19,7 @@ from data_engine.core.helpers import (
     _validate_slot_name,
 )
 from data_engine.core.model import FlowValidationError
-from data_engine.core.primitives import Batch, FlowContext, MirrorSpec, StepSpec, WatchSpec, collect_files
+from data_engine.core.primitives import Batch, FlowContext, ManualInputSpec, MirrorSpec, StepSpec, WatchSpec, collect_files
 
 
 @dataclass(frozen=True)
@@ -59,6 +59,8 @@ class Flow:
         Mirrored output path configuration.
     steps : tuple[StepSpec, ...]
         Ordered callable steps to run.
+    manual_inputs : tuple[ManualInputSpec, ...]
+        Pre-run operator inputs required before manual execution starts.
 
     Notes
     -----
@@ -71,6 +73,7 @@ class Flow:
     trigger: WatchSpec | None = None
     mirror_spec: MirrorSpec | None = None
     steps: tuple[StepSpec, ...] = ()
+    manual_inputs: tuple[ManualInputSpec, ...] = ()
     _workspace_root: Path | None = None
 
     def __post_init__(self) -> None:
@@ -80,6 +83,8 @@ class Flow:
             raise FlowValidationError("Flow label must be a non-empty string when provided.")
         if not isinstance(self.group, str) or not self.group.strip():
             raise FlowValidationError("Flow group must be a non-empty string.")
+        if self.manual_inputs and self.mode != "manual":
+            raise FlowValidationError("Flow manual inputs are only supported for manual flows.")
 
     def _clone(self, **kwargs) -> "Flow":
         return replace(self, **kwargs)
@@ -156,6 +161,8 @@ class Flow:
         normalized_mode = str(mode).strip().lower()
         if normalized_mode not in {"manual", "poll", "schedule"}:
             raise FlowValidationError("watch() mode must be one of 'manual', 'poll', or 'schedule'.")
+        if normalized_mode != "manual" and self.manual_inputs:
+            raise FlowValidationError("watch() cannot configure automated modes on flows with manual inputs.")
 
         normalized_run_as = str(run_as).strip().lower()
         if normalized_run_as not in {"individual", "batch"}:
@@ -264,6 +271,41 @@ class Flow:
         """
         return self._clone(mirror_spec=MirrorSpec(root=_resolve_flow_path(root)))
 
+    def date_range_input(
+        self,
+        *,
+        name: str,
+        label: str,
+        required: bool = True,
+        inclusive: bool = True,
+    ) -> "Flow":
+        """Require one start/end date range before a manual run starts.
+
+        Operator surfaces collect the value before starting the run. Runtime
+        steps can read the normalized ``DateRangeInputValue`` from
+        ``context.inputs[name]``.
+        """
+        if self.mode != "manual":
+            raise FlowValidationError("date_range_input() is only supported for manual flows.")
+        normalized_name = _validate_slot_name(method_name="date_range_input", slot_name="name", value=name)
+        normalized_label = _validate_label(method_name="date_range_input", label=label)
+        assert normalized_name is not None
+        assert normalized_label is not None
+        if normalized_name in {item.name for item in self.manual_inputs}:
+            raise FlowValidationError(f"date_range_input() name {normalized_name!r} is already defined.")
+        return self._clone(
+            manual_inputs=(
+                *self.manual_inputs,
+                ManualInputSpec(
+                    name=normalized_name,
+                    label=normalized_label,
+                    kind="date_range",
+                    required=bool(required),
+                    inclusive=bool(inclusive),
+                ),
+            )
+        )
+
     def step(
         self,
         fn: Callable[[FlowContext], object],

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/src/data_engine/core/primitives.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
+from datetime import date, datetime, timezone
 import json
 from pathlib import Path
 import tomllib
@@ -12,7 +12,11 @@ from typing import Callable, Generic, Iterator, TypeVar
 from data_engine.core.helpers import _normalize_extensions, _resolve_flow_path
 from data_engine.core.model import FlowValidationError
 from data_engine.domain.time import utcnow_text
-from data_engine.platform.workspace_models import WORKSPACE_CONFIG_DIR_NAME, WORKSPACE_DATABASES_DIR_NAME
+from data_engine.platform.workspace_models import (
+    WORKSPACE_CONFIG_DIR_NAME,
+    WORKSPACE_DATABASES_DIR_NAME,
+    WORKSPACE_TEMPLATES_DIR_NAME,
+)
 from data_engine.services.debug_artifacts import (
     build_debug_metadata,
     sanitize_debug_name,
@@ -58,6 +62,74 @@ class StepSpec:
     function_name: str
 
 
+@dataclass(frozen=True)
+class DateRangeInputValue:
+    """Submitted inclusive date range for one manual flow run."""
+
+    start: str
+    end: str
+    inclusive: bool = True
+
+
+@dataclass(frozen=True)
+class ManualInputSpec:
+    """One pre-run operator input required by a manual flow."""
+
+    name: str
+    label: str
+    kind: str
+    required: bool = True
+    inclusive: bool = True
+
+
+def _normalize_iso_date(value: object, *, field_name: str) -> str:
+    if isinstance(value, date) and not isinstance(value, datetime):
+        return value.isoformat()
+    if not isinstance(value, str) or not value.strip():
+        raise FlowValidationError(f"Manual input {field_name} must be a YYYY-MM-DD date string.")
+    raw = value.strip()
+    try:
+        parsed = date.fromisoformat(raw)
+    except ValueError as exc:
+        raise FlowValidationError(f"Manual input {field_name} must be a valid YYYY-MM-DD date.") from exc
+    return parsed.isoformat()
+
+
+def normalize_manual_inputs(
+    specs: tuple[ManualInputSpec, ...],
+    values: dict[str, object] | None,
+) -> dict[str, object]:
+    """Validate and normalize submitted manual-run input values."""
+    if not specs:
+        return {}
+    raw_values = values or {}
+    if not isinstance(raw_values, dict):
+        raise FlowValidationError("Manual flow inputs must be provided as a mapping.")
+    normalized: dict[str, object] = {}
+    for spec in specs:
+        if spec.name not in raw_values:
+            if spec.required:
+                raise FlowValidationError(f"Manual input {spec.name!r} is required.")
+            continue
+        raw_value = raw_values[spec.name]
+        if spec.kind == "date_range":
+            if isinstance(raw_value, DateRangeInputValue):
+                if date.fromisoformat(raw_value.start) > date.fromisoformat(raw_value.end):
+                    raise FlowValidationError(f"Manual input {spec.name!r} start date must be on or before end date.")
+                normalized[spec.name] = raw_value
+                continue
+            if not isinstance(raw_value, dict):
+                raise FlowValidationError(f"Manual input {spec.name!r} must be a date range mapping.")
+            start = _normalize_iso_date(raw_value.get("start"), field_name=f"{spec.name}.start")
+            end = _normalize_iso_date(raw_value.get("end"), field_name=f"{spec.name}.end")
+            if date.fromisoformat(start) > date.fromisoformat(end):
+                raise FlowValidationError(f"Manual input {spec.name!r} start date must be on or before end date.")
+            normalized[spec.name] = DateRangeInputValue(start=start, end=end, inclusive=spec.inclusive)
+            continue
+        raise FlowValidationError(f"Unsupported manual input kind: {spec.kind}")
+    return normalized
+
+
 @dataclass(frozen=True)
 class SourceMetadata:
     """Resolved filesystem metadata for the current source file."""
@@ -337,6 +409,8 @@ class FlowContext:
         Active value passed between steps.
     objects : dict[str, object]
         Named intermediate values saved by ``save_as``.
+    inputs : dict[str, object]
+        Normalized manual-run inputs collected before execution starts.
     metadata : dict[str, object]
         Runtime metadata attached to the execution.
     config : WorkspaceConfigContext
@@ -363,6 +437,7 @@ class FlowContext:
     mirror: MirrorContext | None = None
     current: object | None = None
     objects: dict[str, object] = field(default_factory=dict)
+    inputs: dict[str, object] = field(default_factory=dict)
     metadata: dict[str, object] = field(default_factory=dict)
     config: WorkspaceConfigContext = field(default_factory=WorkspaceConfigContext)
     debug: FlowDebugContext | None = None
@@ -386,6 +461,9 @@ class FlowContext:
         Use this for workspace-owned DuckDB files and other durable database
         artifacts. The returned path is rooted under
         ``<workspace>/databases/`` and parent directories are created for you.
+        A ``FlowValidationError`` is raised when the flow is not running from
+        an authored workspace, or when ``name`` is absolute, empty, or escapes
+        the workspace databases directory.
 
         Parameters
         ----------
@@ -398,21 +476,47 @@ class FlowContext:
         Path
             Absolute write-ready database path.
 
-        Raises
-        ------
-        FlowValidationError
-            If the flow is not running from an authored workspace, or if
-            ``name`` is absolute or empty.
         """
+        path = self._workspace_path(
+            name,
+            helper_name="database",
+            directory_name=WORKSPACE_DATABASES_DIR_NAME,
+        )
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def template(self, name: str | Path) -> Path:
+        """Return a write-ready path beneath the workspace templates directory.
+
+        Use this for workspace-owned template files such as Excel workbook
+        shells. The returned path is rooted under ``<workspace>/templates/``
+        and parent directories are created for you. A ``FlowValidationError``
+        is raised when the flow is not running from an authored workspace, or
+        when ``name`` is absolute, empty, or escapes the workspace templates
+        directory.
+        """
+        path = self._workspace_path(
+            name,
+            helper_name="template",
+            directory_name=WORKSPACE_TEMPLATES_DIR_NAME,
+        )
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def _workspace_path(self, name: str | Path, *, helper_name: str, directory_name: str) -> Path:
         if self.config.workspace_root is None:
-            raise FlowValidationError("context.database() is only available for authored workspace flows.")
+            raise FlowValidationError(f"context.{helper_name}() is only available for authored workspace flows.")
         candidate = Path(name)
         if candidate.is_absolute():
-            raise FlowValidationError("context.database() name must be relative.")
+            raise FlowValidationError(f"context.{helper_name}() name must be relative.")
         if not str(candidate).strip():
-            raise FlowValidationError("context.database() name must be non-empty.")
-        path = (self.config.workspace_root / WORKSPACE_DATABASES_DIR_NAME / candidate).resolve()
-        path.parent.mkdir(parents=True, exist_ok=True)
+            raise FlowValidationError(f"context.{helper_name}() name must be non-empty.")
+        base = (self.config.workspace_root / directory_name).resolve()
+        path = (base / candidate).resolve()
+        try:
+            path.relative_to(base)
+        except ValueError as exc:
+            raise FlowValidationError(f"context.{helper_name}() name must stay under the workspace {directory_name} directory.") from exc
         return path
 
 
@@ -619,9 +723,11 @@ def collect_files(
 
 __all__ = [
     "Batch",
+    "DateRangeInputValue",
     "FileRef",
     "FlowContext",
     "FlowDebugContext",
+    "ManualInputSpec",
     "MirrorContext",
     "MirrorSpec",
     "SourceContext",
@@ -630,4 +736,5 @@ __all__ = [
     "WatchSpec",
     "WorkspaceConfigContext",
     "collect_files",
+    "normalize_manual_inputs",
 ]

{py_data_engine-0.3.10 → py_data_engine-0.3.11}/src/data_engine/docs/html/_modules/data_engine/authoring/flow.html

@@ -13,7 +13,7 @@
   
       <script src="../../../_static/jquery.js?v=5d32c60e"></script>
       <script src="../../../_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-      <script src="../../../_static/documentation_options.js?v=9f76a604"></script>
+      <script src="../../../_static/documentation_options.js?v=3b0e221d"></script>
       <script src="../../../_static/doctools.js?v=fd6eb6e6"></script>
       <script src="../../../_static/sphinx_highlight.js?v=6ffebe34"></script>
     <script src="../../../_static/js/theme.js"></script>
@@ -179,6 +179,7 @@
     <span class="k">def</span><span class="w"> </span><span class="nf">run_once</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span>
         <span class="o">*</span><span class="p">,</span>
+        <span class="n">inputs</span><span class="p">:</span> <span class="nb">dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">object</span><span class="p">]</span> <span class="o">|</span> <span class="kc">None</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
         <span class="n">authoring_services</span><span class="p">:</span> <span class="n">AuthoringServices</span> <span class="o">|</span> <span class="kc">None</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
         <span class="n">runtime_execution_service</span><span class="p">:</span> <span class="n">RuntimeExecutionService</span> <span class="o">|</span> <span class="kc">None</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">list</span><span class="p">[</span><span class="n">FlowContext</span><span class="p">]:</span>
@@ -188,6 +189,8 @@
 <span class="sd">        ----------</span>
 <span class="sd">        authoring_services : AuthoringServices | None</span>
 <span class="sd">            Optional service bundle used by tests or embedded hosts.</span>
+<span class="sd">        inputs : dict[str, object] | None</span>
+<span class="sd">            Submitted manual-run input values for flows that declare them.</span>
 <span class="sd">        runtime_execution_service : RuntimeExecutionService | None</span>
 <span class="sd">            Optional runtime execution service override.</span>
 
@@ -201,7 +204,9 @@
             <span class="n">authoring_services</span><span class="o">=</span><span class="n">authoring_services</span><span class="p">,</span>
             <span class="n">runtime_execution_service</span><span class="o">=</span><span class="n">runtime_execution_service</span><span class="p">,</span>
         <span class="p">)</span><span class="o">.</span><span class="n">runtime_execution_service</span>
-        <span class="k">return</span> <span class="n">service</span><span class="o">.</span><span class="n">run_once</span><span class="p">(</span><span class="n">flow</span><span class="p">)</span></div>
+        <span class="k">if</span> <span class="n">inputs</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">service</span><span class="o">.</span><span class="n">run_once</span><span class="p">(</span><span class="n">flow</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">service</span><span class="o">.</span><span class="n">run_once</span><span class="p">(</span><span class="n">flow</span><span class="p">,</span> <span class="n">inputs</span><span class="o">=</span><span class="n">inputs</span><span class="p">)</span></div>
 
 
 <div class="viewcode-block" id="Flow.preview">