dyngle 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

dyngle/__init__.py

@@ -1,9 +1,11 @@
+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):
@@ -11,3 +13,11 @@ 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/__main__.py

@@ -1,4 +1,3 @@
-from . import DyngleApp
-
 if __name__ == '__main__':  # pragma: nocover
+    from . import DyngleApp
     DyngleApp.main()

dyngle/command/run_command.py

@@ -1,8 +1,12 @@
 import shlex
 import subprocess
 from wizlib.parser import WizParser
+from yaml import safe_load
 
 from dyngle.command import DyngleCommand
+from dyngle.expression import expression
+from dyngle.template import Template
+from dyngle.error import DyngleError
 
 
 class RunCommand(DyngleCommand):
@@ -13,40 +17,33 @@ class RunCommand(DyngleCommand):
     @classmethod
     def add_args(cls, parser: WizParser):
         super().add_args(parser)
-        parser.add_argument('flow', help='Operation name to run')
+        parser.add_argument('operation', help='Operation name to run')
 
     def handle_vals(self):
         super().handle_vals()
-        if not self.provided('flow'):
-            self.flow = self.app.ui.get_input('Enter flow name: ')
 
-    def _validate_flow_exists(self, operations):
-        """Validate that the requested flow exists in configuration"""
-        if not operations:
-            raise RuntimeError('No operations configured')
-
-        if self.flow not in operations:
+    def _validate_operation_exists(self, operations):
+        """Validate that the requested operation exists in configuration"""
+        if self.operation not in operations:
             available_operations = ', '.join(operations.keys())
-            raise RuntimeError(
-                f'Operation "{self.flow}" not found. " + \
+            raise DyngleError(
+                f'Operation "{self.operation}" not found. " + \
                     f"Available operations: {available_operations}')
 
-    def _execute_task(self, task_str):
-        """Execute a single task and handle errors"""
-        task_parts = shlex.split(task_str)
-        result = subprocess.run(task_parts)
-
-        if result.returncode != 0:
-            raise RuntimeError(
-                f'Task failed with code {result.returncode}: {task_str}')
-
     @DyngleCommand.wrap
     def execute(self):
+        expressions = self.app.expressions
         operations = self.app.config.get('dyngle-operations')
-        self._validate_flow_exists(operations)
-
-        tasks = operations[self.flow]
-        for task_str in tasks:
-            self._execute_task(task_str)
-
-        return f'Operation "{self.flow}" completed successfully'
+        self._validate_operation_exists(operations)
+        steps = operations[self.operation]
+        data_string = self.app.stream.text
+        data = safe_load(data_string)
+        for step_template in steps:
+            step = Template(step_template).render(data, expressions)
+            parts = shlex.split(step)
+            result = subprocess.run(parts)
+            if result.returncode != 0:
+                raise DyngleError(
+                    f'Task failed with code {result.returncode}: {step}')
+
+        return f'Operation "{self.operation}" completed successfully'

dyngle/error.py

@@ -0,0 +1,2 @@
+class DyngleError(Exception):
+    pass

dyngle/expression.py

@@ -0,0 +1,88 @@
+from typing import Callable
+
+from dyngle.error import DyngleError
+from dyngle.safe_path import SafePath
+
+from datetime import datetime as datetime, date, timedelta
+import math
+import json
+import re
+import yaml
+
+
+def formatted_datetime(dt: datetime, format_string=None) -> str:
+    """Safe datetime formatting using string operations"""
+    if format_string is None:
+        format_string = "{year:04d}{month:02d}{day:02d}"
+    components = {
+        'year': dt.year,
+        'month': dt.month,
+        'day': dt.day,
+        'hour': dt.hour,
+        'minute': dt.minute,
+        'second': dt.second,
+        'microsecond': dt.microsecond,
+        'weekday': dt.weekday(),  # Monday is 0
+    }
+    return format_string.format(**components)
+
+
+GLOBALS = {
+    "__builtins__": {
+        # Basic data types and conversions
+        "int": int,
+        "float": float,
+        "str": str,
+        "bool": bool,
+        "list": list,
+        "dict": dict,
+        "tuple": tuple,
+        "set": set,
+
+        # Essential functions
+        "len": len,
+        "min": min,
+        "max": max,
+        "sum": sum,
+        "abs": abs,
+        "round": round,
+        "sorted": sorted,
+        "reversed": reversed,
+        "enumerate": enumerate,
+        "zip": zip,
+        "range": range,
+    },
+
+    # Mathematical operations
+    "math": math,
+
+    # Date and time handling
+    "datetime": datetime,
+    "date": date,
+    "timedelta": timedelta,
+    "formatted": formatted_datetime,
+
+    # Data parsing and manipulation
+    "json": json,
+    "yaml": yaml,
+    "re": re,
+
+    # Safe Path-like operations (within cwd)
+    "Path": SafePath
+}
+
+
+def _evaluate(expression: str, data: dict) -> str:
+    try:
+        result = eval(expression, GLOBALS, data)
+    except KeyError:
+        raise DyngleError(f"The following expression contains " +
+                          f"at least one invalid name: {expression}")
+    result = result[-1] if isinstance(result, tuple) else result
+    return str(result)
+
+
+def expression(text: str) -> Callable[[dict], str]:
+    def evaluate(data: dict) -> str:
+        return _evaluate(text, data)
+    return evaluate

dyngle/safe_path.py

@@ -0,0 +1,117 @@
+from pathlib import Path
+import os
+from typing import Union
+
+CWD = Path.cwd()
+
+
+class SafePath:
+    """A Path-like class that restricts operations to cwd and its
+    descendants"""
+
+    def __init__(self, path_str: Union[str, 'SafePath'] = "."):
+
+        self._cwd = CWD.resolve()
+
+        if isinstance(path_str, SafePath):
+            self._path = path_str._path
+        else:
+            # Convert to Path and resolve to handle .. and . components
+            try:
+                resolved_path = (self._cwd / path_str).resolve()
+            except (OSError, ValueError):
+                raise ValueError(f"Invalid path: {path_str}")
+
+            # Validate it's within cwd - could probably shorten this
+            if not resolved_path.is_relative_to(self._cwd):
+                raise ValueError(f"Path outside allowed directory: {path_str}")
+
+            self._path = resolved_path
+
+    def __str__(self):
+        return str(self._path.relative_to(self._cwd))
+
+    def __repr__(self):
+        return f"SafePath('{self}')"
+
+    def __truediv__(self, other):
+        """Support path / 'subdir' syntax"""
+        new_path_str = str(self._path / str(other))
+        return SafePath(new_path_str)
+
+    # File content operations
+    def read_text(self, encoding='utf-8'):
+        if not self._path.is_file():
+            raise FileNotFoundError(f"File not found: {self}")
+        return self._path.read_text(encoding=encoding)
+
+    def write_text(self, content, encoding='utf-8'):
+        # Ensure parent directories exist
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._path.write_text(content, encoding=encoding)
+        return self
+
+    def read_bytes(self):
+        if not self._path.is_file():
+            raise FileNotFoundError(f"File not found: {self}")
+        return self._path.read_bytes()
+
+    def write_bytes(self, data):
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._path.write_bytes(data)
+        return self
+
+    # Path properties and checks
+    def exists(self):
+        return self._path.exists()
+
+    def is_file(self):
+        return self._path.is_file()
+
+    def is_dir(self):
+        return self._path.is_dir()
+
+    def is_absolute(self):
+        return self._path.is_absolute()
+
+    @property
+    def name(self):
+        return self._path.name
+
+    @property
+    def stem(self):
+        return self._path.stem
+
+    @property
+    def suffix(self):
+        return self._path.suffix
+
+    @property
+    def parent(self):
+        return SafePath(str(self._path.parent))
+
+    # Directory operations
+    def mkdir(self, parents=True, exist_ok=True):
+        self._path.mkdir(parents=parents, exist_ok=exist_ok)
+        return self
+
+    def iterdir(self):
+        if not self._path.is_dir():
+            raise NotADirectoryError(f"Not a directory: {self}")
+        return [SafePath(str(p)) for p in self._path.iterdir()]
+
+    def glob(self, pattern):
+        return [SafePath(str(p)) for p in self._path.glob(pattern)]
+
+    def rglob(self, pattern):
+        return [SafePath(str(p)) for p in self._path.rglob(pattern)]
+
+    # File metadata
+    def stat(self):
+        return self._path.stat()
+
+    @property
+    def size(self):
+        if not self._path.is_file():
+            raise FileNotFoundError(f"File not found: {self}")
+        return self._path.stat().st_size

dyngle/template.py

@@ -0,0 +1,29 @@
+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, expressions: dict = None) -> str:
+        """Render the template with the provided data."""
+        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 expressions and (key in expressions):
+            return expressions[key](data)
+        else:
+            parts = key.split('.')
+            current = data
+            for part in parts:
+                current = current[part]
+            return current

{dyngle-0.2.0.dist-info → dyngle-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dyngle
-Version: 0.2.0
+Version: 0.4.0
 Summary: Run lightweight local workflows
 License: MIT
 Author: Steampunk Wizard
@@ -73,6 +73,26 @@ dyngle:
       - pip install -r requirements.txt
 ```
 
+## Expressions
+
+Configs can also contain expressions.
+
+```yaml
+dyngle:
+  expressions:
+    say-hello: >-
+        'Hello ' + name + '!'
+  operations:
+    say-hello: echo {{say-hello}}
+```
+Expressions can use a controlled subset of the Python standard library, including:
+
+- Built-in data types such as `str()`
+- Essential built-in functions such as `len()`
+- The core modules from the `datetime` package (but some methods such as `strftime()` will fail)
+- 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
+
 ## 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. 

dyngle-0.4.0.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=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=5R8gUrv6BhppchlMqr_SZtkSVsUo8FYseCw4ETAJxeE,855
+dyngle-0.4.0.dist-info/METADATA,sha256=Vx4RonlVHvFKAW2y1a_OD8_XUvyI2LSI0CMf2tZ8KsM,2941
+dyngle-0.4.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+dyngle-0.4.0.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
+dyngle-0.4.0.dist-info/RECORD,,

dyngle-0.2.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-dyngle/__init__.py,sha256=2KD52sWHfMhk1g1wxHdnxjRtEKeYNJn7sTPkKRpSqNA,338
-dyngle/__main__.py,sha256=mXOQ5tiUi5mEfp1NG2viz5kW2DEeWg1oCPFhfXgxJ4U,92
-dyngle/command/__init__.py,sha256=1S86gbef8MYvG-TWD5JRIWzFg7qV5xKhp9QXx9zEx5c,94
-dyngle/command/run_command.py,sha256=UbkzqlrbAkxQSbN8lHBaTaV23xYmVBlGEOZTiiuARjo,1667
-dyngle-0.2.0.dist-info/METADATA,sha256=naF-xfNR-gcqrJGOOur2pM0gX5tRTwbrTcqfePuhntQ,2288
-dyngle-0.2.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-dyngle-0.2.0.dist-info/entry_points.txt,sha256=rekiGhtweiHKm9g1jdGb3FhzqDrk1kigJDeSNollZSA,48
-dyngle-0.2.0.dist-info/RECORD,,