appligator 0.1.1__tar.gz → 0.2.0.dev1__tar.gz

{appligator-0.1.1 → appligator-0.2.0.dev1}/.gitignore

@@ -17,7 +17,7 @@ __pycache__/
 .Python
 build/
 develop-eggs/
-dist/
+/*/dist/
 downloads/
 eggs/
 .eggs/

{appligator-0.1.1 → appligator-0.2.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appligator
-Version: 0.1.1
+Version: 0.2.0.dev1
 Summary: An application package bundler
 Project-URL: Documentation, https://eo-tools.github.io/eozilla
 Project-URL: Repository, https://github.com/eo-tools/eozilla
@@ -27,14 +27,14 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
-Requires-Dist: gavicore>=0.1.1
+Requires-Dist: gavicore>=0.2.0.dev1
 Requires-Dist: jinja2
-Requires-Dist: procodile>=0.1.1
+Requires-Dist: procodile>=0.2.0.dev1
 Requires-Dist: pydantic
 Requires-Dist: pyyaml
 Requires-Dist: tomli-w
 Requires-Dist: tomli; python_version < '3.11'
-Requires-Dist: typer
+Requires-Dist: typer<1,>=0.26.0
 Description-Content-Type: text/markdown
 
 [![CI](https://github.com/eo-tools/eozilla/actions/workflows/ci.yml/badge.svg)](https://github.com/eo-tools/eozilla/actions/workflows/ci.yml)

{appligator-0.1.1 → appligator-0.2.0.dev1}/appligator/airflow/gen_workflow_dag.py

@@ -3,7 +3,12 @@
 #  https://opensource.org/license/apache-2-0.
 
 from appligator.airflow.ir import workflow_to_ir
-from appligator.airflow.models import ConfigMapMount, PvcMount, ResourceRequirements
+from appligator.airflow.models import (
+    ConfigMapMount,
+    PvcMount,
+    ResourceRequirements,
+    Toleration,
+)
 from appligator.airflow.renderer import AirflowRenderer
 from procodile.workflow import WorkflowStepRegistry
 
@@ -16,6 +21,8 @@ def gen_workflow_dag(
     resources: ResourceRequirements | None = None,
     pvc_mounts: list[PvcMount] | None = None,
     config_map_mounts: list[ConfigMapMount] | None = None,
+    node_selector: dict[str, str] | None = None,
+    tolerations: list[Toleration] | None = None,
 ) -> str:
     """Generates a fully-formed Airflow DAG Python file."""
 
@@ -34,6 +41,8 @@ def gen_workflow_dag(
         resources=resources,
         pvc_mounts=pvc_mounts,
         config_map_mounts=config_map_mounts,
+        node_selector=node_selector,
+        tolerations=tolerations,
     )
 
     dag_code = AirflowRenderer().render(ir)

{appligator-0.1.1 → appligator-0.2.0.dev1}/appligator/airflow/handlers/k8s_handler.py

@@ -76,6 +76,13 @@ class KubernetesOperatorHandler(OperatorHandler):
                 f"\n        volume_mounts=[{', '.join(mount_entries)}],"
             )
 
+        node_selector_block = (
+            "\n        node_selector=_node_selector," if task.node_selector else ""
+        )
+        tolerations_block = (
+            "\n        tolerations=_tolerations," if task.tolerations else ""
+        )
+
         return f"""
     tasks["{task.id}"] = KubernetesPodOperator(
         task_id="{task.id}",
@@ -86,7 +93,7 @@ class KubernetesOperatorHandler(OperatorHandler):
             "func_qualname": "{task.func_qualname}",
             "inputs": {{{inputs}}},
             "output_keys": {task.outputs},
-        }})],{env_from_block}{resources_block}{volumes_block}{volume_mounts_block}
+        }})],{env_from_block}{resources_block}{volumes_block}{volume_mounts_block}{node_selector_block}{tolerations_block}
         do_xcom_push=True,
     )
 """

{appligator-0.1.1 → appligator-0.2.0.dev1}/appligator/airflow/ir.py

@@ -9,6 +9,7 @@ from appligator.airflow.models import (
     PvcMount,
     ResourceRequirements,
     TaskIR,
+    Toleration,
     WorkflowIR,
 )
 from gavicore.models import InputDescription
@@ -24,6 +25,8 @@ def workflow_to_ir(
     resources: ResourceRequirements | None = None,
     pvc_mounts: list[PvcMount] | None = None,
     config_map_mounts: list[ConfigMapMount] | None = None,
+    node_selector: dict[str, str] | None = None,
+    tolerations: list[Toleration] | None = None,
 ) -> WorkflowIR:
     """
     Convert a WorkflowStepRegistry into a fully normalized WorkflowIR (Workflow
@@ -79,6 +82,8 @@ def workflow_to_ir(
             resources=resources,
             pvc_mounts=pvc_mounts or [],
             config_map_mounts=config_map_mounts or [],
+            node_selector=node_selector,
+            tolerations=tolerations,
             inputs={name: f"param:{name}" for name in params},
             outputs=list((main_step.description.outputs or {}).keys()),
             depends_on=[],
@@ -115,6 +120,8 @@ def workflow_to_ir(
                 resources=resources,
                 pvc_mounts=pvc_mounts or [],
                 config_map_mounts=config_map_mounts or [],
+                node_selector=node_selector,
+                tolerations=tolerations,
                 inputs=inputs,
                 outputs=list((step.description.outputs or {}).keys()),
                 depends_on=sorted(set(depends_on)),

{appligator-0.1.1 → appligator-0.2.0.dev1}/appligator/airflow/models.py

@@ -29,6 +29,16 @@ class ConfigMapMount(BaseModel):
     sub_path: str | None = None
 
 
+class Toleration(BaseModel):
+    """A Kubernetes pod toleration."""
+
+    key: str
+    operator: str = "Equal"
+    value: str | None = None
+    effect: str | None = None
+    toleration_seconds: int | None = None
+
+
 class ResourceRequirements(BaseModel):
     """
     CPU and memory resource requests and limits for a container.
@@ -80,6 +90,8 @@ class TaskIR(BaseModel):
     resources: ResourceRequirements | None = None
     pvc_mounts: list[PvcMount] = Field(default_factory=list)
     config_map_mounts: list[ConfigMapMount] = Field(default_factory=list)
+    node_selector: dict[str, str] | None = None
+    tolerations: list[Toleration] | None = None
 
     # Data flow
     inputs: dict[str, str] = Field(default_factory=dict)

{appligator-0.1.1 → appligator-0.2.0.dev1}/appligator/airflow/renderer.py

@@ -8,7 +8,7 @@ from appligator.airflow.handlers.k8s_handler import KubernetesOperatorHandler
 from appligator.airflow.handlers.syn_python_handler import (
     SyntheticPythonsOperatorHandler,
 )
-from appligator.airflow.models import TaskIR, WorkflowIR
+from appligator.airflow.models import TaskIR, Toleration, WorkflowIR
 
 INDENT = "            "
 TAB = "    "
@@ -41,11 +41,20 @@ class AirflowRenderer:
         lines: list[str] = []
 
         needs_k8s = any(
-            t.env_from_secrets or t.resources or t.pvc_mounts or t.config_map_mounts
+            t.env_from_secrets
+            or t.resources
+            or t.pvc_mounts
+            or t.config_map_mounts
+            or t.node_selector
+            or t.tolerations
             for t in workflow.tasks
         )
         lines.extend(render_header(needs_k8s=needs_k8s))
 
+        shared_config = render_k8s_shared_config(workflow)
+        if shared_config:
+            lines.append(shared_config)
+
         lines.append(render_dag_open(workflow))
 
         for task in workflow.tasks:
@@ -66,6 +75,47 @@ class AirflowRenderer:
         raise ValueError(f"No operator adapter for task {task.id}")
 
 
+def render_k8s_shared_config(workflow: WorkflowIR) -> str | None:
+    node_selector = next(
+        (t.node_selector for t in workflow.tasks if t.node_selector), None
+    )
+    tolerations = next((t.tolerations for t in workflow.tasks if t.tolerations), None)
+
+    if not node_selector and not tolerations:
+        return None
+
+    lines = ["# ── Shared Kubernetes config ───────────────────────────────────"]
+
+    if node_selector:
+        lines.append(f"_node_selector = {node_selector!r}")
+        lines.append("")
+
+    if tolerations:
+        tol_items = [_render_toleration(t) for t in tolerations]
+        lines.append("_tolerations = [")
+        for i, item in enumerate(tol_items):
+            sep = "," if i < len(tol_items) - 1 else ""
+            lines.append(f"{item}{sep}")
+        lines.append("]")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def _render_toleration(t: Toleration) -> str:
+    args = ["    k8s.V1Toleration("]
+    args.append(f"        key={t.key!r},")
+    args.append(f"        operator={t.operator!r},")
+    if t.value is not None:
+        args.append(f"        value={t.value!r},")
+    if t.effect is not None:
+        args.append(f"        effect={t.effect!r},")
+    if t.toleration_seconds is not None:
+        args.append(f"        toleration_seconds={t.toleration_seconds},")
+    args.append("    )")
+    return "\n".join(args)
+
+
 def render_header(needs_k8s: bool = False) -> list[str]:
     lines = [
         "import json",

appligator-0.2.0.dev1/appligator/airflow/run_step.py

@@ -0,0 +1,232 @@
+#  Copyright (c) 2026 by the Eozilla team and contributors
+#  Permissions are hereby granted under the terms of the Apache 2.0 License:
+#  https://opensource.org/license/apache-2-0.
+
+# run_step.py
+# (this is run inside the image that is used by the KPO in Airflow)
+
+import importlib
+import json
+import logging
+import os
+import typing
+from typing import Any, Callable
+
+from pydantic import BaseModel, ValidationError
+
+from gavicore.util.dynimp import import_value
+
+logger = logging.getLogger("appligator.airflow")
+
+# Prefix used to identify step input environment variables.
+# Reserved for future use if inputs are passed via env vars instead of argv.
+INPUT_PREFIX = "STEP_INPUT_"
+
+
+def coerce_inputs(func: Callable[..., Any], inputs: dict[str, Any]) -> dict[str, Any]:
+    """Cast Airflow XCom inputs to the types declared in the signature of `func`.
+
+    Airflow renders all Jinja {{ params.* }} as strings, so numeric params
+    arrive as str even when declared as float/int in the process function.
+    Pydantic models (e.g. PathRef) arrive as dicts after XCom round-trip.
+    We use the function's type hints (with Annotated stripped) to coerce them.
+
+    Coercion is best-effort: if introspection fails for any reason (e.g. a
+    forward reference that can't be resolved at runtime) we fall back to
+    JSON-parsing string values so that "5.0" → 5.0, "true" → True, etc.
+    """
+    try:
+        # include_extras=False strips Annotated[X, ...] → X so we get the
+        # bare type (e.g. float) rather than Annotated[float, Field(...)].
+        hints = typing.get_type_hints(func, include_extras=False)
+    except Exception:
+        hints = {}  # fall through to json.loads fallback below
+
+    coerced: dict[str, Any] = {}
+    for key, value in inputs.items():
+        if value is None:
+            coerced[key] = value
+            continue
+        hint = hints.get(key)
+        if hint in _SCALAR_TYPES and isinstance(value, str):
+            coerced[key] = hint(value)
+        elif (model_cls := _pydantic_type(hint)) and not isinstance(value, model_cls):
+            if isinstance(value, str):
+                # Airflow Jinja renders dict XCom/param values as Python repr
+                # strings (single-quoted, None not null). Try JSON first, then
+                # ast.literal_eval to recover the dict before model construction.
+                try:
+                    value = json.loads(value)
+                except (json.JSONDecodeError, ValueError):
+                    try:
+                        import ast
+
+                        value = ast.literal_eval(value)
+                    except (ValueError, SyntaxError):  # pragma: no cover
+                        pass
+            try:
+                coerced[key] = model_cls.model_validate(value)
+            except ValidationError:
+                # OGC job results are a mapping of output name -> value
+                # (Link | QualifiedValue | InlineValue); a procodile Workflow
+                # called directly returns that same shape for its single
+                # output. The output name is arbitrary per OGC (procodile
+                # only defaults it to "return_value" when none is declared),
+                # so unwrap by shape -- a single-entry dict -- rather than
+                # matching a specific key.
+                if not isinstance(value, dict) or len(value) != 1:
+                    raise
+                (inner_value,) = value.values()
+                coerced[key] = model_cls.model_validate(inner_value)
+        elif isinstance(value, str):
+            # Fallback: JSON-parse strings that look like non-string scalars.
+            # "5.0" → 5.0, "true" → True, but "dummy" stays "dummy".
+            try:
+                parsed = json.loads(value)
+                coerced[key] = parsed if not isinstance(parsed, str) else value
+            except (json.JSONDecodeError, ValueError):
+                coerced[key] = value
+        else:
+            coerced[key] = value
+    return coerced
+
+
+def resolve_function(module_name: str, qualname: str):
+    """Import *module_name* and return the object at *qualname*.
+
+    *qualname* may be a dotted path to a nested attribute, e.g.
+    ``"MyClass.my_method"``, resolved via gavicore's
+    ``import_value("module:qualname", ...)``.
+
+    If the final segment of *qualname* is ``"function"`` and it can't be
+    resolved directly but the parent object is a procodile Workflow (which
+    stores its main callable in registry.main), the main function is
+    extracted from the registry instead. This handles both old procodile
+    builds (no .function property) and new ones transparently.
+    """
+    importlib.import_module(module_name)  # let ImportError propagate as-is
+    try:
+        obj = import_value(f"{module_name}:{qualname}", type=object, name="step target")
+    except ValueError as e:
+        attr = qualname.rsplit(".", 1)[-1]
+        if attr != "function":
+            raise AttributeError(str(e)) from e
+
+        parent_qualname = qualname.rsplit(".", 1)[0] if "." in qualname else None
+        try:
+            parent = (
+                import_value(
+                    f"{module_name}:{parent_qualname}", type=object, name="step target"
+                )
+                if parent_qualname
+                else importlib.import_module(module_name)
+            )
+        except ValueError as pe:
+            raise AttributeError(str(pe)) from pe
+
+        if not (hasattr(parent, "registry") and hasattr(parent.registry, "main")):
+            raise AttributeError(str(e)) from e
+
+        try:
+            main_id = next(iter(parent.registry.main))
+        except StopIteration:
+            raise AttributeError(
+                f"Workflow registry has no main step (attr={attr!r})"
+            ) from None
+        obj = parent.registry.main[main_id].function
+
+    # If the resolved object is a procodile Step (has a .function attribute
+    # holding the original callable), use the bare function so that calling it
+    # returns the raw result rather than a procodile-wrapped output dict.
+    if hasattr(obj, "function") and callable(obj.function):
+        obj = obj.function
+
+    return obj
+
+
+def main(
+    *,
+    func_module: str,
+    func_qualname: str,
+    inputs: dict[str, Any],
+    output_keys: list[str] | None = None,
+):
+    """Entry point invoked by the Airflow KubernetesPodOperator (KPO).
+
+    The KPO launches this script inside the task container, passing a single
+    JSON-encoded argument via ``sys.argv[1]`` with the keys:
+
+    - ``func_module``: dotted module path of the step function.
+    - ``func_qualname``: qualified name of the function within that module.
+    - ``inputs``: keyword arguments forwarded to the function.
+    - ``output_keys``: names to assign to the function's return value(s).
+      If the function returns a tuple each element is paired with the
+      corresponding key; a scalar return is stored under the first key.
+      Omit to use the default key ``"return_value"``.
+
+    Outputs are written as JSON to the XCom file so Airflow can pass them to
+    downstream tasks.  The XCom directory defaults to ``/airflow/xcom`` but
+    can be overridden via the ``AIRFLOW_XCOM_DIR`` environment variable for
+    local testing.
+    """
+    func = resolve_function(func_module, func_qualname)
+    logger.debug("RAW inputs: %s", inputs)
+    inputs = coerce_inputs(func, inputs)
+    logger.debug("COERCED inputs: %s", inputs)
+
+    result = func(**inputs)
+
+    if output_keys:
+        if isinstance(result, tuple):
+            output = dict(zip(output_keys, result, strict=False))
+        else:
+            output = {output_keys[0]: result}
+    else:
+        output = {"return_value": result}
+
+    XCOM_DIR = os.environ.get("AIRFLOW_XCOM_DIR", "/airflow/xcom")
+    XCOM_FILE = os.path.join(XCOM_DIR, "return.json")
+
+    os.makedirs(XCOM_DIR, exist_ok=True)
+    with open(XCOM_FILE, "w") as f:
+        json.dump(output, f, cls=_XComEncoder)
+
+
+class _XComEncoder(json.JSONEncoder):
+    """Serialize types that json.dump can't handle natively.
+
+    Airflow reads step outputs from a JSON file (XCom).  Standard json.dump
+    fails on Pydantic models and other domain objects, so we serialise them
+    here rather than requiring every step function to return plain dicts.
+    """
+
+    def default(self, obj):
+        if hasattr(obj, "model_dump"):  # Pydantic models (e.g. PathRef)
+            return obj.model_dump()
+        return str(obj)
+
+
+_SCALAR_TYPES = (int, float, bool)
+
+
+def _pydantic_type(hint) -> type[BaseModel] | None:
+    """Return the Pydantic model class from a hint, including Optional[Model]."""
+    if isinstance(hint, type) and issubclass(hint, BaseModel):
+        return hint
+    args = typing.get_args(hint)
+    if args:
+        non_none = [a for a in args if a is not type(None)]
+        if (
+            len(non_none) == 1
+            and isinstance(non_none[0], type)
+            and issubclass(non_none[0], BaseModel)
+        ):
+            return non_none[0]
+    return None
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    payload = json.loads(sys.argv[1])
+    main(**payload)

{appligator-0.1.1 → appligator-0.2.0.dev1}/appligator/cli.py

@@ -17,7 +17,7 @@ CLI_NAME = "appligator"
 cli = typer.Typer(name=CLI_NAME)
 
 
-@cli.command()
+@cli.command(name=CLI_NAME)
 def main(
     process_registry_spec: Annotated[
         str | None,
@@ -122,6 +122,27 @@ def main(
             ),
         ),
     ] = None,
+    node_selector: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--node-selector",
+            help=(
+                "Node selector label for every pod. "
+                "Format: key=value (e.g. --node-selector pool=airflow-workers-big). Repeatable."
+            ),
+        ),
+    ] = None,
+    tolerations: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--toleration",
+            help=(
+                "Toleration for every pod. "
+                "Format: key:operator[:value[:effect]] "
+                "(e.g. --toleration airflow/component:Equal:worker:NoSchedule). Repeatable."
+            ),
+        ),
+    ] = None,
 ):
     """
     Generate various application formats from your processes.
@@ -143,7 +164,12 @@ def main(
     from appligator import __version__
     from appligator.airflow.gen_image import gen_image
     from appligator.airflow.gen_workflow_dag import gen_workflow_dag
-    from appligator.airflow.models import ConfigMapMount, PvcMount, ResourceRequirements
+    from appligator.airflow.models import (
+        ConfigMapMount,
+        PvcMount,
+        ResourceRequirements,
+        Toleration,
+    )
     from appligator.config import AppligatorConfig, load_config
     from gavicore.util.dynimp import import_value
     from procodile import ProcessRegistry
@@ -225,6 +251,39 @@ def main(
         else cfg.config_map_mounts
     )
 
+    parsed_node_selector: dict[str, str] = {}
+    for spec in node_selector or []:
+        if "=" not in spec:
+            typer.echo(f"Error: --node-selector must be key=value, got: {spec!r}")
+            raise typer.Exit(1)
+        k, v = spec.split("=", 1)
+        parsed_node_selector[k] = v
+    effective_node_selector = (
+        parsed_node_selector
+        if node_selector is not None
+        else (cfg.node_selector or None)
+    )
+
+    parsed_tolerations: list[Toleration] = []
+    for spec in tolerations or []:
+        parts = spec.split(":", 3)
+        if len(parts) < 2:  # noqa: PLR2004
+            typer.echo(
+                f"Error: --toleration must be key:operator[:value[:effect]], got: {spec!r}"
+            )
+            raise typer.Exit(1)
+        parsed_tolerations.append(
+            Toleration(
+                key=parts[0],
+                operator=parts[1],
+                value=parts[2] if len(parts) > 2 and parts[2] else None,  # noqa: PLR2004
+                effect=parts[3] if len(parts) > 3 and parts[3] else None,  # noqa: PLR2004
+            )
+        )
+    effective_tolerations = (
+        parsed_tolerations if tolerations is not None else (cfg.tolerations or None)
+    )
+
     process_registry: ProcessRegistry = import_value(
         process_registry_spec,
         type=ProcessRegistry,
@@ -259,9 +318,11 @@ def main(
             resources=resources,
             pvc_mounts=effective_pvc_mounts or None,
             config_map_mounts=effective_config_map_mounts or None,
+            node_selector=effective_node_selector or None,
+            tolerations=effective_tolerations or None,
         )
         dag_file = dags_folder / f"{file_stem}.py"
-        with dag_file.open("w") as stream:
+        with dag_file.open("w", encoding="utf-8") as stream:
             stream.write(
                 f"# WARNING - THIS IS GENERATED CODE\n"
                 f"#   Generator: Eozilla Appligator v{__version__}\n"

{appligator-0.1.1 → appligator-0.2.0.dev1}/appligator/config.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from appligator.airflow.models import ConfigMapMount, PvcMount
+from appligator.airflow.models import ConfigMapMount, PvcMount, Toleration
 
 
 class AppligatorConfig(BaseModel):
@@ -37,6 +37,13 @@ class AppligatorConfig(BaseModel):
             config_map_name: s2gos-settings
             mount_path: /opt/pixi/s2gos_settings.yaml
             sub_path: s2gos_settings.yaml
+        node_selector:
+          pool: airflow-workers-big
+        tolerations:
+          - key: airflow/component
+            operator: Equal
+            value: worker
+            effect: NoSchedule
     """
 
     image_name: str | None = None
@@ -48,6 +55,8 @@ class AppligatorConfig(BaseModel):
     memory_limit: str | None = None
     pvc_mounts: list[PvcMount] = Field(default_factory=list)
     config_map_mounts: list[ConfigMapMount] = Field(default_factory=list)
+    node_selector: dict[str, str] = Field(default_factory=dict)
+    tolerations: list[Toleration] = Field(default_factory=list)
 
 
 def load_config(path: Path) -> AppligatorConfig:

{appligator-0.1.1 → appligator-0.2.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [project]
 name = "appligator"
-version = "0.1.1"
+version = "0.2.0.dev1"
 description = "An application package bundler"
 readme = "README.md"
 authors = [
@@ -45,10 +45,10 @@ dependencies = [
   "pyyaml",
   "tomli-w",
   "tomli; python_version < '3.11'",
-  "typer",
+  "typer >=0.26.0,<1",
   # local dependency
-  "gavicore >=0.1.1",
-  "procodile >=0.1.1",
+  "gavicore >=0.2.0.dev1",
+  "procodile >=0.2.0.dev1",
 ]
 
 [project.urls]

appligator-0.1.1/appligator/airflow/run_step.py

@@ -1,129 +0,0 @@
-#  Copyright (c) 2026 by the Eozilla team and contributors
-#  Permissions are hereby granted under the terms of the Apache 2.0 License:
-#  https://opensource.org/license/apache-2-0.
-
-# run_step.py
-# (this is run inside the image that is used by the KPO in Airflow)
-
-import importlib
-import json
-import os
-import typing
-from typing import Any
-
-# Prefix used to identify step input environment variables.
-# Reserved for future use if inputs are passed via env vars instead of argv.
-INPUT_PREFIX = "STEP_INPUT_"
-
-
-class _XComEncoder(json.JSONEncoder):
-    """Serialize types that json.dump can't handle natively.
-
-    Airflow reads step outputs from a JSON file (XCom).  Standard json.dump
-    fails on Pydantic models and other domain objects, so we serialise them
-    here rather than requiring every step function to return plain dicts.
-    """
-
-    def default(self, obj):
-        if hasattr(obj, "model_dump"):  # Pydantic models (e.g. PathRef)
-            return obj.model_dump()
-        return str(obj)
-
-
-_SCALAR_TYPES = (int, float, bool)
-
-
-def coerce_inputs(func, inputs: dict[str, Any]) -> dict[str, Any]:
-    """Cast string inputs to the types declared in func's signature.
-
-    Airflow renders all Jinja {{ params.* }} as strings, so numeric params
-    arrive as str even when declared as float/int in the process function.
-    We use the function's type hints (with Annotated stripped) to coerce them.
-
-    Coercion is best-effort: if introspection fails for any reason (e.g. a
-    forward reference that can't be resolved at runtime) the original inputs
-    are returned unchanged so the step function can handle or report the error
-    itself.
-    """
-    try:
-        # include_extras=False strips Annotated[X, ...] → X so we get the
-        # bare type (e.g. float) rather than Annotated[float, Field(...)].
-        hints = typing.get_type_hints(func, include_extras=False)
-    except Exception:
-        return inputs
-
-    coerced = {}
-    for key, value in inputs.items():
-        hint = hints.get(key)
-        if hint in _SCALAR_TYPES and isinstance(value, str):
-            coerced[key] = hint(value)
-        else:
-            coerced[key] = value
-    return coerced
-
-
-def resolve_function(module_name: str, qualname: str):
-    """Import *module_name* and return the object at *qualname*.
-
-    *qualname* may be a dotted path to a nested attribute, e.g.
-    ``"MyClass.my_method"``, which is walked attribute-by-attribute after the
-    module is imported.
-    """
-    module = importlib.import_module(module_name)
-    obj = module
-    for attr in qualname.split("."):
-        obj = getattr(obj, attr)
-    return obj
-
-
-def main(
-    *,
-    func_module: str,
-    func_qualname: str,
-    inputs: dict[str, Any],
-    output_keys: list[str] | None = None,
-):
-    """Entry point invoked by the Airflow KubernetesPodOperator (KPO).
-
-    The KPO launches this script inside the task container, passing a single
-    JSON-encoded argument via ``sys.argv[1]`` with the keys:
-
-    - ``func_module``: dotted module path of the step function.
-    - ``func_qualname``: qualified name of the function within that module.
-    - ``inputs``: keyword arguments forwarded to the function.
-    - ``output_keys``: names to assign to the function's return value(s).
-      If the function returns a tuple each element is paired with the
-      corresponding key; a scalar return is stored under the first key.
-      Omit to use the default key ``"return_value"``.
-
-    Outputs are written as JSON to the XCom file so Airflow can pass them to
-    downstream tasks.  The XCom directory defaults to ``/airflow/xcom`` but
-    can be overridden via the ``AIRFLOW_XCOM_DIR`` environment variable for
-    local testing.
-    """
-    func = resolve_function(func_module, func_qualname)
-    inputs = coerce_inputs(func, inputs)
-
-    result = func(**inputs)
-
-    if output_keys:
-        if isinstance(result, tuple):
-            output = dict(zip(output_keys, result, strict=False))
-        else:
-            output = {output_keys[0]: result}
-    else:
-        output = {"return_value": result}
-
-    XCOM_DIR = os.environ.get("AIRFLOW_XCOM_DIR", "/airflow/xcom")
-    XCOM_FILE = os.path.join(XCOM_DIR, "return.json")
-
-    os.makedirs(XCOM_DIR, exist_ok=True)
-    with open(XCOM_FILE, "w") as f:
-        json.dump(output, f, cls=_XComEncoder)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    payload = json.loads(sys.argv[1])
-    main(**payload)