dyngle 0.5.0__tar.gz → 0.6.0__tar.gz

{dyngle-0.5.0 → dyngle-0.6.0}/PACKAGE.md

@@ -39,6 +39,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.
@@ -128,6 +140,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.5.0 → dyngle-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dyngle
-Version: 0.5.0
+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.5.0 → dyngle-0.6.0}/dyngle/__init__.py

@@ -8,6 +8,7 @@ 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):
@@ -44,15 +45,31 @@ class DyngleApp(WizApp):
 
     @cached_property
     def operations(self):
-        operations = self._get_configuration_details('operations')
-        if not operations:
-            raise DyngleError("No operations defined")
+        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 expressions(self):
+    def global_expressions(self):
         expr_texts = self._get_configuration_details('expressions')
-        if expr_texts:
-            return {k: expression(t) for k, t in expr_texts.items()}
-        else:
-            return {}
+        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-0.5.0 → dyngle-0.6.0}/dyngle/command/run_command.py

@@ -34,10 +34,12 @@ class RunCommand(DyngleCommand):
 
     @DyngleCommand.wrap
     def execute(self):
-        expressions = self.app.expressions
         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-0.6.0/dyngle/operation.py

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

{dyngle-0.5.0 → dyngle-0.6.0}/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.5.0 → dyngle-0.6.0}/pyproject.toml

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