yamlgraph 0.1.1__py3-none-any.whl

examples/storyboard/retry_images.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Retry image generation from existing animated storyboard metadata.
+
+Usage:
+    python examples/storyboard/retry_images.py outputs/storyboard/20260117_112419/animated
+
+Options:
+    --model MODEL         Image model to use (default: hidream)
+    --reference PATH      Override reference image path
+    --magic FLOAT         Magic value for img2img (default: 0.25)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+# Add project root to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from examples.storyboard.nodes.animated_character_node import (
+    generate_animated_character_images,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Retry image generation from existing metadata"
+    )
+    parser.add_argument(
+        "output_dir",
+        type=Path,
+        help="Path to animated output directory (contains animated_character_story.json)",
+    )
+    parser.add_argument(
+        "--model",
+        default="hidream",
+        help="Image model to use (default: hidream)",
+    )
+    parser.add_argument(
+        "--reference",
+        type=Path,
+        help="Override reference image path",
+    )
+    parser.add_argument(
+        "--new-id",
+        help="New thread ID for output (default: adds _retry suffix)",
+    )
+    args = parser.parse_args()
+
+    # Find metadata file
+    output_dir = args.output_dir
+    if output_dir.name != "animated":
+        output_dir = output_dir / "animated"
+
+    metadata_path = output_dir / "animated_character_story.json"
+    if not metadata_path.exists():
+        print(f"❌ Metadata not found: {metadata_path}")
+        sys.exit(1)
+
+    print(f"📂 Loading: {metadata_path}")
+    metadata = json.loads(metadata_path.read_text())
+
+    # Reconstruct animated_panels from metadata
+    animated_panels = []
+    for panel in metadata["panels"]:
+        animated_panels.append(
+            {
+                "_map_index": panel["index"] - 1,
+                **panel["prompts"],
+            }
+        )
+
+    # Determine thread_id
+    original_thread = output_dir.parent.name
+    thread_id = args.new_id or f"{original_thread}_retry"
+
+    # Build state
+    state = {
+        "concept": metadata["concept"],
+        "model": args.model,
+        "thread_id": thread_id,
+        "story": {
+            "title": metadata["title"],
+            "narrative": metadata["narrative"],
+            "character_prompt": metadata["character_prompt"],
+        },
+        "animated_panels": animated_panels,
+    }
+
+    # Handle reference image
+    if args.reference:
+        state["reference_image"] = str(args.reference)
+    elif metadata.get("reference_image"):
+        ref_path = Path(metadata["reference_image"])
+        if ref_path.exists():
+            state["reference_image"] = str(ref_path)
+            print(f"🎭 Using existing reference: {ref_path}")
+
+    print("🎬 Retrying image generation...")
+    print(f"   Model: {args.model}")
+    print(f"   Panels: {len(animated_panels)}")
+    print(f"   Output: outputs/storyboard/{thread_id}/animated/")
+
+    # Run image generation
+    result = generate_animated_character_images(state)
+
+    if result.get("error"):
+        print(f"❌ Error: {result['error']}")
+        sys.exit(1)
+
+    print(f"\n✅ Generated images in: {result['output_dir']}")
+
+
+if __name__ == "__main__":
+    main()

tests/__init__.py

@@ -0,0 +1 @@
+"""Test suite for yamlgraph."""

tests/conftest.py

@@ -0,0 +1,178 @@
+"""Shared test fixtures for yamlgraph tests.
+
+This module provides test-only Pydantic models and fixtures for testing.
+These models are intentionally NOT imported from yamlgraph.models to
+demonstrate that the framework is truly generic and works with any schema.
+"""
+
+from pathlib import Path
+from typing import Generator
+from unittest.mock import MagicMock
+
+import pytest
+from pydantic import BaseModel, Field
+
+from yamlgraph.models import create_initial_state
+from yamlgraph.storage import YamlGraphDB
+
+# =============================================================================
+# Test-Only Pydantic Models (Fixtures)
+# =============================================================================
+# These replicate demo model structures but are defined here to prove
+# the framework is generic and doesn't depend on demo-specific schemas.
+# Named with "Fixture" suffix to avoid pytest collection warnings.
+
+
+class FixtureGeneratedContent(BaseModel):
+    """Test fixture for generated content."""
+
+    title: str = Field(description="Title of the generated content")
+    content: str = Field(description="The main generated text")
+    word_count: int = Field(description="Approximate word count")
+    tags: list[str] = Field(default_factory=list, description="Relevant tags")
+
+
+class FixtureAnalysis(BaseModel):
+    """Test fixture for content analysis."""
+
+    summary: str = Field(description="Brief summary of the content")
+    key_points: list[str] = Field(description="Main points extracted")
+    sentiment: str = Field(description="Overall sentiment")
+    confidence: float = Field(ge=0.0, le=1.0, description="Confidence score 0-1")
+
+
+class FixtureToneClassification(BaseModel):
+    """Test fixture for tone classification."""
+
+    tone: str = Field(description="Detected tone: positive, negative, or neutral")
+    confidence: float = Field(ge=0.0, le=1.0, description="Confidence score 0-1")
+    reasoning: str = Field(description="Explanation for the classification")
+
+
+class FixtureDraftContent(BaseModel):
+    """Test fixture for draft content."""
+
+    content: str = Field(description="The draft content")
+    version: int = Field(default=1, description="Draft version number")
+
+
+class FixtureCritique(BaseModel):
+    """Test fixture for critique output."""
+
+    score: float = Field(ge=0.0, le=1.0, description="Quality score 0-1")
+    feedback: str = Field(description="Specific improvement suggestions")
+    issues: list[str] = Field(
+        default_factory=list, description="List of identified issues"
+    )
+    should_refine: bool = Field(
+        default=True, description="Whether refinement is needed"
+    )
+
+
+class FixtureGitReport(BaseModel):
+    """Test fixture for git report."""
+
+    title: str = Field(description="Report title")
+    summary: str = Field(description="Executive summary")
+    key_findings: list[str] = Field(description="Main findings")
+    recommendations: list[str] = Field(default_factory=list, description="Suggestions")
+
+
+# =============================================================================
+# Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def sample_generated_content() -> FixtureGeneratedContent:
+    """Sample generated content for testing."""
+    return FixtureGeneratedContent(
+        title="Test Article",
+        content="This is test content about artificial intelligence. " * 20,
+        word_count=100,
+        tags=["test", "ai"],
+    )
+
+
+@pytest.fixture
+def sample_analysis() -> FixtureAnalysis:
+    """Sample analysis for testing."""
+    return FixtureAnalysis(
+        summary="This is a test summary of the content.",
+        key_points=["Point 1", "Point 2", "Point 3"],
+        sentiment="positive",
+        confidence=0.85,
+    )
+
+
+@pytest.fixture
+def sample_state(sample_generated_content, sample_analysis) -> dict:
+    """Complete sample state for testing."""
+    state = create_initial_state(
+        topic="artificial intelligence",
+        style="informative",
+        word_count=300,
+        thread_id="test123",
+    )
+    state["generated"] = sample_generated_content
+    state["analysis"] = sample_analysis
+    state["final_summary"] = "This is the final summary."
+    state["current_step"] = "summarize"
+    return state
+
+
+@pytest.fixture
+def empty_state() -> dict:
+    """Initial empty state for testing."""
+    return create_initial_state(
+        topic="test topic",
+        style="casual",
+        word_count=200,
+    )
+
+
+@pytest.fixture
+def temp_db(tmp_path: Path) -> Generator[YamlGraphDB, None, None]:
+    """Temporary database for testing."""
+    db_path = tmp_path / "test.db"
+    db = YamlGraphDB(db_path=db_path)
+    yield db
+
+
+@pytest.fixture
+def temp_output_dir(tmp_path: Path) -> Path:
+    """Temporary output directory for testing."""
+    output_dir = tmp_path / "outputs"
+    output_dir.mkdir()
+    return output_dir
+
+
+@pytest.fixture
+def mock_llm_response():
+    """Mock LLM that returns predictable responses."""
+
+    def _create_mock(response_content: str | dict = "Mocked response"):
+        mock = MagicMock()
+        mock_response = MagicMock()
+        mock_response.content = response_content
+        mock.invoke.return_value = mock_response
+        return mock
+
+    return _create_mock
+
+
+@pytest.fixture
+def mock_structured_llm(sample_generated_content, sample_analysis):
+    """Mock LLM with structured output support."""
+
+    def _create_mock(model_type: str):
+        mock = MagicMock()
+        if model_type == "generate":
+            mock.invoke.return_value = sample_generated_content
+        elif model_type == "analyze":
+            mock.invoke.return_value = sample_analysis
+        else:
+            mock.invoke.return_value = "Mocked summary"
+        return mock
+
+    return _create_mock

tests/integration/__init__.py

@@ -0,0 +1 @@
+"""Integration tests for yamlgraph."""

tests/integration/test_animated_storyboard.py

@@ -0,0 +1,63 @@
+"""Tests for animated storyboard graph."""
+
+from unittest.mock import MagicMock, patch
+
+from yamlgraph.graph_loader import compile_graph, load_graph_config
+
+
+class TestAnimatedStoryboardGraph:
+    """Tests for the animated-character-storyboard graph."""
+
+    def test_config_loads(self) -> None:
+        """Animated character storyboard config loads successfully."""
+        config = load_graph_config("examples/storyboard/animated-character-graph.yaml")
+        assert config.name == "animated-character-storyboard"
+        assert "expand_story" in config.nodes
+        assert "animate_panels" in config.nodes
+        assert "generate_images" in config.nodes
+
+    def test_animate_panels_is_map_node(self) -> None:
+        """animate_panels node is type: map."""
+        config = load_graph_config("examples/storyboard/animated-character-graph.yaml")
+        animate_node = config.nodes["animate_panels"]
+
+        assert animate_node["type"] == "map"
+        assert animate_node["over"] == "{state.story.panels}"
+        assert animate_node["as"] == "panel_prompt"
+        assert animate_node["collect"] == "animated_panels"
+
+    def test_graph_compiles(self) -> None:
+        """Animated character storyboard graph compiles to StateGraph."""
+        config = load_graph_config("examples/storyboard/animated-character-graph.yaml")
+
+        with patch("yamlgraph.graph_loader.compile_map_node") as mock_compile_map:
+            mock_map_edge_fn = MagicMock()
+            mock_compile_map.return_value = (
+                mock_map_edge_fn,
+                "_map_animate_panels_sub",
+            )
+
+            compile_graph(config)
+
+            # Should have called compile_map_node for animate_panels
+            mock_compile_map.assert_called_once()
+            call_args = mock_compile_map.call_args
+            assert call_args[0][0] == "animate_panels"
+
+    def test_state_has_animated_panels_sorted_reducer(self) -> None:
+        """State class has sorted_add reducer for animated_panels."""
+        from typing import Annotated, get_args, get_origin
+
+        from yamlgraph.models.state_builder import build_state_class, sorted_add
+
+        config = load_graph_config("examples/storyboard/animated-character-graph.yaml")
+        state_class = build_state_class(config.raw_config)
+
+        annotations = state_class.__annotations__
+        assert "animated_panels" in annotations
+
+        field_type = annotations["animated_panels"]
+        assert get_origin(field_type) is Annotated
+        args = get_args(field_type)
+        assert args[0] is list
+        assert args[1] is sorted_add

tests/integration/test_cli_commands.py

@@ -0,0 +1,242 @@
+"""Integration tests for CLI commands.
+
+Tests actual command execution with real (but minimal) operations.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+class TestGraphCommands:
+    """Integration tests for graph subcommands."""
+
+    def test_graph_list_returns_graphs(self):
+        """'graph list' shows available graphs."""
+        result = subprocess.run(
+            [sys.executable, "-m", "yamlgraph.cli", "graph", "list"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        assert result.returncode == 0
+        assert "yamlgraph.yaml" in result.stdout
+        assert "Available graphs" in result.stdout
+
+    def test_graph_list_shows_all_demos(self):
+        """'graph list' shows all demo graphs."""
+        result = subprocess.run(
+            [sys.executable, "-m", "yamlgraph.cli", "graph", "list"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        assert result.returncode == 0
+        # Should list all main demo graphs
+        assert "router-demo.yaml" in result.stdout
+        assert "reflexion-demo.yaml" in result.stdout
+        assert "git-report.yaml" in result.stdout
+
+    def test_graph_validate_valid_graph(self):
+        """'graph validate' succeeds for valid graph."""
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "yamlgraph.cli",
+                "graph",
+                "validate",
+                "graphs/yamlgraph.yaml",
+            ],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        assert result.returncode == 0
+        assert "VALID" in result.stdout
+
+    def test_graph_validate_all_demos(self):
+        """'graph validate' succeeds for all demo graphs."""
+        demos = [
+            "graphs/yamlgraph.yaml",
+            "graphs/router-demo.yaml",
+            "graphs/reflexion-demo.yaml",
+            "graphs/git-report.yaml",
+            "graphs/memory-demo.yaml",
+            "graphs/map-demo.yaml",
+        ]
+        for demo in demos:
+            result = subprocess.run(
+                [sys.executable, "-m", "yamlgraph.cli", "graph", "validate", demo],
+                capture_output=True,
+                text=True,
+                cwd=Path(__file__).parent.parent.parent,
+            )
+            assert result.returncode == 0, f"Failed to validate {demo}: {result.stderr}"
+
+    def test_graph_validate_invalid_path(self):
+        """'graph validate' fails for missing file."""
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "yamlgraph.cli",
+                "graph",
+                "validate",
+                "nonexistent.yaml",
+            ],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        assert result.returncode != 0
+
+    def test_graph_info_shows_nodes(self):
+        """'graph info' shows node details."""
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "yamlgraph.cli",
+                "graph",
+                "info",
+                "graphs/yamlgraph.yaml",
+            ],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        assert result.returncode == 0
+        assert "Nodes:" in result.stdout or "nodes" in result.stdout.lower()
+
+    def test_graph_info_shows_edges(self):
+        """'graph info' shows edge details."""
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "yamlgraph.cli",
+                "graph",
+                "info",
+                "graphs/yamlgraph.yaml",
+            ],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        assert result.returncode == 0
+        assert "Edges:" in result.stdout or "edges" in result.stdout.lower()
+
+    def test_graph_info_router_demo(self):
+        """'graph info' shows router-demo structure."""
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "yamlgraph.cli",
+                "graph",
+                "info",
+                "graphs/router-demo.yaml",
+            ],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        assert result.returncode == 0
+        assert "classify" in result.stdout
+        assert "router" in result.stdout.lower()
+
+    def test_graph_run_nonexistent_file_shows_error(self):
+        """'graph run' with nonexistent file shows error."""
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "yamlgraph.cli",
+                "graph",
+                "run",
+                "graphs/does-not-exist.yaml",
+            ],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        # Should fail with file not found
+        assert result.returncode != 0
+        assert (
+            "not found" in result.stdout.lower() + result.stderr.lower()
+            or "Error" in result.stdout + result.stderr
+        )
+
+    def test_graph_run_invalid_var_format(self):
+        """'graph run' with invalid --var format shows error."""
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "yamlgraph.cli",
+                "graph",
+                "run",
+                "graphs/yamlgraph.yaml",
+                "--var",
+                "invalid_no_equals",
+            ],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+        )
+        assert result.returncode != 0
+        assert (
+            "Invalid" in result.stdout + result.stderr
+            or "key=value" in result.stdout + result.stderr
+        )
+
+
+class TestListRunsCommand:
+    """Integration tests for list-runs command."""
+
+    def test_list_runs_with_empty_db(self, tmp_path, monkeypatch):
+        """'list-runs' handles empty database gracefully."""
+        # Use temp db
+        monkeypatch.setenv("SHOWCASE_DB_PATH", str(tmp_path / "test.db"))
+
+        result = subprocess.run(
+            [sys.executable, "-m", "yamlgraph.cli", "list-runs"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent.parent,
+            env={
+                **subprocess.os.environ,
+                "SHOWCASE_DB_PATH": str(tmp_path / "test.db"),
+            },
+        )
+        # Should succeed even with no runs
+        assert result.returncode == 0
+        assert "No runs found" in result.stdout or "runs" in result.stdout.lower()
+
+
+class TestHelpOutput:
+    """Test help messages work correctly."""
+
+    def test_main_help(self):
+        """Main --help shows available commands."""
+        result = subprocess.run(
+            [sys.executable, "-m", "yamlgraph.cli", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert "graph" in result.stdout
+        assert "list-runs" in result.stdout
+
+    def test_graph_help(self):
+        """'graph --help' shows subcommands."""
+        result = subprocess.run(
+            [sys.executable, "-m", "yamlgraph.cli", "graph", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert "run" in result.stdout
+        assert "list" in result.stdout
+        assert "validate" in result.stdout

tests/integration/test_map_demo.py

@@ -0,0 +1,50 @@
+"""Integration tests for map-demo graph."""
+
+from unittest.mock import MagicMock, patch
+
+from yamlgraph.graph_loader import compile_graph, load_graph_config
+
+
+class TestMapDemoGraph:
+    """Integration tests for the map-demo graph."""
+
+    def test_map_demo_config_loads(self) -> None:
+        """Map demo graph config loads successfully."""
+        config = load_graph_config("graphs/map-demo.yaml")
+        assert config.name == "map-demo"
+        assert "expand" in config.nodes
+        assert config.nodes["expand"]["type"] == "map"
+
+    def test_map_demo_graph_compiles(self) -> None:
+        """Map demo graph compiles to StateGraph."""
+        config = load_graph_config("graphs/map-demo.yaml")
+
+        # Mock compile_map_node to avoid needing prompt execution
+        with patch("yamlgraph.graph_loader.compile_map_node") as mock_compile_map:
+            mock_map_edge_fn = MagicMock()
+            mock_compile_map.return_value = (mock_map_edge_fn, "_map_expand_sub")
+
+            compile_graph(config)
+
+            # Should have called compile_map_node for expand
+            mock_compile_map.assert_called_once()
+            call_args = mock_compile_map.call_args
+            assert call_args[0][0] == "expand"
+
+    def test_map_demo_state_has_sorted_reducer(self) -> None:
+        """Map demo compiled state has sorted_add reducer for expansions."""
+        from typing import Annotated, get_args, get_origin
+
+        from yamlgraph.models.state_builder import build_state_class, sorted_add
+
+        config = load_graph_config("graphs/map-demo.yaml")
+        state_class = build_state_class(config.raw_config)
+
+        annotations = state_class.__annotations__
+        assert "expansions" in annotations
+
+        field_type = annotations["expansions"]
+        assert get_origin(field_type) is Annotated
+        args = get_args(field_type)
+        assert args[0] is list
+        assert args[1] is sorted_add