base

from nadoo_flow import WorkflowExecutor

executor = WorkflowExecutor(config=None)

async def execute(
    workflow: Workflow,
    input_data: Dict[str, Any],
    context: Optional[WorkflowContext] = None
) -> ExecutionResult

result = await executor.execute(
    workflow=my_workflow,
    input_data={"user_id": 123}
)

from nadoo_flow import NodeContext

context = NodeContext(node_id="node_1")

def get_input(key: Optional[str] = None) -> Any

def set_output(data: Dict[str, Any]) -> None

def set_variable(key: str, value: Any) -> None

from nadoo_flow import WorkflowContext

context = WorkflowContext(workflow_id="workflow_1")

from nadoo_flow import BaseNode

class MyNode(BaseNode):
    async def execute(self, node_context, workflow_context):
        # Implementation
        pass

@abstractmethod
async def execute(
    node_context: NodeContext,
    workflow_context: WorkflowContext
) -> NodeResult

@abstractmethod
async def validate() -> bool

async def pre_execute(
    node_context: NodeContext,
    workflow_context: WorkflowContext
) -> None

async def post_execute(
    node_context: NodeContext,
    workflow_context: WorkflowContext
) -> None

from nadoo_flow import NodeResult

result = NodeResult(
    success=True,
    output={"data": "value"},
    error=None
)

from nadoo_flow import IStepNode

class CustomNode(IStepNode):
    async def execute(self, node_context, workflow_context):
        pass

    async def validate(self):
        pass

from nadoo_flow import NodeStatus

class NodeStatus(Enum):
    PENDING = "pending"
    RUNNING = "running"
    SUCCESS = "success"
    FAILED = "failed"
    SKIPPED = "skipped"
    CANCELLED = "cancelled"

from nadoo_flow import CommonNodeTypes

class CommonNodeTypes:
    START = "start"
    END = "end"
    CONDITION = "condition"
    PARALLEL = "parallel"
    LOOP = "loop"
    AI_AGENT = "ai_agent"
    LLM = "llm"
    TOOL = "tool"
    DATABASE = "database"
    PYTHON = "python"
    CUSTOM = "custom"

from nadoo_flow import ExecutionConfig

config = ExecutionConfig(
    max_parallel_nodes=10,
    timeout_seconds=300,
    retry_failed_nodes=True,
    max_retries=3,
    enable_checkpoints=True,
    checkpoint_interval=5,
    trace_execution=True
)

from nadoo_flow import ExecutionResult

result = ExecutionResult(
    success=True,
    output={"result": "data"},
    error=None,
    context=workflow_context,
    execution_time=1.23
)

from nadoo_flow import WorkflowExecutionError

raise WorkflowExecutionError("Workflow failed", node_id="node_1")

from nadoo_flow import NodeExecutionError

raise NodeExecutionError("Node failed", node_id="node_1", error_details={})

from nadoo_flow import ValidationError

raise ValidationError("Invalid configuration", field="config.timeout")

from nadoo_flow import create_workflow

workflow = create_workflow({
    "id": "workflow_1",
    "nodes": [...],
    "edges": [...]
})

from nadoo_flow import validate_workflow

is_valid = validate_workflow(workflow)

from nadoo_flow import BaseNode, NodeResult

class ProcessingNode(BaseNode):
    def __init__(self):
        super().__init__(
            node_id="processor",
            node_type=CommonNodeTypes.CUSTOM,
            name="Data Processor"
        )

    async def execute(self, node_context, workflow_context):
        # Access input
        data = node_context.input_data

        # Process data
        result = await self.process(data)

        # Return result
        return NodeResult(
            success=True,
            output={"processed": result}
        )

    async def validate(self):
        return True

    async def process(self, data):
        # Custom processing logic
        return data

from nadoo_flow import WorkflowExecutor, ExecutionConfig

# Configure executor
config = ExecutionConfig(
    timeout_seconds=60,
    retry_failed_nodes=True
)

executor = WorkflowExecutor(config)

# Execute workflow
result = await executor.execute(
    workflow=my_workflow,
    input_data={"user_id": 123}
)

if result.success:
    print(f"Output: {result.output}")
else:
    print(f"Error: {result.error}")

from nadoo_flow import NodeContext, WorkflowContext

# Create contexts
workflow_context = WorkflowContext("workflow_1")
workflow_context.global_variables["api_key"] = "sk-..."

node_context = NodeContext("node_1")
node_context.input_data = {"message": "Hello"}

# Execute node with contexts
result = await node.execute(node_context, workflow_context)

# Access results
print(f"Node output: {node_context.output_data}")
print(f"Workflow state: {workflow_context.shared_state}")