dyngle 1.3.3__py3-none-any.whl → 1.4.0__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,32 @@ 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:
+                full_filename = Path(filename).expanduser()
+                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/run_command.py

@@ -25,7 +25,7 @@ class RunCommand(DyngleCommand):
 
     def handle_vals(self):
         super().handle_vals()
-        keys = self.app.operations.keys()
+        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:
@@ -37,7 +37,6 @@ class RunCommand(DyngleCommand):
     def execute(self):
         data_string = self.app.stream.text
         data = safe_load(data_string) or {}
-        data['args'] = self.args
-        operation = self.app.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/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,25 @@ 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
+        operation_key = definition['sub']
+        self.operation = self.dyngleverse.operations.get(operation_key)
+        if not self.operation:
+            raise DyngleError(f"Unknown operation {operation_key}")
+        self.args_template = definition.get('args') or ''
+
+    def run(self, live_data: LiveData):
+        args = [Template(word).render(live_data).strip()
+                for word in self.args_template]
+        self.operation.run(live_data, args)

{dyngle-1.3.3.dist-info → dyngle-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dyngle
-Version: 1.3.3
+Version: 1.4.0
 Summary: Run lightweight local workflows
 License: MIT
 Author: Steampunk Wizard

{dyngle-1.3.3.dist-info → dyngle-1.4.0.dist-info}/RECORD

@@ -1,16 +1,17 @@
-dyngle/__init__.py,sha256=ZSBChSHOOTW68vZ-2q4ts8VhmEJ5hssG45jhbTTMvk0,2919
+dyngle/__init__.py,sha256=29WRau3q4WjHFo_Zak3Ud0izH7uvmnzYONDzi7Kn90E,1945
 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=ze3gsOUWX7XqL5_WiDQcKG1WTH5-gBNPpwhyb6fsVX4,1457
+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=nSz-8Eh03xAvQlc6Wzn56t-dMArp9uJWY_8XJJZEIwc,1743
+dyngle/model/operation.py,sha256=kvJKcrqOYYf7d2U9UuIT7Rgpg6GXhYhoyPe8miR3u4I,4404
 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.3.dist-info/METADATA,sha256=Z8aRd8CpmgSGImJoyPmFJMakhjE6NffTsMPz3gaWhow,9711
-dyngle-1.3.3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-dyngle-1.3.3.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
-dyngle-1.3.3.dist-info/RECORD,,
+dyngle-1.4.0.dist-info/METADATA,sha256=P7Hcvdhb4jEnnWfytfaJbvzu2Y2LUMYRyDnH5M9EdTM,9711
+dyngle-1.4.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dyngle-1.4.0.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
+dyngle-1.4.0.dist-info/RECORD,,