groundhog-hpc 0.5.7__tar.gz → 0.7.1__tar.gz

{groundhog_hpc-0.5.7 → groundhog_hpc-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: groundhog-hpc
-Version: 0.5.7
+Version: 0.7.1
 Summary: Iterative HPC function development. As many 'first tries' as you need.
 Author-email: Owen Price Skelly <OwenPriceSkelly@uchicago.edu>
 License: MIT

{groundhog_hpc-0.5.7 → groundhog_hpc-0.7.1}/src/groundhog_hpc/app/main.py

@@ -16,7 +16,11 @@ from groundhog_hpc.app.run import run
 
 app = typer.Typer(pretty_exceptions_show_locals=False)
 
-app.command(no_args_is_help=True)(run)
+# Enable extra args for run command to capture harness arguments after --
+app.command(
+    no_args_is_help=True,
+    context_settings={"allow_extra_args": True, "allow_interspersed_args": False},
+)(run)
 app.command(no_args_is_help=True)(init)
 app.command(no_args_is_help=True)(add)
 app.command(no_args_is_help=True)(remove)

{groundhog_hpc-0.5.7 → groundhog_hpc-0.7.1}/src/groundhog_hpc/app/run.py

@@ -1,8 +1,10 @@
 """Run command for executing Groundhog scripts on Globus Compute endpoints."""
 
+import inspect
 import os
 import sys
 from pathlib import Path
+from typing import Any
 
 import typer
 
@@ -21,7 +23,38 @@ from groundhog_hpc.utils import (
 )
 
 
+def invoke_harness_with_args(harness: Harness, args: list[str]) -> Any:
+    """Parse CLI args and invoke harness function.
+
+    Reproduces typer.run() logic but with explicit args and standalone_mode=False
+    to capture return values and exceptions instead of sys.exit().
+
+    Args:
+        harness: The harness to invoke
+        args: CLI arguments to parse (e.g., ["arg1", "--count=5"])
+
+    Returns:
+        The return value from the harness function
+
+    Raises:
+        SystemExit: If argument parsing fails (from Click/Typer)
+        Any exception raised by the harness function
+    """
+    original_argv = sys.argv
+    # Use harness name for better help/error messages
+    sys.argv = [harness.func.__name__] + args
+
+    try:
+        app = typer.Typer(add_completion=False)
+        app.command()(harness.func)
+        result = app(standalone_mode=False)
+        return result
+    finally:
+        sys.argv = original_argv
+
+
 def run(
+    ctx: typer.Context,
     script: Path = typer.Argument(
         ..., help="Path to script with PEP 723 dependencies to deploy to the endpoint"
     ),
@@ -39,7 +72,20 @@ def run(
         help="Set logging level (DEBUG, INFO, WARNING, ERROR)\n\n[env: GROUNDHOG_LOG_LEVEL=]",
     ),
 ) -> None:
-    """Run a Python script on a Globus Compute endpoint."""
+    """Run a Python script on a Globus Compute endpoint.
+
+    Use -- to pass arguments to parameterized harnesses:
+        hog run script.py harness -- arg1 --option=value
+    """
+    # Handle the -- separator for harness arguments
+    # ctx.args may contain ['--', 'arg1', 'arg2'] - strip the '--' if present
+    harness_args = ctx.args  # List of extra args, or empty list
+    if harness_args and harness_args[0] == "--":
+        harness_args = harness_args[1:]  # Strip leading '--'
+    if harness == "--":
+        # User typed: hog run script.py -- args
+        # Use default harness "main" and shift args
+        harness = "main"
     if no_fun_allowed:
         os.environ["GROUNDHOG_NO_FUN_ALLOWED"] = str(no_fun_allowed)
 
@@ -98,7 +144,18 @@ def run(
             )
             raise typer.Exit(1)
 
-        result = harness_func()
+        # Dispatch based on whether harness arguments were provided
+        if not harness_args:
+            # No extra args: zero-arg call (backward compatible)
+            result = harness_func()
+        else:
+            # Has extra args: parse and invoke parameterized harness
+            sig = inspect.signature(harness_func.func)
+            if len(sig.parameters) == 0:
+                typer.echo(f"Error: Harness '{harness}' takes no arguments", err=True)
+                raise typer.Exit(1)
+            result = invoke_harness_with_args(harness_func, harness_args)
+
         typer.echo(result)
     except RemoteExecutionError as e:
         if e.returncode == 124:

{groundhog_hpc-0.5.7 → groundhog_hpc-0.7.1}/src/groundhog_hpc/decorators.py

@@ -20,22 +20,36 @@ logger = logging.getLogger(__name__)
 def harness() -> Callable[[FunctionType], Harness]:
     """Decorator to mark a function as a local orchestrator harness.
 
+    Harness functions are entry points that coordinate remote function calls.
+    They run locally and can accept parameters passed as CLI arguments.
+
     Harness functions:
 
-    - Must be called via the CLI: `hog run script.py harness_name`
-    - Cannot accept any arguments
+    - Are invoked via the CLI: `hog run script.py [harness_name]`
+    - Can accept parameters, which map to CLI arguments
     - Can call `.remote()` or `.submit()` on `@hog.function`-decorated functions
 
     Returns:
         A decorator function that wraps the harness
 
     Example:
+        Zero-argument harness:
         ```python
         @hog.harness()
         def main():
             result = my_function.remote("far out, man!")
             return result
         ```
+
+        Parameterized harness:
+        ```python
+        @hog.harness()
+        def train(dataset: str, epochs: int = 10):
+            result = train_model.remote(dataset, epochs)
+            return result
+        ```
+
+        Run with: `hog run script.py train -- my_data --epochs=20`
     """
 
     def decorator(func: FunctionType) -> Harness:

groundhog_hpc-0.7.1/src/groundhog_hpc/harness.py

@@ -0,0 +1,44 @@
+"""Harness wrapper for orchestrating remote function execution.
+
+This module provides the Harness class, which wraps entry point functions that
+orchestrate calls to remote @hog.function decorated functions. Harnesses can
+accept parameters which are parsed from CLI arguments via `hog run`.
+"""
+
+import inspect
+from types import FunctionType
+from typing import Any
+
+
+class Harness:
+    """Wrapper for an orchestrator function.
+
+    Harness functions are entry points that typically coordinate calls to
+    @hog.function decorated functions. They can accept parameters that are
+    parsed from CLI arguments when invoked via `hog run script.py -- args`.
+
+    Attributes:
+        func: The wrapped orchestrator function
+        signature: The function's signature for CLI argument parsing
+    """
+
+    def __init__(self, func: FunctionType):
+        """Initialize a Harness wrapper.
+
+        Args:
+            func: The orchestrator function to wrap
+        """
+        self.func: FunctionType = func
+        self.signature: inspect.Signature = inspect.signature(func)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Execute the harness function with optional arguments.
+
+        Args:
+            *args: Positional arguments to pass to the harness function
+            **kwargs: Keyword arguments to pass to the harness function
+
+        Returns:
+            The result of the harness function execution
+        """
+        return self.func(*args, **kwargs)

{groundhog_hpc-0.5.7 → groundhog_hpc-0.7.1}/src/groundhog_hpc/templates/shell_command.sh.jinja

@@ -37,10 +37,12 @@ mkdir -p "$UV_CACHE_DIR" "$UV_PYTHON_INSTALL_DIR"
 {% if log_level %}
 # Local override - use value from dispatching environment
 export GROUNDHOG_LOG_LEVEL="{{ log_level }}"
+export RUST_LOG=uv="${{GROUNDHOG_LOG_LEVEL}}"
 {% else %}
 {% raw %}
 # Respect remote environment if set, otherwise default to WARNING
 export GROUNDHOG_LOG_LEVEL="${{GROUNDHOG_LOG_LEVEL:-WARNING}}"
+export RUST_LOG=uv="${{GROUNDHOG_LOG_LEVEL:-WARNING}}"
 {% endraw %}
 {% endif %}
 
@@ -57,6 +59,7 @@ cat > {{ script_name }}.in << 'PAYLOAD_EOF'
 PAYLOAD_EOF
 
 "$UV_BIN" run --with {{ version_spec }} \
+  --exclude-newer-package groundhog-hpc={{ groundhog_timestamp }} \
   {{ runner_name }}.py
 
 echo "__GROUNDHOG_RESULT__"

{groundhog_hpc-0.5.7 → groundhog_hpc-0.7.1}/src/groundhog_hpc/templating.py

@@ -10,6 +10,7 @@ user functions remotely. It creates shell commands that:
 import logging
 import os
 import uuid
+from datetime import datetime, timezone
 from hashlib import sha1
 from pathlib import Path
 
@@ -74,6 +75,10 @@ def template_shell_command(script_path: str, function_name: str, payload: str) -
     version_spec = get_groundhog_version_spec()
     logger.debug(f"Using groundhog version spec: {version_spec}")
 
+    # Generate timestamp for groundhog-hpc exclude-newer override
+    # This allows groundhog to bypass user's exclude-newer restrictions
+    groundhog_timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
     # Load runner template
     templates_dir = Path(__file__).parent / "templates"
     jinja_env = Environment(loader=FileSystemLoader(templates_dir))
@@ -106,6 +111,7 @@ def template_shell_command(script_path: str, function_name: str, payload: str) -
         version_spec=version_spec,
         payload=payload,
         log_level=local_log_level,
+        groundhog_timestamp=groundhog_timestamp,
     )
 
     logger.debug(f"Generated shell command ({len(shell_command_string)} chars)")

groundhog_hpc-0.5.7/src/groundhog_hpc/harness.py

@@ -1,48 +0,0 @@
-"""Harness wrapper for orchestrating remote function execution.
-
-This module provides the Harness class, which wraps zero-argument entry point
-functions that orchestrate calls to remote @hog.function decorated functions.
-"""
-
-import inspect
-from types import FunctionType
-from typing import Any
-
-
-class Harness:
-    """Wrapper for a zero-argument orchestrator function.
-
-    Harness functions are entry points that typically coordinate calls to
-    @hog.function decorated functions. They must not accept any arguments.
-
-    Attributes:
-        func: The wrapped orchestrator function
-    """
-
-    def __init__(self, func: FunctionType):
-        """Initialize a Harness wrapper.
-
-        Args:
-            func: The orchestrator function to wrap
-
-        Raises:
-            TypeError: If the function accepts any arguments
-        """
-        self.func: FunctionType = func
-        self._validate_signature()
-
-    def __call__(self) -> Any:
-        """Execute the harness function.
-
-        Returns:
-            The result of the harness function execution
-        """
-        return self.func()
-
-    def _validate_signature(self) -> None:
-        sig = inspect.signature(self.func)
-        if len(sig.parameters) > 0:
-            raise TypeError(
-                f"Harness function '{self.func.__qualname__}' must not accept any arguments, "
-                f"but has parameters: {list(sig.parameters.keys())}"
-            )