highway-dsl 1.0.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

highway_dsl/__init__.py

@@ -1,15 +1,18 @@
 from .workflow_dsl import (
-    Workflow,
-    WorkflowBuilder,
-    TaskOperator,
     ConditionOperator,
-    ParallelOperator,
-    WaitOperator,
+    EmitEventOperator,
     ForEachOperator,
-    WhileOperator,
+    OperatorType,
+    ParallelOperator,
     RetryPolicy,
+    SwitchOperator,
+    TaskOperator,
     TimeoutPolicy,
-    OperatorType,
+    WaitForEventOperator,
+    WaitOperator,
+    WhileOperator,
+    Workflow,
+    WorkflowBuilder,
 )
 
 __all__ = [
@@ -22,6 +25,9 @@ __all__ = [
     "WaitOperator",
     "ForEachOperator",
     "WhileOperator",
+    "EmitEventOperator",
+    "WaitForEventOperator",
+    "SwitchOperator",
     "RetryPolicy",
     "TimeoutPolicy",
     "OperatorType",

highway_dsl/workflow_dsl.py

@@ -1,11 +1,12 @@
 # workflow_dsl.py
-from typing import Any, Dict, List, Optional, Union, Callable, Type
-from enum import Enum
+from abc import ABC
+from collections.abc import Callable
 from datetime import datetime, timedelta
+from enum import Enum
+from typing import Any, Optional, Union
+
 import yaml
-import json
-from abc import ABC, abstractmethod
-from pydantic import BaseModel, Field, model_validator, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class OperatorType(Enum):
@@ -17,6 +18,8 @@ class OperatorType(Enum):
     SWITCH = "switch"
     TRY_CATCH = "try_catch"
     WHILE = "while"
+    EMIT_EVENT = "emit_event"
+    WAIT_FOR_EVENT = "wait_for_event"
 
 
 class RetryPolicy(BaseModel):
@@ -28,19 +31,23 @@ class RetryPolicy(BaseModel):
 class TimeoutPolicy(BaseModel):
     timeout: timedelta = Field(..., description="Timeout duration")
     kill_on_timeout: bool = Field(
-        True, description="Whether to kill the task on timeout"
+        True, description="Whether to kill the task on timeout",
     )
 
 
 class BaseOperator(BaseModel, ABC):
     task_id: str
     operator_type: OperatorType
-    dependencies: List[str] = Field(default_factory=list)
-    retry_policy: Optional[RetryPolicy] = None
-    timeout_policy: Optional[TimeoutPolicy] = None
-    metadata: Dict[str, Any] = Field(default_factory=dict)
+    dependencies: list[str] = Field(default_factory=list)
+    retry_policy: RetryPolicy | None = None
+    timeout_policy: TimeoutPolicy | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    description: str = Field(default="", description="Task description")
+    # Phase 3: Callback hooks
+    on_success_task_id: str | None = Field(None, description="Task to run on success")
+    on_failure_task_id: str | None = Field(None, description="Task to run on failure")
     is_internal_loop_task: bool = Field(
-        default=False, exclude=True
+        default=False, exclude=True,
     )  # Mark if task is internal to a loop
 
     model_config = ConfigDict(use_enum_values=True, arbitrary_types_allowed=True)
@@ -48,21 +55,21 @@ class BaseOperator(BaseModel, ABC):
 
 class TaskOperator(BaseOperator):
     function: str
-    args: List[Any] = Field(default_factory=list)
-    kwargs: Dict[str, Any] = Field(default_factory=dict)
-    result_key: Optional[str] = None
+    args: list[Any] = Field(default_factory=list)
+    kwargs: dict[str, Any] = Field(default_factory=dict)
+    result_key: str | None = None
     operator_type: OperatorType = Field(OperatorType.TASK, frozen=True)
 
 
 class ConditionOperator(BaseOperator):
     condition: str
-    if_true: Optional[str]
-    if_false: Optional[str]
+    if_true: str | None
+    if_false: str | None
     operator_type: OperatorType = Field(OperatorType.CONDITION, frozen=True)
 
 
 class WaitOperator(BaseOperator):
-    wait_for: Union[timedelta, datetime, str]
+    wait_for: timedelta | datetime | str
     operator_type: OperatorType = Field(OperatorType.WAIT, frozen=True)
 
     @model_validator(mode="before")
@@ -77,7 +84,7 @@ class WaitOperator(BaseOperator):
                     data["wait_for"] = datetime.fromisoformat(wait_for.split(":", 1)[1])
         return data
 
-    def model_dump(self, **kwargs) -> Dict[str, Any]:
+    def model_dump(self, **kwargs: Any) -> dict[str, Any]:
         data = super().model_dump(**kwargs)
         wait_for = data["wait_for"]
         if isinstance(wait_for, timedelta):
@@ -88,13 +95,14 @@ class WaitOperator(BaseOperator):
 
 
 class ParallelOperator(BaseOperator):
-    branches: Dict[str, List[str]] = Field(default_factory=dict)
+    branches: dict[str, list[str]] = Field(default_factory=dict)
+    timeout: int | None = Field(None, description="Optional timeout in seconds for branch execution")
     operator_type: OperatorType = Field(OperatorType.PARALLEL, frozen=True)
 
 
 class ForEachOperator(BaseOperator):
     items: str
-    loop_body: List[
+    loop_body: list[
         Union[
             TaskOperator,
             ConditionOperator,
@@ -102,6 +110,9 @@ class ForEachOperator(BaseOperator):
             ParallelOperator,
             "ForEachOperator",
             "WhileOperator",
+            "EmitEventOperator",
+            "WaitForEventOperator",
+            "SwitchOperator",
         ]
     ] = Field(default_factory=list)
     operator_type: OperatorType = Field(OperatorType.FOREACH, frozen=True)
@@ -109,7 +120,7 @@ class ForEachOperator(BaseOperator):
 
 class WhileOperator(BaseOperator):
     condition: str
-    loop_body: List[
+    loop_body: list[
         Union[
             TaskOperator,
             ConditionOperator,
@@ -117,41 +128,109 @@ class WhileOperator(BaseOperator):
             ParallelOperator,
             ForEachOperator,
             "WhileOperator",
+            "EmitEventOperator",
+            "WaitForEventOperator",
+            "SwitchOperator",
         ]
     ] = Field(default_factory=list)
     operator_type: OperatorType = Field(OperatorType.WHILE, frozen=True)
 
 
+class EmitEventOperator(BaseOperator):
+    """Phase 2: Emit an event that other workflows can wait for."""
+    event_name: str = Field(..., description="Name of the event to emit")
+    payload: dict[str, Any] = Field(default_factory=dict, description="Event payload data")
+    operator_type: OperatorType = Field(OperatorType.EMIT_EVENT, frozen=True)
+
+
+class WaitForEventOperator(BaseOperator):
+    """Phase 2: Wait for an external event with optional timeout."""
+    event_name: str = Field(..., description="Name of the event to wait for")
+    timeout_seconds: int | None = Field(None, description="Timeout in seconds (None = wait forever)")
+    operator_type: OperatorType = Field(OperatorType.WAIT_FOR_EVENT, frozen=True)
+
+
+class SwitchOperator(BaseOperator):
+    """Phase 4: Multi-branch switch/case operator."""
+    switch_on: str = Field(..., description="Expression to evaluate for switch")
+    cases: dict[str, str] = Field(default_factory=dict, description="Map of case values to task IDs")
+    default: str | None = Field(None, description="Default task ID if no case matches")
+    operator_type: OperatorType = Field(OperatorType.SWITCH, frozen=True)
+
+
 class Workflow(BaseModel):
     name: str
-    version: str = "1.0.0"
+    version: str = "1.1.0"
     description: str = ""
-    tasks: Dict[
+    tasks: dict[
         str,
-        Union[
-            TaskOperator,
-            ConditionOperator,
-            WaitOperator,
-            ParallelOperator,
-            ForEachOperator,
-            WhileOperator,
-        ],
+        TaskOperator | ConditionOperator | WaitOperator | ParallelOperator | ForEachOperator | WhileOperator | EmitEventOperator | WaitForEventOperator | SwitchOperator,
     ] = Field(default_factory=dict)
-    variables: Dict[str, Any] = Field(default_factory=dict)
-    start_task: Optional[str] = None
+    variables: dict[str, Any] = Field(default_factory=dict)
+    start_task: str | None = None
+
+    # Phase 1: Scheduling metadata
+    schedule: str | None = Field(None, description="Cron expression for scheduled execution")
+    start_date: datetime | None = Field(None, description="When the schedule becomes active")
+    catchup: bool = Field(False, description="Whether to backfill missed runs")
+    is_paused: bool = Field(False, description="Whether the workflow is paused")
+    tags: list[str] = Field(default_factory=list, description="Workflow categorization tags")
+    max_active_runs: int = Field(1, description="Maximum number of concurrent runs")
+    default_retry_policy: RetryPolicy | None = Field(None, description="Default retry policy for all tasks")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_workflow_name_and_version(cls, data: Any) -> Any:
+        """Validate workflow name and version don't contain '__' (double underscore).
+
+        The double underscore is reserved as a separator for display purposes:
+        {workflow_name}__{version}__{step_name}
+
+        Workflow names must match: ^[a-z][a-z0-9_]*$ (lowercase, alphanumeric, single underscore)
+        Workflow versions must match: ^[a-zA-Z0-9._-]+$ (semver compatible)
+        """
+        import re
+
+        if isinstance(data, dict):
+            name = data.get("name", "")
+            version = data.get("version", "")
+
+            # Check for double underscore (reserved separator)
+            if "__" in name:
+                msg = f"Workflow name '{name}' cannot contain '__' (double underscore) - it's reserved as a separator"
+                raise ValueError(msg)
+
+            if "__" in version:
+                msg = f"Workflow version '{version}' cannot contain '__' (double underscore) - it's reserved as a separator"
+                raise ValueError(msg)
+
+            # Validate workflow name format
+            if name and not re.match(r"^[a-z][a-z0-9_]*$", name):
+                msg = f"Workflow name '{name}' must start with lowercase letter and contain only lowercase letters, digits, and single underscores"
+                raise ValueError(msg)
+
+            # Validate workflow version format (semver compatible)
+            if version and not re.match(r"^[a-zA-Z0-9._-]+$", version):
+                msg = f"Workflow version '{version}' must contain only alphanumeric characters, dots, hyphens, and underscores (semver compatible)"
+                raise ValueError(msg)
+
+        return data
 
     @model_validator(mode="before")
     @classmethod
     def validate_tasks(cls, data: Any) -> Any:
         if isinstance(data, dict) and "tasks" in data:
             validated_tasks = {}
-            operator_classes: Dict[str, Type[BaseOperator]] = {
+            operator_classes: dict[str, type[BaseOperator]] = {
                 OperatorType.TASK.value: TaskOperator,
                 OperatorType.CONDITION.value: ConditionOperator,
                 OperatorType.WAIT.value: WaitOperator,
                 OperatorType.PARALLEL.value: ParallelOperator,
                 OperatorType.FOREACH.value: ForEachOperator,
                 OperatorType.WHILE.value: WhileOperator,
+                OperatorType.EMIT_EVENT.value: EmitEventOperator,
+                OperatorType.WAIT_FOR_EVENT.value: WaitForEventOperator,
+                OperatorType.SWITCH.value: SwitchOperator,
             }
             for task_id, task_data in data["tasks"].items():
                 operator_type = task_data.get("operator_type")
@@ -159,25 +238,19 @@ class Workflow(BaseModel):
                     operator_class = operator_classes[operator_type]
                     validated_tasks[task_id] = operator_class.model_validate(task_data)
                 else:
-                    raise ValueError(f"Unknown operator type: {operator_type}")
+                    msg = f"Unknown operator type: {operator_type}"
+                    raise ValueError(msg)
             data["tasks"] = validated_tasks
         return data
 
     def add_task(
         self,
-        task: Union[
-            TaskOperator,
-            ConditionOperator,
-            WaitOperator,
-            ParallelOperator,
-            ForEachOperator,
-            WhileOperator,
-        ],
+        task: TaskOperator | ConditionOperator | WaitOperator | ParallelOperator | ForEachOperator | WhileOperator | EmitEventOperator | WaitForEventOperator | SwitchOperator,
     ) -> "Workflow":
         self.tasks[task.task_id] = task
         return self
 
-    def set_variables(self, variables: Dict[str, Any]) -> "Workflow":
+    def set_variables(self, variables: dict[str, Any]) -> "Workflow":
         self.variables.update(variables)
         return self
 
@@ -185,6 +258,42 @@ class Workflow(BaseModel):
         self.start_task = task_id
         return self
 
+    # Phase 1: Scheduling methods
+    def set_schedule(self, cron: str) -> "Workflow":
+        """Set the cron schedule for this workflow."""
+        self.schedule = cron
+        return self
+
+    def set_start_date(self, start_date: datetime) -> "Workflow":
+        """Set when the schedule becomes active."""
+        self.start_date = start_date
+        return self
+
+    def set_catchup(self, enabled: bool) -> "Workflow":
+        """Set whether to backfill missed runs."""
+        self.catchup = enabled
+        return self
+
+    def set_paused(self, paused: bool) -> "Workflow":
+        """Set whether the workflow is paused."""
+        self.is_paused = paused
+        return self
+
+    def add_tags(self, *tags: str) -> "Workflow":
+        """Add tags to the workflow."""
+        self.tags.extend(tags)
+        return self
+
+    def set_max_active_runs(self, count: int) -> "Workflow":
+        """Set maximum number of concurrent runs."""
+        self.max_active_runs = count
+        return self
+
+    def set_default_retry_policy(self, policy: RetryPolicy) -> "Workflow":
+        """Set default retry policy for all tasks."""
+        self.default_retry_policy = policy
+        return self
+
     def to_yaml(self) -> str:
         data = self.model_dump(mode="json", by_alias=True, exclude_none=True)
         return yaml.dump(data, default_flow_style=False)
@@ -192,6 +301,68 @@ class Workflow(BaseModel):
     def to_json(self) -> str:
         return self.model_dump_json(indent=2)
 
+    def to_mermaid(self) -> str:
+        """ convert to mermaid state diagram format """
+        lines = ["stateDiagram-v2"]
+        
+        all_dependencies = {dep for task in self.tasks.values() for dep in task.dependencies}
+        
+        for task_id, task in self.tasks.items():
+            # Add state with description for regular tasks
+            if task.description and not isinstance(task, (ForEachOperator, WhileOperator)):
+                lines.append(f'    state "{task.description}" as {task_id}')
+            
+            # Add dependencies
+            if not task.dependencies:
+                if self.start_task == task_id or not self.start_task:
+                    lines.append(f'    [*] --> {task_id}')
+            else:
+                for dep in task.dependencies:
+                    lines.append(f'    {dep} --> {task_id}')
+            
+            # Add transitions for conditional operator
+            if isinstance(task, ConditionOperator):
+                if task.if_true:
+                    lines.append(f'    {task_id} --> {task.if_true} : True')
+                if task.if_false:
+                    lines.append(f'    {task_id} --> {task.if_false} : False')
+
+            # Add composite state for parallel operator
+            if isinstance(task, ParallelOperator):
+                lines.append(f'    state {task_id} {{')
+                for i, branch in enumerate(task.branches):
+                    lines.append(f'        state "Branch {i+1}" as {branch}')
+                    if i < len(task.branches) - 1:
+                        lines.append('        --')
+                lines.append('    }')
+
+            # Add composite state for foreach operator
+            if isinstance(task, ForEachOperator):
+                lines.append(f'    state {task_id} {{')
+                for sub_task in task.loop_body:
+                    if sub_task.description:
+                        lines.append(f'        state "{sub_task.description}" as {sub_task.task_id}')
+                    else:
+                        lines.append(f'        {sub_task.task_id}')
+                lines.append('    }')
+
+            # Add composite state for while operator
+            if isinstance(task, WhileOperator):
+                lines.append(f'    state {task_id} {{')
+                for sub_task in task.loop_body:
+                    if sub_task.description:
+                        lines.append(f'        state "{sub_task.description}" as {sub_task.task_id}')
+                    else:
+                        lines.append(f'        {sub_task.task_id}')
+                lines.append('    }')
+
+            # End states
+            if task_id not in all_dependencies:
+                if not (isinstance(task, ConditionOperator) and (task.if_true or task.if_false)):
+                    lines.append(f'    {task_id} --> [*]')
+                
+        return "\n".join(lines)
+
     @classmethod
     def from_yaml(cls, yaml_str: str) -> "Workflow":
         data = yaml.safe_load(yaml_str)
@@ -206,38 +377,45 @@ class WorkflowBuilder:
     def __init__(
         self,
         name: str,
-        existing_workflow: Optional[Workflow] = None,
+        existing_workflow: Workflow | None = None,
         parent: Optional["WorkflowBuilder"] = None,
-    ):
+    ) -> None:
         if existing_workflow:
             self.workflow = existing_workflow
         else:
-            self.workflow = Workflow(name=name)
-        self._current_task: Optional[str] = None
+            self.workflow = Workflow(
+                name=name,
+                version="1.1.0",
+                description="",
+                tasks={},
+                variables={},
+                start_task=None,
+                schedule=None,
+                start_date=None,
+                catchup=False,
+                is_paused=False,
+                tags=[],
+                max_active_runs=1,
+                default_retry_policy=None,
+            )
+        self._current_task: str | None = None
         self.parent = parent
 
     def _add_task(
         self,
-        task: Union[
-            TaskOperator,
-            ConditionOperator,
-            WaitOperator,
-            ParallelOperator,
-            ForEachOperator,
-            WhileOperator,
-        ],
-        **kwargs,
+        task: TaskOperator | ConditionOperator | WaitOperator | ParallelOperator | ForEachOperator | WhileOperator | EmitEventOperator | WaitForEventOperator | SwitchOperator,
+        **kwargs: Any,
     ) -> None:
         dependencies = kwargs.get("dependencies", [])
         if self._current_task and not dependencies:
             dependencies.append(self._current_task)
 
-        task.dependencies = sorted(list(set(dependencies)))
+        task.dependencies = sorted(set(dependencies))
 
         self.workflow.add_task(task)
         self._current_task = task.task_id
 
-    def task(self, task_id: str, function: str, **kwargs) -> "WorkflowBuilder":
+    def task(self, task_id: str, function: str, **kwargs: Any) -> "WorkflowBuilder":
         task = TaskOperator(task_id=task_id, function=function, **kwargs)
         self._add_task(task, **kwargs)
         return self
@@ -248,7 +426,7 @@ class WorkflowBuilder:
         condition: str,
         if_true: Callable[["WorkflowBuilder"], "WorkflowBuilder"],
         if_false: Callable[["WorkflowBuilder"], "WorkflowBuilder"],
-        **kwargs,
+        **kwargs: Any,
     ) -> "WorkflowBuilder":
         true_builder = if_true(WorkflowBuilder(f"{task_id}_true", parent=self))
         false_builder = if_false(WorkflowBuilder(f"{task_id}_false", parent=self))
@@ -281,7 +459,7 @@ class WorkflowBuilder:
         return self
 
     def wait(
-        self, task_id: str, wait_for: Union[timedelta, datetime, str], **kwargs
+        self, task_id: str, wait_for: timedelta | datetime | str, **kwargs: Any,
     ) -> "WorkflowBuilder":
         task = WaitOperator(task_id=task_id, wait_for=wait_for, **kwargs)
         self._add_task(task, **kwargs)
@@ -290,13 +468,13 @@ class WorkflowBuilder:
     def parallel(
         self,
         task_id: str,
-        branches: Dict[str, Callable[["WorkflowBuilder"], "WorkflowBuilder"]],
-        **kwargs,
+        branches: dict[str, Callable[["WorkflowBuilder"], "WorkflowBuilder"]],
+        **kwargs: Any,
     ) -> "WorkflowBuilder":
         branch_builders = {}
         for name, branch_func in branches.items():
             branch_builder = branch_func(
-                WorkflowBuilder(f"{task_id}_{name}", parent=self)
+                WorkflowBuilder(f"{task_id}_{name}", parent=self),
             )
             branch_builders[name] = branch_builder
 
@@ -328,7 +506,7 @@ class WorkflowBuilder:
         task_id: str,
         items: str,
         loop_body: Callable[["WorkflowBuilder"], "WorkflowBuilder"],
-        **kwargs,
+        **kwargs: Any,
     ) -> "WorkflowBuilder":
         # Create a temporary builder for the loop body.
         temp_builder = WorkflowBuilder(f"{task_id}_loop", parent=self)
@@ -369,7 +547,7 @@ class WorkflowBuilder:
         task_id: str,
         condition: str,
         loop_body: Callable[["WorkflowBuilder"], "WorkflowBuilder"],
-        **kwargs,
+        **kwargs: Any,
     ) -> "WorkflowBuilder":
         loop_builder = loop_body(WorkflowBuilder(f"{task_id}_loop", parent=self))
         loop_tasks = list(loop_builder.workflow.tasks.values())
@@ -408,24 +586,106 @@ class WorkflowBuilder:
         backoff_factor: float = 2.0,
     ) -> "WorkflowBuilder":
         if self._current_task and isinstance(
-            self.workflow.tasks[self._current_task], TaskOperator
+            self.workflow.tasks[self._current_task], TaskOperator,
         ):
             self.workflow.tasks[self._current_task].retry_policy = RetryPolicy(
-                max_retries=max_retries, delay=delay, backoff_factor=backoff_factor
+                max_retries=max_retries, delay=delay, backoff_factor=backoff_factor,
             )
         return self
 
     def timeout(
-        self, timeout: timedelta, kill_on_timeout: bool = True
+        self, timeout: timedelta, kill_on_timeout: bool = True,
     ) -> "WorkflowBuilder":
         if self._current_task and isinstance(
-            self.workflow.tasks[self._current_task], TaskOperator
+            self.workflow.tasks[self._current_task], TaskOperator,
         ):
             self.workflow.tasks[self._current_task].timeout_policy = TimeoutPolicy(
-                timeout=timeout, kill_on_timeout=kill_on_timeout
+                timeout=timeout, kill_on_timeout=kill_on_timeout,
             )
         return self
 
+    # Phase 2: Event-based operators
+    def emit_event(self, task_id: str, event_name: str, **kwargs: Any) -> "WorkflowBuilder":
+        """Emit an event that other workflows can wait for."""
+        task = EmitEventOperator(task_id=task_id, event_name=event_name, **kwargs)
+        self._add_task(task, **kwargs)
+        return self
+
+    def wait_for_event(
+        self, task_id: str, event_name: str, timeout_seconds: int | None = None, **kwargs: Any,
+    ) -> "WorkflowBuilder":
+        """Wait for an external event with optional timeout."""
+        task = WaitForEventOperator(
+            task_id=task_id, event_name=event_name, timeout_seconds=timeout_seconds, **kwargs,
+        )
+        self._add_task(task, **kwargs)
+        return self
+
+    # Phase 3: Callback hooks (applies to current task)
+    def on_success(self, success_task_id: str) -> "WorkflowBuilder":
+        """Set the task to run when the current task succeeds."""
+        if self._current_task:
+            self.workflow.tasks[self._current_task].on_success_task_id = success_task_id
+        return self
+
+    def on_failure(self, failure_task_id: str) -> "WorkflowBuilder":
+        """Set the task to run when the current task fails."""
+        if self._current_task:
+            self.workflow.tasks[self._current_task].on_failure_task_id = failure_task_id
+        return self
+
+    # Phase 4: Switch operator
+    def switch(
+        self,
+        task_id: str,
+        switch_on: str,
+        cases: dict[str, str],
+        default: str | None = None,
+        **kwargs: Any,
+    ) -> "WorkflowBuilder":
+        """Multi-branch switch/case operator."""
+        task = SwitchOperator(
+            task_id=task_id, switch_on=switch_on, cases=cases, default=default, **kwargs,
+        )
+        self._add_task(task, **kwargs)
+        return self
+
+    # Phase 1: Scheduling methods (delegate to Workflow)
+    def set_schedule(self, cron: str) -> "WorkflowBuilder":
+        """Set the cron schedule for this workflow."""
+        self.workflow.set_schedule(cron)
+        return self
+
+    def set_start_date(self, start_date: datetime) -> "WorkflowBuilder":
+        """Set when the schedule becomes active."""
+        self.workflow.set_start_date(start_date)
+        return self
+
+    def set_catchup(self, enabled: bool) -> "WorkflowBuilder":
+        """Set whether to backfill missed runs."""
+        self.workflow.set_catchup(enabled)
+        return self
+
+    def set_paused(self, paused: bool) -> "WorkflowBuilder":
+        """Set whether the workflow is paused."""
+        self.workflow.set_paused(paused)
+        return self
+
+    def add_tags(self, *tags: str) -> "WorkflowBuilder":
+        """Add tags to the workflow."""
+        self.workflow.add_tags(*tags)
+        return self
+
+    def set_max_active_runs(self, count: int) -> "WorkflowBuilder":
+        """Set maximum number of concurrent runs."""
+        self.workflow.set_max_active_runs(count)
+        return self
+
+    def set_default_retry_policy(self, policy: RetryPolicy) -> "WorkflowBuilder":
+        """Set default retry policy for all tasks."""
+        self.workflow.set_default_retry_policy(policy)
+        return self
+
     def build(self) -> Workflow:
         if not self.workflow.start_task and self.workflow.tasks:
             self.workflow.start_task = next(iter(self.workflow.tasks.keys()))

highway_dsl-1.2.0.dist-info/METADATA

@@ -0,0 +1,481 @@
+Metadata-Version: 2.4
+Name: highway_dsl
+Version: 1.2.0
+Summary: A stable domain specific language (DSL) for defining and managing data processing pipelines and workflow engines.
+Author-email: Farseed Ashouri <farseed.ashouri@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rodmena-limited/highway_dsl
+Project-URL: Issues, https://github.com/rodmena-limited/highway_dsl/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.12.3
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.12.1; extra == "dev"
+Dynamic: license-file
+
+# Highway DSL
+
+[![PyPI version](https://badge.fury.io/py/highway-dsl.svg)](https://badge.fury.io/py/highway-dsl)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Stable](https://img.shields.io/badge/Status-Stable-brightgreen)](https://pypi.org/project/highway-dsl/)
+[![Publish to PyPI](https://github.com/rodmena-limited/highway_dsl/actions/workflows/publish.yml/badge.svg)](https://github.com/rodmena-limited/highway_dsl/actions/workflows/publish.yml)
+
+**Highway DSL** is a Python-based domain-specific language for defining complex workflows in a clear, concise, and fluent manner. It is part of the larger **Highway** project, an advanced workflow engine capable of running complex DAG-based workflows.
+
+## Version 1.1.0 - Feature Release
+
+This major feature release adds **Airflow-parity** features to enable production-grade workflows:
+
+### New Features
+
+#### 1. **Scheduling Metadata** (Airflow Parity)
+Define cron-based schedules directly in your workflow:
+```python
+builder = (
+    WorkflowBuilder("daily_pipeline")
+    .set_schedule("0 2 * * *")  # Run daily at 2 AM
+    .set_start_date(datetime(2025, 1, 1))
+    .set_catchup(False)
+    .add_tags("production", "daily")
+    .set_max_active_runs(1)
+)
+```
+
+#### 2. **Event-Based Operators** (Absurd Integration)
+First-class support for event-driven workflows:
+```python
+# Emit an event that other workflows can wait for
+builder.emit_event(
+    "notify_completion",
+    event_name="pipeline_done",
+    payload={"status": "success"}
+)
+
+# Wait for an external event
+builder.wait_for_event(
+    "wait_upstream",
+    event_name="data_ready",
+    timeout_seconds=3600
+)
+```
+
+#### 3. **Callback Hooks** (Production Workflows)
+Durable success/failure handlers as first-class workflow nodes:
+```python
+builder.task("risky_operation", "process.data")
+
+builder.task("send_alert", "alerts.notify")
+builder.on_failure("send_alert")  # Runs if risky_operation fails
+
+builder.task("cleanup", "cleanup.resources")
+builder.on_success("cleanup")  # Runs if risky_operation succeeds
+```
+
+#### 4. **Switch/Case Operator**
+Multi-branch routing with cleaner syntax than nested conditions:
+```python
+builder.switch(
+    "route_by_status",
+    switch_on="{{data.status}}",
+    cases={
+        "approved": "approve_task",
+        "rejected": "reject_task",
+        "pending": "review_task"
+    },
+    default="unknown_handler"
+)
+```
+
+#### 5. **Task Descriptions**
+Document your workflow inline:
+```python
+builder.task(
+    "process",
+    "data.transform",
+    description="Transform raw data into analytics format"
+)
+```
+
+#### 6. **Workflow-Level Default Retry Policy**
+Set a default retry policy for all tasks:
+```python
+builder.set_default_retry_policy(
+    RetryPolicy(max_retries=3, delay=timedelta(seconds=60))
+)
+```
+
+See `examples/scheduled_event_workflow.py` for a comprehensive example using all new features.
+
+### RFC-Style Specification
+
+For implementers and advanced users, Highway DSL v1.1.0 includes a comprehensive **3,215-line RFC-style specification** (`spec.txt`) modeled after IETF RFCs (RFC 2119, RFC 8259). This authoritative document provides:
+
+- Complete operator specifications with execution semantics
+- Integration guidance for Absurd and other runtimes
+- Security considerations and best practices
+- Comprehensive examples for all features
+- Formal data model definitions
+
+Access the specification at `/dsl/spec.txt` in the repository.
+
+## Architecture Diagram
+
+```mermaid
+graph TB
+    subgraph "Highway DSL v1.1.0 Features"
+        A[WorkflowBuilder<br/>Fluent API] --> B[Core Operators]
+        A --> C[Scheduling]
+        A --> D[Events]
+        A --> E[Error Handling]
+
+        B --> B1[Task]
+        B --> B2[Condition]
+        B --> B3[Parallel]
+        B --> B4[ForEach]
+        B --> B5[While]
+        B --> B6[Wait]
+        B --> B7[Switch]
+
+        C --> C1[Cron Schedules]
+        C --> C2[Start Date]
+        C --> C3[Catchup]
+        C --> C4[Tags]
+
+        D --> D1[EmitEvent]
+        D --> D2[WaitForEvent]
+
+        E --> E1[RetryPolicy]
+        E --> E2[TimeoutPolicy]
+        E --> E3[Callbacks]
+    end
+
+    subgraph "Output Formats"
+        F[YAML]
+        G[JSON]
+    end
+
+    subgraph "Runtime Integration"
+        H[Absurd Runtime]
+        I[Airflow]
+        J[Temporal]
+        K[Custom Engines]
+    end
+
+    A --> F
+    A --> G
+    F --> H
+    F --> I
+    F --> J
+    F --> K
+    G --> H
+    G --> I
+    G --> J
+    G --> K
+
+    style A fill:#2563eb,stroke:#1e40af,color:#fff
+    style B fill:#8b5cf6,stroke:#7c3aed,color:#fff
+    style C fill:#10b981,stroke:#059669,color:#fff
+    style D fill:#f59e0b,stroke:#d97706,color:#fff
+    style E fill:#ef4444,stroke:#dc2626,color:#fff
+```
+
+## Features
+
+*   **Fluent API:** A powerful and intuitive `WorkflowBuilder` for defining workflows programmatically.
+*   **Pydantic-based:** All models are built on Pydantic, providing robust data validation, serialization, and documentation.
+*   **Rich Operators:** A comprehensive set of operators for handling various workflow scenarios:
+    *   `Task` - Basic workflow steps
+    *   `Condition` (if/else) - Conditional branching
+    *   `Parallel` - Execute multiple branches simultaneously
+    *   `ForEach` - Iterate over collections with proper dependency management
+    *   `Wait` - Pause execution for scheduled tasks
+    *   `While` - Execute loops based on conditions
+    *   **NEW in v1.1:** `EmitEvent` - Emit events for cross-workflow coordination
+    *   **NEW in v1.1:** `WaitForEvent` - Wait for external events with timeout
+    *   **NEW in v1.1:** `Switch` - Multi-branch routing (switch/case)
+*   **Scheduling:** Built-in support for cron-based scheduling, start dates, and catchup configuration
+*   **Event-Driven:** First-class support for event emission and waiting (Absurd integration)
+*   **Callback Hooks:** Durable success/failure handlers as workflow nodes
+*   **YAML/JSON Interoperability:** Workflows can be defined in Python and exported to YAML or JSON, and vice-versa.
+*   **Retry and Timeout Policies:** Built-in error handling and execution time management.
+*   **Extensible:** The DSL is designed to be extensible with custom operators and policies.
+
+## Installation
+
+```bash
+pip install highway-dsl
+```
+
+## Quick Start
+
+Here's a simple example of how to define a workflow using the `WorkflowBuilder`:
+
+```python
+from datetime import timedelta
+from highway_dsl import WorkflowBuilder
+
+workflow = (
+    WorkflowBuilder("simple_etl")
+    .task("extract", "etl.extract_data", result_key="raw_data")
+    .task(
+        "transform",
+        "etl.transform_data",
+        args=["{{raw_data}}"],
+        result_key="transformed_data",
+    )
+    .retry(max_retries=3, delay=timedelta(seconds=10))
+    .task("load", "etl.load_data", args=["{{transformed_data}}"])
+    .timeout(timeout=timedelta(minutes=30))
+    .wait("wait_next", timedelta(hours=24))
+    .task("cleanup", "etl.cleanup")
+    .build()
+)
+
+print(workflow.to_yaml())
+```
+
+## Real-World Example: E-Commerce Order Processing
+
+```python
+from highway_dsl import WorkflowBuilder, RetryPolicy
+from datetime import datetime, timedelta
+
+# Production-ready e-commerce order workflow
+workflow = (
+    WorkflowBuilder("order_processing")
+    .set_schedule("*/5 * * * *")  # Run every 5 minutes
+    .set_start_date(datetime(2025, 1, 1))
+    .add_tags("production", "orders", "critical")
+    .set_default_retry_policy(RetryPolicy(max_retries=3, delay=timedelta(seconds=30)))
+
+    # Fetch pending orders
+    .task("fetch_orders", "orders.get_pending", result_key="orders")
+
+    # Process each order
+    .foreach(
+        "process_each_order",
+        items="{{orders}}",
+        loop_body=lambda b: (
+            b.task("validate", "orders.validate", args=["{{item}}"])
+            .task("charge_payment", "payments.charge", args=["{{item}}"],
+                  result_key="payment_result")
+            .task("send_failure_email", "email.send_failure",
+                  args=["{{item.customer_email}}"])
+            .on_failure("send_failure_email")  # Alert on payment failure
+            .switch(
+                "route_by_amount",
+                switch_on="{{item.total}}",
+                cases={
+                    "high": "priority_shipping",  # > $500
+                    "medium": "standard_shipping",  # $100-500
+                    "low": "economy_shipping"  # < $100
+                },
+                default="standard_shipping"
+            )
+        )
+    )
+
+    # Emit completion event for analytics workflow
+    .emit_event(
+        "notify_analytics",
+        event_name="orders_processed_{{ds}}",
+        payload={"count": "{{orders.length}}", "timestamp": "{{run.started_at}}"}
+    )
+
+    .build()
+)
+```
+
+This workflow demonstrates:
+- Scheduled execution every 5 minutes
+- Default retry policy for all tasks
+- ForEach loop processing multiple orders
+- Payment failure callbacks
+- Switch/case routing based on order amount
+- Event emission for cross-workflow coordination
+
+## Mermaid Diagram Generation
+
+You can generate a Mermaid state diagram of your workflow using the `to_mermaid` method:
+
+```python
+print(workflow.to_mermaid())
+```
+
+This will output a Mermaid diagram in the `stateDiagram-v2` format, which can be used with a variety of tools to visualize your workflow.
+
+## Bank ETL Example
+
+A more complex example of a bank's end-of-day ETL process can be found in `examples/bank_end_of_the_day_etl_workflow.py`.
+
+A mermaid diagram of this workflow can be found [here](docs/bank_etl.mermaid).
+
+## Advanced Usage
+
+### Conditional Logic
+
+```python
+from highway_dsl import WorkflowBuilder, RetryPolicy
+from datetime import timedelta
+
+builder = WorkflowBuilder("data_processing_pipeline")
+
+builder.task("start", "workflows.tasks.initialize", result_key="init_data")
+builder.task(
+    "validate",
+    "workflows.tasks.validate_data",
+    args=["{{init_data}}"],
+    result_key="validated_data",
+)
+
+builder.condition(
+    "check_quality",
+    condition="{{validated_data.quality_score}} > 0.8",
+    if_true=lambda b: b.task(
+        "high_quality_processing",
+        "workflows.tasks.advanced_processing",
+        args=["{{validated_data}}"],
+        retry_policy=RetryPolicy(max_retries=5, delay=timedelta(seconds=10), backoff_factor=2.0),
+    ),
+    if_false=lambda b: b.task(
+        "standard_processing",
+        "workflows.tasks.basic_processing",
+        args=["{{validated_data}}"],
+    ),
+)
+
+workflow = builder.build()
+```
+
+### While Loops
+
+```python
+from highway_dsl import WorkflowBuilder
+
+builder = WorkflowBuilder("qa_rework_workflow")
+
+builder.task("start_qa", "workflows.tasks.start_qa", result_key="qa_results")
+
+builder.while_loop(
+    "qa_rework_loop",
+    condition="{{qa_results.status}} == 'failed'",
+    loop_body=lambda b: b.task("perform_rework", "workflows.tasks.perform_rework").task(
+        "re_run_qa", "workflows.tasks.run_qa", result_key="qa_results"
+    ),
+)
+
+builder.task("finalize_product", "workflows.tasks.finalize_product", dependencies=["qa_rework_loop"])
+
+workflow = builder.build()
+```
+
+### For-Each Loops with Proper Dependency Management
+
+Fixed bug where foreach loops were incorrectly inheriting dependencies from containing parallel operators:
+
+```python
+# This loop now properly encapsulates its internal tasks
+builder.foreach(
+    "process_items",
+    items="{{data.items}}",
+    loop_body=lambda fb: fb.task("process_item", "processor.handle_item", args=["{{item.id}}"])
+    # Loop body tasks only have proper dependencies, not unwanted "grandparent" dependencies
+)
+```
+
+### Retry Policies
+
+```python
+from highway_dsl import RetryPolicy
+from datetime import timedelta
+
+builder.task(
+    "reliable_task",
+    "service.operation",
+    retry_policy=RetryPolicy(
+        max_retries=5,
+        delay=timedelta(seconds=10),
+        backoff_factor=2.0
+    )
+)
+```
+
+### Timeout Policies
+
+```python
+from highway_dsl import TimeoutPolicy
+from datetime import timedelta
+
+builder.task(
+    "timed_task",
+    "service.operation",
+    timeout_policy=TimeoutPolicy(
+        timeout=timedelta(hours=1),
+        kill_on_timeout=True
+    )
+)
+```
+
+## Version History
+
+### Version 1.1.0 - Feature Release (Current)
+
+**Airflow-Parity Features:**
+- Scheduling metadata (cron, start_date, catchup, tags, max_active_runs)
+- Workflow-level default retry policy
+
+**Event-Driven Features:**
+- EmitEventOperator for cross-workflow coordination
+- WaitForEventOperator with timeout support
+
+**Production Features:**
+- Durable callback hooks (on_success, on_failure)
+- SwitchOperator for multi-branch routing
+- Task descriptions for documentation
+- RFC-style specification document (3,215 lines)
+
+### Version 1.0.3 - Stable Release
+
+This is a stable release with important bug fixes and enhancements, including a critical fix for the ForEach operator dependency management issue.
+
+## Development
+
+To set up the development environment:
+
+```bash
+git clone https://github.com/your-username/highway.git
+cd highway/dsl
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .[dev]
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Type Checking
+
+```bash
+mypy .
+```
+
+## Documentation
+
+- **README.md** (this file) - Getting started and examples
+- **spec.txt** - RFC-style formal specification (3,215 lines)
+- **examples/** - Comprehensive workflow examples
+
+## License
+
+MIT License

highway_dsl-1.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+highway_dsl/__init__.py,sha256=D3gFgy3Wq5-NqfmnGcN1RDw8JxGsJBGVKwVsUFDKn4A,651
+highway_dsl/workflow_dsl.py,sha256=NGXTddjeVz530wwKwLvvx0bjMDDmk9WNOxcPqXxNZzs,26742
+highway_dsl-1.2.0.dist-info/licenses/LICENSE,sha256=qdFq1H66BvKg67mf4-WGpFwtG2u_dNknxuJDQ1_ubaY,1072
+highway_dsl-1.2.0.dist-info/METADATA,sha256=4fokdO8BWKOF3v8lnM1cl77BJ4YK_1XhSwSxXks3hbE,14242
+highway_dsl-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+highway_dsl-1.2.0.dist-info/top_level.txt,sha256=_5uX-bbBsQ2rsi1XMr7WRyKbr6ack5GqVBcy-QjF1C8,12
+highway_dsl-1.2.0.dist-info/RECORD,,

highway_dsl-1.0.2.dist-info/METADATA

@@ -1,228 +0,0 @@
-Metadata-Version: 2.4
-Name: highway_dsl
-Version: 1.0.2
-Summary: A stable domain specific language (DSL) for defining and managing data processing pipelines and workflow engines.
-Author-email: Farseed Ashouri <farseed.ashouri@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/rodmena-limited/highway_dsl
-Project-URL: Issues, https://github.com/rodmena-limited/highway_dsl/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pydantic>=2.12.3
-Requires-Dist: pyyaml>=6.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: mypy>=1.0.0; extra == "dev"
-Requires-Dist: types-PyYAML>=6.0.0; extra == "dev"
-Requires-Dist: pytest-cov>=2.12.1; extra == "dev"
-Dynamic: license-file
-
-# Highway DSL
-
-[![PyPI version](https://badge.fury.io/py/highway-dsl.svg)](https://badge.fury.io/py/highway-dsl)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Stable](https://img.shields.io/badge/Status-Stable-brightgreen)](https://pypi.org/project/highway-dsl/)
-
-**Highway DSL** is a stable, Python-based domain-specific language for defining complex workflows in a clear, concise, and fluent manner. It is part of the larger **Highway** project, an advanced workflow engine capable of running complex DAG-based workflows.
-
-## Version 1.0.2 - Stable Release
-
-This is a stable release with important bug fixes and enhancements, including a critical fix for the ForEach operator dependency management issue.
-
-## Features
-
-*   **Fluent API:** A powerful and intuitive `WorkflowBuilder` for defining workflows programmatically.
-*   **Pydantic-based:** All models are built on Pydantic, providing robust data validation, serialization, and documentation.
-*   **Rich Operators:** A comprehensive set of operators for handling various workflow scenarios:
-    *   `Task` - Basic workflow steps
-    *   `Condition` (if/else) - Conditional branching
-    *   `Parallel` - Execute multiple branches simultaneously 
-    *   `ForEach` - Iterate over collections with proper dependency management
-    *   `Wait` - Pause execution for scheduled tasks
-    *   `While` - Execute loops based on conditions
-*   **Fixed ForEach Bug:** Proper encapsulation of loop body tasks to prevent unwanted "grandparent" dependencies from containing parallel operators.
-*   **YAML/JSON Interoperability:** Workflows can be defined in Python and exported to YAML or JSON, and vice-versa.
-*   **Retry and Timeout Policies:** Built-in error handling and execution time management.
-*   **Extensible:** The DSL is designed to be extensible with custom operators and policies.
-
-## Installation
-
-```bash
-pip install highway-dsl
-```
-
-## Quick Start
-
-Here's a simple example of how to define a workflow using the `WorkflowBuilder`:
-
-```python
-from datetime import timedelta
-from highway_dsl import WorkflowBuilder
-
-workflow = (
-    WorkflowBuilder("simple_etl")
-    .task("extract", "etl.extract_data", result_key="raw_data")
-    .task(
-        "transform",
-        "etl.transform_data",
-        args=["{{raw_data}}"],
-        result_key="transformed_data",
-    )
-    .retry(max_retries=3, delay=timedelta(seconds=10))
-    .task("load", "etl.load_data", args=["{{transformed_data}}"])
-    .timeout(timeout=timedelta(minutes=30))
-    .wait("wait_next", timedelta(hours=24))
-    .task("cleanup", "etl.cleanup")
-    .build()
-)
-
-print(workflow.to_yaml())
-```
-
-## Advanced Usage
-
-### Conditional Logic
-
-```python
-from highway_dsl import WorkflowBuilder, RetryPolicy
-from datetime import timedelta
-
-builder = WorkflowBuilder("data_processing_pipeline")
-
-builder.task("start", "workflows.tasks.initialize", result_key="init_data")
-builder.task(
-    "validate",
-    "workflows.tasks.validate_data",
-    args=["{{init_data}}"],
-    result_key="validated_data",
-)
-
-builder.condition(
-    "check_quality",
-    condition="{{validated_data.quality_score}} > 0.8",
-    if_true=lambda b: b.task(
-        "high_quality_processing",
-        "workflows.tasks.advanced_processing",
-        args=["{{validated_data}}"],
-        retry_policy=RetryPolicy(max_retries=5, delay=timedelta(seconds=10), backoff_factor=2.0),
-    ),
-    if_false=lambda b: b.task(
-        "standard_processing",
-        "workflows.tasks.basic_processing",
-        args=["{{validated_data}}"],
-    ),
-)
-
-workflow = builder.build()
-```
-
-### While Loops
-
-```python
-from highway_dsl import WorkflowBuilder
-
-builder = WorkflowBuilder("qa_rework_workflow")
-
-builder.task("start_qa", "workflows.tasks.start_qa", result_key="qa_results")
-
-builder.while_loop(
-    "qa_rework_loop",
-    condition="{{qa_results.status}} == 'failed'",
-    loop_body=lambda b: b.task("perform_rework", "workflows.tasks.perform_rework").task(
-        "re_run_qa", "workflows.tasks.run_qa", result_key="qa_results"
-    ),
-)
-
-builder.task("finalize_product", "workflows.tasks.finalize_product", dependencies=["qa_rework_loop"])
-
-workflow = builder.build()
-```
-
-### For-Each Loops with Proper Dependency Management
-
-Fixed bug where foreach loops were incorrectly inheriting dependencies from containing parallel operators:
-
-```python
-# This loop now properly encapsulates its internal tasks
-builder.foreach(
-    "process_items",
-    items="{{data.items}}",
-    loop_body=lambda fb: fb.task("process_item", "processor.handle_item", args=["{{item.id}}"])
-    # Loop body tasks only have proper dependencies, not unwanted "grandparent" dependencies
-)
-```
-
-### Retry Policies
-
-```python
-from highway_dsl import RetryPolicy
-from datetime import timedelta
-
-builder.task(
-    "reliable_task",
-    "service.operation",
-    retry_policy=RetryPolicy(
-        max_retries=5,
-        delay=timedelta(seconds=10),
-        backoff_factor=2.0
-    )
-)
-```
-
-### Timeout Policies
-
-```python
-from highway_dsl import TimeoutPolicy
-from datetime import timedelta
-
-builder.task(
-    "timed_task",
-    "service.operation",
-    timeout_policy=TimeoutPolicy(
-        timeout=timedelta(hours=1),
-        kill_on_timeout=True
-    )
-)
-```
-
-## What's New in Version 1.0.2
-
-### Bug Fixes
-* **Fixed ForEach Operator Bug**: Resolved issue where foreach loops were incorrectly getting "grandparent" dependencies from containing parallel operators. Loop body tasks are now properly encapsulated and only depend on their parent loop operator and internal chain dependencies.
-
-### Enhancements
-* **Improved Loop Dependency Management**: While loops and ForEach loops now properly encapsulate their internal dependencies without being affected by containing parallel operators.
-* **Better Error Handling**: Enhanced error handling throughout the DSL.
-* **Comprehensive Test Suite**: Added functional tests for all example workflows to ensure consistency.
-
-## Development
-
-To set up the development environment:
-
-```bash
-git clone https://github.com/your-username/highway.git
-cd highway
-python -m venv .venv
-source .venv/bin/activate
-pip install -e .[dev]
-```
-
-### Running Tests
-
-```bash
-pytest
-```
-
-### Type Checking
-
-```bash
-mypy .
-```
-
-## License
-
-MIT License

highway_dsl-1.0.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-highway_dsl/__init__.py,sha256=mr1oMylxliFwu2VO2qpyM3sVQwYIoPL2P6JE-6ZuF7M,507
-highway_dsl/workflow_dsl.py,sha256=bhCKDPrMaIkEI4HduKoeqd2VlZsK8wjr8RURifPufGU,14700
-highway_dsl-1.0.2.dist-info/licenses/LICENSE,sha256=qdFq1H66BvKg67mf4-WGpFwtG2u_dNknxuJDQ1_ubaY,1072
-highway_dsl-1.0.2.dist-info/METADATA,sha256=uCUL4xLYOkZ10TzFzxn6jZ3rjtcL_h7f5fLX5RD41Kk,7187
-highway_dsl-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-highway_dsl-1.0.2.dist-info/top_level.txt,sha256=_5uX-bbBsQ2rsi1XMr7WRyKbr6ack5GqVBcy-QjF1C8,12
-highway_dsl-1.0.2.dist-info/RECORD,,