prepare-assignment 0.2.0__tar.gz → 0.3.0__tar.gz

prepare_assignment-0.3.0/.github/workflows/release.yml

@@ -0,0 +1,30 @@
+name: Release Prepare to PyPi
+
+on:
+  push:
+    branches:
+      - 'releases/**'
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    strategy:
+        matrix:
+          python-version: ["3.9"]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: uv sync
+      - name: Build
+        run: uv build
+      - name: Publish
+        run: uv publish --token ${{ secrets.PYPI_TOKEN }}

prepare_assignment-0.3.0/.github/workflows/test.yml

@@ -0,0 +1,63 @@
+name: Test
+
+defaults:
+  run:
+    shell: bash
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+        os: ["ubuntu-latest", "windows-latest", "macos-latest"]
+    runs-on: ${{ matrix.os }}
+    permissions:
+      contents: read
+      checks: write
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+      with:
+        enable-cache: true
+        cache-dependency-glob: "uv.lock"
+    - name: Set up Python ${{ matrix.python-version }}
+      run: uv python install ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: uv sync --group test
+    - name: Run tests
+      env:
+        PREPARE_TEST_GIT_MODE: https
+      run: uv run pytest --cov --cov-report=xml --junitxml=tests.xml
+    - name: Test Report
+      uses: mikepenz/action-junit-report@v6
+      if: success() || failure()
+      with:
+        check_name: Test Results (Python version ${{ matrix.python-version }})
+        report_paths: tests.xml
+
+  typecheck:
+    strategy:
+      matrix:
+        python-version: [ "3.12" ]
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: uv sync --group test
+      - name: Type checker
+        run: uv run mypy prepare_assignment

prepare_assignment-0.3.0/.gitignore

@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+exampleproject/
+tests.xml
+out.txt
+out/
+.vscode

{prepare_assignment-0.2.0 → prepare_assignment-0.3.0}/PKG-INFO

@@ -1,28 +1,23 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: prepare-assignment
-Version: 0.2.0
+Version: 0.3.0
 Summary: Prepare assignment
+Author-email: Bonajo <m.bonajo@fontys.nl>
 License: MIT
-Author: Bonajo
-Author-email: m.bonajo@fontys.nl
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: dacite (>=1.9.2,<2.0.0)
-Requires-Dist: gitpython (>=3.1.41,<4.0.0)
-Requires-Dist: importlib-resources (>=6.1.1,<7.0.0)
-Requires-Dist: jsonschema (>=4.21.1,<5.0.0)
-Requires-Dist: multipledispatch (>=1.0.0,<2.0.0)
-Requires-Dist: prepare-toolbox (==0.4.0)
-Requires-Dist: ruamel-yaml (>=0.18.5,<0.19.0)
-Requires-Dist: treelib (>=1.7.0,<2.0.0)
-Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
-Requires-Dist: virtualenv (>=20.25.0,<21.0.0)
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: dacite>=1.9.2
+Requires-Dist: gitpython>=3.1.41
+Requires-Dist: importlib-resources>=6.1.1
+Requires-Dist: jsonschema>=4.21.1
+Requires-Dist: multipledispatch>=1.0.0
+Requires-Dist: packaging>=24.0
+Requires-Dist: prepare-toolbox==0.4.0
+Requires-Dist: ruamel-yaml>=0.18.5
+Requires-Dist: simpleeval>=1.0.0
+Requires-Dist: treelib>=1.7.0
+Requires-Dist: typer==0.17.3
+Requires-Dist: virtualenv>=20.25.0
 Description-Content-Type: text/markdown
 
 # Prepare assignment
@@ -124,4 +119,3 @@ It is possible to create custom (python/composite) tasks.
 3. Validate that the task definition is correct against the [json schema](https://github.com/prepare-assignment/core/blob/main/prepare_assignment/schemas/task.schema.json)
 4. If python task, create a script that implements desired functionality
 
-

{prepare_assignment-0.2.0 → prepare_assignment-0.3.0}/prepare_assignment/cli/main.py

@@ -1,6 +1,6 @@
 import os.path
 import sys
-from typing import Optional
+from typing import Dict, List, Optional
 
 import typer
 from typing_extensions import Annotated
@@ -31,8 +31,9 @@ def main(ctx: typer.Context):
         typer.echo(f"Virtual env: {get_virtualenv_name()}")
 
 
-@app.command()
+@app.command(context_settings={"allow_extra_args": True, "ignore_unknown_options": True})
 def run(
+    ctx: typer.Context,
     file_name: Annotated[
         Optional[str],
         typer.Option("--file", "-f", help="Configuration file")
@@ -48,7 +49,11 @@ def run(
     verbose: Annotated[
         int,
         typer.Option("--verbose", "-v", count=True, help="increase task output verbosity")
-    ] = CONFIG.core.verbose
+    ] = CONFIG.core.verbose,
+    env: Annotated[
+        Optional[List[str]],
+        typer.Option("-e", "--env", help="Set environment variable (KEY=VALUE)")
+    ] = None,
 ):
     """
     Parse 'prepare_assignment.y(a)ml' and execute all jobs
@@ -57,5 +62,31 @@ def run(
     CONFIG.core.git_mode = git # type: ignore
     CONFIG.core.verbose = verbose  # type: ignore
 
-    prepare(file_name)
+    env_vars: Dict[str, str] = {}
+    for item in (env or []):
+        if "=" not in item:
+            raise typer.BadParameter("Environment variables must be in KEY=VALUE format.", param_hint="-e/--env")
+        key, value = item.split("=", 1)
+        if not key:
+            raise typer.BadParameter("Environment variable name cannot be empty.", param_hint="-e/--env")
+        env_vars[key] = value
+    # ctx.args only contains arguments unknown to Click (known options like --debug,
+    # --verbose are consumed by the parser and never appear here)
+    for arg in ctx.args:
+        if not arg.startswith("--"):
+            continue
+        key_value = arg[2:]
+        if not key_value:
+            continue
+        if "=" in key_value:
+            key, value = key_value.split("=", 1)
+            if not key:
+                continue
+        else:
+            key, value = key_value, "true"
+        env_vars[key] = value
 
+    try:
+        prepare(file_name, env_vars)
+    except Exception:
+        raise typer.Exit(code=1)

{prepare_assignment-0.2.0 → prepare_assignment-0.3.0}/prepare_assignment/cli/task.py

@@ -50,7 +50,7 @@ def display_update(
         update(task, recursive)
     except Exception as e:
         logger.exception(e)
-        typer.Abort()
+        raise typer.Abort()
 
 
 @app.command("add")

{prepare_assignment-0.2.0 → prepare_assignment-0.3.0}/prepare_assignment/core/command.py

@@ -21,6 +21,9 @@ def handle_set_failed(environment: JobEnvironment, params: List[str]) -> None:
 
 
 def handle_set_output(environment: JobEnvironment, params: List[str]) -> None:
+    if environment.current_task_definition is None:
+        logger.warning("'set-output' is not supported for shell commands and will be ignored")
+        return
     if len(params) < 2:
         raise AssertionError(f"Missing required params for 'set_failed'")
     try:
@@ -33,11 +36,11 @@ def handle_set_output(environment: JobEnvironment, params: List[str]) -> None:
         definition = environment.current_task_definition.outputs.get(key, None)  # type: ignore
         if definition is None:
             logger.warning(f"Trying to set output '{key}', but is not defined in task. Skipping for now.")
-            break
+            continue
         expected_type = TYPE_MAPPING.get(definition.type, None)
         if expected_type is None or not isinstance(value, expected_type):
             logger.warning(f"Output '{key}' is of type '{type(value)}', but expected '{definition.type}'")
-            break
+            continue
         environment.outputs[environment.current_task.key][key] = value  # type: ignore
 
 
@@ -65,9 +68,23 @@ def handle_debug(environment: JobEnvironment, params: List[str]) -> None:
     logger.debug(__handle_message(params[0]))
 
 
+def handle_set_env(environment: JobEnvironment, params: List[str]) -> None:
+    if len(params) < 2:
+        raise AssertionError(f"Missing required params for 'set-env'")
+    name = unquote_plus(params[0])
+    try:
+        value = json.loads(params[1])
+    except JSONDecodeError:
+        raise AssertionError(f"'set-env' expects a JSON-encoded value as second param")
+    if not isinstance(value, str):
+        raise AssertionError(f"'set-env' expects a string value")
+    environment.environment[name] = value
+
+
 COMMAND_MAPPING = {
     "set-failed": handle_set_failed,
     "set-output": handle_set_output,
+    "set-env": handle_set_env,
     "error": handle_error,
     "warning": handle_warning,
     "info": handle_info,

prepare_assignment-0.3.0/prepare_assignment/core/expression.py

@@ -0,0 +1,137 @@
+import re
+from typing import Any, Dict
+
+from simpleeval import EvalWithCompoundTypes, InvalidExpression
+
+from prepare_assignment.data.job_environment import JobEnvironment
+
+_OP_RE = re.compile(r'&&|\|\||!(?!=)')
+# Match attribute access where the name contains hyphens (not valid Python identifiers)
+# e.g. .stripped-files → ["stripped-files"]
+_HYPHEN_ATTR_RE = re.compile(r'\.([a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)+)')
+# Matches quoted strings (to preserve them) OR bare true/false literals to capitalise.
+# Group 1 is set only for bare boolean literals; quoted strings are captured but not replaced.
+_BOOL_RE = re.compile(r"'[^']*'|\"[^\"]*\"|\b(true|false)\b")
+
+
+def _preprocess(expr: str) -> str:
+    def replace_op(m: re.Match) -> str:  # type: ignore
+        token = m.group(0)
+        if token == "&&":
+            return " and "
+        if token == "||":
+            return " or "
+        return "not "
+
+    def replace_bool(m: re.Match) -> str:  # type: ignore
+        # Only replace when group 1 matched (bare literal, not inside quotes)
+        if m.group(1) is not None:
+            return str(m.group(1)).capitalize()
+        return str(m.group(0))
+
+    expr = _OP_RE.sub(replace_op, expr)
+    expr = _HYPHEN_ATTR_RE.sub(lambda m: f'["{m.group(1)}"]', expr)
+    expr = _BOOL_RE.sub(replace_bool, expr)
+    return expr
+
+
+class _Namespace:
+    """Wraps a dict to allow attribute-style access (e.g. inputs.foo, tasks.step.outputs.bar)."""
+
+    def __init__(self, d: Dict[str, Any]) -> None:
+        object.__setattr__(self, "_d", d)
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        d: Dict[str, Any] = object.__getattribute__(self, "_d")
+        _MISSING = object()
+        val = d.get(name, _MISSING)
+        if val is _MISSING:
+            raise AttributeError(name)
+        return _Namespace(val) if isinstance(val, dict) else val
+
+    def __getitem__(self, key: str) -> Any:
+        d: Dict[str, Any] = object.__getattribute__(self, "_d")
+        val = d[key]
+        return _Namespace(val) if isinstance(val, dict) else val
+
+    def __contains__(self, item: Any) -> bool:
+        d: Dict[str, Any] = object.__getattribute__(self, "_d")
+        return item in d
+
+
+def _coerce_env(env: Dict[str, str]) -> Dict[str, Any]:
+    """Convert string "true"/"false" env var values to Python booleans."""
+    result: Dict[str, Any] = {}
+    for k, v in env.items():
+        if v.lower() == "true":
+            result[k] = True
+        elif v.lower() == "false":
+            result[k] = False
+        else:
+            result[k] = v
+    return result
+
+
+def _build_names(environment: JobEnvironment) -> Dict[str, Any]:
+    tasks_ctx = {
+        step: {"outputs": outputs}
+        for step, outputs in environment.outputs.items()
+    }
+    return {
+        "inputs": _Namespace(environment.inputs),
+        "env": _Namespace(_coerce_env(environment.environment)),
+        "tasks": _Namespace(tasks_ctx),
+    }
+
+
+def _contains(collection: Any, item: Any) -> bool:
+    return item in collection
+
+
+def _starts_with(s: str, prefix: str) -> bool:
+    return s.startswith(prefix)
+
+
+def _ends_with(s: str, suffix: str) -> bool:
+    return s.endswith(suffix)
+
+
+def _build_functions(environment: JobEnvironment) -> Dict[str, Any]:
+    return {
+        "contains": _contains,
+        "startsWith": _starts_with,
+        "endsWith": _ends_with,
+        "success": lambda: not environment.job_failed,
+        "failure": lambda: environment.job_failed,
+        "always": lambda: True,
+        "never": lambda: False,
+    }
+
+
+def evaluate(expr: str, environment: JobEnvironment) -> Any:
+    """
+    Evaluate an expression, optionally wrapped in ${{ }}.
+    Returns the typed result.
+    """
+    stripped = expr.strip()
+    m = re.fullmatch(r'\${{\s*(.*?)\s*}}', stripped, re.DOTALL)
+    if m:
+        stripped = m.group(1).strip()
+
+    processed = _preprocess(stripped)
+    names = _build_names(environment)
+    evaluator = EvalWithCompoundTypes(names=names, functions=_build_functions(environment))
+    return evaluator.eval(processed)
+
+
+def evaluate_condition(expr: str, environment: JobEnvironment) -> bool:
+    """
+    Evaluate an expression as a boolean condition.
+    """
+    try:
+        result = evaluate(expr, environment)
+        return bool(result)
+    except (InvalidExpression, Exception):
+        return False

{prepare_assignment-0.2.0 → prepare_assignment-0.3.0}/prepare_assignment/core/main.py

@@ -1,7 +1,7 @@
 import logging
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Dict, Optional
 
 from prepare_toolbox.file import get_matching_files
 
@@ -9,7 +9,7 @@ from prepare_assignment.core.preparer import prepare_tasks
 from prepare_assignment.core.runner import run
 from prepare_assignment.core.validator import validate_prepare
 from prepare_assignment.data.constants import CONFIG
-from prepare_assignment.data.errors import PrepareTaskError, PrepareError
+from prepare_assignment.data.errors import PrepareTaskError, PrepareError, TaskExecutionError
 from prepare_assignment.data.prepare import Prepare
 from prepare_assignment.utils.logger import add_logging_level, set_logger_level
 from prepare_assignment.utils.yml_loader import YAML_LOADER
@@ -40,7 +40,8 @@ def __get_prepare_file(file: Optional[str]) -> str:
     return file
 
 
-def prepare(file_name: Optional[str]) -> None:
+def prepare(file_name: Optional[str], env_vars: Optional[Dict[str, str]] = None) -> None:
+    env_vars = env_vars or {}
     # Set the logger
     add_logging_level("TRACE", logging.DEBUG - 5, "trace")
     logger = logging.getLogger("prepare_assignment")
@@ -68,12 +69,17 @@ def prepare(file_name: Optional[str]) -> None:
         prepare = Prepare.of(yaml)
 
         # Execute
-        run(prepare, mapping)
+        run(prepare, mapping, env_vars)
+    except TaskExecutionError as e:
+        logger.error(e.message)
+        raise
     except PrepareTaskError as PE:
         logger.error(PE.message)
         if isinstance(PE.cause, PrepareError):
             logger.error(PE.cause.message)
         else:
             logger.error(str(PE.cause))
+        raise
     except Exception as e:
-        logger.error(str(e))
+        logger.error(str(e))
+        raise