Troubleshooting Guide

# Install Flow Core
pip install nadoo-flow-core

# Or install from GitHub
pip install git+https://github.com/nadoo-ai/nadoo-flow-core.git

# Create fresh virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install with specific versions
pip install nadoo-flow-core==0.1.0

# Wrong - Missing await
result = workflow.execute(data)

# Correct - Use await
result = await workflow.execute(data)

# Or use asyncio.run for top-level
import asyncio
result = asyncio.run(workflow.execute(data))

# In Jupyter notebooks
import nest_asyncio
nest_asyncio.apply()

# Then you can use await directly
result = await workflow.execute(data)

# Or use await in async cells
# %% (async cell in Jupyter)
result = await workflow.execute(data)

import os

# Set environment variable
os.environ["OPENAI_API_KEY"] = "your-api-key"

# Or use .env file
from dotenv import load_dotenv
load_dotenv()

# Verify it's set
assert os.getenv("OPENAI_API_KEY"), "API key not found"

from nadoo_flow import RetryNode, LLMNode

# Add retry with exponential backoff
workflow = RetryNode(
    node=LLMNode(model="gpt-4"),
    max_retries=5,
    backoff_factor=2.0,
    retry_on_errors=[RateLimitError]
)

# Increase timeout
llm = LLMNode(
    model="gpt-4",
    timeout=60.0  # 60 seconds
)

# Or implement timeout handling
import asyncio

try:
    result = await asyncio.wait_for(
        workflow.execute(data),
        timeout=30.0
    )
except asyncio.TimeoutError:
    print("Workflow timed out")

import time

start = time.time()
result = await workflow.execute(data)
print(f"Duration: {time.time() - start:.2f}s")

from nadoo_flow import ParallelNode

# Sequential (slow)
workflow = NodeA() | NodeB() | NodeC()

# Parallel (fast)
workflow = ParallelNode([NodeA(), NodeB(), NodeC()])

from functools import lru_cache

class CachedNode(ChainableNode):
    @lru_cache(maxsize=100)
    async def _cached_operation(self, key: str):
        # Expensive operation
        pass

# Use cheaper model for simple tasks
simple_llm = LLMNode(model="gpt-3.5-turbo")

# Reduce max_tokens
llm = LLMNode(model="gpt-4", max_tokens=500)

# Process in batches
async def process_batch(items, batch_size=10):
    for i in range(0, len(items), batch_size):
        batch = items[i:i+batch_size]
        results = await asyncio.gather(*[
            workflow.execute(item) for item in batch
        ])
        # Process results immediately
        yield results

# Clear caches periodically
import gc
gc.collect()

# Add type validation
from pydantic import BaseModel

class WorkflowInput(BaseModel):
    message: str
    user_id: str

# Validate before execution
validated = WorkflowInput(**input_data)
result = await workflow.execute(validated.dict())

# Use .get() with defaults
value = data.get("key", "default_value")

# Or validate with Pydantic
class Input(BaseModel):
    required_field: str
    optional_field: str = "default"

# Add logging
import logging
logging.basicConfig(level=logging.DEBUG)

class DebugNode(ChainableNode):
    async def execute(self, data):
        print(f"Executing with data: {data}")
        result = await self.process(data)
        print(f"Result: {result}")
        return result

# Add maximum iterations
class SafeLoopNode(ChainableNode):
    def __init__(self, max_iterations=100):
        super().__init__()
        self.max_iterations = max_iterations

    async def execute(self, data):
        iterations = 0
        while condition and iterations < self.max_iterations:
            # Process
            iterations += 1

        if iterations >= self.max_iterations:
            raise RuntimeError("Max iterations reached")

from sqlalchemy import create_engine
from sqlalchemy.pool import NullPool

# Use connection pooling
engine = create_engine(
    database_url,
    pool_size=10,
    max_overflow=20,
    pool_pre_ping=True  # Verify connections
)

# Add retry logic
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=1, max=10)
)
async def connect_db():
    return await database.connect()

import aiohttp
from aiohttp import ClientTimeout

async def api_call_with_retry():
    timeout = ClientTimeout(total=30)

    async with aiohttp.ClientSession(timeout=timeout) as session:
        for attempt in range(3):
            try:
                async with session.get(url) as response:
                    return await response.json()
            except aiohttp.ClientError as e:
                if attempt == 2:
                    raise
                await asyncio.sleep(2 ** attempt)

import logging

# Set up logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# Create logger
logger = logging.getLogger("nadoo_flow")
logger.setLevel(logging.DEBUG)

class DebugNode(ChainableNode):
    async def execute(self, data):
        import pdb; pdb.set_trace()  # Add breakpoint
        result = await self.process(data)
        return result

class TracingNode(ChainableNode):
    async def execute(self, data):
        print(f"[{self.__class__.__name__}] Input: {data}")

        try:
            result = await self.process(data)
            print(f"[{self.__class__.__name__}] Output: {result}")
            return result
        except Exception as e:
            print(f"[{self.__class__.__name__}] Error: {e}")
            raise

import cProfile
import pstats

async def profile_workflow():
    profiler = cProfile.Profile()
    profiler.enable()

    result = await workflow.execute(data)

    profiler.disable()
    stats = pstats.Stats(profiler)
    stats.sort_stats('cumulative')
    stats.print_stats(10)  # Top 10 slowest

# System information
import sys
import platform

print(f"Python: {sys.version}")
print(f"Platform: {platform.platform()}")

# Package versions
import nadoo_flow
print(f"Nadoo Flow Core: {nadoo_flow.__version__}")

# Minimal reproducible example
from nadoo_flow import LLMNode

workflow = LLMNode(model="gpt-4")
result = await workflow.execute({"prompt": "test"})
# Error occurs here