dyngle 1.3.3__tar.gz → 1.4.0__tar.gz

{dyngle-1.3.3 → dyngle-1.4.0}/PKG-INFO

@@ -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.4.0/dyngle/__init__.py

@@ -0,0 +1,50 @@
+from functools import cached_property
+from pathlib import Path
+from wizlib.app import WizApp
+from wizlib.stream_handler import StreamHandler
+from wizlib.config_handler import ConfigHandler
+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
+
+
+class DyngleApp(WizApp):
+
+    base = DyngleCommand
+    name = 'dyngle'
+    handlers = [StreamHandler, ConfigHandler, UIHandler]
+
+    @property
+    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))
+        return confs

{dyngle-1.3.3 → dyngle-1.4.0}/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-1.4.0/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-1.4.0/dyngle/model/operation.py

@@ -0,0 +1,126 @@
+from dataclasses import dataclass
+from functools import cached_property
+import re
+import shlex
+import subprocess
+
+from dyngle.error import DyngleError
+from dyngle.model.live_data import LiveData
+from dyngle.model.template import Template
+
+
+class Operation:
+    """A named operation defined in configuration. Can be called from a Dyngle
+    command (i.e. `dyngle run`) or as a sub-operation."""
+
+    all_locals = {}
+
+    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 | 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)
+
+
+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 __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)
+
+
+class Step:
+
+    @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:
+
+    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()
+                   for word in self.command_template]
+        pipes = {}
+        if self.input:
+            pipes["input"] = live_data.resolve(self.input)
+        if self.output:
+            pipes['stdout'] = subprocess.PIPE
+        result = subprocess.run(command, text=True, **pipes)
+        if result.returncode != 0:
+            raise DyngleError(
+                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 → dyngle-1.4.0}/pyproject.toml

@@ -8,7 +8,7 @@ description = "Run lightweight local workflows"
 authors = ["Steampunk Wizard <dyngle@steamwiz.io>"]
 license = "MIT"
 readme = "PACKAGE.md"
-version = "1.3.3"
+version = "1.4.0"
 
 [tool.poetry.dependencies]
 python = "^3.13"

dyngle-1.3.3/dyngle/__init__.py

@@ -1,79 +0,0 @@
-from functools import cached_property
-from pathlib import Path
-from wizlib.app import WizApp
-from wizlib.stream_handler import StreamHandler
-from wizlib.config_handler import ConfigHandler
-from wizlib.ui_handler import UIHandler
-
-from dyngle.command import DyngleCommand
-from dyngle.error import DyngleError
-from dyngle.model.expression import expression
-from dyngle.model.operation import Operation
-from dyngle.model.template import Template
-
-
-class DyngleApp(WizApp):
-
-    base = DyngleCommand
-    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()
-                    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 {}

dyngle-1.3.3/dyngle/model/operation.py

@@ -1,62 +0,0 @@
-from dataclasses import dataclass
-from functools import cached_property
-import re
-import shlex
-import subprocess
-
-from dyngle.error import DyngleError
-from dyngle.model.live_data import LiveData
-from dyngle.model.template import Template
-
-
-@dataclass
-class Operation:
-
-    # Expressions and values defined within the operation
-    locals: dict
-
-    steps: list
-
-    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)
-
-
-STEP_PATTERN = re.compile(
-    r'^\s*(?:([\w.-]+)\s+->\s+)?(.+?)(?:\s+=>\s+([\w.-]+))?\s*$')
-
-
-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}}")
-
-
-@dataclass
-class Step:
-
-    markup: str
-
-    def __post_init__(self):
-        self.input, self.command_template, self.output = \
-            parse_step(self.markup)
-
-    def run(self, live_data: LiveData):
-        command = [Template(word).render(live_data).strip()
-                   for word in self.command_template]
-        pipes = {}
-        if self.input:
-            pipes["input"] = live_data.resolve(self.input)
-        if self.output:
-            pipes['stdout'] = subprocess.PIPE
-        result = subprocess.run(command, text=True, **pipes)
-        if result.returncode != 0:
-            raise DyngleError(
-                f'Step failed with code {result.returncode}: {self.markup}')
-        if self.output:
-            live_data[self.output] = result.stdout.rstrip()