agi-app-polars-execution 0.1.0__tar.gz

agi_app_polars_execution-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Jean-Pierre Morard, THALES SIX GTS France SAS
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided with the distribution.
+3. Neither the name of Jean-Pierre MORARD nor the names of its contributors, or THALES SIX GTS France SAS, may be used
+to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

agi_app_polars_execution-0.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: agi-app-polars-execution
+Version: 0.1.0
+Summary: AGILAB Polars execution app project
+Author: Jean-Pierre Morard
+Maintainer: Jean-Pierre Morard
+License-Expression: BSD-3-Clause
+Project-URL: Documentation, https://thalesgroup.github.io/agilab
+Project-URL: Source, https://github.com/ThalesGroup/agilab/tree/main/src/agilab/lib/agi-app-polars-execution
+Project-URL: Issues, https://github.com/ThalesGroup/agilab/issues
+Project-URL: Homepage, https://github.com/ThalesGroup/agilab
+Project-URL: Repository, https://github.com/ThalesGroup/agilab
+Project-URL: Discussions, https://github.com/ThalesGroup/agilab/discussions
+Project-URL: Changelog, https://github.com/ThalesGroup/agilab/releases
+Keywords: agilab,apps,reproducibility,workflow-orchestration
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agi-core<2027.0,>=2026.05.13
+Dynamic: license-file
+
+# agi-app-polars-execution
+
+[![PyPI version](https://img.shields.io/pypi/v/agi-app-polars-execution.svg?cacheSeconds=300)](https://pypi.org/project/agi-app-polars-execution/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agi-app-polars-execution.svg)](https://pypi.org/project/agi-app-polars-execution/)
+[![License: BSD 3-Clause](https://img.shields.io/pypi/l/agi-app-polars-execution)](https://opensource.org/licenses/BSD-3-Clause)
+
+`agi-app-polars-execution` publishes the `execution_polars_project` AGILAB app
+project as a self-contained payload. The distribution name is PyPI-facing; the
+installed AGILAB project name remains `execution_polars_project`.
+
+The package advertises the project through the `agilab.apps` entry point group
+so `AgiEnv(app="execution_polars_project")` can resolve it without a monorepo
+checkout.
+
+## Install
+
+```bash
+pip install agi-app-polars-execution
+```
+
+Most users install these app packages through the umbrella `agi-apps` package or
+through `agilab[ui]` / `agilab[examples]`.

agi_app_polars_execution-0.1.0/README.md

@@ -0,0 +1,22 @@
+# agi-app-polars-execution
+
+[![PyPI version](https://img.shields.io/pypi/v/agi-app-polars-execution.svg?cacheSeconds=300)](https://pypi.org/project/agi-app-polars-execution/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agi-app-polars-execution.svg)](https://pypi.org/project/agi-app-polars-execution/)
+[![License: BSD 3-Clause](https://img.shields.io/pypi/l/agi-app-polars-execution)](https://opensource.org/licenses/BSD-3-Clause)
+
+`agi-app-polars-execution` publishes the `execution_polars_project` AGILAB app
+project as a self-contained payload. The distribution name is PyPI-facing; the
+installed AGILAB project name remains `execution_polars_project`.
+
+The package advertises the project through the `agilab.apps` entry point group
+so `AgiEnv(app="execution_polars_project")` can resolve it without a monorepo
+checkout.
+
+## Install
+
+```bash
+pip install agi-app-polars-execution
+```
+
+Most users install these app packages through the umbrella `agi-apps` package or
+through `agilab[ui]` / `agilab[examples]`.

agi_app_polars_execution-0.1.0/pyproject.toml

@@ -0,0 +1,84 @@
+[project]
+version = "0.1.0"
+name = "agi-app-polars-execution"
+description = "AGILAB Polars execution app project"
+requires-python = ">=3.11"
+readme = "README.md"
+authors = [
+    { name = "Jean-Pierre Morard" }
+]
+maintainers = [{ name = "Jean-Pierre Morard" }]
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+
+classifiers = [
+    "Intended Audience :: Developers",
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+]
+
+keywords = [
+    "agilab",
+    "apps",
+    "reproducibility",
+    "workflow-orchestration",
+]
+
+dependencies = ["agi-core>=2026.05.13,<2027.0"]
+
+[project.urls]
+Documentation = "https://thalesgroup.github.io/agilab"
+Source = "https://github.com/ThalesGroup/agilab/tree/main/src/agilab/lib/agi-app-polars-execution"
+Issues = "https://github.com/ThalesGroup/agilab/issues"
+Homepage = "https://github.com/ThalesGroup/agilab"
+Repository = "https://github.com/ThalesGroup/agilab"
+Discussions = "https://github.com/ThalesGroup/agilab/discussions"
+Changelog = "https://github.com/ThalesGroup/agilab/releases"
+
+[project.entry-points."agilab.apps"]
+execution_polars = "agi_app_polars_execution:project_root"
+execution_polars_project = "agi_app_polars_execution:project_root"
+
+[dependency-groups]
+dev = [
+    "pytest",
+]
+
+[tool.uv.sources.agi-core]
+    path = "../../core/agi-core"
+    editable = true
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+include-package-data = false
+package-dir = {"" = "src"}
+packages = ["agi_app_polars_execution"]
+
+[tool.setuptools.package-data]
+"agi_app_polars_execution" = [
+    "project/**/*",
+]
+
+[tool.setuptools.exclude-package-data]
+"agi_app_polars_execution" = [
+    "project/**/.venv/**",
+    "project/**/__pycache__/**",
+    "project/**/*.pyc",
+    "project/**/*.pyo",
+    "project/**/*.pyx",
+    "project/**/*.c",
+    "project/**/*.so",
+    "project/**/uv.lock",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["test"]

agi_app_polars_execution-0.1.0/setup.cfg

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

agi_app_polars_execution-0.1.0/setup.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+from setuptools import setup
+from setuptools.command.build_py import build_py as _build_py
+from setuptools.command.sdist import sdist as _sdist
+
+APP_PROJECT = 'execution_polars_project'
+PACKAGE_IMPORT = 'agi_app_polars_execution'
+
+
+def _load_build_support():
+    module_path = Path(__file__).resolve().parents[4] / "src" / "agilab" / "lib" / "app_project_build_support.py"
+    if not module_path.exists():
+        return None
+    spec = importlib.util.spec_from_file_location("agilab_app_project_build_support", module_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Unable to load app project build support from {module_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _copy_payload(target_root: Path) -> None:
+    support = _load_build_support()
+    if support is None:
+        return
+    changed = support.copy_app_project_payload(APP_PROJECT, target_root)
+    for pyproject_path in changed:
+        print(f"[{PACKAGE_IMPORT}] sanitized packaged app manifest: {pyproject_path}")
+
+
+class build_py(_build_py):
+    def run(self):
+        super().run()
+        _copy_payload(Path(self.build_lib) / PACKAGE_IMPORT / "project")
+
+
+class sdist(_sdist):
+    def make_release_tree(self, base_dir, files):
+        super().make_release_tree(base_dir, files)
+        _copy_payload(Path(base_dir) / "src" / PACKAGE_IMPORT / "project")
+
+
+setup(cmdclass={"build_py": build_py, "sdist": sdist})

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/__init__.py

@@ -0,0 +1,33 @@
+"""Installed AGILAB app project provider for execution_polars_project."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+APP_SLUG = 'execution_polars'
+PROJECT_NAME = 'execution_polars_project'
+PACKAGE_NAME = 'agi-app-polars-execution'
+
+
+def package_root() -> Path:
+    return Path(__file__).resolve().parent
+
+
+def project_root() -> Path:
+    packaged_root = package_root() / "project" / PROJECT_NAME
+    if packaged_root.exists():
+        return packaged_root
+    source_root = Path(__file__).resolve().parents[4] / "apps" / "builtin" / PROJECT_NAME
+    return source_root if source_root.exists() else packaged_root
+
+
+def metadata() -> dict[str, str]:
+    return {
+        "slug": APP_SLUG,
+        "project": PROJECT_NAME,
+        "package": PACKAGE_NAME,
+        "project_root": str(project_root()),
+    }
+
+
+__all__ = ["APP_SLUG", "PACKAGE_NAME", "PROJECT_NAME", "metadata", "package_root", "project_root"]

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/README.md

@@ -0,0 +1,34 @@
+# Execution Polars Project
+
+`execution_polars_project` is a built-in AGILAB execution playground for the
+`PolarsWorker` path.
+
+The app uses the same deterministic workload shape as
+`execution_pandas_project`, then processes the partitions with polars so the two
+execution paths can be compared without changing the benchmark input.
+
+## What It Shows
+
+- deterministic first-run dataset generation under shared storage
+- worker distribution over multiple CSV partitions
+- polars-based compute and aggregation through the AGILAB worker contract
+- parity outputs for comparing execution modes, engines, and reducer behavior
+
+## Typical Flow
+
+1. Select `execution_polars_project` in `PROJECT`.
+2. Run `INSTALL` from `ORCHESTRATE`.
+3. Run `EXECUTE` with the default settings or adjusted partition counts.
+4. Inspect generated CSV or Parquet outputs under `execution_polars/results`.
+
+## Outputs
+
+Each worker writes an output file under the run results directory. The reducer
+also emits a summary artifact that records row counts, score metrics, source
+files, and the execution engine label.
+
+## Scope
+
+This app is intentionally synthetic. It is useful for validating AGILAB
+execution behavior and comparing worker paths, not for demonstrating a
+domain-specific analytics workflow.

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "execution_polars_project"
+version = "0.1.0"
+description = "Built-in AGILab execution playground using PolarsWorker"
+requires-python = ">=3.11"
+dependencies = ["agi-env>=2026.05.13.post3,<2027.0", "agi-node>=2026.05.13.post3,<2027.0", "agi-cluster>=2026.05.13.post3,<2027.0", "polars", "pydantic", "streamlit>=1.56.0"]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/app_args_form.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+from typing import Any
+
+import streamlit as st
+from pydantic import ValidationError
+
+_HERE = Path(__file__).resolve().parent
+if str(_HERE) not in sys.path:
+    sys.path.insert(0, str(_HERE))
+
+from execution_polars.app_args import ExecutionPolarsArgs, dump_args, load_args
+
+
+PAGE_ID = "execution_polars_project:app_args_form"
+
+
+def _k(name: str) -> str:
+    return f"{PAGE_ID}:{name}"
+
+
+def _get_env():
+    env = st.session_state.get("env") or st.session_state.get("_env")
+    if env is None:
+        st.error("AGILab environment is not initialised yet. Return to the main page and try again.")
+        st.stop()
+    return env
+
+
+def _load_current_args(settings_path: Path) -> ExecutionPolarsArgs:
+    try:
+        return load_args(settings_path)
+    except Exception as exc:
+        st.warning(f"Unable to load Execution Polars args from `{settings_path}`: {exc}")
+        return ExecutionPolarsArgs()
+
+
+def _safe_rows_per_partition(rows_per_file: int, n_partitions: int) -> int:
+    if n_partitions <= 0:
+        return 0
+    return rows_per_file // n_partitions
+
+
+env = _get_env()
+settings_path = Path(env.app_settings_file)
+current_args = _load_current_args(settings_path)
+current_payload = current_args.model_dump(mode="json")
+
+st.caption(
+    "Execution Polars generates a synthetic CSV dataset and runs the distributed Polars worker path. "
+    "Use this form to size the playground workload before EXECUTE."
+)
+
+for key, default in (
+    ("data_in", str(current_payload.get("data_in", "execution_playground/dataset") or "execution_playground/dataset")),
+    ("data_out", str(current_payload.get("data_out", "execution_polars/results") or "execution_polars/results")),
+    ("files", str(current_payload.get("files", "*.csv") or "*.csv")),
+    ("nfile", int(current_payload.get("nfile", 16) or 16)),
+    ("n_partitions", int(current_payload.get("n_partitions", 16) or 16)),
+    ("rows_per_file", int(current_payload.get("rows_per_file", 100_000) or 100_000)),
+    ("n_groups", int(current_payload.get("n_groups", 32) or 32)),
+    ("compute_passes", int(current_payload.get("compute_passes", 32) or 32)),
+    ("output_format", str(current_payload.get("output_format", "csv") or "csv")),
+    ("seed", int(current_payload.get("seed", 42) or 42)),
+    ("reset_target", bool(current_payload.get("reset_target", False))),
+):
+    st.session_state.setdefault(_k(key), default)
+
+c1, c2, c3 = st.columns([2, 2, 1.2])
+with c1:
+    st.text_input("Dataset directory", key=_k("data_in"))
+with c2:
+    st.text_input("Results directory", key=_k("data_out"))
+with c3:
+    st.selectbox("Output format", options=["csv", "parquet"], key=_k("output_format"))
+
+c4, c5, c6, c7 = st.columns([1.2, 1.2, 1.2, 1.2])
+with c4:
+    st.text_input("Files glob", key=_k("files"))
+with c5:
+    st.number_input("Files", key=_k("nfile"), min_value=1, step=1)
+with c6:
+    st.number_input("Partitions", key=_k("n_partitions"), min_value=1, step=1)
+with c7:
+    st.number_input("Rows / file", key=_k("rows_per_file"), min_value=1, step=10_000)
+
+c8, c9, c10, c11 = st.columns([1.2, 1.2, 1.2, 1.2])
+with c8:
+    st.number_input("Groups", key=_k("n_groups"), min_value=1, step=1)
+with c9:
+    st.number_input("Compute passes", key=_k("compute_passes"), min_value=1, step=1)
+with c10:
+    st.number_input("Seed", key=_k("seed"), min_value=0, step=1)
+with c11:
+    st.checkbox("Reset output", key=_k("reset_target"))
+
+candidate: dict[str, Any] = {
+    "data_in": (st.session_state.get(_k("data_in")) or "").strip(),
+    "data_out": (st.session_state.get(_k("data_out")) or "").strip(),
+    "files": (st.session_state.get(_k("files")) or "*.csv").strip() or "*.csv",
+    "nfile": st.session_state.get(_k("nfile"), 16),
+    "n_partitions": st.session_state.get(_k("n_partitions"), 16),
+    "rows_per_file": st.session_state.get(_k("rows_per_file"), 100_000),
+    "n_groups": st.session_state.get(_k("n_groups"), 32),
+    "compute_passes": st.session_state.get(_k("compute_passes"), 32),
+    "output_format": st.session_state.get(_k("output_format")) or "csv",
+    "seed": st.session_state.get(_k("seed"), 42),
+    "reset_target": bool(st.session_state.get(_k("reset_target"), False)),
+}
+
+try:
+    validated = ExecutionPolarsArgs(**candidate)
+except ValidationError as exc:
+    st.error("Invalid Execution Polars parameters:")
+    if hasattr(env, "humanize_validation_errors"):
+        for msg in env.humanize_validation_errors(exc):
+            st.markdown(msg)
+    else:
+        st.code(str(exc))
+else:
+    validated_payload = validated.model_dump(mode="json")
+    if validated_payload != current_payload:
+        dump_args(validated, settings_path)
+        app_settings = st.session_state.get("app_settings")
+        if not isinstance(app_settings, dict):
+            app_settings = {}
+        app_settings.setdefault("cluster", {})
+        app_settings["args"] = validated_payload
+        st.session_state["app_settings"] = app_settings
+        st.session_state["is_args_from_ui"] = True
+        st.success(f"Saved to `{settings_path}`.")
+    else:
+        st.info("No changes to save.")
+
+    total_rows = validated.nfile * validated.rows_per_file
+    rows_per_partition = _safe_rows_per_partition(validated.rows_per_file, validated.n_partitions)
+    st.caption(
+        f"Planned workload: `{validated.nfile}` files, about `{total_rows:,}` rows total, "
+        f"`{validated.n_partitions}` partitions per file, about `{rows_per_partition:,}` rows per partition."
+    )

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/app_settings.toml

@@ -0,0 +1,41 @@
+[args]
+data_in = "execution_playground/dataset"
+data_out = "execution_polars/results"
+files = "*.csv"
+nfile = 16
+n_partitions = 16
+rows_per_file = 100000
+n_groups = 32
+compute_passes = 32
+output_format = "csv"
+seed = 42
+reset_target = false
+
+[cluster]
+verbose = 1
+cython = false
+pool = false
+rapids = false
+cluster_enabled = false
+scheduler = "127.0.0.1:8786"
+workers_data_path = ""
+
+[cluster.workers]
+"127.0.0.1" = 2
+
+[cluster.service_health]
+allow_idle = false
+max_unhealthy = 0
+max_restart_rate = 0.25
+
+[connector_catalog]
+path = "connectors/data_connectors.toml"
+
+[connector_refs]
+benchmark_sql = "execution_polars_sql"
+operator_events = "execution_polars_ops_opensearch"
+artifact_store = "execution_polars_artifact_store"
+
+[legacy_paths]
+data_in = "execution_playground/dataset"
+data_out = "execution_polars/results"

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/connectors/data_connectors.toml

@@ -0,0 +1,27 @@
+[[connectors]]
+id = "execution_polars_sql"
+kind = "sql"
+label = "Execution Polars SQL"
+description = "Read-only benchmark input table for polars execution experiments."
+uri = "postgresql://execution.example.invalid/polars"
+driver = "postgresql"
+query_mode = "read_only"
+
+[[connectors]]
+id = "execution_polars_ops_opensearch"
+kind = "opensearch"
+label = "Execution Polars Operations OpenSearch"
+description = "Execution benchmark run evidence index."
+url = "https://opensearch.example.invalid"
+index = "agilab-execution-polars-*"
+auth_ref = "env:OPENSEARCH_TOKEN"
+
+[[connectors]]
+id = "execution_polars_artifact_store"
+kind = "object_storage"
+label = "Execution Polars Artifact Store"
+description = "Object-storage prefix for polars benchmark artifacts."
+provider = "s3"
+bucket = "agilab-artifacts"
+prefix = "execution_polars/"
+auth_ref = "env:AWS_PROFILE"

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/execution_polars/__init__.py

@@ -0,0 +1,10 @@
+from .app_args import ExecutionPolarsArgs
+from .execution_polars import ExecutionPolars, ExecutionPolarsApp
+from .reduction import EXECUTION_POLARS_REDUCE_CONTRACT
+
+__all__ = [
+    "EXECUTION_POLARS_REDUCE_CONTRACT",
+    "ExecutionPolars",
+    "ExecutionPolarsApp",
+    "ExecutionPolarsArgs",
+]

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/execution_polars/app_args.py

@@ -0,0 +1,83 @@
+"""Argument helpers for the execution playground polars app."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Literal, TypedDict
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from agi_env.app_args import dump_model_to_toml, load_model_from_toml, merge_model_data
+
+
+class ExecutionPolarsArgs(BaseModel):
+    """Runtime parameters for the polars execution playground."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    data_in: Path = Field(default_factory=lambda: Path("execution_playground/dataset"))
+    data_out: Path = Field(default_factory=lambda: Path("execution_polars/results"))
+    files: str = "*.csv"
+    nfile: int = 16
+    n_partitions: int = 16
+    rows_per_file: int = 100_000
+    n_groups: int = 32
+    compute_passes: int = 32
+    output_format: Literal["csv", "parquet"] = "csv"
+    seed: int = 42
+    reset_target: bool = False
+
+
+class ExecutionPolarsArgsTD(TypedDict, total=False):
+    data_in: str
+    data_out: str
+    files: str
+    nfile: int
+    n_partitions: int
+    rows_per_file: int
+    n_groups: int
+    compute_passes: int
+    output_format: str
+    seed: int
+    reset_target: bool
+
+
+ArgsModel = ExecutionPolarsArgs
+ArgsOverrides = ExecutionPolarsArgsTD
+
+
+def load_args(settings_path: str | Path, *, section: str = "args") -> ExecutionPolarsArgs:
+    return load_model_from_toml(ExecutionPolarsArgs, settings_path, section=section)
+
+
+def merge_args(
+    base: ExecutionPolarsArgs,
+    overrides: ExecutionPolarsArgsTD | None = None,
+) -> ExecutionPolarsArgs:
+    return merge_model_data(base, overrides)
+
+
+def dump_args(
+    args: ExecutionPolarsArgs,
+    settings_path: str | Path,
+    *,
+    section: str = "args",
+    create_missing: bool = True,
+) -> None:
+    dump_model_to_toml(args, settings_path, section=section, create_missing=create_missing)
+
+
+def ensure_defaults(args: ExecutionPolarsArgs, **_: Any) -> ExecutionPolarsArgs:
+    return args
+
+
+__all__ = [
+    "ArgsModel",
+    "ArgsOverrides",
+    "ExecutionPolarsArgs",
+    "ExecutionPolarsArgsTD",
+    "dump_args",
+    "ensure_defaults",
+    "load_args",
+    "merge_args",
+]

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/execution_polars/execution_polars.py

@@ -0,0 +1,187 @@
+"""Execution playground manager for the polars worker path."""
+
+from __future__ import annotations
+
+import csv
+import json
+import logging
+import math
+import random
+import shutil
+from pathlib import Path
+from typing import Any
+
+from pydantic import ValidationError
+
+from agi_node.agi_dispatcher import BaseWorker, WorkDispatcher
+
+from .app_args import (
+    ArgsOverrides,
+    ExecutionPolarsArgs,
+    dump_args,
+    ensure_defaults,
+    load_args,
+    merge_args,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ExecutionPolars(BaseWorker):
+    """AGILab manager that generates the same workload as the pandas variant."""
+
+    worker_vars: dict[str, Any] = {}
+
+    def __init__(
+        self,
+        env,
+        args: ExecutionPolarsArgs | None = None,
+        **kwargs: ArgsOverrides,
+    ) -> None:
+        self.env = env
+        self._ensure_managed_pc_share_dir(env)
+        self.verbose = int(kwargs.pop("verbose", getattr(env, "verbose", 0) or 0))
+
+        if args is None:
+            try:
+                args = ExecutionPolarsArgs(**kwargs)
+            except ValidationError as exc:
+                raise ValueError(f"Invalid ExecutionPolars arguments: {exc}") from exc
+
+        self.args = ensure_defaults(args, env=env)
+        self.args = self._apply_managed_pc_paths(self.args)
+        self.args.data_in = env.resolve_share_path(self.args.data_in)
+        self.args.data_out = env.resolve_share_path(self.args.data_out)
+        self.data_out = self.args.data_out
+
+        self.args.data_in.mkdir(parents=True, exist_ok=True)
+        self._ensure_dataset(self.args.data_in)
+
+        if self.args.reset_target and self.data_out.exists():
+            shutil.rmtree(self.data_out, ignore_errors=True, onerror=WorkDispatcher._onerror)
+        self.data_out.mkdir(parents=True, exist_ok=True)
+
+        WorkDispatcher.args = self.args.model_dump(mode="json")
+
+    @classmethod
+    def from_toml(
+        cls,
+        env,
+        settings_path: str | Path = "app_settings.toml",
+        section: str = "args",
+        **overrides: ArgsOverrides,
+    ) -> "ExecutionPolars":
+        base = load_args(settings_path, section=section)
+        merged = ensure_defaults(merge_args(base, overrides or None), env=env)
+        return cls(env, args=merged)
+
+    def to_toml(
+        self,
+        settings_path: str | Path = "app_settings.toml",
+        section: str = "args",
+        create_missing: bool = True,
+    ) -> None:
+        dump_args(self.args, settings_path, section=section, create_missing=create_missing)
+
+    def as_dict(self) -> dict[str, Any]:
+        return self.args.model_dump(mode="json")
+
+    def _manifest_path(self, data_in: Path) -> Path:
+        return data_in / "_execution_playground_manifest.json"
+
+    def _dataset_manifest(self) -> dict[str, int]:
+        return {
+            "n_partitions": int(self.args.n_partitions),
+            "rows_per_file": int(self.args.rows_per_file),
+            "n_groups": int(self.args.n_groups),
+            "seed": int(self.args.seed),
+        }
+
+    def _ensure_dataset(self, data_in: Path) -> None:
+        manifest_path = self._manifest_path(data_in)
+        expected = self._dataset_manifest()
+        existing_files = sorted(data_in.glob(self.args.files))
+        regenerate = not existing_files
+
+        if manifest_path.exists():
+            try:
+                current = json.loads(manifest_path.read_text(encoding="utf-8"))
+            except Exception:
+                current = {}
+            regenerate = regenerate or current != expected
+        else:
+            regenerate = True
+
+        if not regenerate:
+            return
+
+        for candidate in data_in.glob("*.csv"):
+            candidate.unlink()
+
+        segments = ("alpha", "beta", "gamma", "delta")
+        for partition_idx in range(self.args.n_partitions):
+            rng = random.Random(self.args.seed + partition_idx)
+            output = data_in / f"part_{partition_idx:02d}.csv"
+            with output.open("w", newline="", encoding="utf-8") as stream:
+                writer = csv.writer(stream)
+                writer.writerow(
+                    ["row_id", "group_id", "bucket", "segment", "x", "y", "signal", "weight"]
+                )
+                for row_idx in range(self.args.rows_per_file):
+                    group_id = row_idx % self.args.n_groups
+                    bucket = (group_id + partition_idx) % 8
+                    segment = segments[group_id % len(segments)]
+                    x = round(rng.random() * 100.0 + group_id * 0.3, 6)
+                    y = round(rng.random() * 50.0 + bucket * 0.7 + math.sin(row_idx / 17.0), 6)
+                    signal = round(((row_idx % 97) - 48) * 0.15 + rng.random() * 0.25, 6)
+                    weight = round(1.0 + (row_idx % 11) * 0.05 + partition_idx * 0.01, 6)
+                    writer.writerow(
+                        [f"{partition_idx}-{row_idx}", group_id, bucket, segment, x, y, signal, weight]
+                    )
+
+        manifest_path.write_text(json.dumps(expected, indent=2), encoding="utf-8")
+
+    def build_distribution(self, workers):
+        files = sorted(self.args.data_in.glob(self.args.files))
+        if self.args.nfile > 0:
+            files = files[: self.args.nfile]
+        if not files:
+            raise FileNotFoundError(
+                f"No workload files found in {self.args.data_in} with pattern {self.args.files!r}"
+            )
+
+        weights = [(str(path), max(int(path.stat().st_size // 1024), 1)) for path in files]
+        if len(weights) == 1:
+            worker_chunks = [[weights[0]]]
+        else:
+            worker_chunks = WorkDispatcher.make_chunks(
+                len(weights),
+                weights,
+                workers=workers,
+                verbose=self.verbose,
+                threshold=12,
+            )
+
+        work_plan = []
+        work_plan_metadata = []
+        for chunk in worker_chunks:
+            file_batch = [file_path for file_path, _ in chunk]
+            total_size_kb = sum(size_kb for _, size_kb in chunk)
+            batch_label = (
+                Path(file_batch[0]).name
+                if len(file_batch) == 1
+                else f"{len(file_batch)} files"
+            )
+            work_plan.append([file_batch])
+            work_plan_metadata.append(
+                [{"file": batch_label, "size_kb": total_size_kb}]
+            )
+
+        return work_plan, work_plan_metadata, "file", "size_kb", "KB"
+
+
+class ExecutionPolarsApp(ExecutionPolars):
+    """Compatibility alias retaining the historic *App suffix."""
+
+
+__all__ = ["ExecutionPolars", "ExecutionPolarsApp"]

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/execution_polars/execution_polars_args.py

@@ -0,0 +1,3 @@
+"""Compatibility wrapper for older imports."""
+
+from .app_args import *  # noqa: F401,F403

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/execution_polars/reduction.py

@@ -0,0 +1,191 @@
+"""Reduce-contract adoption for the built-in polars execution app."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+import polars as pl
+
+from agi_node.reduction import (
+    ReduceArtifact,
+    ReduceContract,
+    ReducePartial,
+    require_payload_keys,
+)
+
+
+REDUCE_ARTIFACT_FILENAME_TEMPLATE = "reduce_summary_worker_{worker_id}.json"
+REDUCE_ARTIFACT_NAME = "execution_polars_reduce_summary"
+REDUCER_NAME = "execution_polars.weighted-score.v1"
+
+_REQUIRED_FRAME_COLUMNS = frozenset(
+    {
+        "row_count",
+        "x_sum",
+        "weight_sum",
+        "weighted_score",
+        "python_tail_checksum",
+        "source_file",
+        "engine",
+        "execution_model",
+    }
+)
+
+_REQUIRED_PAYLOAD_KEYS = (
+    "row_count",
+    "result_rows",
+    "source_file_count",
+    "x_sum",
+    "weight_sum",
+    "weighted_score_sum",
+    "python_tail_checksum",
+    "source_files",
+    "engines",
+    "execution_models",
+)
+
+
+def _sorted_unique_strings(values: pl.Series) -> list[str]:
+    return sorted({str(value) for value in values.drop_nulls().to_list()})
+
+
+def _merge_execution_polars_partials(partials: Sequence[ReducePartial]) -> dict[str, Any]:
+    source_files: set[str] = set()
+    engines: set[str] = set()
+    execution_models: set[str] = set()
+    payload: dict[str, Any] = {
+        "row_count": 0,
+        "result_rows": 0,
+        "source_file_count": 0,
+        "x_sum": 0.0,
+        "weight_sum": 0.0,
+        "weighted_score_sum": 0.0,
+        "python_tail_checksum": 0.0,
+    }
+
+    for partial in partials:
+        partial_payload = partial.payload
+        payload["row_count"] += int(partial_payload["row_count"])
+        payload["result_rows"] += int(partial_payload["result_rows"])
+        payload["x_sum"] += float(partial_payload["x_sum"])
+        payload["weight_sum"] += float(partial_payload["weight_sum"])
+        payload["weighted_score_sum"] += float(partial_payload["weighted_score_sum"])
+        payload["python_tail_checksum"] += float(partial_payload["python_tail_checksum"])
+        source_files.update(str(item) for item in partial_payload["source_files"])
+        engines.update(str(item) for item in partial_payload["engines"])
+        execution_models.update(str(item) for item in partial_payload["execution_models"])
+
+    payload["source_files"] = sorted(source_files)
+    payload["source_file_count"] = len(source_files)
+    payload["engines"] = sorted(engines)
+    payload["execution_models"] = sorted(execution_models)
+    return payload
+
+
+def _validate_execution_polars_artifact(artifact: ReduceArtifact) -> None:
+    payload = artifact.payload
+    if int(payload["row_count"]) <= 0:
+        raise ValueError("execution_polars reducer produced no source rows")
+    if int(payload["source_file_count"]) <= 0:
+        raise ValueError("execution_polars reducer produced no source files")
+    if not payload["engines"]:
+        raise ValueError("execution_polars reducer produced no engine metadata")
+
+
+EXECUTION_POLARS_REDUCE_CONTRACT = ReduceContract(
+    name=REDUCER_NAME,
+    artifact_name=REDUCE_ARTIFACT_NAME,
+    merge=_merge_execution_polars_partials,
+    validate_partial=require_payload_keys(*_REQUIRED_PAYLOAD_KEYS),
+    validate_artifact=_validate_execution_polars_artifact,
+    metadata={
+        "app": "execution_polars_project",
+        "engine": "polars",
+        "scope": "worker-result",
+    },
+)
+
+
+def reduce_artifact_path(output_dir: Path | str, worker_id: int | str) -> Path:
+    filename = REDUCE_ARTIFACT_FILENAME_TEMPLATE.format(worker_id=worker_id)
+    return Path(output_dir) / filename
+
+
+def partial_from_result_frame(
+    df: pl.DataFrame,
+    *,
+    partial_id: str,
+    artifact_path: Path | str | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> ReducePartial:
+    if df is None or df.is_empty():
+        raise ValueError("execution_polars reducer requires a non-empty result frame")
+
+    missing = sorted(_REQUIRED_FRAME_COLUMNS.difference(df.columns))
+    if missing:
+        raise ValueError(f"execution_polars result frame missing columns: {', '.join(missing)}")
+
+    source_files = _sorted_unique_strings(df["source_file"])
+    checksum_by_file = (
+        df.select(["source_file", "python_tail_checksum"])
+        .unique(subset=["source_file"], keep="first")
+        .get_column("python_tail_checksum")
+    )
+    payload = {
+        "row_count": int(df["row_count"].sum()),
+        "result_rows": int(df.height),
+        "source_file_count": len(source_files),
+        "x_sum": float(df["x_sum"].sum()),
+        "weight_sum": float(df["weight_sum"].sum()),
+        "weighted_score_sum": float(df["weighted_score"].sum()),
+        "python_tail_checksum": float(checksum_by_file.sum()),
+        "source_files": source_files,
+        "engines": _sorted_unique_strings(df["engine"]),
+        "execution_models": _sorted_unique_strings(df["execution_model"]),
+    }
+    return ReducePartial(
+        partial_id=partial_id,
+        payload=payload,
+        metadata=metadata or {},
+        artifact_path=str(artifact_path) if artifact_path else None,
+    )
+
+
+def build_reduce_artifact(partials: Sequence[ReducePartial]) -> ReduceArtifact:
+    return EXECUTION_POLARS_REDUCE_CONTRACT.build_artifact(partials)
+
+
+def write_reduce_artifact(
+    df: pl.DataFrame,
+    output_dir: Path | str,
+    *,
+    worker_id: int | str,
+) -> Path:
+    output_path = reduce_artifact_path(output_dir, worker_id)
+    partial = partial_from_result_frame(
+        df,
+        partial_id=f"execution_polars_worker_{worker_id}",
+        artifact_path=output_path,
+        metadata={"worker_id": str(worker_id)},
+    )
+    artifact = build_reduce_artifact((partial,))
+    output_path.write_text(
+        json.dumps(artifact.to_dict(), indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    return output_path
+
+
+__all__ = [
+    "EXECUTION_POLARS_REDUCE_CONTRACT",
+    "REDUCE_ARTIFACT_FILENAME_TEMPLATE",
+    "REDUCE_ARTIFACT_NAME",
+    "REDUCER_NAME",
+    "build_reduce_artifact",
+    "partial_from_result_frame",
+    "reduce_artifact_path",
+    "write_reduce_artifact",
+]

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/execution_polars_worker/__init__.py

@@ -0,0 +1,3 @@
+from .execution_polars_worker import ExecutionPolarsWorker
+
+__all__ = ["ExecutionPolarsWorker"]

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/execution_polars_worker/execution_polars_worker.py

@@ -0,0 +1,151 @@
+"""Polars-based worker for the execution playground."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+import time
+
+import polars as pl
+
+from agi_node.polars_worker import PolarsWorker
+from execution_polars.reduction import write_reduce_artifact
+
+_runtime: dict[str, object] = {}
+
+
+class ExecutionPolarsWorker(PolarsWorker):
+    """Execute the benchmark workload through the PolarsWorker path."""
+
+    pool_vars: dict[str, object] = {}
+
+    def start(self):
+        global _runtime
+        if isinstance(self.args, dict):
+            self.args = SimpleNamespace(**self.args)
+        elif not isinstance(self.args, SimpleNamespace):
+            self.args = SimpleNamespace(**vars(self.args))
+
+        data_paths = self.setup_data_directories(
+            source_path=self.args.data_in,
+            target_path=self.args.data_out,
+            target_subdir="results",
+            reset_target=bool(getattr(self.args, "reset_target", False)),
+        )
+        self.args.data_in = data_paths.normalized_input
+        self.args.data_out = data_paths.normalized_output
+        self.data_out = data_paths.output_path
+        self.pool_vars = {"args": self.args}
+        _runtime = self.pool_vars
+
+    def pool_init(self, worker_vars):
+        global _runtime
+        _runtime = worker_vars
+
+    def _current_args(self) -> SimpleNamespace:
+        args = _runtime.get("args", self.args)
+        if isinstance(args, dict):
+            return SimpleNamespace(**args)
+        return args
+
+    def work_init(self) -> None:
+        """Keep parity with the PolarsWorker execution contract."""
+        return None
+
+    def _python_tail_checksum(self, df: pl.DataFrame) -> float:
+        """Add a small GIL-bound scalar tail so execution modes separate more clearly."""
+        args = self._current_args()
+        loop_passes = max(int(getattr(args, "compute_passes", 1)), 1) * 8
+        sample_stride = 64
+        checksum = 0.0
+        x_values = df["x"].to_list()
+        y_values = df["y"].to_list()
+        signal_values = df["signal"].to_list()
+        weight_values = df["weight"].to_list()
+        for idx in range(0, len(x_values), sample_stride):
+            value = float(x_values[idx]) + float(y_values[idx]) * 0.01
+            signal = float(signal_values[idx])
+            weight = float(weight_values[idx])
+            for _ in range(loop_passes):
+                value = abs((value * 1.0000007) + signal * 0.17 - weight * 0.03)
+            checksum += value
+        return checksum
+
+    def works(self, workers_plan, workers_plan_metadata) -> float:
+        """Treat pool and dask bits as parallel paths for this benchmark worker."""
+        if workers_plan:
+            if self._mode & 0b0101:
+                self._exec_multi_process(workers_plan, workers_plan_metadata)
+            else:
+                self._exec_mono_process(workers_plan, workers_plan_metadata)
+
+        self.stop()
+
+        if getattr(PolarsWorker, "_t0", None) is None:
+            PolarsWorker._t0 = time.time()
+        return time.time() - PolarsWorker._t0
+
+    def work_pool(self, file_path):
+        args = self._current_args()
+        source = Path(str(file_path)).expanduser()
+        df = pl.read_csv(source)
+
+        passes = max(int(getattr(args, "compute_passes", 1)), 1)
+        for idx in range(passes):
+            column = f"score_{idx}"
+            df = df.with_columns(
+                (
+                    (pl.col("x") * (idx + 1.3))
+                    - (pl.col("y") * (0.35 + idx * 0.05))
+                    + (pl.col("signal") * pl.col("weight"))
+                )
+                .abs()
+                .alias(column)
+            )
+
+        agg = (
+            df.group_by(["group_id", "bucket", "segment"])
+            .agg(
+                pl.len().alias("row_count"),
+                pl.col("x").sum().alias("x_sum"),
+                pl.col("y").mean().alias("y_mean"),
+                pl.col("score_0").mean().alias("score_mean"),
+                pl.col(f"score_{passes - 1}").max().alias("score_max"),
+                pl.col("weight").sum().alias("weight_sum"),
+            )
+            .sort(["bucket", "group_id"])
+        )
+
+        segment_weights = pl.DataFrame(
+            {
+                "segment": ["alpha", "beta", "gamma", "delta"],
+                "segment_weight": [1.00, 1.08, 1.14, 1.22],
+            }
+        )
+        python_tail_checksum = self._python_tail_checksum(df)
+        agg = (
+            agg.join(segment_weights, on="segment", how="left")
+            .with_columns(
+                (pl.col("score_mean") * pl.col("segment_weight") * pl.col("row_count")).alias("weighted_score"),
+                pl.lit(python_tail_checksum).alias("python_tail_checksum"),
+                pl.lit(source.name).alias("source_file"),
+                pl.lit("polars").alias("engine"),
+                pl.lit("threads").alias("execution_model"),
+            )
+        )
+        return agg
+
+    def work_done(self, df: pl.DataFrame | None = None) -> None:
+        if df is None or df.is_empty():
+            return
+        output_format = getattr(self._current_args(), "output_format", "csv")
+        output_path = Path(self.data_out) / f"{self._worker_id}_output"
+        if output_format == "parquet":
+            df.write_parquet(output_path.with_suffix(".parquet"))
+        else:
+            df.write_csv(output_path.with_suffix(".csv"))
+        write_reduce_artifact(
+            df,
+            self.data_out,
+            worker_id=getattr(self, "_worker_id", 0),
+        )

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/execution_polars_worker/pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "execution_polars_project"
+version = "0.1.0"
+description = "Built-in AGILab execution playground using PolarsWorker"
+requires-python = ">=3.11"
+dependencies = ["agi-env>=2026.05.13.post3,<2027.0", "agi-node>=2026.05.13.post3,<2027.0", "polars", "pydantic", "streamlit>=1.56.0"]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/src/pre_prompt.json

@@ -0,0 +1 @@
+[]

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution/project/execution_polars_project/uv_config.toml

@@ -0,0 +1,5 @@
+extra-index-url = ["https://pypi.nvidia.com"]
+
+override-dependencies = [
+  "cuspatial-cu12==25.4.0; platform_system == 'Linux'",
+]

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: agi-app-polars-execution
+Version: 0.1.0
+Summary: AGILAB Polars execution app project
+Author: Jean-Pierre Morard
+Maintainer: Jean-Pierre Morard
+License-Expression: BSD-3-Clause
+Project-URL: Documentation, https://thalesgroup.github.io/agilab
+Project-URL: Source, https://github.com/ThalesGroup/agilab/tree/main/src/agilab/lib/agi-app-polars-execution
+Project-URL: Issues, https://github.com/ThalesGroup/agilab/issues
+Project-URL: Homepage, https://github.com/ThalesGroup/agilab
+Project-URL: Repository, https://github.com/ThalesGroup/agilab
+Project-URL: Discussions, https://github.com/ThalesGroup/agilab/discussions
+Project-URL: Changelog, https://github.com/ThalesGroup/agilab/releases
+Keywords: agilab,apps,reproducibility,workflow-orchestration
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agi-core<2027.0,>=2026.05.13
+Dynamic: license-file
+
+# agi-app-polars-execution
+
+[![PyPI version](https://img.shields.io/pypi/v/agi-app-polars-execution.svg?cacheSeconds=300)](https://pypi.org/project/agi-app-polars-execution/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agi-app-polars-execution.svg)](https://pypi.org/project/agi-app-polars-execution/)
+[![License: BSD 3-Clause](https://img.shields.io/pypi/l/agi-app-polars-execution)](https://opensource.org/licenses/BSD-3-Clause)
+
+`agi-app-polars-execution` publishes the `execution_polars_project` AGILAB app
+project as a self-contained payload. The distribution name is PyPI-facing; the
+installed AGILAB project name remains `execution_polars_project`.
+
+The package advertises the project through the `agilab.apps` entry point group
+so `AgiEnv(app="execution_polars_project")` can resolve it without a monorepo
+checkout.
+
+## Install
+
+```bash
+pip install agi-app-polars-execution
+```
+
+Most users install these app packages through the umbrella `agi-apps` package or
+through `agilab[ui]` / `agilab[examples]`.

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/agi_app_polars_execution/__init__.py
+src/agi_app_polars_execution.egg-info/PKG-INFO
+src/agi_app_polars_execution.egg-info/SOURCES.txt
+src/agi_app_polars_execution.egg-info/dependency_links.txt
+src/agi_app_polars_execution.egg-info/entry_points.txt
+src/agi_app_polars_execution.egg-info/requires.txt
+src/agi_app_polars_execution.egg-info/top_level.txt

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[agilab.apps]
+execution_polars = agi_app_polars_execution:project_root
+execution_polars_project = agi_app_polars_execution:project_root

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution.egg-info/requires.txt

@@ -0,0 +1 @@
+agi-core<2027.0,>=2026.05.13

agi_app_polars_execution-0.1.0/src/agi_app_polars_execution.egg-info/top_level.txt

@@ -0,0 +1 @@
+agi_app_polars_execution