hpcflow-new2 0.2.0a163__py3-none-any.whl → 0.2.0a166__py3-none-any.whl

hpcflow/_version.py

@@ -1 +1 @@
-__version__ = "0.2.0a163"
+__version__ = "0.2.0a166"

hpcflow/sdk/core/actions.py

@@ -141,6 +141,7 @@ class ElementActionRun:
         element_action,
         index: int,
         data_idx: Dict,
+        commands_idx: List[int],
         start_time: Union[datetime, None],
         end_time: Union[datetime, None],
         snapshot_start: Union[Dict, None],
@@ -157,6 +158,7 @@ class ElementActionRun:
         self._element_action = element_action
         self._index = index  # local index of this run with the action
         self._data_idx = data_idx
+        self._commands_idx = commands_idx
         self._start_time = start_time
         self._end_time = end_time
         self._submission_idx = submission_idx
@@ -222,6 +224,10 @@ class ElementActionRun:
     def data_idx(self):
         return self._data_idx
 
+    @property
+    def commands_idx(self):
+        return self._commands_idx
+
     @property
     def metadata(self):
         return self._metadata
@@ -715,11 +721,13 @@ class ElementActionRun:
 
         shell_vars = {}  # keys are cmd_idx, each value is a list of tuples
         for cmd_idx, command in enumerate(self.action.commands):
-            cmd_str, shell_vars_i = command.get_command_line(
-                EAR=self, shell=jobscript.shell, env=env
-            )
-            shell_vars[cmd_idx] = shell_vars_i
-            command_lns.append(cmd_str)
+            if cmd_idx in self.commands_idx:
+                # only execute commands that have no rules, or all valid rules:
+                cmd_str, shell_vars_i = command.get_command_line(
+                    EAR=self, shell=jobscript.shell, env=env
+                )
+                shell_vars[cmd_idx] = shell_vars_i
+                command_lns.append(cmd_str)
 
         commands = "\n".join(command_lns) + "\n"
 
@@ -1025,6 +1033,7 @@ class ActionRule(JSONLike):
 
         self.rule = rule
         self.action = None  # assigned by parent action
+        self.command = None  # assigned by parent command
 
     def __eq__(self, other):
         if type(other) is not self.__class__:
@@ -1958,9 +1967,17 @@ class Action(JSONLike):
                 return True
 
     @TimeIt.decorator
-    def test_rules(self, element_iter) -> List[bool]:
+    def test_rules(self, element_iter) -> Tuple[bool, List[int]]:
         """Test all rules against the specified element iteration."""
-        return [i.test(element_iteration=element_iter) for i in self.rules]
+        rules_valid = [rule.test(element_iteration=element_iter) for rule in self.rules]
+        action_valid = all(rules_valid)
+        commands_idx = []
+        if action_valid:
+            for cmd_idx, cmd in enumerate(self.commands):
+                if any(not i.test(element_iteration=element_iter) for i in cmd.rules):
+                    continue
+                commands_idx.append(cmd_idx)
+        return action_valid, commands_idx
 
     def get_required_executables(self) -> Tuple[str]:
         """Return executable labels required by this action."""

hpcflow/sdk/core/commands.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from functools import partial
 from pathlib import Path
 import re
@@ -6,15 +6,24 @@ from typing import Dict, Iterable, List, Optional, Tuple, Union
 
 import numpy as np
 
+from hpcflow.sdk import app
 from hpcflow.sdk.core.element import ElementResources
 from hpcflow.sdk.core.errors import NoCLIFormatMethodError
-from hpcflow.sdk.core.json_like import JSONLike
+from hpcflow.sdk.core.json_like import ChildObjectSpec, JSONLike
 from hpcflow.sdk.core.parameters import ParameterValue
 
 
 @dataclass
 class Command(JSONLike):
     _app_attr = "app"
+    _child_objects = (
+        ChildObjectSpec(
+            name="rules",
+            class_name="ActionRule",
+            is_multiple=True,
+            parent_ref="command",
+        ),
+    )
 
     command: Optional[str] = None
     executable: Optional[str] = None
@@ -23,6 +32,7 @@ class Command(JSONLike):
     stdout: Optional[str] = None
     stderr: Optional[str] = None
     stdin: Optional[str] = None
+    rules: Optional[List[app.ActionRule]] = field(default_factory=lambda: [])
 
     def __repr__(self) -> str:
         out = []
@@ -40,6 +50,8 @@ class Command(JSONLike):
             out.append(f"stderr={self.stderr!r}")
         if self.stdin:
             out.append(f"stdin={self.stdin!r}")
+        if self.rules:
+            out.append(f"rules={self.rules!r}")
 
         return f"{self.__class__.__name__}({', '.join(out)})"
 

hpcflow/sdk/core/errors.py

@@ -55,6 +55,18 @@ class ExtraInputs(Exception):
         super().__init__(message)
 
 
+class UnavailableInputSource(ValueError):
+    pass
+
+
+class InapplicableInputSourceElementIters(ValueError):
+    pass
+
+
+class NoCoincidentInputSources(ValueError):
+    pass
+
+
 class TaskTemplateInvalidNesting(ValueError):
     pass
 
@@ -131,6 +143,10 @@ class MalformedParameterPathError(ValueError):
     pass
 
 
+class MalformedNestingOrderPath(ValueError):
+    pass
+
+
 class UnknownResourceSpecItemError(ValueError):
     pass
 

hpcflow/sdk/core/parameters.py

@@ -869,6 +869,11 @@ class ValueSequence(JSONLike):
             vals = (vals.T).tolist()
         return vals
 
+    @classmethod
+    def _values_from_random_uniform(cls, num, low=0.0, high=1.0, seed=None):
+        rng = np.random.default_rng(seed)
+        return rng.uniform(low=low, high=high, size=num).tolist()
+
     @classmethod
     def from_linear_space(
         cls,
@@ -1027,6 +1032,25 @@ class ValueSequence(JSONLike):
         obj._values_method_args = args
         return obj
 
+    @classmethod
+    def from_random_uniform(
+        cls,
+        path,
+        num,
+        low=0.0,
+        high=1.0,
+        seed=None,
+        nesting_order=0,
+        label=None,
+        **kwargs,
+    ):
+        args = {"low": low, "high": high, "num": num, "seed": seed, **kwargs}
+        values = cls._values_from_random_uniform(**args)
+        obj = cls(values=values, path=path, nesting_order=nesting_order, label=label)
+        obj._values_method = "from_random_uniform"
+        obj._values_method_args = args
+        return obj
+
 
 @dataclass
 class AbstractInputValue(JSONLike):
@@ -1793,7 +1817,7 @@ class InputSource(JSONLike):
                 f"task_source_type={self.task_source_type.name.lower()!r}",
             )
 
-        if self.element_iters:
+        if self.element_iters is not None:
             args_lst.append(f"element_iters={self.element_iters}")
 
         if self.where is not None:
@@ -1831,7 +1855,7 @@ class InputSource(JSONLike):
         out = [self.source_type.name.lower()]
         if self.source_type is InputSourceType.TASK:
             out += [str(self.task_ref), self.task_source_type.name.lower()]
-            if self.element_iters:
+            if self.element_iters is not None:
                 out += ["[" + ",".join(f"{i}" for i in self.element_iters) + "]"]
         elif self.source_type is InputSourceType.IMPORT:
             out += [str(self.import_ref)]