pypeline-runner 1.10.0__tar.gz → 1.12.0__tar.gz

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pypeline-runner
-Version: 1.10.0
+Version: 1.12.0
 Summary: Configure and execute pipelines with Python (similar to GitHub workflows or Jenkins pipelines).
 License: MIT
 Author: cuinixam
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
-Requires-Dist: py-app-dev (>=2.9,<3.0)
+Requires-Dist: py-app-dev (>=2.10,<3.0)
 Requires-Dist: pyyaml (>=6.0,<7.0)
 Requires-Dist: typer (>=0,<1)
 Project-URL: Bug Tracker, https://github.com/cuinixam/pypeline/issues

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pypeline-runner"
-version = "1.10.0"
+version = "1.12.0"
 description = "Configure and execute pipelines with Python (similar to GitHub workflows or Jenkins pipelines)."
 authors = ["cuinixam <me@cuinixam.com>"]
 license = "MIT"
@@ -27,7 +27,7 @@ pypeline = "pypeline.main:main"
 
 [tool.poetry.dependencies]
 python = "^3.10"
-py-app-dev = "^2.9"
+py-app-dev = "^2.10"
 typer = "^0"
 pyyaml = "^6.0"
 

pypeline_runner-1.12.0/src/pypeline/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.12.0"

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/src/pypeline/domain/config.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Literal, Optional
 
 import yaml
 from mashumaro import DataClassDictMixin
@@ -10,10 +10,23 @@ from yaml.scanner import ScannerError
 
 from .pipeline import PipelineConfig
 
+InputType = Literal["string", "integer", "boolean"]
+
+
+@dataclass
+class ProjectInput(DataClassDictMixin):
+    """Represents a single input parameter for a pipeline step similar to GitHub workflows inputs."""
+
+    type: InputType
+    description: Optional[str] = None
+    default: Optional[Any] = None
+    required: bool = False
+
 
 @dataclass
 class ProjectConfig(DataClassDictMixin):
     pipeline: PipelineConfig
+    inputs: Optional[Dict[str, ProjectInput]] = None
     # This field is intended to keep track of where configuration was loaded from and
     # it is automatically added when configuration is loaded from file
     file: Optional[Path] = None

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/src/pypeline/domain/execution_context.py

@@ -1,7 +1,7 @@
 import os
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 from py_app_dev.core.data_registry import DataRegistry
 from py_app_dev.core.subprocess import SubprocessExecutor
@@ -16,6 +16,8 @@ class ExecutionContext:
     install_dirs: List[Path] = field(default_factory=list)
     # Data registry to exchange data of any type
     data_registry: DataRegistry = field(default_factory=DataRegistry)
+    # Inputs provided for the pipeline run
+    inputs: Dict[str, Any] = field(default_factory=dict)
 
     def add_install_dirs(self, install_dirs: List[Path]) -> None:
         self.install_dirs.extend(install_dirs)

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/src/pypeline/domain/project_slurper.py

@@ -21,3 +21,7 @@ class ProjectSlurper:
     @property
     def project_dir(self) -> Path:
         return self.artifacts_locator.project_root_dir
+
+    @property
+    def project_config(self) -> ProjectConfig:
+        return self.user_config

pypeline_runner-1.12.0/src/pypeline/inputs_parser.py

@@ -0,0 +1,88 @@
+import argparse
+import distutils.util
+from typing import Any, Dict, List
+
+from py_app_dev.core.exceptions import UserNotificationException
+
+from .domain.config import InputType, ProjectInput
+
+
+def _map_type_for_argparse(input_type: InputType) -> Any:
+    if input_type == "string":
+        return str
+    elif input_type == "integer":
+        return int
+    elif input_type == "boolean":
+        return lambda x: bool(distutils.util.strtobool(x))
+    else:
+        raise ValueError(f"Unsupported input type specified: {input_type}")
+
+
+def create_argument_parser_from_definitions(
+    input_definitions: Dict[str, ProjectInput],
+    description: str = "Pypeline inputs parser.",
+) -> argparse.ArgumentParser:
+    """Creates and configures an ArgumentParser based on input definitions."""
+    parser = argparse.ArgumentParser(
+        description=description,
+        exit_on_error=False,
+    )
+
+    for name, definition in input_definitions.items():
+        arg_type = _map_type_for_argparse(definition.type)
+
+        help_text = definition.description or f"Input parameter '{name}'."
+        help_text += f" (Type: {definition.type}"
+        if definition.default is not None:
+            help_text += f", Default: {definition.default}"
+        help_text += ")"
+
+        parser.add_argument(
+            f"--{name}",
+            dest=name,  # Attribute name in the parsed namespace
+            help=help_text,
+            type=arg_type,  # Type conversion function
+            required=definition.required,
+            default=definition.default,
+        )
+
+    return parser
+
+
+class InputsParser:
+    """Parses input arguments based on definitions using argparse."""
+
+    def __init__(self, parser: argparse.ArgumentParser) -> None:
+        self.parser = parser
+
+    @classmethod
+    def from_inputs_definitions(
+        cls,
+        input_definitions: Dict[str, ProjectInput],
+        description: str = "Pypeline inputs parser.",
+    ) -> "InputsParser":
+        """Factory method to create an InputsParser instance from input definitions."""
+        return cls(create_argument_parser_from_definitions(input_definitions, description))
+
+    def parse_inputs(self, inputs: List[str]) -> Dict[str, Any]:
+        """Parses and validates the provided input strings against the configured parser. Inputs are expected as a list of 'name=value' elements."""
+        try:
+            args = []
+            for item in inputs:
+                if "=" not in item:
+                    raise UserNotificationException(f"Invalid input format: '{item}', expected 'name=value'")
+                name, value = item.split("=", 1)
+                args.append(f"--{name}")
+                args.append(value)
+
+            parsed_namespace = self.parser.parse_args(args)
+            return vars(parsed_namespace)
+        except argparse.ArgumentError as e:
+            error_message = f"Input validation error: {e}"
+            raise UserNotificationException(error_message) from e
+        except SystemExit as e:
+            error_message = f"Input parsing failed: {e}"
+            raise UserNotificationException(error_message) from e
+        except Exception as e:
+            error_message = f"An unexpected error occurred during input parsing: {e}"
+            raise UserNotificationException(error_message) from e

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/src/pypeline/kickstart/templates/project/pypeline.yaml

@@ -1,3 +1,9 @@
+inputs:
+  my_input:
+    type: string
+    description: My input description
+    default: my_input_default
+
 pipeline:
   - step: CreateVEnv
     module: pypeline.steps.create_venv

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/src/pypeline/main.py

@@ -10,6 +10,7 @@ from pypeline import __version__
 from pypeline.domain.execution_context import ExecutionContext
 from pypeline.domain.pipeline import PipelineConfigIterator
 from pypeline.domain.project_slurper import ProjectSlurper
+from pypeline.inputs_parser import InputsParser
 from pypeline.kickstart.create import KickstartProject
 from pypeline.pypeline import PipelineScheduler, PipelineStepsExecutor
 
@@ -48,6 +49,12 @@ def run(
     print: bool = typer.Option(False, help="Print the pipeline steps."),
     force_run: bool = typer.Option(False, help="Force the execution of a step even if it is not dirty."),
     dry_run: bool = typer.Option(False, help="Do not run any step, just print the steps that would be executed."),
+    inputs: Optional[List[str]] = typer.Option(  # noqa: B008
+        None,
+        "--input",
+        "-i",
+        help="Provide input parameters as key=value pairs (e.g., -i name=value -i flag=true).",
+    ),
 ) -> None:
     project_slurper = ProjectSlurper(project_dir, config_file)
     if print:
@@ -65,8 +72,15 @@ def run(
     if not steps_references:
         logger.info("No steps to run.")
         return
-
-    PipelineStepsExecutor[ExecutionContext](ExecutionContext(project_dir), steps_references, force_run, dry_run).run()
+    # Parse the inputs
+    input_definitions = project_slurper.project_config.inputs
+    if input_definitions is None and inputs:
+        raise UserNotificationException(f"Inputs are not accepted because there are no inputs defined in the '{project_slurper.project_config.file}' configuration.")
+    if input_definitions and inputs:
+        inputs_dict = InputsParser.from_inputs_definitions(input_definitions).parse_inputs(inputs)
+    else:
+        inputs_dict = {}
+    PipelineStepsExecutor[ExecutionContext](ExecutionContext(project_dir, inputs=inputs_dict), steps_references, force_run, dry_run).run()
 
 
 def main() -> None:

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/src/pypeline/steps/create_venv.py

@@ -55,3 +55,6 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
 
     def update_execution_context(self) -> None:
         pass
+
+    def get_needs_dependency_management(self) -> bool:
+        return False

{pypeline_runner-1.10.0 → pypeline_runner-1.12.0}/src/pypeline/steps/scoop_install.py

@@ -68,7 +68,9 @@ class ScoopInstall(PipelineStep[ExecutionContext]):
     def run(self) -> int:
         self.logger.debug(f"Run {self.get_name()} step. Output dir: {self.output_dir}")
         installed_apps = create_scoop_wrapper().install(self.scoop_file)
+        self.logger.debug("Installed apps:")
         for app in installed_apps:
+            self.logger.debug(f" - {app.name} ({app.version})")
             self.install_dirs.extend(app.get_all_required_paths())
         self.execution_info.to_json_file(self.execution_info_file)
         return 0

pypeline_runner-1.10.0/src/pypeline/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.10.0"