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

dyngle/command/run_command.py

@@ -18,6 +18,8 @@ class RunCommand(DyngleCommand):
     def add_args(cls, parser: WizParser):
         super().add_args(parser)
         parser.add_argument('operation', help='Operation name to run')
+        parser.add_argument(
+            'args', nargs='*', help='Optional operation arguments')
 
     def handle_vals(self):
         super().handle_vals()
@@ -37,7 +39,8 @@ class RunCommand(DyngleCommand):
         self._validate_operation_exists(operations)
         steps = operations[self.operation]
         data_string = self.app.stream.text
-        data = safe_load(data_string)
+        data = safe_load(data_string) or {}
+        data['args'] = self.args
         for step_template in steps:
             step = Template(step_template).render(data, expressions)
             parts = shlex.split(step)

dyngle/expression.py

@@ -9,6 +9,8 @@ import json
 import re
 import yaml
 
+from dyngle.template import Template
+
 
 def formatted_datetime(dt: datetime, format_string=None) -> str:
     """Safe datetime formatting using string operations"""
@@ -72,9 +74,38 @@ GLOBALS = {
 }
 
 
-def _evaluate(expression: str, data: dict) -> str:
+def _evaluate(expression: str, locals: dict) -> str:
+    """Evaluate a Python expression with safe globals and user data context.
+
+    Safely evaluates a Python expression string using a restricted set of
+    global functions and modules, combined with user-provided data. The
+    expression is evaluated in a sandboxed environment that includes basic
+    Python built-ins, mathematical operations, date/time handling, and data
+    manipulation utilities.
+
+    Parameters
+    ----------
+    expression : str
+        A valid Python expression string to be evaluated.
+    data : dict
+        Dictionary containing variables and values to be made available during
+        expression evaluation. Note that hyphens in keys will be replaced by
+        underscores to create valid Python names.
+
+    Returns
+    -------
+    str
+        String representation of the evaluated expression result. If the result
+        is a tuple, returns the string representation of the last element.
+
+    Raises
+    ------
+    DyngleError
+        If the expression contains invalid variable names that are not found in
+        the provided data dictionary or global context.
+    """
     try:
-        result = eval(expression, GLOBALS, data)
+        result = eval(expression, GLOBALS, locals)
     except KeyError:
         raise DyngleError(f"The following expression contains " +
                           f"at least one invalid name: {expression}")
@@ -83,6 +114,9 @@ def _evaluate(expression: str, data: dict) -> str:
 
 
 def expression(text: str) -> Callable[[dict], str]:
-    def evaluate(data: dict) -> str:
-        return _evaluate(text, data)
+    def evaluate(data: dict = None) -> str:
+        items = data.items() if data else ()
+        locals = {k.replace('-', '_'): v for k, v in items}
+        def resolve(s): return Template.resolve(s, data)
+        return _evaluate(text, locals | {'resolve': resolve})
     return evaluate

dyngle/template.py

@@ -12,20 +12,40 @@ class Template:
     template: str
 
     def render(self, data: dict = None, expressions: dict = None) -> str:
-        """Render the template with the provided data."""
+        """Render the template with the provided data and expressions.
+
+        Parameters
+        ----------
+        data : dict
+            String data to insert
+        expressions : dict
+            Functions to call with data
+
+        Returns
+        -------
+        str
+            Template rendered with expression resolution and values inserted.
+        """
+
         data = data if data else {}
         expressions = expressions if expressions else {}
-        resolver = partial(self._resolve, data=data, expressions=expressions)
+        resolver = partial(self._resolve, live_data=data | expressions)
         return PATTERN.sub(resolver, self.template)
 
-    def _resolve(self, match, *, data: dict, expressions: dict):
-        """Resolve a single name/path from the template."""
+    def _resolve(self, match, *, live_data: dict):
+        """Resolve a single name/path from the template. The argument is a
+        merge of the raw data and the expressions, either of which are valid
+        substitutions."""
         key = match.group(1).strip()
-        if key in expressions:
-            return expressions[key](data)
+        return self.resolve(key, live_data)
+
+    @staticmethod
+    def resolve(key: str, live_data: dict):
+        parts = key.split('.')
+        current = live_data
+        for part in parts:
+            current = current[part]
+        if callable(current):
+            return current(live_data)
         else:
-            parts = key.split('.')
-            current = data
-            for part in parts:
-                current = current[part]
             return current

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dyngle
-Version: 0.4.2
+Version: 0.4.3
 Summary: Run lightweight local workflows
 License: MIT
 Author: Steampunk Wizard
@@ -109,6 +109,39 @@ Expressions can use a controlled subset of the Python standard library, includin
 - A specialized function called `formatted()` to perform string formatting operations on a `datetime` object
 - A restricted version of `Path()` that only operates within the current working directory
 - Various other useful utilities, mostly read-only, such as the `math` module
+- A special function called `resolve` which resolves data expressions using the same logic as in templates
+
+Data keys containing hyphens are converted to valid Python names by replacing hyphens with underscores.
+
+Expressions can reference data directly as local names in Python (using the underscore replacements)...
+
+```yaml
+dyngle:
+  expressions:
+    say-hello: >-
+        'Hello ' + full_name + '!'
+```
+
+... or using the `resolve()` function, which also allows expressions to essentially call other expressions, using the same underlying data set.
+
+```yaml
+dyngle:
+  expressions:
+    hello: >-
+        'Hello ' + resolve('formal-name') + '!'
+    formal-name: >-
+        'Ms. ' + full_name
+```
+
+Note it's also _possible_ to call other expressions by name as functions, if they only return hard-coded values (i.e. constants).
+
+```yaml
+dyngle:
+  expressions:
+    author-name: Francis Potter
+    author-hello: >-
+        'Hello ' + author_name()
+``` 
 
 ## Security
 

dyngle-0.4.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

dyngle-0.4.2.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=0E8Bg7TRa8qXdfZNyC4Wygb1cEG4-ejRJ5ZfYz_L1_Y,1718
-dyngle/error.py,sha256=CGcTa8L4O1qsHEYnzp_JBbkvntJTv2Qz46wj_TI8NLk,39
-dyngle/expression.py,sha256=x-2Ald34lmXfG8070H96Wszln5Rd1AWGyYuYtf7iZFA,2134
-dyngle/safe_path.py,sha256=Hk2AhP6e3yKGh3kKrLLwhvAlMNx-j2jObBYJL-_doAU,3339
-dyngle/template.py,sha256=jE-rJiR2kZBHrjy_VJyiXCr4uu1JH8JCafShrMK9lVM,937
-dyngle-0.4.2.dist-info/METADATA,sha256=RnHf4ODiubIgBsF5Q1B8Rk1QRHgjMWshS-7bN7KMl9w,3594
-dyngle-0.4.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-dyngle-0.4.2.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
-dyngle-0.4.2.dist-info/RECORD,,