dyngle 0.1.3__tar.gz → 0.3.0__tar.gz

{dyngle-0.1.3 → dyngle-0.3.0}/PACKAGE.md

@@ -6,11 +6,11 @@ Dyngle is a simple workflow runner that executes sequences of commands defined i
 
 ## Basic usage
 
-Create a configuration file (e.g., `config.yml`) with your workflows:
+Create a configuration file (e.g., `.dyngle.yml`) with your workflows:
 
 ```yaml
 dyngle:
-  flows:
+  operations:
     build:
       - python -m pip install -e .
       - python -m pytest
@@ -22,10 +22,10 @@ dyngle:
       - rm -rf .pytest_cache
 ```
 
-Run a workflow:
+Run an operation:
 
 ```bash
-dyngle --config config.yml run build
+dyngle run build
 ```
 
 ## Configuration
@@ -39,13 +39,13 @@ Dyngle reads configuration from YAML files. You can specify the config file loca
 
 ## Workflow structure
 
-Each workflow (called a "flow") is defined as a list of tasks under `dyngle.flows`. Tasks are executed sequentially using Python's subprocess module for security.
+Each operation is defined as a list of tasks under `dyngle.operations`. Tasks are executed sequentially using Python's subprocess module for security.
 
-Example with multiple flows:
+Example with multiple operations:
 
 ```yaml
 dyngle:
-  flows:
+  operations:
     test:
       - python -m unittest discover
       - python -m coverage report
@@ -60,12 +60,12 @@ dyngle:
 
 ## Security
 
-Commands are executed using Python's `subprocess.run()` with arguments split by spaces. The shell is not used, preventing shell injection attacks.
+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. 
 
 ## Quick installation (MacOS)
 
 ```bash
 brew install python@3.11
 python3.11 -m pip install pipx
-pipx install kwark
+pipx install dyngle
 ```

{dyngle-0.1.3 → dyngle-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dyngle
-Version: 0.1.3
+Version: 0.3.0
 Summary: Run lightweight local workflows
 License: MIT
 Author: Steampunk Wizard
@@ -21,11 +21,11 @@ Dyngle is a simple workflow runner that executes sequences of commands defined i
 
 ## Basic usage
 
-Create a configuration file (e.g., `config.yml`) with your workflows:
+Create a configuration file (e.g., `.dyngle.yml`) with your workflows:
 
 ```yaml
 dyngle:
-  flows:
+  operations:
     build:
       - python -m pip install -e .
       - python -m pytest
@@ -37,10 +37,10 @@ dyngle:
       - rm -rf .pytest_cache
 ```
 
-Run a workflow:
+Run an operation:
 
 ```bash
-dyngle --config config.yml run build
+dyngle run build
 ```
 
 ## Configuration
@@ -54,13 +54,13 @@ Dyngle reads configuration from YAML files. You can specify the config file loca
 
 ## Workflow structure
 
-Each workflow (called a "flow") is defined as a list of tasks under `dyngle.flows`. Tasks are executed sequentially using Python's subprocess module for security.
+Each operation is defined as a list of tasks under `dyngle.operations`. Tasks are executed sequentially using Python's subprocess module for security.
 
-Example with multiple flows:
+Example with multiple operations:
 
 ```yaml
 dyngle:
-  flows:
+  operations:
     test:
       - python -m unittest discover
       - python -m coverage report
@@ -75,13 +75,13 @@ dyngle:
 
 ## Security
 
-Commands are executed using Python's `subprocess.run()` with arguments split by spaces. The shell is not used, preventing shell injection attacks.
+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. 
 
 ## Quick installation (MacOS)
 
 ```bash
 brew install python@3.11
 python3.11 -m pip install pipx
-pipx install kwark
+pipx install dyngle
 ```
 

{dyngle-0.1.3 → dyngle-0.3.0}/dyngle/__init__.py

@@ -6,6 +6,10 @@ from wizlib.ui_handler import UIHandler
 from dyngle.command import DyngleCommand
 
 
+class DyngleError(Exception):
+    pass
+
+
 class DyngleApp(WizApp):
 
     base = DyngleCommand

{dyngle-0.1.3 → dyngle-0.3.0}/dyngle/__main__.py

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

dyngle-0.3.0/dyngle/command/run_command.py

@@ -0,0 +1,47 @@
+import shlex
+import subprocess
+from wizlib.parser import WizParser
+from yaml import safe_load
+
+from dyngle.command import DyngleCommand
+from dyngle.template import Template
+from dyngle import DyngleError
+
+
+class RunCommand(DyngleCommand):
+    """Run a workflow defined in the configuration"""
+
+    name = 'run'
+
+    @classmethod
+    def add_args(cls, parser: WizParser):
+        super().add_args(parser)
+        parser.add_argument('operation', help='Operation name to run')
+
+    def handle_vals(self):
+        super().handle_vals()
+
+    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 DyngleError(
+                f'Operation "{self.operation}" not found. " + \
+                    f"Available operations: {available_operations}')
+
+    @DyngleCommand.wrap
+    def execute(self):
+        operations = self.app.config.get('dyngle-operations')
+        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)
+            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-0.3.0/dyngle/template.py

@@ -0,0 +1,30 @@
+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):
+        """Render the template with the provided data."""
+        resolver = partial(self._resolve, data=data)
+        return PATTERN.sub(resolver, self.template)
+
+    def _resolve(self, match, *, data):
+        """Resolve a single name/path from the template."""
+        path = match.group(1).strip()
+        # Try an expression first, then data
+        if False:
+            pass
+        else:
+            parts = path.split('.')
+            current = data
+            for part in parts:
+                current = current[part]
+            return current

{dyngle-0.1.3 → dyngle-0.3.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.1.3"
+version = "0.3.0"
 
 [tool.poetry.dependencies]
 python = "~3.11"

dyngle-0.1.3/dyngle/command/run_command.py

@@ -1,52 +0,0 @@
-import shlex
-import subprocess
-from wizlib.parser import WizParser
-
-from dyngle.command import DyngleCommand
-
-
-class RunCommand(DyngleCommand):
-    """Run a workflow defined in the configuration"""
-
-    name = 'run'
-
-    @classmethod
-    def add_args(cls, parser: WizParser):
-        super().add_args(parser)
-        parser.add_argument('flow', help='Flow 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, flows):
-        """Validate that the requested flow exists in configuration"""
-        if not flows:
-            raise RuntimeError('No flows configured')
-
-        if self.flow not in flows:
-            available_flows = ', '.join(flows.keys())
-            raise RuntimeError(
-                f'Flow "{self.flow}" not found. " + \
-                    f"Available flows: {available_flows}')
-
-    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):
-        flows = self.app.config.get('dyngle-flows')
-        self._validate_flow_exists(flows)
-
-        tasks = flows[self.flow]
-        for task_str in tasks:
-            self._execute_task(task_str)
-
-        return f'Flow "{self.flow}" completed successfully'