dyngle 0.4.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

dyngle/__init__.py

@@ -1,11 +1,14 @@
 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.expression import expression
+from dyngle.operation import Operation
 
 
 class DyngleApp(WizApp):
@@ -14,10 +17,59 @@ 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()
+                    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 expressions(self):
-        expr_texts = self.config.get('dyngle-expressions')
-        if expr_texts:
-            return {k: expression(t) for k, t in expr_texts.items()}
-        else:
-            return {}
+    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):
+                local_expr_texts = config.get('expressions') or {}
+                local_expressions = _expressions_from_texts(local_expr_texts)
+                steps = config.get('steps') or []
+                operation = Operation(local_expressions, steps)
+            else:
+                raise DyngleError(f"Invalid operation configuration for {key}")
+            operations[key] = operation
+        return operations
+
+    @cached_property
+    def global_expressions(self):
+        expr_texts = self._get_configuration_details('expressions')
+        return _expressions_from_texts(expr_texts)
+
+
+def _expressions_from_texts(expr_texts):
+    if expr_texts:
+        return {k: expression(t) for k, t in expr_texts.items()}
+    else:
+        return {}

dyngle/command/run_command.py

@@ -29,15 +29,17 @@ class RunCommand(DyngleCommand):
         if self.operation not in operations:
             available_operations = ', '.join(operations.keys())
             raise DyngleError(
-                f'Operation "{self.operation}" not found. " + \
-                    f"Available operations: {available_operations}')
+                f"Operation '{self.operation}' not found. " +
+                f"Available operations: {available_operations}")
 
     @DyngleCommand.wrap
     def execute(self):
-        expressions = self.app.expressions
-        operations = self.app.config.get('dyngle-operations')
+        operations = self.app.operations
         self._validate_operation_exists(operations)
-        steps = operations[self.operation]
+        operation = operations[self.operation]
+        steps = operation.steps
+        expressions = self.app.global_expressions | \
+            operation.local_expressions
         data_string = self.app.stream.text
         data = safe_load(data_string) or {}
         data['args'] = self.args

dyngle/operation.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Operation:
+
+    local_expressions: dict
+
+    steps: list

dyngle/template.py

@@ -2,6 +2,8 @@ from dataclasses import dataclass
 from functools import partial
 import re
 
+from dyngle.error import DyngleError
+
 
 PATTERN = re.compile(r'\{\{\s*([^}]+)\s*\}\}')
 
@@ -44,6 +46,9 @@ class Template:
         parts = key.split('.')
         current = live_data
         for part in parts:
+            if part not in current:
+                raise DyngleError(
+                    f"Invalid expression or data reference '{key}")
             current = current[part]
         if callable(current):
             return current(live_data)

{dyngle-0.4.3.dist-info → dyngle-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dyngle
-Version: 0.4.3
+Version: 0.6.0
 Summary: Run lightweight local workflows
 License: MIT
 Author: Steampunk Wizard
@@ -54,6 +54,18 @@ Dyngle reads configuration from YAML files. You can specify the config file loca
 
 The configuration has 2 parts: `operations:` and `expressions`.
 
+Configuration files can import other configuration files, by providing an entry `imports:` with an array of filepaths. The most obvious example is a Dyngle config in a local directory which imports the user-level configuration.
+
+```yaml
+dyngle:
+  imports:
+    - ~/.dyngle.yml
+  expressions:
+  operations:
+```
+
+In the event of item name conflicts, expressions and operations are loaded from imports in the order specified, so imports lower in the array will override those higher up. The expressions and operations defined in the main file override the imports. Imports are not recursive.
+
 ## Data
 
 Dyngle maintains a block of data throughout operations, which is parsed from YAML in stdin.
@@ -143,6 +155,22 @@ dyngle:
         'Hello ' + author_name()
 ``` 
 
+## Local Expressions
+
+Expressions can also be defined in a way that applies only to one operation - especially useful for command-line arguments.
+
+In this case, the operation definition has a different structure. See the example below.
+
+```yaml
+dyngle:
+  operations:
+    name_from_arg:
+      expressions:
+        local_name: "args[0]"
+      steps:
+        - echo "Hello {{local_name}}"
+```
+
 ## Security
 
 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-0.6.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+dyngle/__init__.py,sha256=kCFjx6sIuf0hiuH2C4QyHIaC9DY6YKudvkiiziFybgk,2716
+dyngle/__main__.py,sha256=pYRIwzix_AL8CdJaDDis_8yMBBWO2N72NNwkroo1dQo,95
+dyngle/command/__init__.py,sha256=1S86gbef8MYvG-TWD5JRIWzFg7qV5xKhp9QXx9zEx5c,94
+dyngle/command/run_command.py,sha256=s6hR4PHBXbZ9pfQ-thVmpcvSW5DP5rwSpz3aginaPJ8,1914
+dyngle/error.py,sha256=CGcTa8L4O1qsHEYnzp_JBbkvntJTv2Qz46wj_TI8NLk,39
+dyngle/expression.py,sha256=-uLVbrO8ovNZGGLNqMZWIy_StCK-0laZqcQ1gOPhU6w,3476
+dyngle/operation.py,sha256=QCAUH2YAYq9dtCO49F_irWgIWxBDaxyDv4X7Xen04Jo,110
+dyngle/safe_path.py,sha256=Hk2AhP6e3yKGh3kKrLLwhvAlMNx-j2jObBYJL-_doAU,3339
+dyngle/template.py,sha256=AbgGCVi9B0K_SY_0BO0Q8vbFNvFM0aYAVBJoOE4N_pE,1612
+dyngle-0.6.0.dist-info/METADATA,sha256=r511S0EBtCDb5SdfP6V8kuhcGYaAF1sxKfRSewmyt14,5524
+dyngle-0.6.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+dyngle-0.6.0.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
+dyngle-0.6.0.dist-info/RECORD,,

dyngle-0.4.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-dyngle/__init__.py,sha256=drqd18F3T7LMTNqAU38WYjanczl1kANAA1vVBjbPEyU,653
-dyngle/__main__.py,sha256=pYRIwzix_AL8CdJaDDis_8yMBBWO2N72NNwkroo1dQo,95
-dyngle/command/__init__.py,sha256=1S86gbef8MYvG-TWD5JRIWzFg7qV5xKhp9QXx9zEx5c,94
-dyngle/command/run_command.py,sha256=fgso_ZadAkA0f1ZjSGAUHs32hCHnX3QE_abnAmvg77g,1854
-dyngle/error.py,sha256=CGcTa8L4O1qsHEYnzp_JBbkvntJTv2Qz46wj_TI8NLk,39
-dyngle/expression.py,sha256=-uLVbrO8ovNZGGLNqMZWIy_StCK-0laZqcQ1gOPhU6w,3476
-dyngle/safe_path.py,sha256=Hk2AhP6e3yKGh3kKrLLwhvAlMNx-j2jObBYJL-_doAU,3339
-dyngle/template.py,sha256=XM5VtOiuMVzNjMTsUdMMfugiygcOuAh-8MedfhEbGn0,1435
-dyngle-0.4.3.dist-info/METADATA,sha256=RpCvS1bRIN-Xcdyw2VIJ7j-zm-BAEVokemfUh52bpr0,4544
-dyngle-0.4.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-dyngle-0.4.3.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
-dyngle-0.4.3.dist-info/RECORD,,