forked from genewildish/Mainline
Compare commits
2 Commits
ef0c43266a
...
7c26150408
| Author | SHA1 | Date | |
|---|---|---|---|
| 7c26150408 | |||
| 7185005f9b |
36
TODO.md
36
TODO.md
@@ -19,6 +19,42 @@
|
||||
- [x] Enumerate all effect plugin parameters automatically for UI control (intensity, decay, etc.)
|
||||
- [ ] Implement pipeline hot-rebuild when stage toggles or params change, preserving camera and display state [#43](https://git.notsosm.art/david/Mainline/issues/43)
|
||||
|
||||
## Test Suite Cleanup & Feature Implementation
|
||||
### Phase 1: Test Suite Cleanup (In Progress)
|
||||
- [x] Port figment feature to modern pipeline architecture
|
||||
- [x] Create `engine/effects/plugins/figment.py` (full port)
|
||||
- [x] Add `figment.py` to `engine/effects/plugins/`
|
||||
- [x] Copy SVG files to `figments/` directory
|
||||
- [x] Update `pyproject.toml` with figment extra
|
||||
- [x] Add `test-figment` preset to `presets.toml`
|
||||
- [x] Update pipeline adapters for overlay effects
|
||||
- [x] Clean up `test_adapters.py` (removed 18 mock-only tests)
|
||||
- [x] Verify all tests pass (652 passing, 20 skipped, 58% coverage)
|
||||
- [ ] Review remaining mock-heavy tests in `test_pipeline.py`
|
||||
- [ ] Review `test_effects.py` for implementation detail tests
|
||||
- [ ] Identify additional tests to remove/consolidate
|
||||
- [ ] Target: ~600 tests total
|
||||
|
||||
### Phase 2: Acceptance Test Expansion (Planned)
|
||||
- [ ] Create `test_message_overlay.py` for message rendering
|
||||
- [ ] Create `test_firehose.py` for firehose rendering
|
||||
- [ ] Create `test_pipeline_order.py` for execution order verification
|
||||
- [ ] Expand `test_figment_effect.py` for animation phases
|
||||
- [ ] Target: 10-15 new acceptance tests
|
||||
|
||||
### Phase 3: Post-Branch Features (Planned)
|
||||
- [ ] Port message overlay system from `upstream_layers.py`
|
||||
- [ ] Port firehose rendering from `upstream_layers.py`
|
||||
- [ ] Create `MessageOverlayStage` for pipeline integration
|
||||
- [ ] Verify figment renders in correct order (effects → figment → messages → display)
|
||||
|
||||
### Phase 4: Visual Quality Improvements (Planned)
|
||||
- [ ] Compare upstream vs current pipeline output
|
||||
- [ ] Implement easing functions for figment animations
|
||||
- [ ] Add animated gradient shifts
|
||||
- [ ] Improve strobe effect patterns
|
||||
- [ ] Use introspection to match visual style
|
||||
|
||||
## Gitea Issues Tracking
|
||||
- [#37](https://git.notsosm.art/david/Mainline/issues/37): Refactor app.py and adapter.py for better maintainability
|
||||
- [#35](https://git.notsosm.art/david/Mainline/issues/35): Epic: Pipeline Mutation API for Stage Hot-Swapping
|
||||
|
||||
656
engine/display/backends/animation_report.py
Normal file
656
engine/display/backends/animation_report.py
Normal file
@@ -0,0 +1,656 @@
|
||||
"""
|
||||
Animation Report Display Backend
|
||||
|
||||
Captures frames from pipeline stages and generates an interactive HTML report
|
||||
showing before/after states for each transformative stage.
|
||||
"""
|
||||
|
||||
import time
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from engine.display.streaming import compute_diff
|
||||
|
||||
|
||||
@dataclass
|
||||
class CapturedFrame:
|
||||
"""A captured frame with metadata."""
|
||||
|
||||
stage: str
|
||||
buffer: list[str]
|
||||
timestamp: float
|
||||
frame_number: int
|
||||
diff_from_previous: dict[str, Any] | None = None
|
||||
|
||||
|
||||
@dataclass
|
||||
class StageCapture:
|
||||
"""Captures frames for a single pipeline stage."""
|
||||
|
||||
name: str
|
||||
frames: list[CapturedFrame] = field(default_factory=list)
|
||||
start_time: float = field(default_factory=time.time)
|
||||
end_time: float = 0.0
|
||||
|
||||
def add_frame(
|
||||
self,
|
||||
buffer: list[str],
|
||||
frame_number: int,
|
||||
previous_buffer: list[str] | None = None,
|
||||
) -> None:
|
||||
"""Add a captured frame."""
|
||||
timestamp = time.time()
|
||||
diff = None
|
||||
if previous_buffer is not None:
|
||||
diff_data = compute_diff(previous_buffer, buffer)
|
||||
diff = {
|
||||
"changed_lines": len(diff_data.changed_lines),
|
||||
"total_lines": len(buffer),
|
||||
"width": diff_data.width,
|
||||
"height": diff_data.height,
|
||||
}
|
||||
|
||||
frame = CapturedFrame(
|
||||
stage=self.name,
|
||||
buffer=list(buffer),
|
||||
timestamp=timestamp,
|
||||
frame_number=frame_number,
|
||||
diff_from_previous=diff,
|
||||
)
|
||||
self.frames.append(frame)
|
||||
|
||||
def finish(self) -> None:
|
||||
"""Mark capture as finished."""
|
||||
self.end_time = time.time()
|
||||
|
||||
|
||||
class AnimationReportDisplay:
|
||||
"""
|
||||
Display backend that captures frames for animation report generation.
|
||||
|
||||
Instead of rendering to terminal, this display captures the buffer at each
|
||||
stage and stores it for later HTML report generation.
|
||||
"""
|
||||
|
||||
width: int = 80
|
||||
height: int = 24
|
||||
|
||||
def __init__(self, output_dir: str = "./reports"):
|
||||
"""
|
||||
Initialize the animation report display.
|
||||
|
||||
Args:
|
||||
output_dir: Directory where reports will be saved
|
||||
"""
|
||||
self.output_dir = Path(output_dir)
|
||||
self.output_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
self._stages: dict[str, StageCapture] = {}
|
||||
self._current_stage: str = ""
|
||||
self._previous_buffer: list[str] | None = None
|
||||
self._frame_number: int = 0
|
||||
self._total_frames: int = 0
|
||||
self._start_time: float = 0.0
|
||||
|
||||
def init(self, width: int, height: int, reuse: bool = False) -> None:
|
||||
"""Initialize display with dimensions."""
|
||||
self.width = width
|
||||
self.height = height
|
||||
self._start_time = time.time()
|
||||
|
||||
def show(self, buffer: list[str], border: bool = False) -> None:
|
||||
"""
|
||||
Capture a frame for the current stage.
|
||||
|
||||
Args:
|
||||
buffer: The frame buffer to capture
|
||||
border: Border flag (ignored)
|
||||
"""
|
||||
if not self._current_stage:
|
||||
# If no stage is set, use a default name
|
||||
self._current_stage = "final"
|
||||
|
||||
if self._current_stage not in self._stages:
|
||||
self._stages[self._current_stage] = StageCapture(self._current_stage)
|
||||
|
||||
stage = self._stages[self._current_stage]
|
||||
stage.add_frame(buffer, self._frame_number, self._previous_buffer)
|
||||
|
||||
self._previous_buffer = list(buffer)
|
||||
self._frame_number += 1
|
||||
self._total_frames += 1
|
||||
|
||||
def start_stage(self, stage_name: str) -> None:
|
||||
"""
|
||||
Start capturing frames for a new stage.
|
||||
|
||||
Args:
|
||||
stage_name: Name of the stage (e.g., "noise", "fade", "firehose")
|
||||
"""
|
||||
if self._current_stage and self._current_stage in self._stages:
|
||||
# Finish previous stage
|
||||
self._stages[self._current_stage].finish()
|
||||
|
||||
self._current_stage = stage_name
|
||||
self._previous_buffer = None # Reset for new stage
|
||||
|
||||
def clear(self) -> None:
|
||||
"""Clear the display (no-op for report display)."""
|
||||
pass
|
||||
|
||||
def cleanup(self) -> None:
|
||||
"""Cleanup resources."""
|
||||
# Finish current stage
|
||||
if self._current_stage and self._current_stage in self._stages:
|
||||
self._stages[self._current_stage].finish()
|
||||
|
||||
def get_dimensions(self) -> tuple[int, int]:
|
||||
"""Get current dimensions."""
|
||||
return (self.width, self.height)
|
||||
|
||||
def get_stages(self) -> dict[str, StageCapture]:
|
||||
"""Get all captured stages."""
|
||||
return self._stages
|
||||
|
||||
def generate_report(self, title: str = "Animation Report") -> Path:
|
||||
"""
|
||||
Generate an HTML report with captured frames and animations.
|
||||
|
||||
Args:
|
||||
title: Title of the report
|
||||
|
||||
Returns:
|
||||
Path to the generated HTML file
|
||||
"""
|
||||
report_path = self.output_dir / f"animation_report_{int(time.time())}.html"
|
||||
html_content = self._build_html(title)
|
||||
report_path.write_text(html_content)
|
||||
return report_path
|
||||
|
||||
def _build_html(self, title: str) -> str:
|
||||
"""Build the HTML content for the report."""
|
||||
# Collect all frames across stages
|
||||
all_frames = []
|
||||
for stage_name, stage in self._stages.items():
|
||||
for frame in stage.frames:
|
||||
all_frames.append(frame)
|
||||
|
||||
# Sort frames by timestamp
|
||||
all_frames.sort(key=lambda f: f.timestamp)
|
||||
|
||||
# Build stage sections
|
||||
stages_html = ""
|
||||
for stage_name, stage in self._stages.items():
|
||||
stages_html += self._build_stage_section(stage_name, stage)
|
||||
|
||||
# Build full HTML
|
||||
html = f"""
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>{title}</title>
|
||||
<style>
|
||||
* {{
|
||||
box-sizing: border-box;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
}}
|
||||
body {{
|
||||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||||
background: #1a1a2e;
|
||||
color: #eee;
|
||||
padding: 20px;
|
||||
line-height: 1.6;
|
||||
}}
|
||||
.container {{
|
||||
max-width: 1400px;
|
||||
margin: 0 auto;
|
||||
}}
|
||||
.header {{
|
||||
background: linear-gradient(135deg, #16213e 0%, #1a1a2e 100%);
|
||||
padding: 30px;
|
||||
border-radius: 12px;
|
||||
margin-bottom: 30px;
|
||||
text-align: center;
|
||||
box-shadow: 0 4px 20px rgba(0,0,0,0.3);
|
||||
}}
|
||||
.header h1 {{
|
||||
font-size: 2.5em;
|
||||
margin-bottom: 10px;
|
||||
background: linear-gradient(90deg, #00d4ff, #00ff88);
|
||||
-webkit-background-clip: text;
|
||||
-webkit-text-fill-color: transparent;
|
||||
background-clip: text;
|
||||
}}
|
||||
.header .meta {{
|
||||
color: #888;
|
||||
font-size: 0.9em;
|
||||
}}
|
||||
.stats-grid {{
|
||||
display: grid;
|
||||
grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
|
||||
gap: 15px;
|
||||
margin: 20px 0;
|
||||
}}
|
||||
.stat-card {{
|
||||
background: #16213e;
|
||||
padding: 15px;
|
||||
border-radius: 8px;
|
||||
text-align: center;
|
||||
}}
|
||||
.stat-value {{
|
||||
font-size: 1.8em;
|
||||
font-weight: bold;
|
||||
color: #00ff88;
|
||||
}}
|
||||
.stat-label {{
|
||||
color: #888;
|
||||
font-size: 0.85em;
|
||||
margin-top: 5px;
|
||||
}}
|
||||
.stage-section {{
|
||||
background: #16213e;
|
||||
border-radius: 12px;
|
||||
margin-bottom: 25px;
|
||||
overflow: hidden;
|
||||
box-shadow: 0 2px 10px rgba(0,0,0,0.2);
|
||||
}}
|
||||
.stage-header {{
|
||||
background: #1f2a48;
|
||||
padding: 15px 20px;
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
cursor: pointer;
|
||||
user-select: none;
|
||||
}}
|
||||
.stage-header:hover {{
|
||||
background: #253252;
|
||||
}}
|
||||
.stage-name {{
|
||||
font-weight: bold;
|
||||
font-size: 1.1em;
|
||||
color: #00d4ff;
|
||||
}}
|
||||
.stage-info {{
|
||||
color: #888;
|
||||
font-size: 0.9em;
|
||||
}}
|
||||
.stage-content {{
|
||||
padding: 20px;
|
||||
}}
|
||||
.frames-container {{
|
||||
display: grid;
|
||||
grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
|
||||
gap: 15px;
|
||||
}}
|
||||
.frame-card {{
|
||||
background: #0f0f1a;
|
||||
border-radius: 8px;
|
||||
overflow: hidden;
|
||||
border: 1px solid #333;
|
||||
transition: transform 0.2s, box-shadow 0.2s;
|
||||
}}
|
||||
.frame-card:hover {{
|
||||
transform: translateY(-2px);
|
||||
box-shadow: 0 4px 15px rgba(0,212,255,0.2);
|
||||
}}
|
||||
.frame-header {{
|
||||
background: #1a1a2e;
|
||||
padding: 10px 15px;
|
||||
font-size: 0.85em;
|
||||
color: #888;
|
||||
border-bottom: 1px solid #333;
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
}}
|
||||
.frame-number {{
|
||||
color: #00ff88;
|
||||
}}
|
||||
.frame-diff {{
|
||||
color: #ff6b6b;
|
||||
}}
|
||||
.frame-content {{
|
||||
padding: 10px;
|
||||
font-family: 'Fira Code', 'Consolas', 'Monaco', monospace;
|
||||
font-size: 11px;
|
||||
line-height: 1.3;
|
||||
white-space: pre;
|
||||
overflow-x: auto;
|
||||
max-height: 200px;
|
||||
overflow-y: auto;
|
||||
}}
|
||||
.timeline-section {{
|
||||
background: #16213e;
|
||||
border-radius: 12px;
|
||||
padding: 20px;
|
||||
margin-bottom: 25px;
|
||||
}}
|
||||
.timeline-header {{
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
margin-bottom: 15px;
|
||||
}}
|
||||
.timeline-title {{
|
||||
font-weight: bold;
|
||||
color: #00d4ff;
|
||||
}}
|
||||
.timeline-controls {{
|
||||
display: flex;
|
||||
gap: 10px;
|
||||
}}
|
||||
.timeline-controls button {{
|
||||
background: #1f2a48;
|
||||
border: 1px solid #333;
|
||||
color: #eee;
|
||||
padding: 8px 15px;
|
||||
border-radius: 6px;
|
||||
cursor: pointer;
|
||||
transition: all 0.2s;
|
||||
}}
|
||||
.timeline-controls button:hover {{
|
||||
background: #253252;
|
||||
border-color: #00d4ff;
|
||||
}}
|
||||
.timeline-controls button.active {{
|
||||
background: #00d4ff;
|
||||
color: #000;
|
||||
}}
|
||||
.timeline-canvas {{
|
||||
width: 100%;
|
||||
height: 100px;
|
||||
background: #0f0f1a;
|
||||
border-radius: 8px;
|
||||
position: relative;
|
||||
overflow: hidden;
|
||||
}}
|
||||
.timeline-track {{
|
||||
position: absolute;
|
||||
top: 50%;
|
||||
left: 0;
|
||||
right: 0;
|
||||
height: 4px;
|
||||
background: #333;
|
||||
transform: translateY(-50%);
|
||||
}}
|
||||
.timeline-marker {{
|
||||
position: absolute;
|
||||
top: 50%;
|
||||
transform: translate(-50%, -50%);
|
||||
width: 12px;
|
||||
height: 12px;
|
||||
background: #00d4ff;
|
||||
border-radius: 50%;
|
||||
cursor: pointer;
|
||||
transition: all 0.2s;
|
||||
}}
|
||||
.timeline-marker:hover {{
|
||||
transform: translate(-50%, -50%) scale(1.3);
|
||||
box-shadow: 0 0 10px #00d4ff;
|
||||
}}
|
||||
.timeline-marker.stage-{{stage_name}} {{
|
||||
background: var(--stage-color, #00d4ff);
|
||||
}}
|
||||
.comparison-view {{
|
||||
display: grid;
|
||||
grid-template-columns: 1fr 1fr;
|
||||
gap: 20px;
|
||||
margin-top: 20px;
|
||||
}}
|
||||
.comparison-panel {{
|
||||
background: #0f0f1a;
|
||||
border-radius: 8px;
|
||||
padding: 15px;
|
||||
border: 1px solid #333;
|
||||
}}
|
||||
.comparison-panel h4 {{
|
||||
color: #888;
|
||||
margin-bottom: 10px;
|
||||
font-size: 0.9em;
|
||||
}}
|
||||
.comparison-content {{
|
||||
font-family: 'Fira Code', 'Consolas', 'Monaco', monospace;
|
||||
font-size: 11px;
|
||||
line-height: 1.3;
|
||||
white-space: pre;
|
||||
}}
|
||||
.diff-added {{
|
||||
background: rgba(0, 255, 136, 0.2);
|
||||
}}
|
||||
.diff-removed {{
|
||||
background: rgba(255, 107, 107, 0.2);
|
||||
}}
|
||||
@keyframes pulse {{
|
||||
0%, 100% {{ opacity: 1; }}
|
||||
50% {{ opacity: 0.7; }}
|
||||
}}
|
||||
.animating {{
|
||||
animation: pulse 1s infinite;
|
||||
}}
|
||||
.footer {{
|
||||
text-align: center;
|
||||
color: #666;
|
||||
padding: 20px;
|
||||
font-size: 0.9em;
|
||||
}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<div class="header">
|
||||
<h1>🎬 {title}</h1>
|
||||
<div class="meta">
|
||||
Generated: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")} |
|
||||
Total Frames: {self._total_frames} |
|
||||
Duration: {time.time() - self._start_time:.2f}s
|
||||
</div>
|
||||
<div class="stats-grid">
|
||||
<div class="stat-card">
|
||||
<div class="stat-value">{len(self._stages)}</div>
|
||||
<div class="stat-label">Pipeline Stages</div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="stat-value">{self._total_frames}</div>
|
||||
<div class="stat-label">Total Frames</div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="stat-value">{time.time() - self._start_time:.2f}s</div>
|
||||
<div class="stat-label">Capture Duration</div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="stat-value">{self.width}x{self.height}</div>
|
||||
<div class="stat-label">Resolution</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="timeline-section">
|
||||
<div class="timeline-header">
|
||||
<div class="timeline-title">Timeline</div>
|
||||
<div class="timeline-controls">
|
||||
<button onclick="playAnimation()">▶ Play</button>
|
||||
<button onclick="pauseAnimation()">⏸ Pause</button>
|
||||
<button onclick="stepForward()">⏭ Step</button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="timeline-canvas" id="timeline">
|
||||
<div class="timeline-track"></div>
|
||||
<!-- Timeline markers will be added by JavaScript -->
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{stages_html}
|
||||
|
||||
<div class="footer">
|
||||
<p>Animation Report generated by Mainline</p>
|
||||
<p>Use the timeline controls above to play/pause the animation</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
// Animation state
|
||||
let currentFrame = 0;
|
||||
let isPlaying = false;
|
||||
let animationInterval = null;
|
||||
const totalFrames = {len(all_frames)};
|
||||
|
||||
// Stage colors for timeline markers
|
||||
const stageColors = {{
|
||||
{self._build_stage_colors()}
|
||||
}};
|
||||
|
||||
// Initialize timeline
|
||||
function initTimeline() {{
|
||||
const timeline = document.getElementById('timeline');
|
||||
const track = timeline.querySelector('.timeline-track');
|
||||
|
||||
{self._build_timeline_markers(all_frames)}
|
||||
}}
|
||||
|
||||
function playAnimation() {{
|
||||
if (isPlaying) return;
|
||||
isPlaying = true;
|
||||
animationInterval = setInterval(() => {{
|
||||
currentFrame = (currentFrame + 1) % totalFrames;
|
||||
updateFrameDisplay();
|
||||
}}, 100);
|
||||
}}
|
||||
|
||||
function pauseAnimation() {{
|
||||
isPlaying = false;
|
||||
if (animationInterval) {{
|
||||
clearInterval(animationInterval);
|
||||
animationInterval = null;
|
||||
}}
|
||||
}}
|
||||
|
||||
function stepForward() {{
|
||||
currentFrame = (currentFrame + 1) % totalFrames;
|
||||
updateFrameDisplay();
|
||||
}}
|
||||
|
||||
function updateFrameDisplay() {{
|
||||
// Highlight current frame in timeline
|
||||
const markers = document.querySelectorAll('.timeline-marker');
|
||||
markers.forEach((marker, index) => {{
|
||||
if (index === currentFrame) {{
|
||||
marker.style.transform = 'translate(-50%, -50%) scale(1.5)';
|
||||
marker.style.boxShadow = '0 0 15px #00ff88';
|
||||
}} else {{
|
||||
marker.style.transform = 'translate(-50%, -50%) scale(1)';
|
||||
marker.style.boxShadow = 'none';
|
||||
}}
|
||||
}});
|
||||
}}
|
||||
|
||||
// Initialize on page load
|
||||
document.addEventListener('DOMContentLoaded', initTimeline);
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
"""
|
||||
return html
|
||||
|
||||
def _build_stage_section(self, stage_name: str, stage: StageCapture) -> str:
|
||||
"""Build HTML for a single stage section."""
|
||||
frames_html = ""
|
||||
for i, frame in enumerate(stage.frames):
|
||||
diff_info = ""
|
||||
if frame.diff_from_previous:
|
||||
changed = frame.diff_from_previous.get("changed_lines", 0)
|
||||
total = frame.diff_from_previous.get("total_lines", 0)
|
||||
diff_info = f'<span class="frame-diff">Δ {changed}/{total}</span>'
|
||||
|
||||
frames_html += f"""
|
||||
<div class="frame-card">
|
||||
<div class="frame-header">
|
||||
<span>Frame <span class="frame-number">{frame.frame_number}</span></span>
|
||||
{diff_info}
|
||||
</div>
|
||||
<div class="frame-content">{self._escape_html("".join(frame.buffer))}</div>
|
||||
</div>
|
||||
"""
|
||||
|
||||
return f"""
|
||||
<div class="stage-section">
|
||||
<div class="stage-header" onclick="this.nextElementSibling.classList.toggle('hidden')">
|
||||
<span class="stage-name">{stage_name}</span>
|
||||
<span class="stage-info">{len(stage.frames)} frames</span>
|
||||
</div>
|
||||
<div class="stage-content">
|
||||
<div class="frames-container">
|
||||
{frames_html}
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
"""
|
||||
|
||||
def _build_timeline(self, all_frames: list[CapturedFrame]) -> str:
|
||||
"""Build timeline HTML."""
|
||||
if not all_frames:
|
||||
return ""
|
||||
|
||||
markers_html = ""
|
||||
for i, frame in enumerate(all_frames):
|
||||
left_percent = (i / len(all_frames)) * 100
|
||||
markers_html += f'<div class="timeline-marker" style="left: {left_percent}%" data-frame="{i}"></div>'
|
||||
|
||||
return markers_html
|
||||
|
||||
def _build_stage_colors(self) -> str:
|
||||
"""Build stage color mapping for JavaScript."""
|
||||
colors = [
|
||||
"#00d4ff",
|
||||
"#00ff88",
|
||||
"#ff6b6b",
|
||||
"#ffd93d",
|
||||
"#a855f7",
|
||||
"#ec4899",
|
||||
"#14b8a6",
|
||||
"#f97316",
|
||||
"#8b5cf6",
|
||||
"#06b6d4",
|
||||
]
|
||||
color_map = ""
|
||||
for i, stage_name in enumerate(self._stages.keys()):
|
||||
color = colors[i % len(colors)]
|
||||
color_map += f' "{stage_name}": "{color}",\n'
|
||||
return color_map.rstrip(",\n")
|
||||
|
||||
def _build_timeline_markers(self, all_frames: list[CapturedFrame]) -> str:
|
||||
"""Build timeline markers in JavaScript."""
|
||||
if not all_frames:
|
||||
return ""
|
||||
|
||||
markers_js = ""
|
||||
for i, frame in enumerate(all_frames):
|
||||
left_percent = (i / len(all_frames)) * 100
|
||||
stage_color = f"stageColors['{frame.stage}']"
|
||||
markers_js += f"""
|
||||
const marker{i} = document.createElement('div');
|
||||
marker{i}.className = 'timeline-marker stage-{{frame.stage}}';
|
||||
marker{i}.style.left = '{left_percent}%';
|
||||
marker{i}.style.setProperty('--stage-color', {stage_color});
|
||||
marker{i}.onclick = () => {{
|
||||
currentFrame = {i};
|
||||
updateFrameDisplay();
|
||||
}};
|
||||
timeline.appendChild(marker{i});
|
||||
"""
|
||||
|
||||
return markers_js
|
||||
|
||||
def _escape_html(self, text: str) -> str:
|
||||
"""Escape HTML special characters."""
|
||||
return (
|
||||
text.replace("&", "&")
|
||||
.replace("<", "<")
|
||||
.replace(">", ">")
|
||||
.replace('"', """)
|
||||
.replace("'", "'")
|
||||
)
|
||||
332
engine/effects/plugins/figment.py
Normal file
332
engine/effects/plugins/figment.py
Normal file
@@ -0,0 +1,332 @@
|
||||
"""
|
||||
Figment overlay effect for modern pipeline architecture.
|
||||
|
||||
Provides periodic SVG glyph overlays with reveal/hold/dissolve animation phases.
|
||||
Integrates directly with the pipeline's effect system without legacy dependencies.
|
||||
"""
|
||||
|
||||
import random
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum, auto
|
||||
from pathlib import Path
|
||||
|
||||
from engine import config
|
||||
from engine.effects.types import EffectConfig, EffectContext, EffectPlugin
|
||||
from engine.figment_render import rasterize_svg
|
||||
from engine.figment_trigger import FigmentAction, FigmentCommand, FigmentTrigger
|
||||
from engine.terminal import RST
|
||||
from engine.themes import THEME_REGISTRY
|
||||
|
||||
|
||||
class FigmentPhase(Enum):
|
||||
"""Animation phases for figment overlay."""
|
||||
|
||||
REVEAL = auto()
|
||||
HOLD = auto()
|
||||
DISSOLVE = auto()
|
||||
|
||||
|
||||
@dataclass
|
||||
class FigmentState:
|
||||
"""State of a figment overlay at a given frame."""
|
||||
|
||||
phase: FigmentPhase
|
||||
progress: float
|
||||
rows: list[str]
|
||||
gradient: list[int]
|
||||
center_row: int
|
||||
center_col: int
|
||||
|
||||
|
||||
def _color_codes_to_ansi(gradient: list[int]) -> list[str]:
|
||||
"""Convert gradient list to ANSI color codes.
|
||||
|
||||
Args:
|
||||
gradient: List of 256-color palette codes
|
||||
|
||||
Returns:
|
||||
List of ANSI escape code strings
|
||||
"""
|
||||
codes = []
|
||||
for color in gradient:
|
||||
if isinstance(color, int):
|
||||
codes.append(f"\033[38;5;{color}m")
|
||||
else:
|
||||
# Fallback to green
|
||||
codes.append("\033[38;5;46m")
|
||||
return codes if codes else ["\033[38;5;46m"]
|
||||
|
||||
|
||||
def render_figment_overlay(figment_state: FigmentState, w: int, h: int) -> list[str]:
|
||||
"""Render figment overlay as ANSI cursor-positioning commands.
|
||||
|
||||
Args:
|
||||
figment_state: FigmentState with phase, progress, rows, gradient, centering.
|
||||
w: terminal width
|
||||
h: terminal height
|
||||
|
||||
Returns:
|
||||
List of ANSI strings to append to display buffer.
|
||||
"""
|
||||
rows = figment_state.rows
|
||||
if not rows:
|
||||
return []
|
||||
|
||||
phase = figment_state.phase
|
||||
progress = figment_state.progress
|
||||
gradient = figment_state.gradient
|
||||
center_row = figment_state.center_row
|
||||
center_col = figment_state.center_col
|
||||
|
||||
cols = _color_codes_to_ansi(gradient)
|
||||
|
||||
# Build a list of non-space cell positions
|
||||
cell_positions = []
|
||||
for r_idx, row in enumerate(rows):
|
||||
for c_idx, ch in enumerate(row):
|
||||
if ch != " ":
|
||||
cell_positions.append((r_idx, c_idx))
|
||||
|
||||
n_cells = len(cell_positions)
|
||||
if n_cells == 0:
|
||||
return []
|
||||
|
||||
# Use a deterministic seed so the reveal/dissolve pattern is stable per-figment
|
||||
rng = random.Random(hash(tuple(rows[0][:10])) if rows[0] else 42)
|
||||
shuffled = list(cell_positions)
|
||||
rng.shuffle(shuffled)
|
||||
|
||||
# Phase-dependent visibility
|
||||
if phase == FigmentPhase.REVEAL:
|
||||
visible_count = int(n_cells * progress)
|
||||
visible = set(shuffled[:visible_count])
|
||||
elif phase == FigmentPhase.HOLD:
|
||||
visible = set(cell_positions)
|
||||
# Strobe: dim some cells periodically
|
||||
if int(progress * 20) % 3 == 0:
|
||||
dim_count = int(n_cells * 0.3)
|
||||
visible -= set(shuffled[:dim_count])
|
||||
elif phase == FigmentPhase.DISSOLVE:
|
||||
remaining_count = int(n_cells * (1.0 - progress))
|
||||
visible = set(shuffled[:remaining_count])
|
||||
else:
|
||||
visible = set(cell_positions)
|
||||
|
||||
# Build overlay commands
|
||||
overlay: list[str] = []
|
||||
n_cols = len(cols)
|
||||
max_x = max((len(r.rstrip()) for r in rows if r.strip()), default=1)
|
||||
|
||||
for r_idx, row in enumerate(rows):
|
||||
scr_row = center_row + r_idx + 1 # 1-indexed
|
||||
if scr_row < 1 or scr_row > h:
|
||||
continue
|
||||
|
||||
line_buf: list[str] = []
|
||||
has_content = False
|
||||
|
||||
for c_idx, ch in enumerate(row):
|
||||
scr_col = center_col + c_idx + 1
|
||||
if scr_col < 1 or scr_col > w:
|
||||
continue
|
||||
|
||||
if ch != " " and (r_idx, c_idx) in visible:
|
||||
# Apply gradient color
|
||||
shifted = (c_idx / max(max_x - 1, 1)) % 1.0
|
||||
idx = min(round(shifted * (n_cols - 1)), n_cols - 1)
|
||||
line_buf.append(f"{cols[idx]}{ch}{RST}")
|
||||
has_content = True
|
||||
else:
|
||||
line_buf.append(" ")
|
||||
|
||||
if has_content:
|
||||
line_str = "".join(line_buf).rstrip()
|
||||
if line_str.strip():
|
||||
overlay.append(f"\033[{scr_row};{center_col + 1}H{line_str}{RST}")
|
||||
|
||||
return overlay
|
||||
|
||||
|
||||
class FigmentEffect(EffectPlugin):
|
||||
"""Figment overlay effect for pipeline architecture.
|
||||
|
||||
Provides periodic SVG overlays with reveal/hold/dissolve animation.
|
||||
"""
|
||||
|
||||
name = "figment"
|
||||
config = EffectConfig(
|
||||
enabled=True,
|
||||
intensity=1.0,
|
||||
params={
|
||||
"interval_secs": 60,
|
||||
"display_secs": 4.5,
|
||||
"figment_dir": "figments",
|
||||
},
|
||||
)
|
||||
supports_partial_updates = False
|
||||
is_overlay = True # Figment is an overlay effect that composes on top of the buffer
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
figment_dir: str | None = None,
|
||||
triggers: list[FigmentTrigger] | None = None,
|
||||
):
|
||||
self.config = EffectConfig(
|
||||
enabled=True,
|
||||
intensity=1.0,
|
||||
params={
|
||||
"interval_secs": 60,
|
||||
"display_secs": 4.5,
|
||||
"figment_dir": figment_dir or "figments",
|
||||
},
|
||||
)
|
||||
self._triggers = triggers or []
|
||||
self._phase: FigmentPhase | None = None
|
||||
self._progress: float = 0.0
|
||||
self._rows: list[str] = []
|
||||
self._gradient: list[int] = []
|
||||
self._center_row: int = 0
|
||||
self._center_col: int = 0
|
||||
self._timer: float = 0.0
|
||||
self._last_svg: str | None = None
|
||||
self._svg_files: list[str] = []
|
||||
self._scan_svgs()
|
||||
|
||||
def _scan_svgs(self) -> None:
|
||||
"""Scan figment directory for SVG files."""
|
||||
figment_dir = Path(self.config.params["figment_dir"])
|
||||
if figment_dir.is_dir():
|
||||
self._svg_files = sorted(str(p) for p in figment_dir.glob("*.svg"))
|
||||
|
||||
def process(self, buf: list[str], ctx: EffectContext) -> list[str]:
|
||||
"""Add figment overlay to buffer."""
|
||||
if not self.config.enabled:
|
||||
return buf
|
||||
|
||||
# Get figment state using frame number from context
|
||||
figment_state = self.get_figment_state(
|
||||
ctx.frame_number, ctx.terminal_width, ctx.terminal_height
|
||||
)
|
||||
|
||||
if figment_state:
|
||||
# Render overlay and append to buffer
|
||||
overlay = render_figment_overlay(
|
||||
figment_state, ctx.terminal_width, ctx.terminal_height
|
||||
)
|
||||
buf = buf + overlay
|
||||
|
||||
return buf
|
||||
|
||||
def configure(self, config: EffectConfig) -> None:
|
||||
"""Configure the effect."""
|
||||
# Preserve figment_dir if the new config doesn't supply one
|
||||
figment_dir = config.params.get(
|
||||
"figment_dir", self.config.params.get("figment_dir", "figments")
|
||||
)
|
||||
self.config = config
|
||||
if "figment_dir" not in self.config.params:
|
||||
self.config.params["figment_dir"] = figment_dir
|
||||
self._scan_svgs()
|
||||
|
||||
def trigger(self, w: int, h: int) -> None:
|
||||
"""Manually trigger a figment display."""
|
||||
if not self._svg_files:
|
||||
return
|
||||
|
||||
# Pick a random SVG, avoid repeating
|
||||
candidates = [s for s in self._svg_files if s != self._last_svg]
|
||||
if not candidates:
|
||||
candidates = self._svg_files
|
||||
svg_path = random.choice(candidates)
|
||||
self._last_svg = svg_path
|
||||
|
||||
# Rasterize
|
||||
try:
|
||||
self._rows = rasterize_svg(svg_path, w, h)
|
||||
except Exception:
|
||||
return
|
||||
|
||||
# Pick random theme gradient
|
||||
theme_key = random.choice(list(THEME_REGISTRY.keys()))
|
||||
self._gradient = THEME_REGISTRY[theme_key].main_gradient
|
||||
|
||||
# Center in viewport
|
||||
figment_h = len(self._rows)
|
||||
figment_w = max((len(r) for r in self._rows), default=0)
|
||||
self._center_row = max(0, (h - figment_h) // 2)
|
||||
self._center_col = max(0, (w - figment_w) // 2)
|
||||
|
||||
# Start reveal phase
|
||||
self._phase = FigmentPhase.REVEAL
|
||||
self._progress = 0.0
|
||||
|
||||
def get_figment_state(
|
||||
self, frame_number: int, w: int, h: int
|
||||
) -> FigmentState | None:
|
||||
"""Tick the state machine and return current state, or None if idle."""
|
||||
if not self.config.enabled:
|
||||
return None
|
||||
|
||||
# Poll triggers
|
||||
for trig in self._triggers:
|
||||
cmd = trig.poll()
|
||||
if cmd is not None:
|
||||
self._handle_command(cmd, w, h)
|
||||
|
||||
# Tick timer when idle
|
||||
if self._phase is None:
|
||||
self._timer += config.FRAME_DT
|
||||
interval = self.config.params.get("interval_secs", 60)
|
||||
if self._timer >= interval:
|
||||
self._timer = 0.0
|
||||
self.trigger(w, h)
|
||||
|
||||
# Tick animation — snapshot current phase/progress, then advance
|
||||
if self._phase is not None:
|
||||
# Capture the state at the start of this frame
|
||||
current_phase = self._phase
|
||||
current_progress = self._progress
|
||||
|
||||
# Advance for next frame
|
||||
display_secs = self.config.params.get("display_secs", 4.5)
|
||||
phase_duration = display_secs / 3.0
|
||||
self._progress += config.FRAME_DT / phase_duration
|
||||
|
||||
if self._progress >= 1.0:
|
||||
self._progress = 0.0
|
||||
if self._phase == FigmentPhase.REVEAL:
|
||||
self._phase = FigmentPhase.HOLD
|
||||
elif self._phase == FigmentPhase.HOLD:
|
||||
self._phase = FigmentPhase.DISSOLVE
|
||||
elif self._phase == FigmentPhase.DISSOLVE:
|
||||
self._phase = None
|
||||
|
||||
return FigmentState(
|
||||
phase=current_phase,
|
||||
progress=current_progress,
|
||||
rows=self._rows,
|
||||
gradient=self._gradient,
|
||||
center_row=self._center_row,
|
||||
center_col=self._center_col,
|
||||
)
|
||||
|
||||
return None
|
||||
|
||||
def _handle_command(self, cmd: FigmentCommand, w: int, h: int) -> None:
|
||||
"""Handle a figment command."""
|
||||
if cmd.action == FigmentAction.TRIGGER:
|
||||
self.trigger(w, h)
|
||||
elif cmd.action == FigmentAction.SET_INTENSITY and isinstance(
|
||||
cmd.value, (int, float)
|
||||
):
|
||||
self.config.intensity = float(cmd.value)
|
||||
elif cmd.action == FigmentAction.SET_INTERVAL and isinstance(
|
||||
cmd.value, (int, float)
|
||||
):
|
||||
self.config.params["interval_secs"] = float(cmd.value)
|
||||
elif cmd.action == FigmentAction.SET_COLOR and isinstance(cmd.value, str):
|
||||
if cmd.value in THEME_REGISTRY:
|
||||
self._gradient = THEME_REGISTRY[cmd.value].main_gradient
|
||||
elif cmd.action == FigmentAction.STOP:
|
||||
self._phase = None
|
||||
self._progress = 0.0
|
||||
90
engine/figment_render.py
Normal file
90
engine/figment_render.py
Normal file
@@ -0,0 +1,90 @@
|
||||
"""
|
||||
SVG to half-block terminal art rasterization.
|
||||
|
||||
Pipeline: SVG -> cairosvg -> PIL -> greyscale threshold -> half-block encode.
|
||||
Follows the same pixel-pair approach as engine/render.py for OTF fonts.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import sys
|
||||
from io import BytesIO
|
||||
|
||||
# cairocffi (used by cairosvg) calls dlopen() to find the Cairo C library.
|
||||
# On macOS with Homebrew, Cairo lives in /opt/homebrew/lib (Apple Silicon) or
|
||||
# /usr/local/lib (Intel), which are not in dyld's default search path.
|
||||
# Setting DYLD_LIBRARY_PATH before the import directs dlopen() to those paths.
|
||||
if sys.platform == "darwin" and not os.environ.get("DYLD_LIBRARY_PATH"):
|
||||
for _brew_lib in ("/opt/homebrew/lib", "/usr/local/lib"):
|
||||
if os.path.exists(os.path.join(_brew_lib, "libcairo.2.dylib")):
|
||||
os.environ["DYLD_LIBRARY_PATH"] = _brew_lib
|
||||
break
|
||||
|
||||
import cairosvg
|
||||
from PIL import Image
|
||||
|
||||
_cache: dict[tuple[str, int, int], list[str]] = {}
|
||||
|
||||
|
||||
def rasterize_svg(svg_path: str, width: int, height: int) -> list[str]:
|
||||
"""Convert SVG file to list of half-block terminal rows (uncolored).
|
||||
|
||||
Args:
|
||||
svg_path: Path to SVG file.
|
||||
width: Target terminal width in columns.
|
||||
height: Target terminal height in rows.
|
||||
|
||||
Returns:
|
||||
List of strings, one per terminal row, containing block characters.
|
||||
"""
|
||||
cache_key = (svg_path, width, height)
|
||||
if cache_key in _cache:
|
||||
return _cache[cache_key]
|
||||
|
||||
# SVG -> PNG in memory
|
||||
png_bytes = cairosvg.svg2png(
|
||||
url=svg_path,
|
||||
output_width=width,
|
||||
output_height=height * 2, # 2 pixel rows per terminal row
|
||||
)
|
||||
|
||||
# PNG -> greyscale PIL image
|
||||
# Composite RGBA onto white background so transparent areas become white (255)
|
||||
# and drawn pixels retain their luminance values.
|
||||
img_rgba = Image.open(BytesIO(png_bytes)).convert("RGBA")
|
||||
img_rgba = img_rgba.resize((width, height * 2), Image.Resampling.LANCZOS)
|
||||
background = Image.new("RGBA", img_rgba.size, (255, 255, 255, 255))
|
||||
background.paste(img_rgba, mask=img_rgba.split()[3])
|
||||
img = background.convert("L")
|
||||
|
||||
data = img.tobytes()
|
||||
pix_w = width
|
||||
pix_h = height * 2
|
||||
# White (255) = empty space, dark (< threshold) = filled pixel
|
||||
threshold = 128
|
||||
|
||||
# Half-block encode: walk pixel pairs
|
||||
rows: list[str] = []
|
||||
for y in range(0, pix_h, 2):
|
||||
row: list[str] = []
|
||||
for x in range(pix_w):
|
||||
top = data[y * pix_w + x] < threshold
|
||||
bot = data[(y + 1) * pix_w + x] < threshold if y + 1 < pix_h else False
|
||||
if top and bot:
|
||||
row.append("█")
|
||||
elif top:
|
||||
row.append("▀")
|
||||
elif bot:
|
||||
row.append("▄")
|
||||
else:
|
||||
row.append(" ")
|
||||
rows.append("".join(row))
|
||||
|
||||
_cache[cache_key] = rows
|
||||
return rows
|
||||
|
||||
|
||||
def clear_cache() -> None:
|
||||
"""Clear the rasterization cache (e.g., on terminal resize)."""
|
||||
_cache.clear()
|
||||
36
engine/figment_trigger.py
Normal file
36
engine/figment_trigger.py
Normal file
@@ -0,0 +1,36 @@
|
||||
"""
|
||||
Figment trigger protocol and command types.
|
||||
|
||||
Defines the extensible input abstraction for triggering figment displays
|
||||
from any control surface (ntfy, MQTT, serial, etc.).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum
|
||||
from typing import Protocol
|
||||
|
||||
|
||||
class FigmentAction(Enum):
|
||||
TRIGGER = "trigger"
|
||||
SET_INTENSITY = "set_intensity"
|
||||
SET_INTERVAL = "set_interval"
|
||||
SET_COLOR = "set_color"
|
||||
STOP = "stop"
|
||||
|
||||
|
||||
@dataclass
|
||||
class FigmentCommand:
|
||||
action: FigmentAction
|
||||
value: float | str | None = None
|
||||
|
||||
|
||||
class FigmentTrigger(Protocol):
|
||||
"""Protocol for figment trigger sources.
|
||||
|
||||
Any input source (ntfy, MQTT, serial) can implement this
|
||||
to trigger and control figment displays.
|
||||
"""
|
||||
|
||||
def poll(self) -> FigmentCommand | None: ...
|
||||
@@ -27,9 +27,9 @@ class EffectPluginStage(Stage):
|
||||
def stage_type(self) -> str:
|
||||
"""Return stage_type based on effect name.
|
||||
|
||||
HUD effects are overlays.
|
||||
Overlay effects have stage_type "overlay".
|
||||
"""
|
||||
if self.name == "hud":
|
||||
if self.is_overlay:
|
||||
return "overlay"
|
||||
return self.category
|
||||
|
||||
@@ -37,19 +37,26 @@ class EffectPluginStage(Stage):
|
||||
def render_order(self) -> int:
|
||||
"""Return render_order based on effect type.
|
||||
|
||||
HUD effects have high render_order to appear on top.
|
||||
Overlay effects have high render_order to appear on top.
|
||||
"""
|
||||
if self.name == "hud":
|
||||
if self.is_overlay:
|
||||
return 100 # High order for overlays
|
||||
return 0
|
||||
|
||||
@property
|
||||
def is_overlay(self) -> bool:
|
||||
"""Return True for HUD effects.
|
||||
"""Return True for overlay effects.
|
||||
|
||||
HUD is an overlay - it composes on top of the buffer
|
||||
Overlay effects compose on top of the buffer
|
||||
rather than transforming it for the next stage.
|
||||
"""
|
||||
# Check if the effect has an is_overlay attribute that is explicitly True
|
||||
# (not just any truthy value from a mock object)
|
||||
if hasattr(self._effect, "is_overlay"):
|
||||
effect_overlay = self._effect.is_overlay
|
||||
# Only return True if it's explicitly set to True
|
||||
if effect_overlay is True:
|
||||
return True
|
||||
return self.name == "hud"
|
||||
|
||||
@property
|
||||
|
||||
165
engine/pipeline/adapters/frame_capture.py
Normal file
165
engine/pipeline/adapters/frame_capture.py
Normal file
@@ -0,0 +1,165 @@
|
||||
"""
|
||||
Frame Capture Stage Adapter
|
||||
|
||||
Wraps pipeline stages to capture frames for animation report generation.
|
||||
"""
|
||||
|
||||
from typing import Any
|
||||
|
||||
from engine.display.backends.animation_report import AnimationReportDisplay
|
||||
from engine.pipeline.core import PipelineContext, Stage
|
||||
|
||||
|
||||
class FrameCaptureStage(Stage):
|
||||
"""
|
||||
Wrapper stage that captures frames before and after a wrapped stage.
|
||||
|
||||
This allows generating animation reports showing how each stage
|
||||
transforms the data.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
wrapped_stage: Stage,
|
||||
display: AnimationReportDisplay,
|
||||
name: str | None = None,
|
||||
):
|
||||
"""
|
||||
Initialize frame capture stage.
|
||||
|
||||
Args:
|
||||
wrapped_stage: The stage to wrap and capture frames from
|
||||
display: The animation report display to send frames to
|
||||
name: Optional name for this capture stage
|
||||
"""
|
||||
self._wrapped_stage = wrapped_stage
|
||||
self._display = display
|
||||
self.name = name or f"capture_{wrapped_stage.name}"
|
||||
self.category = wrapped_stage.category
|
||||
self.optional = wrapped_stage.optional
|
||||
|
||||
# Capture state
|
||||
self._captured_input = False
|
||||
self._captured_output = False
|
||||
|
||||
@property
|
||||
def stage_type(self) -> str:
|
||||
return self._wrapped_stage.stage_type
|
||||
|
||||
@property
|
||||
def capabilities(self) -> set[str]:
|
||||
return self._wrapped_stage.capabilities
|
||||
|
||||
@property
|
||||
def dependencies(self) -> set[str]:
|
||||
return self._wrapped_stage.dependencies
|
||||
|
||||
@property
|
||||
def inlet_types(self) -> set:
|
||||
return self._wrapped_stage.inlet_types
|
||||
|
||||
@property
|
||||
def outlet_types(self) -> set:
|
||||
return self._wrapped_stage.outlet_types
|
||||
|
||||
def init(self, ctx: PipelineContext) -> bool:
|
||||
"""Initialize the wrapped stage."""
|
||||
return self._wrapped_stage.init(ctx)
|
||||
|
||||
def process(self, data: Any, ctx: PipelineContext) -> Any:
|
||||
"""
|
||||
Process data through wrapped stage and capture frames.
|
||||
|
||||
Args:
|
||||
data: Input data (typically a text buffer)
|
||||
ctx: Pipeline context
|
||||
|
||||
Returns:
|
||||
Output data from wrapped stage
|
||||
"""
|
||||
# Capture input frame (before stage processing)
|
||||
if isinstance(data, list) and all(isinstance(line, str) for line in data):
|
||||
self._display.start_stage(f"{self._wrapped_stage.name}_input")
|
||||
self._display.show(data)
|
||||
self._captured_input = True
|
||||
|
||||
# Process through wrapped stage
|
||||
result = self._wrapped_stage.process(data, ctx)
|
||||
|
||||
# Capture output frame (after stage processing)
|
||||
if isinstance(result, list) and all(isinstance(line, str) for line in result):
|
||||
self._display.start_stage(f"{self._wrapped_stage.name}_output")
|
||||
self._display.show(result)
|
||||
self._captured_output = True
|
||||
|
||||
return result
|
||||
|
||||
def cleanup(self) -> None:
|
||||
"""Cleanup the wrapped stage."""
|
||||
self._wrapped_stage.cleanup()
|
||||
|
||||
|
||||
class FrameCaptureController:
|
||||
"""
|
||||
Controller for managing frame capture across the pipeline.
|
||||
|
||||
This class provides an easy way to enable frame capture for
|
||||
specific stages or the entire pipeline.
|
||||
"""
|
||||
|
||||
def __init__(self, display: AnimationReportDisplay):
|
||||
"""
|
||||
Initialize frame capture controller.
|
||||
|
||||
Args:
|
||||
display: The animation report display to use for capture
|
||||
"""
|
||||
self._display = display
|
||||
self._captured_stages: list[FrameCaptureStage] = []
|
||||
|
||||
def wrap_stage(self, stage: Stage, name: str | None = None) -> FrameCaptureStage:
|
||||
"""
|
||||
Wrap a stage with frame capture.
|
||||
|
||||
Args:
|
||||
stage: The stage to wrap
|
||||
name: Optional name for the capture stage
|
||||
|
||||
Returns:
|
||||
Wrapped stage that captures frames
|
||||
"""
|
||||
capture_stage = FrameCaptureStage(stage, self._display, name)
|
||||
self._captured_stages.append(capture_stage)
|
||||
return capture_stage
|
||||
|
||||
def wrap_stages(self, stages: dict[str, Stage]) -> dict[str, Stage]:
|
||||
"""
|
||||
Wrap multiple stages with frame capture.
|
||||
|
||||
Args:
|
||||
stages: Dictionary of stage names to stages
|
||||
|
||||
Returns:
|
||||
Dictionary of stage names to wrapped stages
|
||||
"""
|
||||
wrapped = {}
|
||||
for name, stage in stages.items():
|
||||
wrapped[name] = self.wrap_stage(stage, name)
|
||||
return wrapped
|
||||
|
||||
def get_captured_stages(self) -> list[FrameCaptureStage]:
|
||||
"""Get list of all captured stages."""
|
||||
return self._captured_stages
|
||||
|
||||
def generate_report(self, title: str = "Pipeline Animation Report") -> str:
|
||||
"""
|
||||
Generate the animation report.
|
||||
|
||||
Args:
|
||||
title: Title for the report
|
||||
|
||||
Returns:
|
||||
Path to the generated HTML file
|
||||
"""
|
||||
report_path = self._display.generate_report(title)
|
||||
return str(report_path)
|
||||
60
engine/themes.py
Normal file
60
engine/themes.py
Normal file
@@ -0,0 +1,60 @@
|
||||
"""
|
||||
Theme definitions with color gradients for terminal rendering.
|
||||
|
||||
This module is data-only and does not import config or render
|
||||
to prevent circular dependencies.
|
||||
"""
|
||||
|
||||
|
||||
class Theme:
|
||||
"""Represents a color theme with two gradients."""
|
||||
|
||||
def __init__(self, name, main_gradient, message_gradient):
|
||||
"""Initialize a theme with name and color gradients.
|
||||
|
||||
Args:
|
||||
name: Theme identifier string
|
||||
main_gradient: List of 12 ANSI 256-color codes for main gradient
|
||||
message_gradient: List of 12 ANSI 256-color codes for message gradient
|
||||
"""
|
||||
self.name = name
|
||||
self.main_gradient = main_gradient
|
||||
self.message_gradient = message_gradient
|
||||
|
||||
|
||||
# ─── GRADIENT DEFINITIONS ─────────────────────────────────────────────────
|
||||
# Each gradient is 12 ANSI 256-color codes in sequence
|
||||
# Format: [light...] → [medium...] → [dark...] → [black]
|
||||
|
||||
_GREEN_MAIN = [231, 195, 123, 118, 82, 46, 40, 34, 28, 22, 22, 235]
|
||||
_GREEN_MSG = [231, 225, 219, 213, 207, 201, 165, 161, 125, 89, 89, 235]
|
||||
|
||||
_ORANGE_MAIN = [231, 215, 209, 208, 202, 166, 130, 94, 58, 94, 94, 235]
|
||||
_ORANGE_MSG = [231, 195, 33, 27, 21, 21, 21, 18, 18, 18, 18, 235]
|
||||
|
||||
_PURPLE_MAIN = [231, 225, 177, 171, 165, 135, 129, 93, 57, 57, 57, 235]
|
||||
_PURPLE_MSG = [231, 226, 226, 220, 220, 184, 184, 178, 178, 172, 172, 235]
|
||||
|
||||
|
||||
# ─── THEME REGISTRY ───────────────────────────────────────────────────────
|
||||
|
||||
THEME_REGISTRY = {
|
||||
"green": Theme("green", _GREEN_MAIN, _GREEN_MSG),
|
||||
"orange": Theme("orange", _ORANGE_MAIN, _ORANGE_MSG),
|
||||
"purple": Theme("purple", _PURPLE_MAIN, _PURPLE_MSG),
|
||||
}
|
||||
|
||||
|
||||
def get_theme(theme_id):
|
||||
"""Retrieve a theme by ID.
|
||||
|
||||
Args:
|
||||
theme_id: Theme identifier string
|
||||
|
||||
Returns:
|
||||
Theme object matching the ID
|
||||
|
||||
Raises:
|
||||
KeyError: If theme_id is not in registry
|
||||
"""
|
||||
return THEME_REGISTRY[theme_id]
|
||||
@@ -0,0 +1,32 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
|
||||
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
|
||||
<svg fill="#000000" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
|
||||
width="800px" height="800px" viewBox="0 0 577.362 577.362"
|
||||
xml:space="preserve">
|
||||
<g>
|
||||
<g id="Layer_2_21_">
|
||||
<path d="M547.301,156.98c-23.113-2.132-181.832-24.174-314.358,5.718c-37.848-16.734-57.337-21.019-85.269-31.078
|
||||
c-12.47-4.494-28.209-7.277-41.301-9.458c-26.01-4.322-45.89,1.253-54.697,31.346C36.94,203.846,19.201,253.293,0,311.386
|
||||
c15.118-0.842,40.487-8.836,40.487-8.836l48.214-7.966l-9.964,66.938l57.777-19.526v57.776l66.938-29.883l19.125,49.41
|
||||
c0,0,44.647-34.081,57.375-49.41c28.076,83.634,104.595,105.981,175.71,70.122c21.42-10.806,39.914-46.637,48.129-65.255
|
||||
c23.926-54.229,11.6-93.712-5.891-137.155c20.254-9.562,34.061-13.464,66.344-30.628
|
||||
C582.365,197.764,585.951,161.904,547.301,156.98z M63.352,196.119c11.924-8.396,18.599,0.889,34.511-10.308
|
||||
c6.971-5.183,4.581-18.924-4.542-21.908c-3.997-1.31-6.722-2.897-12.049-5.192c-7.449-2.984-0.851-20.082,7.325-18.676
|
||||
c15.443,2.572,24.575,3.012,32.159,12.125c8.702,10.452,9.008,37.074,4.991,45.843c-9.553,20.885-35.257,19.087-53.923,17.241
|
||||
C57.624,214.097,56.744,201.034,63.352,196.119z M284.073,346.938c-51.915,6.685-102.921,0.794-142.462-42.313
|
||||
c-25.331-27.616-57.231-46.187-88.654-68.611c28.84-11.121,64.49-5.078,84.781,25.704
|
||||
c45.383,68.841,106.344,71.279,176.887,56.247c24.127-5.145,52.9-8.052,76.807-2.983c26.297,5.574,29.279,31.24,12.039,48.118
|
||||
c-18.227,19.775-39.045-0.794-29.482-6.378c7.967-4.38,12.643-10.997,10.482-19.259c-6.197-9.668-21.707-2.975-31.586-1.425
|
||||
C324.953,340.437,312.023,343.344,284.073,346.938z M472.188,381.049c-24.176,34.31-54.775,55.969-100.789,47.602
|
||||
c-27.846-5.059-61.41-30.179-53.789-65.14c34.061,41.836,95.625,35.859,114.75,1.195c16.533-29.969-4.141-62.5-23.793-66.852
|
||||
c-30.676-6.779-69.891-0.134-101.381,4.408c-58.58,8.444-104.48,7.812-152.579-43.844c-26.067-27.99,15.376-53.493-7.736-107.282
|
||||
c44.351,8.578,72.121,22.711,89.247,79.292c11.293,37.294,59.096,61.325,110.762,53.387
|
||||
c38.031-5.842,81.912-22.873,119.703-31.853C499.66,299.786,498.293,343.984,472.188,381.049z M288.195,243.568
|
||||
c31.805-12.135,64.67-9.151,94.362,0C350.475,273.26,301.467,268.479,288.195,243.568z M528.979,198.959
|
||||
c-35.459,17.337-60.961,25.102-98.809,37.055c-5.146,1.626-13.895,1.042-18.438-2.17c-47.803-33.813-114.846-27.425-142.338-6.292
|
||||
c-18.522-11.456-21.038-42.582,8.406-49.304c83.834-19.125,179.45-13.646,248.788,0.793
|
||||
C540.529,183.42,538.674,194.876,528.979,198.959z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 2.7 KiB |
60
figments/mayan-mask-of-mexico-svgrepo-com.svg
Normal file
60
figments/mayan-mask-of-mexico-svgrepo-com.svg
Normal file
@@ -0,0 +1,60 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
|
||||
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
|
||||
<svg fill="#000000" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
|
||||
width="800px" height="800px" viewBox="0 0 559.731 559.731"
|
||||
xml:space="preserve">
|
||||
<g>
|
||||
<g id="Layer_2_36_">
|
||||
<path d="M295.414,162.367l-15.061-39.302l-14.918,39.34c5.049-0.507,10.165-0.774,15.339-0.774
|
||||
C285.718,161.621,290.595,161.898,295.414,162.367z"/>
|
||||
<path d="M522.103,244.126c-20.062-0.631-36.71,12.67-55.787,21.937c-25.111,12.192-17.548-7.526-17.548-7.526l56.419-107.186
|
||||
c-31.346-31.967-127.869-68.324-127.869-68.324l-38.968,85.957L280.774,27.249L221.295,168.84l-38.9-85.804
|
||||
c0,0-96.533,36.356-127.87,68.324l56.418,107.186c0,0,7.564,19.718-17.547,7.525c-19.077-9.266-35.726-22.567-55.788-21.936
|
||||
C17.547,244.767,0,275.481,0,305.565c0,30.084,7.525,68.955,39.493,68.955c31.967,0,47.64-16.926,58.924-23.188
|
||||
c11.284-6.273,20.062,1.252,14.105,12.536S49.524,465.412,49.524,465.412s57.041,40.115,130.375,67.071l33.22-84.083
|
||||
c-49.601-24.91-83.796-76.127-83.796-135.31c0-61.372,36.758-114.214,89.352-137.986c1.511-0.688,3.002-1.406,4.542-2.037
|
||||
c9.964-4.112,20.483-7.095,31.384-9.008l25.732-67.836l25.943,67.731c10.576,1.807,20.779,4.657,30.495,8.53
|
||||
c1.176,0.468,2.391,0.88,3.557,1.377c53.99,23.18,91.925,76.844,91.925,139.229c0,59.795-34.913,111.441-85.346,136.056
|
||||
l32.924,83.337c73.335-26.956,130.375-67.071,130.375-67.071s-57.04-90.26-62.998-101.544
|
||||
c-5.957-11.284,2.821-18.81,14.105-12.536c11.283,6.272,26.956,23.188,58.924,23.188s39.493-38.861,39.493-68.955
|
||||
C559.712,275.472,542.165,244.757,522.103,244.126z"/>
|
||||
<path d="M256.131,173.478c-1.836,0.325-3.682,0.612-5.499,1.004c-8.912,1.932-17.518,4.676-25.723,8.205
|
||||
c-4.045,1.74-7.995,3.634-11.839,5.728c-44.159,24.078-74.195,70.925-74.195,124.667c0,55.146,31.681,102.931,77.743,126.396
|
||||
c19.297,9.831,41.052,15.491,64.146,15.491c22.481,0,43.682-5.393,62.596-14.745c46.895-23.18,79.302-71.394,79.302-127.152
|
||||
c0-54.851-31.336-102.434-77.007-126.043c-3.557-1.836-7.172-3.576-10.892-5.116c-7.86-3.242-16.056-5.814-24.547-7.622
|
||||
c-1.808-0.382-3.652-0.622-5.479-0.937c-1.807-0.306-3.614-0.593-5.44-0.832c-6.082-0.793-12.24-1.348-18.532-1.348
|
||||
c-6.541,0-12.919,0.602-19.221,1.463C259.736,172.895,257.929,173.163,256.131,173.478z M280.783,196.084
|
||||
c10.433,0,20.493,1.501,30.132,4.074c8.559,2.285,16.754,5.441,24.423,9.496c37.093,19.641,62.443,58.608,62.443,103.418
|
||||
c0,43.155-23.543,80.832-58.408,101.114c-17.251,10.04-37.227,15.883-58.59,15.883c-22.127,0-42.753-6.282-60.416-16.992
|
||||
c-33.842-20.531-56.581-57.614-56.581-100.005c0-44.064,24.499-82.486,60.578-102.434c14.889-8.233,31.776-13.196,49.715-14.22
|
||||
C276.309,196.294,278.518,196.084,280.783,196.084z"/>
|
||||
<path d="M236.997,354.764c-6.694,0-12.145,5.45-12.145,12.145v4.398c0,6.694,5.441,12.145,12.145,12.145h16.457
|
||||
c-1.683-11.743-0.717-22.376,0.268-28.688H236.997z"/>
|
||||
<path d="M327.458,383.452c5.001,0,9.295-3.041,11.15-7.373c0.641-1.473,0.994-3.079,0.994-4.771v-4.398
|
||||
c0-1.874-0.507-3.605-1.271-5.192c-1.961-4.074-6.054-6.952-10.873-6.952h-17.882c2.592,8.415,3.5,18.303,1.683,28.688H327.458z"
|
||||
/>
|
||||
<path d="M173.339,313.082c0,36.949,18.752,69.596,47.239,88.94c14.516,9.859,31.566,16.237,49.945,17.978
|
||||
c-7.879-8.176-12.527-17.633-15.089-26.985h-18.437c-6.407,0-12.116-2.85-16.084-7.277c-3.461-3.844-5.623-8.874-5.623-14.43
|
||||
v-4.398c0-5.938,2.41-11.322,6.283-15.243c3.939-3.987,9.39-6.464,15.424-6.464h18.809h49.974h21.697
|
||||
c3.863,0,7.449,1.1,10.595,2.888c6.579,3.729,11.093,10.72,11.093,18.819v4.398c0,7.765-4.131,14.535-10.279,18.379
|
||||
c-3.328,2.075-7.22,3.328-11.428,3.328h-18.676c-3.088,9.056-8.463,18.227-16.791,26.909c17.27-1.798,33.296-7.756,47.162-16.772
|
||||
c29.48-19.173,49.056-52.355,49.056-90.069c0-39.216-21.19-73.498-52.661-92.259c-16.064-9.572-34.75-15.176-54.765-15.176
|
||||
c-20.798,0-40.172,6.043-56.638,16.313C193.698,240.942,173.339,274.64,173.339,313.082z M306.287,274.583
|
||||
c4.513-9.027,15.156-14.64,27.778-14.64c0.775,0,1.502,0.201,2.257,0.249c11.026,0.622,21.22,5.499,27.53,13.598l2.238,2.888
|
||||
l-2.19,2.926c-6.789,9.036-16.667,14.688-26.89,15.597c-0.956,0.086-1.912,0.19-2.878,0.19c-11.284,0-21.362-5.89-27.664-16.16
|
||||
l-1.387-2.257L306.287,274.583z M268.353,311.484l1.271,3.691c1.501,4.398,6.206,13.493,11.159,13.493
|
||||
c4.915,0,9.649-9.372,11.055-13.646l1.138-3.48l3.653,0.201c9.658,0.517,12.594-1.454,13.244-2.065
|
||||
c0.392-0.363,0.641-0.794,0.641-1.722c0-2.639,2.142-4.781,4.781-4.781c2.639,0,4.781,2.143,4.781,4.781
|
||||
c0,3.414-1.253,6.417-3.624,8.664c-3.396,3.223-8.731,4.666-16.84,4.781c-2.534,5.852-8.635,16.839-18.838,16.839
|
||||
c-10.06,0-16.19-10.595-18.81-16.428c-5.756,0.315-13.368-0.249-18.216-4.514c-2.716-2.391-4.16-5.623-4.16-9.343
|
||||
c0-2.639,2.142-4.781,4.781-4.781s4.781,2.143,4.781,4.781c0,0.976,0.258,1.597,0.908,2.171c2.2,1.932,8.004,2.696,14.42,1.855
|
||||
L268.353,311.484z M257.9,273.789l2.238,2.878l-2.19,2.916c-7.411,9.888-18.532,15.788-29.758,15.788
|
||||
c-1.875,0-3.701-0.22-5.499-0.535c-9.018-1.598-16.916-7.058-22.166-15.625l-1.396-2.266l1.186-2.372
|
||||
c3.94-7.87,12.546-13.148,23.055-14.363c1.54-0.182,3.127-0.277,4.733-0.277C240.028,259.942,251.168,265.116,257.9,273.789z"/>
|
||||
<path d="M301.468,383.452c2.228-10.596,1.08-20.636-1.961-28.688h-36.06c-0.918,5.489-2.171,16.591-0.191,28.688
|
||||
c0.517,3.146,1.272,6.359,2.295,9.562c2.763,8.664,7.563,17.231,15.73,24.088c8.443-7.707,13.941-15.94,17.26-24.088
|
||||
C299.86,389.801,300.808,386.607,301.468,383.452z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 5.6 KiB |
110
figments/mayan-symbol-of-mexico-svgrepo-com.svg
Normal file
110
figments/mayan-symbol-of-mexico-svgrepo-com.svg
Normal file
@@ -0,0 +1,110 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
|
||||
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
|
||||
<svg fill="#000000" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
|
||||
width="800px" height="800px" viewBox="0 0 589.748 589.748"
|
||||
xml:space="preserve">
|
||||
<g>
|
||||
<g id="Layer_2_2_">
|
||||
<path d="M498.658,267.846c-9.219-9.744-20.59-14.382-33.211-15.491c-13.914-1.234-26.719,3.098-37.514,12.278
|
||||
c-4.82,4.093-15.416,2.763-16.916-5.413c-0.795-4.303-0.096-7.602,2.305-11.246c3.854-5.862,6.98-12.202,10.422-18.331
|
||||
c3.73-6.646,7.508-13.263,11.16-19.947c5.26-9.61,10.375-19.307,15.672-28.898c3.76-6.799,7.785-13.445,11.486-20.273
|
||||
c0.459-0.851,0.104-3.031-0.594-3.48c-7.898-5.106-15.777-10.28-23.982-14.86c-7.602-4.236-15.502-7.975-23.447-11.542
|
||||
c-8.348-3.739-16.889-7.076-25.418-10.404c-0.879-0.344-2.869,0.191-3.299,0.928c-5.26,9.008-10.346,18.111-15.443,27.215
|
||||
c-4.006,7.153-7.918,14.363-11.924,21.516c-2.381,4.255-4.877,8.434-7.297,12.661c-3.193,5.575-6.215,11.255-9.609,16.715
|
||||
c-1.234,1.989-0.363,2.467,1.07,3.232c5.25,2.812,11.016,5.001,15.586,8.673c7.736,6.225,15.109,13.034,21.879,20.301
|
||||
c4.629,4.963,8.598,10.796,11.725,16.82c3.824,7.373,6.865,15.233,9.477,23.132c2.094,6.34,4.006,13.024,4.283,19.632
|
||||
c0.441,10.317,1.473,20.837-1.291,31.04c-2.352,8.645-4.484,17.423-7.764,25.723c-2.41,6.101-6.445,11.58-9.879,17.27
|
||||
c-6.225,10.309-14.354,18.943-24.115,25.925c-6.428,4.599-13.207,8.701-20.035,13.157c14.621,26.584,29.396,53.436,44.266,80.459
|
||||
c4.762-1.788,9.256-3.375,13.664-5.154c7.412-2.974,14.918-5.766,22.129-9.189c6.082-2.888,11.857-6.464,17.662-9.906
|
||||
c7.41-4.399,14.734-8.932,22.012-13.541c0.604-0.382,1.043-2.056,0.717-2.706c-1.768-3.5-3.748-6.904-5.766-10.271
|
||||
c-4.246-7.085-8.635-14.095-12.812-21.219c-3.5-5.967-6.752-12.077-10.166-18.083c-3.711-6.512-7.525-12.957-11.207-19.488
|
||||
c-2.611-4.638-4.887-9.477-7.65-14.019c-2.008-3.299-3.91-6.292-3.768-10.528c0.152-4.6,2.18-7.583,5.824-9.668
|
||||
c3.613-2.056,7.391-1.864,10.814,0.546c2.945,2.074,5.412,5.077,8.615,6.492c5.527,2.438,11.408,4.122,17.232,5.834
|
||||
c7.602,2.228,15.328,0.927,22.586-1.062c7.268-1.989,14.258-5.394,19.861-10.806c2.85-2.754,5.939-5.441,8.09-8.712
|
||||
c4.285-6.493,7.432-13.426,8.885-21.324c1.51-8.195,0.688-16.065-1.645-23.61C508.957,280.516,504.404,273.927,498.658,267.846z"
|
||||
/>
|
||||
<path d="M183.983,301.85c0.421-46.885,24.174-79.417,64.69-100.846c-1.817-3.471-3.461-6.761-5.24-9.983
|
||||
c-3.423-6.177-6.99-12.278-10.375-18.475c-5.518-10.117-10.882-20.32-16.438-30.418c-3.577-6.502-7.574-12.766-10.987-19.345
|
||||
c-1.454-2.802-2.802-3.137-5.613-2.142c-12.642,4.466-25.016,9.543-36.979,15.606c-11.915,6.043-23.418,12.728-34.32,20.492
|
||||
c-1.778,1.262-1.96,2.104-1.004,3.777c2.792,4.848,5.537,9.725,8.271,14.611c4.973,8.874,9.955,17.739,14.86,26.632
|
||||
c3.242,5.871,6.282,11.857,9.572,17.7c5.843,10.375,12.02,20.579,17.643,31.078c2.448,4.571,2.247,10.604-2.639,14.009
|
||||
c-5.011,3.491-9.486,3.596-14.22-0.115c-6.311-4.953-13.167-8.424-20.913-10.509c-11.59-3.127-22.711-1.894-33.564,2.802
|
||||
c-2.18,0.946-4.112,2.429-6.244,3.48c-6.216,3.079-10.815,7.994-14.755,13.455c-4.447,6.168-7.076,13.158-8.683,20.655
|
||||
c-1.73,8.071-1.052,16.008,1.167,23.677c2.878,9.955,8.807,18.149,16.677,24.996c5.613,4.887,12.192,8.339,19.096,9.975
|
||||
c6.666,1.577,13.933,1.367,20.866,0.898c7.621-0.507,14.621-3.528,20.817-8.176c5.699-4.274,11.16-9.209,18.905-3.558
|
||||
c3.242,2.362,5.431,10.375,3.414,13.751c-7.937,13.272-15.816,26.584-23.524,39.99c-4.169,7.249-7.851,14.774-11.915,22.09
|
||||
c-4.456,8.013-9.151,15.902-13.646,23.896c-2.362,4.207-2.094,4.724,2.142,7.277c4.8,2.878,9.505,5.947,14.373,8.711
|
||||
c8.09,4.6,16.18,9.237,24.48,13.436c5.556,2.812,11.427,5.011,17.241,7.286c5.393,2.113,10.892,3.969,16.524,6.006
|
||||
c14.908-27.119,29.653-53.942,44.322-80.631C207.775,381.381,183.563,349.012,183.983,301.85z"/>
|
||||
<path d="M283.979,220.368c-36.777,4.839-64.327,32.302-72.245,60.99c55.348,0,110.629,0,166.129,0
|
||||
C364.667,233.545,324.189,215.08,283.979,220.368z"/>
|
||||
<path d="M381.019,300.482c-9.82,0-19.201,0-28.889,0c0.727,9.562-3.203,28.143-13.1,40.028
|
||||
c-9.926,11.915-22.529,18.207-37.658,19.68c-16.983,1.645-32.694-1.692-45.546-13.464c-13.655-12.498-20.129-27.119-18.81-46.244
|
||||
c-9.763,0-18.972,0-29.223,0c-0.239,38.25,14.688,62.089,45.719,78.986c29.863,16.266,60.559,15.242,88.883-3.433
|
||||
C369.066,358.45,382.291,329.17,381.019,300.482z"/>
|
||||
<path d="M260.656,176.715c3.242,5.948,6.474,11.886,9.477,17.404c6.541-0.88,12.622-2.458,18.675-2.343
|
||||
c9.313,0.182,18.59,1.559,27.893,2.314c0.957,0.077,2.486-0.296,2.869-0.975c2.486-4.332,4.695-8.817,7.057-13.215
|
||||
c2.238-4.169,4.543-8.3,6.752-12.316c-12.719-24.203-25.389-48.319-38.451-73.172c-0.822,1.482-1.358,2.381-1.836,3.309
|
||||
c-1.96,3.825-3.854,7.688-5.862,11.484c-2.438,4.628-4.954,9.218-7.459,13.818c-2.228,4.083-4.456,8.157-6.722,12.221
|
||||
c-2.381,4.274-4.858,8.501-7.201,12.804c-2.381,4.361-4.418,8.932-7.028,13.148c-2.611,4.208-2.917,7.526-0.249,11.762
|
||||
C259.336,174.171,259.967,175.462,260.656,176.715z"/>
|
||||
<path d="M272.991,331.341c10.949,8.501,29.424,10.643,42.047,1.157c10.566-7.938,16.734-22.453,13.721-32.016
|
||||
c-22.807,0-45.632,0-68.41,0C257.127,310.045,263.008,323.595,272.991,331.341z"/>
|
||||
<path d="M322.248,413.836c-1.281-2.447-2.811-3.356-6.119-2.515c-5.699,1.444-11.676,2.133-17.566,2.381
|
||||
c-10.175,0.431-20.388,0.479-30.486-2.696c-2.62,6.034-5.125,11.8-7.688,17.69c22.96,8.894,45.729,8.894,68.889,0.899
|
||||
c-0.049-0.794,0.105-1.492-0.145-1.999C326.886,422.987,324.638,418.379,322.248,413.836z"/>
|
||||
<path d="M541.498,355.343c10.613-15.654,15.863-33.345,15.586-52.556c-0.43-30.237-12.9-55.721-36.088-73.708
|
||||
c-12.527-9.715-25.887-16.065-39.914-18.972c0.469-0.794,0.928-1.597,1.377-2.4c2.295-4.15,4.514-8.338,6.74-12.527
|
||||
c1.914-3.605,3.836-7.21,5.795-10.796c1.482-2.716,3.014-5.403,4.543-8.09c2.295-4.036,4.59-8.081,6.76-12.183
|
||||
c4.189-7.908,3.031-18.59-2.744-25.398c-2.781-3.28-5.785-5.25-7.773-6.56l-0.871-0.583l-4.465-3.213
|
||||
c-3.883-2.812-7.908-5.709-12.184-8.491c-7.707-5.011-14.793-9.343-21.668-13.244c-4.17-2.362-8.387-4.236-12.105-5.891
|
||||
l-3.08-1.377c-1.988-0.909-3.969-1.846-5.957-2.773c-5.633-2.658-11.455-5.402-17.795-7.707c-7.422-2.697-14.861-5.001-22.07-7.22
|
||||
c-3.672-1.138-7.354-2.276-11.008-3.462c-2.236-0.727-5.66-1.683-9.609-1.683c-5.375,0-15.367,1.855-21.832,14.248
|
||||
c-1.338,2.562-2.658,5.125-3.977,7.698L311.625,30.59L294.708,0l-16.639,30.743l-36.873,68.124
|
||||
c-1.884-3.232-3.749-6.474-5.575-9.735c-4.523-8.07-12.125-12.699-20.865-12.699c-2.305,0-4.657,0.334-7,1.004
|
||||
c-4.208,1.195-9.113,2.601-14.038,4.293l-5.747,1.941c-6.866,2.305-13.961,4.686-21.057,7.641
|
||||
c-12.393,5.154-23.543,9.916-34.616,15.902c-9.333,5.049-17.968,10.815-26.316,16.39l-5.106,3.404
|
||||
c-3.796,2.515-7.172,5.25-10.146,7.669c-1.176,0.947-2.343,1.903-3.519,2.821l-12.852,10.002l7.832,14.287l26.479,48.291
|
||||
c-14.86,2.993-28.745,9.763-41.463,20.225c-21.994,18.102-33.938,42.773-34.53,71.355c-0.526,25.293,8.186,48.195,25.178,66.249
|
||||
c14.248,15.128,31.049,24.538,50.107,28.086c-2.936,5.288-5.872,10.575-8.798,15.863c-1.3,2.362-2.562,4.733-3.834,7.115
|
||||
c-1.625,3.05-3.251,6.11-4.963,9.112c-1.214,2.133-2.524,4.218-3.834,6.293c-1.281,2.046-2.563,4.102-3.796,6.187
|
||||
c-5.891,10.012-1.568,21.649,6.015,27.119c7.851,5.671,15.73,11.303,23.677,16.858c12.451,8.702,25.408,15.864,38.508,21.286
|
||||
l4.676,1.941c7.468,3.117,15.195,6.331,23.227,9.123c7.631,2.648,15.3,4.915,22.711,7.104c3.137,0.928,6.264,1.855,9.391,2.812
|
||||
l9.955,4.657c3.892,32.751,35.324,58.283,73.526,58.283c38.508,0,70.112-25.943,73.592-59.058l10.49-3.51l4.715-1.683
|
||||
l10.107-3.118c2.018-0.593,4.035-1.214,6.062-1.778c4.973-1.367,10.117-2.821,15.396-4.743
|
||||
c7.889-2.878,16.352-6.368,26.641-10.949c6.588-2.936,12.938-6.206,18.877-9.696c8.883-5.23,17.566-10.662,25.789-16.142
|
||||
c5.184-3.452,9.707-7.172,14.076-10.776l1.463-1.205c8.492-6.962,9.18-19.153,4.936-26.909c-2.229-4.073-4.562-8.09-6.895-12.097
|
||||
l-2.42-4.159l-3.271-5.651c-3.107-5.374-6.225-10.748-9.295-16.142c-1.156-2.037-2.303-4.073-3.441-6.12
|
||||
c6.961-1.301,13.637-3.404,19.957-6.292C517.552,382.251,531.093,370.69,541.498,355.343z M463.82,378.465
|
||||
c-4.809,0-9.734-0.411-14.764-1.167c3.461,6.254,6.396,11.552,9.332,16.84c3.232,5.823,6.436,11.656,9.727,17.441
|
||||
c4.168,7.325,8.404,14.612,12.621,21.908c3.051,5.278,6.168,10.519,9.096,15.864c0.41,0.746,0.268,2.496-0.287,2.955
|
||||
c-4.562,3.748-9.094,7.573-14,10.844c-8.148,5.422-16.457,10.604-24.891,15.567c-5.471,3.223-11.16,6.12-16.965,8.702
|
||||
c-8.357,3.729-16.811,7.296-25.408,10.433c-6.617,2.409-13.512,4.035-20.281,6.024c-4.82,1.415-9.629,2.83-14.85,4.37
|
||||
c-2.736-4.753-5.49-9.371-8.072-14.066c-2.477-4.504-4.732-9.123-7.172-13.646c-4.34-8.033-8.807-16.008-13.109-24.069
|
||||
c-1.598-2.993-2.133-3.997-3.576-3.997c-0.871,0-2.076,0.363-4.045,0.87c-8.148,2.104-16.324,3.873-24.309,5.661
|
||||
c22.223,7.659,38.221,28.735,38.221,53.607c0,31.326-25.35,56.725-56.609,56.725c-31.27,0-56.61-25.398-56.61-56.725
|
||||
c0-24.566,15.606-45.422,37.409-53.312c-7.516-2.065-15.472-4.341-23.572-6.54c-0.918-0.249-1.721-0.584-2.448-0.584
|
||||
c-1.301,0-2.362,0.546-3.366,2.592c-4.581,9.267-9.744,18.217-14.697,27.301c-3.911,7.182-7.86,14.325-11.791,21.497
|
||||
c-0.804,1.463-1.645,2.897-2.812,4.972c-10.49-3.203-21.076-6.11-31.422-9.696c-9.094-3.155-17.949-6.99-26.852-10.671
|
||||
c-12.345-5.106-23.925-11.638-34.865-19.288c-7.86-5.498-15.664-11.083-23.438-16.696c-0.478-0.344-0.947-1.529-0.717-1.912
|
||||
c2.515-4.274,5.288-8.396,7.746-12.699c3.098-5.422,5.909-10.997,8.931-16.467c5.919-10.729,11.896-21.42,17.834-32.14
|
||||
c1.979-3.576,3.892-7.2,6.264-11.58c-4.848,0.736-9.562,1.109-14.143,1.109c-20.952,0-39.082-7.755-54.085-23.687
|
||||
c-13.78-14.63-20.406-32.607-19.986-52.737c0.478-23.074,9.811-42.38,27.559-56.992c13.952-11.484,29.663-17.643,47.354-17.643
|
||||
c4.523,0,9.17,0.401,13.952,1.224c-14.028-25.589-27.75-50.615-41.692-76.06c4.112-3.204,8.1-6.723,12.479-9.63
|
||||
c9.85-6.521,19.594-13.311,29.959-18.915c10.585-5.718,21.745-10.433,32.866-15.07c8.367-3.481,17.06-6.197,25.646-9.142
|
||||
c4.303-1.472,8.683-2.744,13.053-3.987c0.641-0.182,1.233-0.277,1.788-0.277c1.721,0,3.05,0.908,4.179,2.926
|
||||
c5.393,9.62,11.092,19.067,16.629,28.611c2.018,3.481,3.901,7.048,6.11,11.054c17.853-32.981,35.41-65.426,53.206-98.312
|
||||
c18.322,33.134,36.348,65.732,54.65,98.819c2.467-4.485,4.828-8.597,7.018-12.804c4.553-8.74,8.98-17.538,13.531-26.268
|
||||
c1.463-2.812,2.773-3.968,4.867-3.968c1.014,0,2.219,0.268,3.711,0.755c10.814,3.5,21.773,6.588,32.445,10.461
|
||||
c7.65,2.773,14.938,6.531,22.367,9.916c4.59,2.085,9.285,4.007,13.654,6.483c7.029,3.988,13.914,8.243,20.684,12.651
|
||||
c5.471,3.557,10.682,7.487,15.998,11.265c1.77,1.252,3.777,2.314,5.145,3.92c0.756,0.889,0.977,3.031,0.432,4.074
|
||||
c-3.576,6.751-7.498,13.32-11.18,20.024c-4.236,7.717-8.252,15.558-12.508,23.266c-2.246,4.064-4.895,7.898-7.182,11.943
|
||||
c-3.309,5.862-6.445,11.819-10.012,18.389c4.973-0.947,9.803-1.406,14.498-1.406c17.174,0,32.502,6.13,46.254,16.802
|
||||
c18.951,14.707,28.352,35.065,28.688,58.866c0.209,14.803-3.74,28.927-12.299,41.559c-8.309,12.26-19.039,21.602-32.379,27.693
|
||||
C483.902,376.6,474.101,378.465,463.82,378.465z"/>
|
||||
<path d="M261.746,512.598c0,18.102,14.669,32.818,32.704,32.818c18.034,0,32.704-14.726,32.704-32.818
|
||||
c0-18.092-14.67-32.818-32.704-32.818C276.415,479.779,261.746,494.506,261.746,512.598z"/>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 11 KiB |
@@ -40,6 +40,15 @@ camera_speed = 0.5
|
||||
viewport_width = 80
|
||||
viewport_height = 24
|
||||
|
||||
[presets.test-figment]
|
||||
description = "Test: Figment overlay effect"
|
||||
source = "empty"
|
||||
display = "terminal"
|
||||
camera = "feed"
|
||||
effects = ["figment"]
|
||||
viewport_width = 80
|
||||
viewport_height = 24
|
||||
|
||||
# ============================================
|
||||
# DEMO PRESETS (for demonstration and exploration)
|
||||
# ============================================
|
||||
|
||||
@@ -40,6 +40,9 @@ pygame = [
|
||||
browser = [
|
||||
"playwright>=1.40.0",
|
||||
]
|
||||
figment = [
|
||||
"cairosvg>=2.7.0",
|
||||
]
|
||||
dev = [
|
||||
"pytest>=8.0.0",
|
||||
"pytest-benchmark>=4.0.0",
|
||||
|
||||
@@ -1,17 +1,16 @@
|
||||
"""
|
||||
Tests for engine/pipeline/adapters.py - Stage adapters for the pipeline.
|
||||
|
||||
Tests Stage adapters that bridge existing components to the Stage interface:
|
||||
- DataSourceStage: Wraps DataSource objects
|
||||
- DisplayStage: Wraps Display backends
|
||||
- PassthroughStage: Simple pass-through stage for pre-rendered data
|
||||
- SourceItemsToBufferStage: Converts SourceItem objects to text buffers
|
||||
- EffectPluginStage: Wraps effect plugins
|
||||
Tests Stage adapters that bridge existing components to the Stage interface.
|
||||
Focuses on behavior testing rather than mock interactions.
|
||||
"""
|
||||
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
from engine.data_sources.sources import SourceItem
|
||||
from engine.display.backends.null import NullDisplay
|
||||
from engine.effects.plugins import discover_plugins
|
||||
from engine.effects.registry import get_registry
|
||||
from engine.pipeline.adapters import (
|
||||
DataSourceStage,
|
||||
DisplayStage,
|
||||
@@ -25,28 +24,14 @@ from engine.pipeline.core import PipelineContext
|
||||
class TestDataSourceStage:
|
||||
"""Test DataSourceStage adapter."""
|
||||
|
||||
def test_datasource_stage_name(self):
|
||||
"""DataSourceStage stores name correctly."""
|
||||
def test_datasource_stage_properties(self):
|
||||
"""DataSourceStage has correct name, category, and capabilities."""
|
||||
mock_source = MagicMock()
|
||||
stage = DataSourceStage(mock_source, name="headlines")
|
||||
|
||||
assert stage.name == "headlines"
|
||||
|
||||
def test_datasource_stage_category(self):
|
||||
"""DataSourceStage has 'source' category."""
|
||||
mock_source = MagicMock()
|
||||
stage = DataSourceStage(mock_source, name="headlines")
|
||||
assert stage.category == "source"
|
||||
|
||||
def test_datasource_stage_capabilities(self):
|
||||
"""DataSourceStage advertises source capability."""
|
||||
mock_source = MagicMock()
|
||||
stage = DataSourceStage(mock_source, name="headlines")
|
||||
assert "source.headlines" in stage.capabilities
|
||||
|
||||
def test_datasource_stage_dependencies(self):
|
||||
"""DataSourceStage has no dependencies."""
|
||||
mock_source = MagicMock()
|
||||
stage = DataSourceStage(mock_source, name="headlines")
|
||||
assert stage.dependencies == set()
|
||||
|
||||
def test_datasource_stage_process_calls_get_items(self):
|
||||
@@ -64,7 +49,7 @@ class TestDataSourceStage:
|
||||
assert result == mock_items
|
||||
mock_source.get_items.assert_called_once()
|
||||
|
||||
def test_datasource_stage_process_fallback_returns_data(self):
|
||||
def test_datasource_stage_process_fallback(self):
|
||||
"""DataSourceStage.process() returns data if no get_items method."""
|
||||
mock_source = MagicMock(spec=[]) # No get_items method
|
||||
stage = DataSourceStage(mock_source, name="headlines")
|
||||
@@ -76,124 +61,68 @@ class TestDataSourceStage:
|
||||
|
||||
|
||||
class TestDisplayStage:
|
||||
"""Test DisplayStage adapter."""
|
||||
"""Test DisplayStage adapter using NullDisplay for real behavior."""
|
||||
|
||||
def test_display_stage_properties(self):
|
||||
"""DisplayStage has correct name, category, and capabilities."""
|
||||
display = NullDisplay()
|
||||
stage = DisplayStage(display, name="terminal")
|
||||
|
||||
def test_display_stage_name(self):
|
||||
"""DisplayStage stores name correctly."""
|
||||
mock_display = MagicMock()
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
assert stage.name == "terminal"
|
||||
|
||||
def test_display_stage_category(self):
|
||||
"""DisplayStage has 'display' category."""
|
||||
mock_display = MagicMock()
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
assert stage.category == "display"
|
||||
|
||||
def test_display_stage_capabilities(self):
|
||||
"""DisplayStage advertises display capability."""
|
||||
mock_display = MagicMock()
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
assert "display.output" in stage.capabilities
|
||||
|
||||
def test_display_stage_dependencies(self):
|
||||
"""DisplayStage depends on render.output."""
|
||||
mock_display = MagicMock()
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
assert "render.output" in stage.dependencies
|
||||
|
||||
def test_display_stage_init(self):
|
||||
"""DisplayStage.init() calls display.init() with dimensions."""
|
||||
mock_display = MagicMock()
|
||||
mock_display.init.return_value = True
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
def test_display_stage_init_and_process(self):
|
||||
"""DisplayStage initializes display and processes buffer."""
|
||||
from engine.pipeline.params import PipelineParams
|
||||
|
||||
display = NullDisplay()
|
||||
stage = DisplayStage(display, name="terminal")
|
||||
|
||||
ctx = PipelineContext()
|
||||
ctx.params = MagicMock()
|
||||
ctx.params.viewport_width = 100
|
||||
ctx.params.viewport_height = 30
|
||||
ctx.params = PipelineParams()
|
||||
ctx.params.viewport_width = 80
|
||||
ctx.params.viewport_height = 24
|
||||
|
||||
# Initialize
|
||||
result = stage.init(ctx)
|
||||
|
||||
assert result is True
|
||||
mock_display.init.assert_called_once_with(100, 30, reuse=False)
|
||||
|
||||
def test_display_stage_init_uses_defaults(self):
|
||||
"""DisplayStage.init() uses defaults when params missing."""
|
||||
mock_display = MagicMock()
|
||||
mock_display.init.return_value = True
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
# Process buffer
|
||||
buffer = ["Line 1", "Line 2", "Line 3"]
|
||||
output = stage.process(buffer, ctx)
|
||||
assert output == buffer
|
||||
|
||||
ctx = PipelineContext()
|
||||
ctx.params = None
|
||||
# Verify display captured the buffer
|
||||
assert display._last_buffer == buffer
|
||||
|
||||
result = stage.init(ctx)
|
||||
|
||||
assert result is True
|
||||
mock_display.init.assert_called_once_with(80, 24, reuse=False)
|
||||
|
||||
def test_display_stage_process_calls_show(self):
|
||||
"""DisplayStage.process() calls display.show() with data."""
|
||||
mock_display = MagicMock()
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
|
||||
test_buffer = [[["A", "red"] for _ in range(80)] for _ in range(24)]
|
||||
ctx = PipelineContext()
|
||||
result = stage.process(test_buffer, ctx)
|
||||
|
||||
assert result == test_buffer
|
||||
mock_display.show.assert_called_once_with(test_buffer)
|
||||
|
||||
def test_display_stage_process_skips_none_data(self):
|
||||
def test_display_stage_skips_none_data(self):
|
||||
"""DisplayStage.process() skips show() if data is None."""
|
||||
mock_display = MagicMock()
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
display = NullDisplay()
|
||||
stage = DisplayStage(display, name="terminal")
|
||||
|
||||
ctx = PipelineContext()
|
||||
result = stage.process(None, ctx)
|
||||
|
||||
assert result is None
|
||||
mock_display.show.assert_not_called()
|
||||
|
||||
def test_display_stage_cleanup(self):
|
||||
"""DisplayStage.cleanup() calls display.cleanup()."""
|
||||
mock_display = MagicMock()
|
||||
stage = DisplayStage(mock_display, name="terminal")
|
||||
|
||||
stage.cleanup()
|
||||
|
||||
mock_display.cleanup.assert_called_once()
|
||||
assert display._last_buffer is None
|
||||
|
||||
|
||||
class TestPassthroughStage:
|
||||
"""Test PassthroughStage adapter."""
|
||||
|
||||
def test_passthrough_stage_name(self):
|
||||
"""PassthroughStage stores name correctly."""
|
||||
def test_passthrough_stage_properties(self):
|
||||
"""PassthroughStage has correct properties."""
|
||||
stage = PassthroughStage(name="test")
|
||||
|
||||
assert stage.name == "test"
|
||||
|
||||
def test_passthrough_stage_category(self):
|
||||
"""PassthroughStage has 'render' category."""
|
||||
stage = PassthroughStage()
|
||||
assert stage.category == "render"
|
||||
|
||||
def test_passthrough_stage_is_optional(self):
|
||||
"""PassthroughStage is optional."""
|
||||
stage = PassthroughStage()
|
||||
assert stage.optional is True
|
||||
|
||||
def test_passthrough_stage_capabilities(self):
|
||||
"""PassthroughStage advertises render output capability."""
|
||||
stage = PassthroughStage()
|
||||
assert "render.output" in stage.capabilities
|
||||
|
||||
def test_passthrough_stage_dependencies(self):
|
||||
"""PassthroughStage depends on source."""
|
||||
stage = PassthroughStage()
|
||||
assert "source" in stage.dependencies
|
||||
|
||||
def test_passthrough_stage_process_returns_data_unchanged(self):
|
||||
def test_passthrough_stage_process_unchanged(self):
|
||||
"""PassthroughStage.process() returns data unchanged."""
|
||||
stage = PassthroughStage()
|
||||
ctx = PipelineContext()
|
||||
@@ -210,32 +139,17 @@ class TestPassthroughStage:
|
||||
class TestSourceItemsToBufferStage:
|
||||
"""Test SourceItemsToBufferStage adapter."""
|
||||
|
||||
def test_source_items_to_buffer_stage_name(self):
|
||||
"""SourceItemsToBufferStage stores name correctly."""
|
||||
def test_source_items_to_buffer_stage_properties(self):
|
||||
"""SourceItemsToBufferStage has correct properties."""
|
||||
stage = SourceItemsToBufferStage(name="custom-name")
|
||||
|
||||
assert stage.name == "custom-name"
|
||||
|
||||
def test_source_items_to_buffer_stage_category(self):
|
||||
"""SourceItemsToBufferStage has 'render' category."""
|
||||
stage = SourceItemsToBufferStage()
|
||||
assert stage.category == "render"
|
||||
|
||||
def test_source_items_to_buffer_stage_is_optional(self):
|
||||
"""SourceItemsToBufferStage is optional."""
|
||||
stage = SourceItemsToBufferStage()
|
||||
assert stage.optional is True
|
||||
|
||||
def test_source_items_to_buffer_stage_capabilities(self):
|
||||
"""SourceItemsToBufferStage advertises render output capability."""
|
||||
stage = SourceItemsToBufferStage()
|
||||
assert "render.output" in stage.capabilities
|
||||
|
||||
def test_source_items_to_buffer_stage_dependencies(self):
|
||||
"""SourceItemsToBufferStage depends on source."""
|
||||
stage = SourceItemsToBufferStage()
|
||||
assert "source" in stage.dependencies
|
||||
|
||||
def test_source_items_to_buffer_stage_process_single_line_item(self):
|
||||
def test_source_items_to_buffer_stage_process_single_line(self):
|
||||
"""SourceItemsToBufferStage converts single-line SourceItem."""
|
||||
stage = SourceItemsToBufferStage()
|
||||
ctx = PipelineContext()
|
||||
@@ -247,10 +161,10 @@ class TestSourceItemsToBufferStage:
|
||||
|
||||
assert isinstance(result, list)
|
||||
assert len(result) >= 1
|
||||
# Result should be lines of text
|
||||
assert all(isinstance(line, str) for line in result)
|
||||
assert "Single line content" in result[0]
|
||||
|
||||
def test_source_items_to_buffer_stage_process_multiline_item(self):
|
||||
def test_source_items_to_buffer_stage_process_multiline(self):
|
||||
"""SourceItemsToBufferStage splits multiline SourceItem content."""
|
||||
stage = SourceItemsToBufferStage()
|
||||
ctx = PipelineContext()
|
||||
@@ -283,63 +197,76 @@ class TestSourceItemsToBufferStage:
|
||||
|
||||
|
||||
class TestEffectPluginStage:
|
||||
"""Test EffectPluginStage adapter."""
|
||||
"""Test EffectPluginStage adapter with real effect plugins."""
|
||||
|
||||
def test_effect_plugin_stage_name(self):
|
||||
"""EffectPluginStage stores name correctly."""
|
||||
mock_effect = MagicMock()
|
||||
stage = EffectPluginStage(mock_effect, name="blur")
|
||||
assert stage.name == "blur"
|
||||
def test_effect_plugin_stage_properties(self):
|
||||
"""EffectPluginStage has correct properties for real effects."""
|
||||
discover_plugins()
|
||||
registry = get_registry()
|
||||
effect = registry.get("noise")
|
||||
|
||||
def test_effect_plugin_stage_category(self):
|
||||
"""EffectPluginStage has 'effect' category."""
|
||||
mock_effect = MagicMock()
|
||||
stage = EffectPluginStage(mock_effect, name="blur")
|
||||
stage = EffectPluginStage(effect, name="noise")
|
||||
|
||||
assert stage.name == "noise"
|
||||
assert stage.category == "effect"
|
||||
|
||||
def test_effect_plugin_stage_is_not_optional(self):
|
||||
"""EffectPluginStage is required when configured."""
|
||||
mock_effect = MagicMock()
|
||||
stage = EffectPluginStage(mock_effect, name="blur")
|
||||
assert stage.optional is False
|
||||
|
||||
def test_effect_plugin_stage_capabilities(self):
|
||||
"""EffectPluginStage advertises effect capability with name."""
|
||||
mock_effect = MagicMock()
|
||||
stage = EffectPluginStage(mock_effect, name="blur")
|
||||
assert "effect.blur" in stage.capabilities
|
||||
|
||||
def test_effect_plugin_stage_dependencies(self):
|
||||
"""EffectPluginStage has no static dependencies."""
|
||||
mock_effect = MagicMock()
|
||||
stage = EffectPluginStage(mock_effect, name="blur")
|
||||
# EffectPluginStage has empty dependencies - they are resolved dynamically
|
||||
assert stage.dependencies == set()
|
||||
|
||||
def test_effect_plugin_stage_stage_type(self):
|
||||
"""EffectPluginStage.stage_type returns effect for non-HUD."""
|
||||
mock_effect = MagicMock()
|
||||
stage = EffectPluginStage(mock_effect, name="blur")
|
||||
assert stage.stage_type == "effect"
|
||||
assert "effect.noise" in stage.capabilities
|
||||
|
||||
def test_effect_plugin_stage_hud_special_handling(self):
|
||||
"""EffectPluginStage has special handling for HUD effect."""
|
||||
mock_effect = MagicMock()
|
||||
stage = EffectPluginStage(mock_effect, name="hud")
|
||||
discover_plugins()
|
||||
registry = get_registry()
|
||||
hud_effect = registry.get("hud")
|
||||
|
||||
stage = EffectPluginStage(hud_effect, name="hud")
|
||||
|
||||
assert stage.stage_type == "overlay"
|
||||
assert stage.is_overlay is True
|
||||
assert stage.render_order == 100
|
||||
|
||||
def test_effect_plugin_stage_process(self):
|
||||
"""EffectPluginStage.process() calls effect.process()."""
|
||||
mock_effect = MagicMock()
|
||||
mock_effect.process.return_value = "processed_data"
|
||||
def test_effect_plugin_stage_process_real_effect(self):
|
||||
"""EffectPluginStage.process() calls real effect.process()."""
|
||||
from engine.pipeline.params import PipelineParams
|
||||
|
||||
stage = EffectPluginStage(mock_effect, name="blur")
|
||||
discover_plugins()
|
||||
registry = get_registry()
|
||||
effect = registry.get("noise")
|
||||
|
||||
stage = EffectPluginStage(effect, name="noise")
|
||||
ctx = PipelineContext()
|
||||
test_buffer = "test_buffer"
|
||||
ctx.params = PipelineParams()
|
||||
ctx.params.viewport_width = 80
|
||||
ctx.params.viewport_height = 24
|
||||
ctx.params.frame_number = 0
|
||||
|
||||
test_buffer = ["Line 1", "Line 2", "Line 3"]
|
||||
result = stage.process(test_buffer, ctx)
|
||||
|
||||
assert result == "processed_data"
|
||||
mock_effect.process.assert_called_once()
|
||||
# Should return a list (possibly modified buffer)
|
||||
assert isinstance(result, list)
|
||||
# Noise effect should preserve line count
|
||||
assert len(result) == len(test_buffer)
|
||||
|
||||
def test_effect_plugin_stage_process_with_real_figment(self):
|
||||
"""EffectPluginStage processes figment effect correctly."""
|
||||
from engine.pipeline.params import PipelineParams
|
||||
|
||||
discover_plugins()
|
||||
registry = get_registry()
|
||||
figment = registry.get("figment")
|
||||
|
||||
stage = EffectPluginStage(figment, name="figment")
|
||||
ctx = PipelineContext()
|
||||
ctx.params = PipelineParams()
|
||||
ctx.params.viewport_width = 80
|
||||
ctx.params.viewport_height = 24
|
||||
ctx.params.frame_number = 0
|
||||
|
||||
test_buffer = ["Line 1", "Line 2", "Line 3"]
|
||||
result = stage.process(test_buffer, ctx)
|
||||
|
||||
# Figment is an overlay effect
|
||||
assert stage.is_overlay is True
|
||||
assert stage.stage_type == "overlay"
|
||||
# Result should be a list
|
||||
assert isinstance(result, list)
|
||||
|
||||
285
tests/test_canvas.py
Normal file
285
tests/test_canvas.py
Normal file
@@ -0,0 +1,285 @@
|
||||
"""
|
||||
Unit tests for engine.canvas.Canvas.
|
||||
|
||||
Tests the core 2D rendering surface without any display dependencies.
|
||||
"""
|
||||
|
||||
from engine.canvas import Canvas, CanvasRegion
|
||||
|
||||
|
||||
class TestCanvasRegion:
|
||||
"""Tests for CanvasRegion dataclass."""
|
||||
|
||||
def test_is_valid_positive_dimensions(self):
|
||||
"""Positive width and height returns True."""
|
||||
region = CanvasRegion(0, 0, 10, 5)
|
||||
assert region.is_valid() is True
|
||||
|
||||
def test_is_valid_zero_width(self):
|
||||
"""Zero width returns False."""
|
||||
region = CanvasRegion(0, 0, 0, 5)
|
||||
assert region.is_valid() is False
|
||||
|
||||
def test_is_valid_zero_height(self):
|
||||
"""Zero height returns False."""
|
||||
region = CanvasRegion(0, 0, 10, 0)
|
||||
assert region.is_valid() is False
|
||||
|
||||
def test_is_valid_negative_dimensions(self):
|
||||
"""Negative dimensions return False."""
|
||||
region = CanvasRegion(0, 0, -1, 5)
|
||||
assert region.is_valid() is False
|
||||
|
||||
def test_rows_computes_correct_set(self):
|
||||
"""rows() returns set of row indices in region."""
|
||||
region = CanvasRegion(2, 3, 4, 2)
|
||||
assert region.rows() == {3, 4}
|
||||
|
||||
|
||||
class TestCanvas:
|
||||
"""Tests for Canvas class."""
|
||||
|
||||
def test_init_default_dimensions(self):
|
||||
"""Default width=80, height=24."""
|
||||
canvas = Canvas()
|
||||
assert canvas.width == 80
|
||||
assert canvas.height == 24
|
||||
assert len(canvas._grid) == 24
|
||||
assert len(canvas._grid[0]) == 80
|
||||
|
||||
def test_init_custom_dimensions(self):
|
||||
"""Custom dimensions are set correctly."""
|
||||
canvas = Canvas(100, 50)
|
||||
assert canvas.width == 100
|
||||
assert canvas.height == 50
|
||||
|
||||
def test_clear_empties_grid(self):
|
||||
"""clear() resets all cells to spaces."""
|
||||
canvas = Canvas(5, 3)
|
||||
canvas.put_text(0, 0, "Hello")
|
||||
canvas.clear()
|
||||
region = canvas.get_region(0, 0, 5, 3)
|
||||
assert all(all(cell == " " for cell in row) for row in region)
|
||||
|
||||
def test_clear_marks_entire_canvas_dirty(self):
|
||||
"""clear() marks entire canvas as dirty."""
|
||||
canvas = Canvas(10, 5)
|
||||
canvas.clear()
|
||||
dirty = canvas.get_dirty_regions()
|
||||
assert len(dirty) == 1
|
||||
assert dirty[0].x == 0 and dirty[0].y == 0
|
||||
assert dirty[0].width == 10 and dirty[0].height == 5
|
||||
|
||||
def test_put_text_single_char(self):
|
||||
"""put_text writes a single character at position."""
|
||||
canvas = Canvas(10, 5)
|
||||
canvas.put_text(3, 2, "X")
|
||||
assert canvas._grid[2][3] == "X"
|
||||
|
||||
def test_put_text_multiple_chars(self):
|
||||
"""put_text writes multiple characters in a row."""
|
||||
canvas = Canvas(10, 5)
|
||||
canvas.put_text(2, 1, "ABC")
|
||||
assert canvas._grid[1][2] == "A"
|
||||
assert canvas._grid[1][3] == "B"
|
||||
assert canvas._grid[1][4] == "C"
|
||||
|
||||
def test_put_text_ignores_overflow_right(self):
|
||||
"""Characters beyond width are ignored."""
|
||||
canvas = Canvas(5, 5)
|
||||
canvas.put_text(3, 0, "XYZ")
|
||||
assert canvas._grid[0][3] == "X"
|
||||
assert canvas._grid[0][4] == "Y"
|
||||
# Z would be at index 5, which is out of bounds
|
||||
|
||||
def test_put_text_ignores_overflow_bottom(self):
|
||||
"""Rows beyond height are ignored."""
|
||||
canvas = Canvas(5, 3)
|
||||
canvas.put_text(0, 5, "test")
|
||||
# Row 5 doesn't exist, nothing should be written
|
||||
assert all(cell == " " for row in canvas._grid for cell in row)
|
||||
|
||||
def test_put_text_marks_dirty_region(self):
|
||||
"""put_text marks the written area as dirty."""
|
||||
canvas = Canvas(10, 5)
|
||||
canvas.put_text(2, 1, "Hello")
|
||||
dirty = canvas.get_dirty_regions()
|
||||
assert len(dirty) == 1
|
||||
assert dirty[0].x == 2 and dirty[0].y == 1
|
||||
assert dirty[0].width == 5 and dirty[0].height == 1
|
||||
|
||||
def test_put_text_empty_string_no_dirty(self):
|
||||
"""Empty string does not create dirty region."""
|
||||
canvas = Canvas(10, 5)
|
||||
canvas.put_text(0, 0, "")
|
||||
assert not canvas.is_dirty()
|
||||
|
||||
def test_put_region_single_cell(self):
|
||||
"""put_region writes a single cell correctly."""
|
||||
canvas = Canvas(5, 5)
|
||||
content = [["X"]]
|
||||
canvas.put_region(2, 2, content)
|
||||
assert canvas._grid[2][2] == "X"
|
||||
|
||||
def test_put_region_multiple_rows(self):
|
||||
"""put_region writes multiple rows correctly."""
|
||||
canvas = Canvas(10, 10)
|
||||
content = [["A", "B"], ["C", "D"]]
|
||||
canvas.put_region(1, 1, content)
|
||||
assert canvas._grid[1][1] == "A"
|
||||
assert canvas._grid[1][2] == "B"
|
||||
assert canvas._grid[2][1] == "C"
|
||||
assert canvas._grid[2][2] == "D"
|
||||
|
||||
def test_put_region_partial_out_of_bounds(self):
|
||||
"""put_region clips content that extends beyond canvas bounds."""
|
||||
canvas = Canvas(5, 5)
|
||||
content = [["A", "B", "C"], ["D", "E", "F"]]
|
||||
canvas.put_region(4, 4, content)
|
||||
# Only cell (4,4) should be within bounds
|
||||
assert canvas._grid[4][4] == "A"
|
||||
# Others are out of bounds
|
||||
assert canvas._grid[4][5] == " " if 5 < 5 else True # index 5 doesn't exist
|
||||
assert canvas._grid[5][4] == " " if 5 < 5 else True # row 5 doesn't exist
|
||||
|
||||
def test_put_region_marks_dirty(self):
|
||||
"""put_region marks dirty region covering written area (clipped)."""
|
||||
canvas = Canvas(10, 10)
|
||||
content = [["A", "B", "C"], ["D", "E", "F"]]
|
||||
canvas.put_region(2, 2, content)
|
||||
dirty = canvas.get_dirty_regions()
|
||||
assert len(dirty) == 1
|
||||
assert dirty[0].x == 2 and dirty[0].y == 2
|
||||
assert dirty[0].width == 3 and dirty[0].height == 2
|
||||
|
||||
def test_fill_rectangle(self):
|
||||
"""fill() fills a rectangular region with character."""
|
||||
canvas = Canvas(10, 10)
|
||||
canvas.fill(2, 2, 3, 2, "*")
|
||||
for y in range(2, 4):
|
||||
for x in range(2, 5):
|
||||
assert canvas._grid[y][x] == "*"
|
||||
|
||||
def test_fill_entire_canvas(self):
|
||||
"""fill() can fill entire canvas."""
|
||||
canvas = Canvas(5, 3)
|
||||
canvas.fill(0, 0, 5, 3, "#")
|
||||
for row in canvas._grid:
|
||||
assert all(cell == "#" for cell in row)
|
||||
|
||||
def test_fill_empty_region_no_dirty(self):
|
||||
"""fill with zero dimensions does not mark dirty."""
|
||||
canvas = Canvas(10, 10)
|
||||
canvas.fill(0, 0, 0, 5, "X")
|
||||
assert not canvas.is_dirty()
|
||||
|
||||
def test_fill_clips_to_bounds(self):
|
||||
"""fill clips to canvas boundaries."""
|
||||
canvas = Canvas(5, 5)
|
||||
canvas.fill(3, 3, 5, 5, "X")
|
||||
# Should only fill within bounds: (3,3) to (4,4)
|
||||
assert canvas._grid[3][3] == "X"
|
||||
assert canvas._grid[3][4] == "X"
|
||||
assert canvas._grid[4][3] == "X"
|
||||
assert canvas._grid[4][4] == "X"
|
||||
# Out of bounds should remain spaces
|
||||
assert canvas._grid[5] if 5 < 5 else True # row 5 doesn't exist
|
||||
|
||||
def test_get_region_extracts_subgrid(self):
|
||||
"""get_region returns correct rectangular subgrid."""
|
||||
canvas = Canvas(10, 10)
|
||||
for y in range(10):
|
||||
for x in range(10):
|
||||
canvas._grid[y][x] = chr(ord("A") + (x % 26))
|
||||
region = canvas.get_region(2, 3, 4, 2)
|
||||
assert len(region) == 2
|
||||
assert len(region[0]) == 4
|
||||
assert region[0][0] == "C" # (2,3) = 'C'
|
||||
assert region[1][2] == "E" # (4,4) = 'E'
|
||||
|
||||
def test_get_region_out_of_bounds_returns_spaces(self):
|
||||
"""get_region pads out-of-bounds areas with spaces."""
|
||||
canvas = Canvas(5, 5)
|
||||
canvas.put_text(0, 0, "HELLO")
|
||||
# Region overlapping right edge: cols 3-4 inside, col5+ outside
|
||||
region = canvas.get_region(3, 0, 5, 2)
|
||||
assert region[0][0] == "L"
|
||||
assert region[0][1] == "O"
|
||||
assert region[0][2] == " " # col5 out of bounds
|
||||
assert all(cell == " " for cell in region[1])
|
||||
|
||||
def test_get_region_flat_returns_lines(self):
|
||||
"""get_region_flat returns list of joined strings."""
|
||||
canvas = Canvas(10, 5)
|
||||
canvas.put_text(0, 0, "FIRST")
|
||||
canvas.put_text(0, 1, "SECOND")
|
||||
flat = canvas.get_region_flat(0, 0, 6, 2)
|
||||
assert flat == ["FIRST ", "SECOND"]
|
||||
|
||||
def test_mark_dirty_manual(self):
|
||||
"""mark_dirty() can be called manually to mark arbitrary region."""
|
||||
canvas = Canvas(10, 10)
|
||||
canvas.mark_dirty(5, 5, 3, 2)
|
||||
dirty = canvas.get_dirty_regions()
|
||||
assert len(dirty) == 1
|
||||
assert dirty[0] == CanvasRegion(5, 5, 3, 2)
|
||||
|
||||
def test_get_dirty_rows_union(self):
|
||||
"""get_dirty_rows() returns union of all dirty row indices."""
|
||||
canvas = Canvas(10, 10)
|
||||
canvas.put_text(0, 0, "A") # row 0
|
||||
canvas.put_text(0, 2, "B") # row 2
|
||||
canvas.mark_dirty(0, 1, 1, 1) # row 1
|
||||
rows = canvas.get_dirty_rows()
|
||||
assert rows == {0, 1, 2}
|
||||
|
||||
def test_is_dirty_after_operations(self):
|
||||
"""is_dirty() returns True after any modifying operation."""
|
||||
canvas = Canvas(10, 10)
|
||||
assert not canvas.is_dirty()
|
||||
canvas.put_text(0, 0, "X")
|
||||
assert canvas.is_dirty()
|
||||
_ = canvas.get_dirty_regions() # resets
|
||||
assert not canvas.is_dirty()
|
||||
|
||||
def test_resize_same_size_no_change(self):
|
||||
"""resize with same dimensions does nothing."""
|
||||
canvas = Canvas(10, 5)
|
||||
canvas.put_text(0, 0, "TEST")
|
||||
canvas.resize(10, 5)
|
||||
assert canvas._grid[0][0] == "T"
|
||||
|
||||
def test_resize_larger_preserves_content(self):
|
||||
"""resize to larger canvas preserves existing content."""
|
||||
canvas = Canvas(5, 3)
|
||||
canvas.put_text(1, 1, "AB")
|
||||
canvas.resize(10, 6)
|
||||
assert canvas.width == 10
|
||||
assert canvas.height == 6
|
||||
assert canvas._grid[1][1] == "A"
|
||||
assert canvas._grid[1][2] == "B"
|
||||
# New area should be spaces
|
||||
assert canvas._grid[0][0] == " "
|
||||
|
||||
def test_resize_smaller_truncates(self):
|
||||
"""resize to smaller canvas drops content outside new bounds."""
|
||||
canvas = Canvas(10, 5)
|
||||
canvas.put_text(8, 4, "XYZ")
|
||||
canvas.resize(5, 3)
|
||||
assert canvas.width == 5
|
||||
assert canvas.height == 3
|
||||
# Content at (8,4) should be lost
|
||||
# But content within new bounds should remain
|
||||
canvas2 = Canvas(10, 5)
|
||||
canvas2.put_text(2, 2, "HI")
|
||||
canvas2.resize(5, 3)
|
||||
assert canvas2._grid[2][2] == "H"
|
||||
|
||||
def test_resize_does_not_auto_mark_dirty(self):
|
||||
"""resize() does not automatically mark dirty (caller responsibility)."""
|
||||
canvas = Canvas(10, 10)
|
||||
canvas.put_text(0, 0, "A")
|
||||
_ = canvas.get_dirty_regions() # reset
|
||||
canvas.resize(5, 5)
|
||||
# Resize doesn't mark dirty - this is current implementation
|
||||
assert not canvas.is_dirty()
|
||||
103
tests/test_figment_effect.py
Normal file
103
tests/test_figment_effect.py
Normal file
@@ -0,0 +1,103 @@
|
||||
"""
|
||||
Tests for the FigmentOverlayEffect plugin.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
|
||||
from engine.effects.plugins import discover_plugins
|
||||
from engine.effects.registry import get_registry
|
||||
from engine.effects.types import EffectConfig, create_effect_context
|
||||
from engine.pipeline.adapters import EffectPluginStage
|
||||
|
||||
|
||||
class TestFigmentEffect:
|
||||
"""Tests for FigmentOverlayEffect."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Discover plugins before each test."""
|
||||
discover_plugins()
|
||||
|
||||
def test_figment_plugin_discovered(self):
|
||||
"""Figment plugin is discovered and registered."""
|
||||
registry = get_registry()
|
||||
figment = registry.get("figment")
|
||||
assert figment is not None
|
||||
assert figment.name == "figment"
|
||||
|
||||
def test_figment_plugin_enabled_by_default(self):
|
||||
"""Figment plugin is enabled by default."""
|
||||
registry = get_registry()
|
||||
figment = registry.get("figment")
|
||||
assert figment.config.enabled is True
|
||||
|
||||
def test_figment_renders_overlay(self):
|
||||
"""Figment renders SVG overlay after interval."""
|
||||
registry = get_registry()
|
||||
figment = registry.get("figment")
|
||||
|
||||
# Configure with short interval for testing
|
||||
config = EffectConfig(
|
||||
enabled=True,
|
||||
intensity=1.0,
|
||||
params={
|
||||
"interval_secs": 0.1, # 100ms
|
||||
"display_secs": 1.0,
|
||||
"figment_dir": "figments",
|
||||
},
|
||||
)
|
||||
figment.configure(config)
|
||||
|
||||
# Create test buffer
|
||||
buf = [" " * 80 for _ in range(24)]
|
||||
|
||||
# Create context
|
||||
ctx = create_effect_context(
|
||||
terminal_width=80,
|
||||
terminal_height=24,
|
||||
frame_number=0,
|
||||
)
|
||||
|
||||
# Process frames until figment renders
|
||||
for i in range(20):
|
||||
result = figment.process(buf, ctx)
|
||||
if len(result) > len(buf):
|
||||
# Figment rendered overlay
|
||||
assert len(result) > len(buf)
|
||||
# Check that overlay lines contain ANSI escape codes
|
||||
overlay_lines = result[len(buf) :]
|
||||
assert len(overlay_lines) > 0
|
||||
# First overlay line should contain cursor positioning
|
||||
assert "\x1b[" in overlay_lines[0]
|
||||
assert "H" in overlay_lines[0]
|
||||
return
|
||||
ctx.frame_number += 1
|
||||
|
||||
pytest.fail("Figment did not render in 20 frames")
|
||||
|
||||
def test_figment_stage_capabilities(self):
|
||||
"""EffectPluginStage wraps figment correctly."""
|
||||
registry = get_registry()
|
||||
figment = registry.get("figment")
|
||||
|
||||
stage = EffectPluginStage(figment, name="figment")
|
||||
assert "effect.figment" in stage.capabilities
|
||||
|
||||
def test_figment_configure_preserves_params(self):
|
||||
"""Figment configuration preserves figment_dir."""
|
||||
registry = get_registry()
|
||||
figment = registry.get("figment")
|
||||
|
||||
# Configure without figment_dir
|
||||
config = EffectConfig(
|
||||
enabled=True,
|
||||
intensity=1.0,
|
||||
params={
|
||||
"interval_secs": 30.0,
|
||||
"display_secs": 3.0,
|
||||
},
|
||||
)
|
||||
figment.configure(config)
|
||||
|
||||
# figment_dir should be preserved
|
||||
assert "figment_dir" in figment.config.params
|
||||
assert figment.config.params["figment_dir"] == "figments"
|
||||
79
tests/test_figment_pipeline.py
Normal file
79
tests/test_figment_pipeline.py
Normal file
@@ -0,0 +1,79 @@
|
||||
"""
|
||||
Integration tests for figment effect in the pipeline.
|
||||
"""
|
||||
|
||||
from engine.effects.plugins import discover_plugins
|
||||
from engine.effects.registry import get_registry
|
||||
from engine.pipeline import Pipeline, PipelineConfig, get_preset
|
||||
from engine.pipeline.adapters import (
|
||||
EffectPluginStage,
|
||||
SourceItemsToBufferStage,
|
||||
create_stage_from_display,
|
||||
)
|
||||
from engine.pipeline.controller import PipelineRunner
|
||||
|
||||
|
||||
class TestFigmentPipeline:
|
||||
"""Tests for figment effect in pipeline integration."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Discover plugins before each test."""
|
||||
discover_plugins()
|
||||
|
||||
def test_figment_in_pipeline(self):
|
||||
"""Figment effect can be added to pipeline."""
|
||||
registry = get_registry()
|
||||
figment = registry.get("figment")
|
||||
|
||||
pipeline = Pipeline(
|
||||
config=PipelineConfig(
|
||||
source="empty",
|
||||
display="null",
|
||||
camera="feed",
|
||||
effects=["figment"],
|
||||
)
|
||||
)
|
||||
|
||||
# Add source stage
|
||||
from engine.data_sources.sources import EmptyDataSource
|
||||
from engine.pipeline.adapters import DataSourceStage
|
||||
|
||||
empty_source = EmptyDataSource(width=80, height=24)
|
||||
pipeline.add_stage("source", DataSourceStage(empty_source, name="empty"))
|
||||
|
||||
# Add render stage
|
||||
pipeline.add_stage("render", SourceItemsToBufferStage(name="items-to-buffer"))
|
||||
|
||||
# Add figment effect stage
|
||||
pipeline.add_stage("effect_figment", EffectPluginStage(figment, name="figment"))
|
||||
|
||||
# Add display stage
|
||||
from engine.display import DisplayRegistry
|
||||
|
||||
display = DisplayRegistry.create("null")
|
||||
display.init(0, 0)
|
||||
pipeline.add_stage("display", create_stage_from_display(display, "null"))
|
||||
|
||||
# Build and initialize pipeline
|
||||
pipeline.build()
|
||||
assert pipeline.initialize()
|
||||
|
||||
# Use PipelineRunner to step through frames
|
||||
runner = PipelineRunner(pipeline)
|
||||
runner.start()
|
||||
|
||||
# Run pipeline for a few frames
|
||||
for i in range(10):
|
||||
runner.step()
|
||||
# Result might be None for null display, but that's okay
|
||||
|
||||
# Verify pipeline ran without errors
|
||||
assert pipeline.context.params.frame_number == 10
|
||||
|
||||
def test_figment_preset(self):
|
||||
"""Figment preset is properly configured."""
|
||||
preset = get_preset("test-figment")
|
||||
assert preset is not None
|
||||
assert preset.source == "empty"
|
||||
assert preset.display == "terminal"
|
||||
assert "figment" in preset.effects
|
||||
104
tests/test_figment_render.py
Normal file
104
tests/test_figment_render.py
Normal file
@@ -0,0 +1,104 @@
|
||||
"""
|
||||
Tests to verify figment rendering in the pipeline.
|
||||
"""
|
||||
|
||||
from engine.effects.plugins import discover_plugins
|
||||
from engine.effects.registry import get_registry
|
||||
from engine.effects.types import EffectConfig
|
||||
from engine.pipeline import Pipeline, PipelineConfig
|
||||
from engine.pipeline.adapters import (
|
||||
EffectPluginStage,
|
||||
SourceItemsToBufferStage,
|
||||
create_stage_from_display,
|
||||
)
|
||||
from engine.pipeline.controller import PipelineRunner
|
||||
|
||||
|
||||
def test_figment_renders_in_pipeline():
|
||||
"""Verify figment renders overlay in pipeline."""
|
||||
# Discover plugins
|
||||
discover_plugins()
|
||||
|
||||
# Get figment plugin
|
||||
registry = get_registry()
|
||||
figment = registry.get("figment")
|
||||
|
||||
# Configure with short interval for testing
|
||||
config = EffectConfig(
|
||||
enabled=True,
|
||||
intensity=1.0,
|
||||
params={
|
||||
"interval_secs": 0.1, # 100ms
|
||||
"display_secs": 1.0,
|
||||
"figment_dir": "figments",
|
||||
},
|
||||
)
|
||||
figment.configure(config)
|
||||
|
||||
# Create pipeline
|
||||
pipeline = Pipeline(
|
||||
config=PipelineConfig(
|
||||
source="empty",
|
||||
display="null",
|
||||
camera="feed",
|
||||
effects=["figment"],
|
||||
)
|
||||
)
|
||||
|
||||
# Add source stage
|
||||
from engine.data_sources.sources import EmptyDataSource
|
||||
from engine.pipeline.adapters import DataSourceStage
|
||||
|
||||
empty_source = EmptyDataSource(width=80, height=24)
|
||||
pipeline.add_stage("source", DataSourceStage(empty_source, name="empty"))
|
||||
|
||||
# Add render stage
|
||||
pipeline.add_stage("render", SourceItemsToBufferStage(name="items-to-buffer"))
|
||||
|
||||
# Add figment effect stage
|
||||
pipeline.add_stage("effect_figment", EffectPluginStage(figment, name="figment"))
|
||||
|
||||
# Add display stage
|
||||
from engine.display import DisplayRegistry
|
||||
|
||||
display = DisplayRegistry.create("null")
|
||||
display.init(0, 0)
|
||||
pipeline.add_stage("display", create_stage_from_display(display, "null"))
|
||||
|
||||
# Build and initialize pipeline
|
||||
pipeline.build()
|
||||
assert pipeline.initialize()
|
||||
|
||||
# Use PipelineRunner to step through frames
|
||||
runner = PipelineRunner(pipeline)
|
||||
runner.start()
|
||||
|
||||
# Run pipeline until figment renders (or timeout)
|
||||
figment_rendered = False
|
||||
for i in range(30):
|
||||
runner.step()
|
||||
|
||||
# Check if figment rendered by inspecting the display's internal buffer
|
||||
# The null display stores the last rendered buffer
|
||||
if hasattr(display, "_last_buffer") and display._last_buffer:
|
||||
buffer = display._last_buffer
|
||||
# Check if buffer contains ANSI escape codes (indicating figment overlay)
|
||||
# Figment adds overlay lines at the end of the buffer
|
||||
for line in buffer:
|
||||
if "\x1b[" in line:
|
||||
figment_rendered = True
|
||||
print(f"Figment rendered at frame {i}")
|
||||
# Print first few lines containing escape codes
|
||||
for j, line in enumerate(buffer[:10]):
|
||||
if "\x1b[" in line:
|
||||
print(f"Line {j}: {repr(line[:80])}")
|
||||
break
|
||||
if figment_rendered:
|
||||
break
|
||||
|
||||
assert figment_rendered, "Figment did not render in 30 frames"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_figment_renders_in_pipeline()
|
||||
print("Test passed!")
|
||||
125
tests/test_firehose.py
Normal file
125
tests/test_firehose.py
Normal file
@@ -0,0 +1,125 @@
|
||||
"""Tests for FirehoseEffect plugin."""
|
||||
|
||||
import pytest
|
||||
|
||||
from engine.effects.plugins.firehose import FirehoseEffect
|
||||
from engine.effects.types import EffectContext
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def patch_config(monkeypatch):
|
||||
"""Patch config globals for firehose tests."""
|
||||
import engine.config as config
|
||||
|
||||
monkeypatch.setattr(config, "FIREHOSE", False)
|
||||
monkeypatch.setattr(config, "FIREHOSE_H", 12)
|
||||
monkeypatch.setattr(config, "MODE", "news")
|
||||
monkeypatch.setattr(config, "GLITCH", "░▒▓█▌▐╌╍╎╏┃┆┇┊┋")
|
||||
monkeypatch.setattr(config, "KATA", "ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘｱﾎﾃﾏｹﾒｴｶｷﾑﾕﾗｾﾈｽﾀﾇﾍ")
|
||||
|
||||
|
||||
def test_firehose_disabled_returns_input():
|
||||
"""Firehose disabled returns input buffer unchanged."""
|
||||
effect = FirehoseEffect()
|
||||
effect.configure(effect.config)
|
||||
buf = ["line1", "line2"]
|
||||
ctx = EffectContext(
|
||||
terminal_width=80,
|
||||
terminal_height=24,
|
||||
scroll_cam=0,
|
||||
ticker_height=0,
|
||||
items=[("Title", "Source", "2025-01-01T00:00:00")],
|
||||
)
|
||||
import engine.config as config
|
||||
|
||||
config.FIREHOSE = False
|
||||
result = effect.process(buf, ctx)
|
||||
assert result == buf
|
||||
|
||||
|
||||
def test_firehose_enabled_adds_lines():
|
||||
"""Firehose enabled adds FIREHOSE_H lines to output."""
|
||||
effect = FirehoseEffect()
|
||||
effect.configure(effect.config)
|
||||
buf = ["line1"]
|
||||
ctx = EffectContext(
|
||||
terminal_width=80,
|
||||
terminal_height=24,
|
||||
scroll_cam=0,
|
||||
ticker_height=0,
|
||||
items=[("Title", "Source", "2025-01-01T00:00:00")] * 10,
|
||||
)
|
||||
import engine.config as config
|
||||
|
||||
config.FIREHOSE = True
|
||||
config.FIREHOSE_H = 3
|
||||
result = effect.process(buf, ctx)
|
||||
assert len(result) == 4
|
||||
assert any("\033[" in line for line in result[1:])
|
||||
|
||||
|
||||
def test_firehose_respects_terminal_width():
|
||||
"""Firehose lines are truncated to terminal width."""
|
||||
effect = FirehoseEffect()
|
||||
effect.configure(effect.config)
|
||||
ctx = EffectContext(
|
||||
terminal_width=40,
|
||||
terminal_height=24,
|
||||
scroll_cam=0,
|
||||
ticker_height=0,
|
||||
items=[("A" * 100, "Source", "2025-01-01T00:00:00")],
|
||||
)
|
||||
import engine.config as config
|
||||
|
||||
config.FIREHOSE = True
|
||||
config.FIREHOSE_H = 2
|
||||
result = effect.process([], ctx)
|
||||
firehose_lines = [line for line in result if "\033[" in line]
|
||||
for line in firehose_lines:
|
||||
# Strip all ANSI escape sequences (CSI sequences ending with letter)
|
||||
import re
|
||||
|
||||
plain = re.sub(r"\x1b\[[^a-zA-Z]*[a-zA-Z]", "", line)
|
||||
# Extract content after position code
|
||||
content = plain.split("H", 1)[1] if "H" in plain else plain
|
||||
assert len(content) <= 40
|
||||
|
||||
|
||||
def test_firehose_zero_height_noop():
|
||||
"""Firehose with zero height returns buffer unchanged."""
|
||||
effect = FirehoseEffect()
|
||||
effect.configure(effect.config)
|
||||
buf = ["line1"]
|
||||
ctx = EffectContext(
|
||||
terminal_width=80,
|
||||
terminal_height=24,
|
||||
scroll_cam=0,
|
||||
ticker_height=0,
|
||||
items=[("Title", "Source", "2025-01-01T00:00:00")],
|
||||
)
|
||||
import engine.config as config
|
||||
|
||||
config.FIREHOSE = True
|
||||
config.FIREHOSE_H = 0
|
||||
result = effect.process(buf, ctx)
|
||||
assert result == buf
|
||||
|
||||
|
||||
def test_firehose_with_no_items():
|
||||
"""Firehose with no content items returns buffer unchanged."""
|
||||
effect = FirehoseEffect()
|
||||
effect.configure(effect.config)
|
||||
buf = ["line1"]
|
||||
ctx = EffectContext(
|
||||
terminal_width=80,
|
||||
terminal_height=24,
|
||||
scroll_cam=0,
|
||||
ticker_height=0,
|
||||
items=[],
|
||||
)
|
||||
import engine.config as config
|
||||
|
||||
config.FIREHOSE = True
|
||||
config.FIREHOSE_H = 3
|
||||
result = effect.process(buf, ctx)
|
||||
assert result == buf
|
||||
118
tests/test_pipeline_order.py
Normal file
118
tests/test_pipeline_order.py
Normal file
@@ -0,0 +1,118 @@
|
||||
"""Tests for pipeline execution order verification."""
|
||||
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
import pytest
|
||||
|
||||
from engine.pipeline import Pipeline, Stage, discover_stages
|
||||
from engine.pipeline.core import DataType
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def reset_registry():
|
||||
"""Reset stage registry before each test."""
|
||||
from engine.pipeline.registry import StageRegistry
|
||||
|
||||
StageRegistry._discovered = False
|
||||
StageRegistry._categories.clear()
|
||||
StageRegistry._instances.clear()
|
||||
discover_stages()
|
||||
yield
|
||||
StageRegistry._discovered = False
|
||||
StageRegistry._categories.clear()
|
||||
StageRegistry._instances.clear()
|
||||
|
||||
|
||||
def _create_mock_stage(name: str, category: str, capabilities: set, dependencies: set):
|
||||
"""Helper to create a mock stage."""
|
||||
mock = MagicMock(spec=Stage)
|
||||
mock.name = name
|
||||
mock.category = category
|
||||
mock.stage_type = category
|
||||
mock.render_order = 0
|
||||
mock.is_overlay = False
|
||||
mock.inlet_types = {DataType.ANY}
|
||||
mock.outlet_types = {DataType.TEXT_BUFFER}
|
||||
mock.capabilities = capabilities
|
||||
mock.dependencies = dependencies
|
||||
mock.process = lambda data, ctx: data
|
||||
mock.init = MagicMock(return_value=True)
|
||||
mock.cleanup = MagicMock()
|
||||
mock.is_enabled = MagicMock(return_value=True)
|
||||
mock.set_enabled = MagicMock()
|
||||
mock._enabled = True
|
||||
return mock
|
||||
|
||||
|
||||
def test_pipeline_execution_order_linear():
|
||||
"""Verify stages execute in linear order based on dependencies."""
|
||||
pipeline = Pipeline()
|
||||
pipeline.build(auto_inject=False)
|
||||
|
||||
source = _create_mock_stage("source", "source", {"source"}, set())
|
||||
render = _create_mock_stage("render", "render", {"render"}, {"source"})
|
||||
effect = _create_mock_stage("effect", "effect", {"effect"}, {"render"})
|
||||
display = _create_mock_stage("display", "display", {"display"}, {"effect"})
|
||||
|
||||
pipeline.add_stage("source", source, initialize=False)
|
||||
pipeline.add_stage("render", render, initialize=False)
|
||||
pipeline.add_stage("effect", effect, initialize=False)
|
||||
pipeline.add_stage("display", display, initialize=False)
|
||||
|
||||
pipeline._rebuild()
|
||||
|
||||
assert pipeline.execution_order == [
|
||||
"source",
|
||||
"render",
|
||||
"effect",
|
||||
"display",
|
||||
]
|
||||
|
||||
|
||||
def test_pipeline_effects_chain_order():
|
||||
"""Verify effects execute in config order when chained."""
|
||||
pipeline = Pipeline()
|
||||
pipeline.build(auto_inject=False)
|
||||
|
||||
# Source and render
|
||||
source = _create_mock_stage("source", "source", {"source"}, set())
|
||||
render = _create_mock_stage("render", "render", {"render"}, {"source"})
|
||||
|
||||
# Effects chain: effect_a → effect_b → effect_c
|
||||
effect_a = _create_mock_stage("effect_a", "effect", {"effect_a"}, {"render"})
|
||||
effect_b = _create_mock_stage("effect_b", "effect", {"effect_b"}, {"effect_a"})
|
||||
effect_c = _create_mock_stage("effect_c", "effect", {"effect_c"}, {"effect_b"})
|
||||
|
||||
# Display
|
||||
display = _create_mock_stage("display", "display", {"display"}, {"effect_c"})
|
||||
|
||||
for stage in [source, render, effect_a, effect_b, effect_c, display]:
|
||||
pipeline.add_stage(stage.name, stage, initialize=False)
|
||||
|
||||
pipeline._rebuild()
|
||||
|
||||
effect_names = [
|
||||
name for name in pipeline.execution_order if name.startswith("effect_")
|
||||
]
|
||||
assert effect_names == ["effect_a", "effect_b", "effect_c"]
|
||||
|
||||
|
||||
def test_pipeline_overlay_executes_after_regular_effects():
|
||||
"""Overlay stages should execute after all regular effects."""
|
||||
pipeline = Pipeline()
|
||||
pipeline.build(auto_inject=False)
|
||||
|
||||
effect = _create_mock_stage("effect1", "effect", {"effect1"}, {"render"})
|
||||
overlay = _create_mock_stage("overlay_test", "overlay", {"overlay"}, {"effect1"})
|
||||
display = _create_mock_stage("display", "display", {"display"}, {"overlay"})
|
||||
|
||||
for stage in [effect, overlay, display]:
|
||||
pipeline.add_stage(stage.name, stage, initialize=False)
|
||||
|
||||
pipeline._rebuild()
|
||||
|
||||
names = pipeline.execution_order
|
||||
idx_effect = names.index("effect1")
|
||||
idx_overlay = names.index("overlay_test")
|
||||
idx_display = names.index("display")
|
||||
assert idx_effect < idx_overlay < idx_display
|
||||
164
tests/test_renderer.py
Normal file
164
tests/test_renderer.py
Normal file
@@ -0,0 +1,164 @@
|
||||
"""
|
||||
Unit tests for engine.display.renderer module.
|
||||
|
||||
Tests ANSI parsing and PIL rendering utilities.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
|
||||
try:
|
||||
from PIL import Image
|
||||
|
||||
PIL_AVAILABLE = True
|
||||
except ImportError:
|
||||
PIL_AVAILABLE = False
|
||||
|
||||
from engine.display.renderer import ANSI_COLORS, parse_ansi, render_to_pil
|
||||
|
||||
|
||||
class TestParseANSI:
|
||||
"""Tests for parse_ansi function."""
|
||||
|
||||
def test_plain_text(self):
|
||||
"""Plain text without ANSI codes returns single token."""
|
||||
tokens = parse_ansi("Hello World")
|
||||
assert len(tokens) == 1
|
||||
assert tokens[0][0] == "Hello World"
|
||||
# Check default colors
|
||||
assert tokens[0][1] == (204, 204, 204) # fg
|
||||
assert tokens[0][2] == (0, 0, 0) # bg
|
||||
assert tokens[0][3] is False # bold
|
||||
|
||||
def test_empty_string(self):
|
||||
"""Empty string returns single empty token."""
|
||||
tokens = parse_ansi("")
|
||||
assert tokens == [("", (204, 204, 204), (0, 0, 0), False)]
|
||||
|
||||
def test_reset_code(self):
|
||||
"""Reset code (ESC[0m) restores defaults."""
|
||||
tokens = parse_ansi("\x1b[31mRed\x1b[0mNormal")
|
||||
assert len(tokens) == 2
|
||||
assert tokens[0][0] == "Red"
|
||||
# Red fg should be ANSI_COLORS[1]
|
||||
assert tokens[0][1] == ANSI_COLORS[1]
|
||||
assert tokens[1][0] == "Normal"
|
||||
assert tokens[1][1] == (204, 204, 204) # back to default
|
||||
|
||||
def test_bold_code(self):
|
||||
"""Bold code (ESC[1m) sets bold flag."""
|
||||
tokens = parse_ansi("\x1b[1mBold")
|
||||
assert tokens[0][3] is True
|
||||
|
||||
def test_bold_off_code(self):
|
||||
"""Bold off (ESC[22m) clears bold."""
|
||||
tokens = parse_ansi("\x1b[1mBold\x1b[22mNormal")
|
||||
assert tokens[0][3] is True
|
||||
assert tokens[1][3] is False
|
||||
|
||||
def test_4bit_foreground_colors(self):
|
||||
"""4-bit foreground colors (30-37, 90-97) work."""
|
||||
# Test normal red (31)
|
||||
tokens = parse_ansi("\x1b[31mRed")
|
||||
assert tokens[0][1] == ANSI_COLORS[1] # color 1 = red
|
||||
|
||||
# Test bright cyan (96) - maps to index 14 (bright cyan)
|
||||
tokens = parse_ansi("\x1b[96mCyan")
|
||||
assert tokens[0][1] == ANSI_COLORS[14] # bright cyan
|
||||
|
||||
def test_4bit_background_colors(self):
|
||||
"""4-bit background colors (40-47, 100-107) work."""
|
||||
# Green bg = 42
|
||||
tokens = parse_ansi("\x1b[42mText")
|
||||
assert tokens[0][2] == ANSI_COLORS[2] # color 2 = green
|
||||
|
||||
# Bright magenta bg = 105
|
||||
tokens = parse_ansi("\x1b[105mText")
|
||||
assert tokens[0][2] == ANSI_COLORS[13] # bright magenta (13)
|
||||
|
||||
def test_multiple_ansi_codes_in_sequence(self):
|
||||
"""Multiple codes in one escape sequence are parsed."""
|
||||
tokens = parse_ansi("\x1b[1;31;42mBold Red on Green")
|
||||
assert tokens[0][0] == "Bold Red on Green"
|
||||
assert tokens[0][3] is True # bold
|
||||
assert tokens[0][1] == ANSI_COLORS[1] # red fg
|
||||
assert tokens[0][2] == ANSI_COLORS[2] # green bg
|
||||
|
||||
def test_nested_ansi_sequences(self):
|
||||
"""Multiple separate ANSI sequences are tokenized correctly."""
|
||||
text = "\x1b[31mRed\x1b[32mGreen\x1b[0mNormal"
|
||||
tokens = parse_ansi(text)
|
||||
assert len(tokens) == 3
|
||||
assert tokens[0][0] == "Red"
|
||||
assert tokens[1][0] == "Green"
|
||||
assert tokens[2][0] == "Normal"
|
||||
|
||||
def test_interleaved_text_and_ansi(self):
|
||||
"""Text before and after ANSI codes is tokenized."""
|
||||
tokens = parse_ansi("Pre\x1b[31mRedPost")
|
||||
assert len(tokens) == 2
|
||||
assert tokens[0][0] == "Pre"
|
||||
assert tokens[1][0] == "RedPost"
|
||||
assert tokens[1][1] == ANSI_COLORS[1]
|
||||
|
||||
def test_all_standard_4bit_colors(self):
|
||||
"""All 4-bit color indices (0-15) map to valid RGB."""
|
||||
for i in range(16):
|
||||
tokens = parse_ansi(f"\x1b[{i}mX")
|
||||
# Should be a defined color or default fg
|
||||
fg = tokens[0][1]
|
||||
valid = fg in ANSI_COLORS.values() or fg == (204, 204, 204)
|
||||
assert valid, f"Color {i} produced invalid fg {fg}"
|
||||
|
||||
def test_unknown_code_ignored(self):
|
||||
"""Unknown numeric codes are ignored, keep current style."""
|
||||
tokens = parse_ansi("\x1b[99mText")
|
||||
# 99 is not recognized, should keep previous state (defaults)
|
||||
assert tokens[0][1] == (204, 204, 204)
|
||||
|
||||
|
||||
@pytest.mark.skipif(not PIL_AVAILABLE, reason="PIL not available")
|
||||
class TestRenderToPIL:
|
||||
"""Tests for render_to_pil function (requires PIL)."""
|
||||
|
||||
def test_renders_plain_text(self):
|
||||
"""Plain buffer renders as image."""
|
||||
buffer = ["Hello"]
|
||||
img = render_to_pil(buffer, width=10, height=1)
|
||||
assert isinstance(img, Image.Image)
|
||||
assert img.mode == "RGBA"
|
||||
|
||||
def test_renders_with_ansi_colors(self):
|
||||
"""Buffer with ANSI colors renders correctly."""
|
||||
buffer = ["\x1b[31mRed\x1b[0mNormal"]
|
||||
img = render_to_pil(buffer, width=20, height=1)
|
||||
assert isinstance(img, Image.Image)
|
||||
|
||||
def test_multi_line_buffer(self):
|
||||
"""Multiple lines render with correct height."""
|
||||
buffer = ["Line1", "Line2", "Line3"]
|
||||
img = render_to_pil(buffer, width=10, height=3)
|
||||
# Height should be approximately 3 * cell_height (18-2 padding)
|
||||
assert img.height > 0
|
||||
|
||||
def test_clipping_to_height(self):
|
||||
"""Buffer longer than height is clipped."""
|
||||
buffer = ["Line1", "Line2", "Line3", "Line4"]
|
||||
img = render_to_pil(buffer, width=10, height=2)
|
||||
# Should only render 2 lines
|
||||
assert img.height < img.width * 2 # roughly 2 lines tall
|
||||
|
||||
def test_cell_dimensions_respected(self):
|
||||
"""Custom cell_width and cell_height are used."""
|
||||
buffer = ["Test"]
|
||||
img = render_to_pil(buffer, width=5, height=1, cell_width=20, cell_height=25)
|
||||
assert img.width == 5 * 20
|
||||
assert img.height == 25
|
||||
|
||||
def test_font_fallback_on_invalid(self):
|
||||
"""Invalid font path falls back to default font."""
|
||||
buffer = ["Test"]
|
||||
# Should not crash with invalid font path
|
||||
img = render_to_pil(
|
||||
buffer, width=5, height=1, font_path="/nonexistent/font.ttf"
|
||||
)
|
||||
assert isinstance(img, Image.Image)
|
||||
Reference in New Issue
Block a user