dyngle 1.3.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

dyngle/__init__.py

@@ -7,6 +7,7 @@ from wizlib.ui_handler import UIHandler
 
 from dyngle.command import DyngleCommand
 from dyngle.error import DyngleError
+from dyngle.model.dyngleverse import Dyngleverse
 from dyngle.model.expression import expression
 from dyngle.model.operation import Operation
 from dyngle.model.template import Template
@@ -18,62 +19,39 @@ class DyngleApp(WizApp):
     name = 'dyngle'
     handlers = [StreamHandler, ConfigHandler, UIHandler]
 
-    # For possible upstreaming to WizLib, a mechanism to "import" configuration
-    # settings from external files.
-
     @property
-    def _imported_configrations(self):
-        if not hasattr(self, '__imported_configurations'):
-            imports = self.config.get('dyngle-imports')
-            confs = []
-            if imports:
-                for filename in imports:
-                    full_filename = Path(filename).expanduser()
+    def dyngleverse(self):
+        """Offload the indexing of operation and expression definitions to
+        another class. But we keep import handling here in the app because we
+        might want to upstream import/include to WizLib at some point."""
+
+        if not hasattr(self, '_dyngleverse'):
+            self._dyngleverse = Dyngleverse()
+            imports = self._get_imports(self.config, [])
+            for imported_config in imports:
+                definitions = imported_config.get('dyngle')
+                self._dyngleverse.load_config(definitions)
+            self._dyngleverse.load_config(self.config.get('dyngle'))
+        return self._dyngleverse
+
+    def _get_imports(self,
+                     config_handler: ConfigHandler,
+                     no_loops: list) -> dict:
+        imports = config_handler.get('dyngle-imports')
+        confs = []
+        if imports:
+            for filename in imports:
+                import_path = Path(filename).expanduser()
+                # If the path is relative, resolve it relative to the importing
+                # config file
+                if not import_path.is_absolute() and config_handler.file:
+                    config_dir = Path(config_handler.file).parent
+                    full_filename = (config_dir / import_path).resolve()
+                else:
+                    full_filename = import_path
+                if full_filename not in no_loops:
+                    no_loops.append(full_filename)
+                    child_handler = ConfigHandler(full_filename)
+                    confs += self._get_imports(child_handler, no_loops)
                     confs.append(ConfigHandler(full_filename))
-            self.__imported_configurations = confs
-        return self.__imported_configurations
-
-    def _get_configuration_details(self, type: str):
-        label = f'dyngle-{type}'
-        details = {}
-        for conf in self._imported_configrations:
-            if (imported_details := conf.get(label)):
-                details |= imported_details
-        configured_details = self.config.get(label)
-        if configured_details:
-            details |= configured_details
-        return details
-
-    @cached_property
-    def operations(self):
-        operations_configs = self._get_configuration_details('operations')
-        if not operations_configs:
-            raise DyngleError("No operations defined in configuration")
-        operations = {}
-        for key, config in operations_configs.items():
-            if isinstance(config, list):
-                operation = Operation({}, config)
-            elif isinstance(config, dict):
-                expr_texts = config.get('expressions') or {}
-                expressions = _expressions_from_texts(expr_texts)
-                values = config.get('values') or {}
-                steps = config.get('steps') or []
-                operation = Operation(expressions | values, steps)
-            else:
-                raise DyngleError(f"Invalid operation configuration for {key}")
-            operations[key] = operation
-        return operations
-
-    @cached_property
-    def globals(self):
-        expr_texts = self._get_configuration_details('expressions')
-        expressions = _expressions_from_texts(expr_texts)
-        values = self._get_configuration_details('values')
-        return expressions | (values if values else {})
-
-
-def _expressions_from_texts(expr_texts):
-    if expr_texts:
-        return {k: expression(t) for k, t in expr_texts.items()}
-    else:
-        return {}
+        return confs

dyngle/command/__init__.py

@@ -3,4 +3,4 @@ from wizlib.command import WizCommand
 
 class DyngleCommand(WizCommand):
 
-    default = 'run'
+    default = 'null'

dyngle/command/null_command.py

@@ -0,0 +1,6 @@
+from dyngle.command import DyngleCommand
+
+
+class NullCommand(DyngleCommand):
+
+    name = 'null'

dyngle/command/run_command.py

@@ -1,3 +1,4 @@
+from functools import cached_property
 import shlex
 import subprocess
 from wizlib.parser import WizParser
@@ -17,31 +18,25 @@ class RunCommand(DyngleCommand):
     @classmethod
     def add_args(cls, parser: WizParser):
         super().add_args(parser)
-        parser.add_argument('operation', help='Operation name to run')
+        parser.add_argument(
+            'operation', help='Operation name to run', nargs='?')
         parser.add_argument(
             'args', nargs='*', help='Optional operation arguments')
 
     def handle_vals(self):
         super().handle_vals()
-
-    def _validate_operation_exists(self, operations):
-        """Validate that the requested operation exists in configuration"""
-        if self.operation not in operations:
-            available_operations = ', '.join(operations.keys())
-            raise DyngleError(
-                f"Operation '{self.operation}' not found. " +
-                f"Available operations: {available_operations}")
+        keys = self.app.dyngleverse.operations.keys()
+        if not self.provided('operation'):
+            self.operation = self.app.ui.get_text('Operation: ', sorted(keys))
+            if not self.operation:
+                raise DyngleError(f"Operation required.")
+        if self.operation not in keys:
+            raise DyngleError(f"Invalid operation {self.operation}.")
 
     @DyngleCommand.wrap
     def execute(self):
         data_string = self.app.stream.text
         data = safe_load(data_string) or {}
-        data['args'] = self.args
-
-        operations = self.app.operations
-        self._validate_operation_exists(operations)
-        operation = operations[self.operation]
-
-        operation.run(data, self.app.globals)
-
+        operation = self.app.dyngleverse.operations[self.operation]
+        operation.run(data, self.args)
         return f'Operation "{self.operation}" completed successfully'

dyngle/model/dyngleverse.py

@@ -0,0 +1,37 @@
+from functools import cached_property
+
+from dyngle.model.expression import expression
+from dyngle.model.live_data import LiveData
+from dyngle.model.operation import Operation
+
+
+class Dyngleverse:
+    """Represents the entire immutable set of definitions for operations,
+    expresssions, and values. Operates as a sort of index/database."""
+
+    def __init__(self):
+        self.operations = {}
+        self.all_globals = {}
+
+    def load_config(self, config: dict):
+        """
+        Load additional configuration, which will always take higher precedence
+        than previously loaded configuration.
+        """
+        ops_defs = config.get('operations') or {}
+        for key, op_def in ops_defs.items():
+            operation = Operation(self, op_def, key)
+            self.operations[key] = operation
+        self.all_globals |= Dyngleverse.parse_constants(config)
+
+    @staticmethod
+    def parse_constants(definition: dict):
+        """
+        At either the global (dyngleverse) or local (within an operation)
+        level, we might find values and expressions.
+        """
+
+        expr_texts = definition.get('expressions') or {}
+        expressions = {k: expression(t) for k, t in expr_texts.items()}
+        values = definition.get('values') or {}
+        return expressions | values

dyngle/model/expression.py

@@ -130,8 +130,11 @@ def expression(text: str) -> Callable[[dict], str]:
     def definition(live_data: LiveData | dict | None = None) -> str:
         """The expression function itself"""
 
-        # Allow for blankness and testability
-        live_data = LiveData(live_data)
+        # We only work if passed some data to use - also we don't know our name
+        # so can't report it.
+
+        if live_data is None:
+            raise DyngleError('Expression called with no argument')
 
         # Translate names to underscore-separated instead of hyphen-separated
         # so they work within the Python namespace.
@@ -140,11 +143,17 @@ def expression(text: str) -> Callable[[dict], str]:
         locals = LiveData({k.replace('-', '_'): v for k, v in items})
 
         # Create a resolve function which allows references using the hyphen
-        # syntax too
+        # syntax too - note it relies on the original live_data object (not the
+        # locals with the key replacement). We're converting it to LiveData in
+        # case for some reason we were passed a raw dict.
+
+        live_data = LiveData(live_data)
 
         def resolve(key):
             return live_data.resolve(key, str_only=False)
-        locals = locals | {'resolve': resolve}
+
+        # Passing the live_data in again allows function(data) in expressions
+        locals = locals | {'resolve': resolve, 'data': live_data}
 
         # Perform the Python eval, expanded above
         return _evaluate(text, locals)

dyngle/model/operation.py

@@ -9,42 +9,84 @@ from dyngle.model.live_data import LiveData
 from dyngle.model.template import Template
 
 
-@dataclass
 class Operation:
+    """A named operation defined in configuration. Can be called from a Dyngle
+    command (i.e. `dyngle run`) or as a sub-operation."""
 
-    # Expressions and values defined within the operation
-    locals: dict
+    all_locals = {}
 
-    steps: list
+    def __init__(self, dyngleverse, definition: dict | list, key: str):
+        """
+        definition: Either a dict containing steps and local
+        expressions/values, or a list containing only steps
+        """
+        self.dyngleverse = dyngleverse
+        if isinstance(definition, list):
+            steps_def = definition
+        elif isinstance(definition, dict):
+            steps_def = definition.get('steps') or []
+            self.all_locals = dyngleverse.parse_constants(definition)
+        self.sequence = Sequence(dyngleverse, self, steps_def)
 
-    def run(self, data: dict, globals: dict):
-        live_data = LiveData(globals) | self.locals | data
-        for markup in self.steps:
-            step = Step(markup)
-            step.run(live_data)
+    def run(self, data: dict | LiveData, args: list):
+        """
+        data - The main set of data going into the operation
+
+        args - Arguments to the operation
+        """
+
+        # The tye of data tells us the run condition - if already a LiveData
+        # object then we don't recreate it (i.e. sub-operation)
 
+        if not isinstance(data, LiveData):
+            live_data = LiveData(data) | self.dyngleverse.all_globals
+        else:
+            live_data = data
+        live_data |= self.all_locals | {'args': args}
+        self.sequence.run(live_data)
 
-STEP_PATTERN = re.compile(
-    r'^\s*(?:([\w.-]+)\s+->\s+)?(.+?)(?:\s+=>\s+([\w.-]+))?\s*$')
 
+class Sequence:
+    """We allow for the possibility that a sequence of steps might run at other
+    levels than the operation itself, for example in a conditional block."""
 
-def parse_step(markup):
-    if match := STEP_PATTERN.match(markup):
-        input, command_text, output = match.groups()
-        command_template = shlex.split(command_text.strip())
-        return input, command_template, output
-    else:
-        raise DyngleError(f"Invalid step markup {{markup}}")
+    def __init__(self, dyngleverse, operation: Operation, steps_def: list):
+        self.steps = [Step.parse_def(dyngleverse, d) for d in steps_def]
+
+    def run(self, live_data: LiveData):
+        for step in self.steps:
+            step.run(live_data)
 
 
-@dataclass
 class Step:
 
-    markup: str
+    @staticmethod
+    def parse_def(dyngleverse, definition: dict | str):
+        for step_type in [CommandStep, SubOperationStep]:
+            if step_type.fits(definition):
+                return step_type(dyngleverse, definition)
+        raise DyngleError(f"Unknown step definition\n{definition}")
+
+
+# Ideally these would be subclasses in a ClassFamily (or use an ABC)
+
+class CommandStep:
 
-    def __post_init__(self):
-        self.input, self.command_template, self.output = \
-            parse_step(self.markup)
+    PATTERN = re.compile(
+        r'^\s*(?:([\w.-]+)\s+->\s+)?(.+?)(?:\s+=>\s+([\w.-]+))?\s*$')
+
+    @classmethod
+    def fits(cls, definition: dict | str):
+        return isinstance(definition, str)
+
+    def __init__(self, dyngleverse, markup: str):
+        self.markup = markup
+        if match := self.PATTERN.match(markup):
+            self.input, command_text, self.output = match.groups()
+            command_template = shlex.split(command_text.strip())
+            self.command_template = command_template
+        else:
+            raise DyngleError(f"Invalid step markup {{markup}}")
 
     def run(self, live_data: LiveData):
         command = [Template(word).render(live_data).strip()
@@ -60,3 +102,26 @@ class Step:
                 f'Step failed with code {result.returncode}: {self.markup}')
         if self.output:
             live_data[self.output] = result.stdout.rstrip()
+
+
+class SubOperationStep:
+    """Instead of calling a system command, call another operation in the same
+    Dyngleverse"""
+
+    @classmethod
+    def fits(cls, definition: dict | str):
+        return isinstance(definition, dict) and 'sub' in definition
+
+    def __init__(self, dyngleverse, definition: dict):
+        self.dyngleverse = dyngleverse
+        self.operation_key = definition['sub']
+        self.args_template = definition.get('args') or ''
+
+    def run(self, live_data: LiveData):
+        # Resolve the operation at runtime, not at init time
+        operation = self.dyngleverse.operations.get(self.operation_key)
+        if not operation:
+            raise DyngleError(f"Unknown operation {self.operation_key}")
+        args = [Template(word).render(live_data).strip()
+                for word in self.args_template]
+        operation.run(live_data, args)

{dyngle-1.3.0.dist-info → dyngle-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dyngle
-Version: 1.3.0
+Version: 1.5.1
 Summary: Run lightweight local workflows
 License: MIT
 Author: Steampunk Wizard
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: wizlib (>=3.3.8,<3.4.0)
+Requires-Dist: wizlib (>=3.3.11,<3.4.0)
 Description-Content-Type: text/markdown
 
 # Dyngle
@@ -245,6 +245,45 @@ dyngle:
 
 If names overlap, data items populated using the data assignment operator take precedence over expressions and data in the original input from the beginning of the Operation.
 
+## Sub-operations
+
+Operations can call other operations as steps using the `sub:` key. This allows for composability and reuse of operation logic.
+
+Basic example:
+
+```yaml
+dyngle:
+  operations:
+    greet:
+      - echo "Hello!"
+    
+    greet-twice:
+      steps:
+        - sub: greet
+        - sub: greet
+```
+
+Sub-operations can accept arguments using the `args:` key. The called operation can access these via the `args` array in expressions:
+
+```yaml
+dyngle:
+  operations:
+    greet-person:
+      expressions:
+        person: "args[0]"
+      steps:
+        - echo "Hello, {{person}}!"
+    
+    greet-team:
+      steps:
+        - sub: greet-person
+          args: ['Alice']
+        - sub: greet-person
+          args: ['Bob']
+```
+
+Sub-operations share the same Live Data context, so data assignments and expressions from the parent operation are available to the sub-operation, and any data populated by the sub-operation is available to subsequent steps in the parent.
+
 ## Lifecycle
 
 The lifecycle of an operation is:
@@ -275,4 +314,3 @@ In the event of item name conflicts, expressions and operations are loaded from
 
 Commands are executed using Python's `subprocess.run()` with arguments split in a shell-like fashion. The shell is not used, which reduces the likelihood of shell injection attacks. However, note that Dyngle is not robust to malicious configuration. Use with caution.
 
-

dyngle-1.5.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+dyngle/__init__.py,sha256=BxgXnQ_cyEuZiMpkv-zkDCTRs9UP8vZsKX2kWeZj_Ck,2336
+dyngle/__main__.py,sha256=pYRIwzix_AL8CdJaDDis_8yMBBWO2N72NNwkroo1dQo,95
+dyngle/command/__init__.py,sha256=ngNOb_k9COcXOs7It3HoFJRW0hzBDpAzxXcGUy6hhko,95
+dyngle/command/null_command.py,sha256=OX1u0z4zjlquxuV0_yu7uE1_K2Lk523WydJu-0Z82QE,96
+dyngle/command/run_command.py,sha256=YOYuTzR1l2t24G1Z2uLjl1Ya1unvE4lHWpaOopMO1Tg,1441
+dyngle/error.py,sha256=CGcTa8L4O1qsHEYnzp_JBbkvntJTv2Qz46wj_TI8NLk,39
+dyngle/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dyngle/model/dyngleverse.py,sha256=tFzx4AhPalODknPqbuFcR4G7QF1VOPlAAy2VDPfRmTA,1301
+dyngle/model/expression.py,sha256=XvHlWqnN-4gkN4ck5iTuwP3OqXXbRzTwIRTX0lzJAdY,4889
+dyngle/model/live_data.py,sha256=FxbMjfaiBIUorEbhRx5I0o-WAFFWdjYaqzw_zhFq86w,1251
+dyngle/model/operation.py,sha256=IrLx6iDZ2_D7384qKsjpS7VBrHqTsSmsOWw_lJFWimI,4465
+dyngle/model/safe_path.py,sha256=Hk2AhP6e3yKGh3kKrLLwhvAlMNx-j2jObBYJL-_doAU,3339
+dyngle/model/template.py,sha256=MeXu--ZNtj_ujABU1GjjcQ1Ea_o_M-50LocuXFeOLRE,887
+dyngle-1.5.1.dist-info/METADATA,sha256=kdyZXIVC7aEXcVvN9gMLweEfpqvh3nlkB2LVSGX-QmQ,10681
+dyngle-1.5.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dyngle-1.5.1.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
+dyngle-1.5.1.dist-info/RECORD,,

dyngle-1.3.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-dyngle/__init__.py,sha256=ZSBChSHOOTW68vZ-2q4ts8VhmEJ5hssG45jhbTTMvk0,2919
-dyngle/__main__.py,sha256=pYRIwzix_AL8CdJaDDis_8yMBBWO2N72NNwkroo1dQo,95
-dyngle/command/__init__.py,sha256=1S86gbef8MYvG-TWD5JRIWzFg7qV5xKhp9QXx9zEx5c,94
-dyngle/command/run_command.py,sha256=gYTQjATRMu_81HLP-hrMz7GNw9Lcz2VjuhP7h_qYLcE,1514
-dyngle/error.py,sha256=CGcTa8L4O1qsHEYnzp_JBbkvntJTv2Qz46wj_TI8NLk,39
-dyngle/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dyngle/model/expression.py,sha256=9nwfahjOHtScjdDzjwWIleo60lJjtXGrPGfroCbslvg,4431
-dyngle/model/live_data.py,sha256=FxbMjfaiBIUorEbhRx5I0o-WAFFWdjYaqzw_zhFq86w,1251
-dyngle/model/operation.py,sha256=nSz-8Eh03xAvQlc6Wzn56t-dMArp9uJWY_8XJJZEIwc,1743
-dyngle/model/safe_path.py,sha256=Hk2AhP6e3yKGh3kKrLLwhvAlMNx-j2jObBYJL-_doAU,3339
-dyngle/model/template.py,sha256=MeXu--ZNtj_ujABU1GjjcQ1Ea_o_M-50LocuXFeOLRE,887
-dyngle-1.3.0.dist-info/METADATA,sha256=LcfQLPcClIK9_TOWRUHGJ4nt7GN8SMtvqkQSqxDQaFg,9710
-dyngle-1.3.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-dyngle-1.3.0.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
-dyngle-1.3.0.dist-info/RECORD,,