dyngle 0.4.2__tar.gz → 0.5.0__tar.gz

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

@@ -94,6 +94,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.2 → dyngle-0.5.0}/PKG-INFO

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

@@ -0,0 +1,58 @@
+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
+
+
+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 = self._get_configuration_details('operations')
+        if not operations:
+            raise DyngleError("No operations defined")
+        return operations
+
+    @cached_property
+    def 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 {}

{dyngle-0.4.2 → dyngle-0.5.0}/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()
@@ -27,17 +29,18 @@ 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]
         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-0.4.2 → dyngle-0.5.0}/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-0.5.0/dyngle/template.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from functools import partial
+import re
+
+
+PATTERN = re.compile(r'\{\{\s*([^}]+)\s*\}\}')
+
+
+@dataclass
+class Template:
+
+    template: str
+
+    def render(self, data: dict = None, expressions: dict = None) -> str:
+        """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, live_data=data | expressions)
+        return PATTERN.sub(resolver, self.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()
+        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:
+            return current

{dyngle-0.4.2 → dyngle-0.5.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.4.2"
+version = "0.5.0"
 
 [tool.poetry.dependencies]
 python = "~3.11"

dyngle-0.4.2/dyngle/__init__.py

@@ -1,23 +0,0 @@
-from functools import cached_property
-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.expression import expression
-
-
-class DyngleApp(WizApp):
-
-    base = DyngleCommand
-    name = 'dyngle'
-    handlers = [StreamHandler, ConfigHandler, UIHandler]
-
-    @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 {}

dyngle-0.4.2/dyngle/template.py

@@ -1,31 +0,0 @@
-from dataclasses import dataclass
-from functools import partial
-import re
-
-
-PATTERN = re.compile(r'\{\{\s*([^}]+)\s*\}\}')
-
-
-@dataclass
-class Template:
-
-    template: str
-
-    def render(self, data: dict = None, expressions: dict = None) -> str:
-        """Render the template with the provided data."""
-        data = data if data else {}
-        expressions = expressions if expressions else {}
-        resolver = partial(self._resolve, data=data, expressions=expressions)
-        return PATTERN.sub(resolver, self.template)
-
-    def _resolve(self, match, *, data: dict, expressions: dict):
-        """Resolve a single name/path from the template."""
-        key = match.group(1).strip()
-        if key in expressions:
-            return expressions[key](data)
-        else:
-            parts = key.split('.')
-            current = data
-            for part in parts:
-                current = current[part]
-            return current