figrecipe 0.7.4__py3-none-any.whl → 0.9.0__py3-none-any.whl

figrecipe/_dev/browser/_video_trim/__init__.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Video trimming with spatiotemporal marker detection.
+
+Uses visual markers with OCR-readable text for reliable detection
+of start/end points. Markers encode metadata that can be re-extracted.
+
+Spatiotemporal Encoding:
+- Temporal: Peak detection finds marker frames (dark frames)
+- Spatial: Text at fixed positions, extracted via OCR
+- Metadata: Version, timestamp embedded and recoverable
+
+Usage:
+    # In recorder - inject markers
+    await inject_start_marker(page, version="0.8.0", timestamp="2025-12-27")
+    # ... record content ...
+    await inject_end_marker(page, version="0.8.0", timestamp="2025-12-27")
+
+    # Post-processing - detect and trim
+    output, metadata = process_video_with_markers(input_path, output_path)
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+from ._detection import detect_markers
+from ._markers import (
+    MARKER_END_ID,
+    MARKER_START_ID,
+    inject_end_marker,
+    inject_start_marker,
+)
+
+
+def trim_video(
+    input_path: Path,
+    output_path: Path,
+    start_time: Optional[float] = None,
+    end_time: Optional[float] = None,
+    codec: str = "libx264",
+) -> bool:
+    """Trim video based on timestamps.
+
+    Parameters
+    ----------
+    input_path : Path
+        Input video file.
+    output_path : Path
+        Output video file.
+    start_time : float, optional
+        Start time in seconds (trim before this).
+    end_time : float, optional
+        End time in seconds (trim after this).
+    codec : str
+        Video codec (default: libx264 for H.264).
+
+    Returns
+    -------
+    bool
+        True if successful.
+    """
+    cmd = ["ffmpeg", "-y"]
+
+    if start_time is not None:
+        cmd.extend(["-ss", str(start_time)])
+
+    cmd.extend(["-i", str(input_path)])
+
+    if end_time is not None and start_time is not None:
+        duration = end_time - start_time
+        if duration > 0:
+            cmd.extend(["-t", str(duration)])
+    elif end_time is not None:
+        cmd.extend(["-t", str(end_time)])
+
+    cmd.extend(["-c:v", codec, "-preset", "fast", "-crf", "23", str(output_path)])
+
+    try:
+        subprocess.run(cmd, capture_output=True, check=True)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def process_video_with_markers(
+    input_path: Path,
+    output_path: Path,
+    cleanup: bool = True,
+    verbose: bool = True,
+) -> Tuple[Path, Dict]:
+    """Full pipeline: detect markers, extract metadata, trim video.
+
+    Parameters
+    ----------
+    input_path : Path
+        Raw recorded video (with markers).
+    output_path : Path
+        Trimmed output video.
+    cleanup : bool
+        Remove input file after success.
+    verbose : bool
+        Print debug information.
+
+    Returns
+    -------
+    Tuple[Path, Dict]
+        (output_path, extracted_metadata)
+    """
+    input_path = Path(input_path)
+    output_path = Path(output_path)
+
+    # Detect markers and extract metadata
+    start_time, end_time, metadata = detect_markers(input_path)
+
+    if verbose:
+        print(f"  Marker detection: start={start_time}, end={end_time}")
+
+    if start_time is None:
+        print("Warning: No start marker detected, using beginning")
+        start_time = 0
+
+    if end_time is None:
+        print("Warning: No end marker detected, using end of video")
+
+    # Trim video
+    success = trim_video(input_path, output_path, start_time, end_time)
+
+    if not success:
+        raise RuntimeError(f"Failed to trim video: {input_path}")
+
+    if cleanup and input_path != output_path and input_path.exists():
+        input_path.unlink()
+
+    return output_path, metadata
+
+
+# Aliases for backward compatibility
+trim_video_by_markers = trim_video
+
+__all__ = [
+    "inject_start_marker",
+    "inject_end_marker",
+    "detect_markers",
+    "trim_video",
+    "trim_video_by_markers",
+    "process_video_with_markers",
+    "MARKER_START_ID",
+    "MARKER_END_ID",
+]
+
+# EOF

figrecipe/_dev/browser/_video_trim/_detection.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Marker detection using spatiotemporal analysis.
+
+- Temporal: Peak detection finds dark marker frames
+- Spatial: OCR extracts text at fixed positions
+"""
+
+import re
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+
+
+def extract_frames(video_path: Path, fps: int = 5) -> List[Tuple[float, np.ndarray]]:
+    """Extract frames from video with timestamps."""
+    frames = []
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        frame_pattern = Path(tmpdir) / "frame_%06d.png"
+        cmd = [
+            "ffmpeg",
+            "-i",
+            str(video_path),
+            "-vf",
+            f"fps={fps}",
+            "-f",
+            "image2",
+            str(frame_pattern),
+        ]
+        subprocess.run(cmd, capture_output=True, check=True)
+
+        for i, frame_file in enumerate(sorted(Path(tmpdir).glob("frame_*.png"))):
+            timestamp = i / fps
+            try:
+                from PIL import Image
+
+                img = Image.open(frame_file)
+                frame = np.array(img)[:, :, :3]
+            except ImportError:
+                import imageio
+
+                frame = imageio.imread(frame_file)[:, :, :3]
+            frames.append((timestamp, frame))
+
+    return frames
+
+
+def frame_brightness(frame: np.ndarray) -> float:
+    """Calculate mean brightness (0-255)."""
+    return float(np.mean(frame))
+
+
+def is_dark_frame(frame: np.ndarray, threshold: float = 30) -> bool:
+    """Check if frame is dark (marker candidate)."""
+    return frame_brightness(frame) < threshold
+
+
+def detect_dark_frames(
+    frames: List[Tuple[float, np.ndarray]],
+) -> List[float]:
+    """Find timestamps of dark frames using peak detection."""
+    if len(frames) < 3:
+        return []
+
+    brightnesses = np.array([frame_brightness(f[1]) for f in frames])
+    dark_timestamps = []
+
+    for i in range(len(brightnesses)):
+        if brightnesses[i] < 40:  # Dark threshold
+            dark_timestamps.append(frames[i][0])
+
+    return dark_timestamps
+
+
+def ocr_frame(frame: np.ndarray) -> str:
+    """Extract text from frame using Tesseract OCR."""
+    try:
+        import pytesseract
+        from PIL import Image
+
+        img = Image.fromarray(frame)
+        text = pytesseract.image_to_string(
+            img,
+            config="--psm 6",
+        )
+        return text.strip()
+    except ImportError:
+        return ""
+    except Exception:
+        return ""
+
+
+def extract_marker_metadata(frame: np.ndarray) -> Optional[Dict]:
+    """Extract metadata from marker frame via OCR.
+
+    Detection strategy (OCR is unreliable, so be lenient):
+    1. Accept frames with version string (vX.Y.Z or X.Y.Z pattern)
+    2. OR accept frames with marker keywords (TRIM, START, END)
+    3. Caller determines type by position (first=start, last=end)
+    """
+    text = ocr_frame(frame)
+    if not text:
+        return None
+
+    metadata = {}
+    text_upper = text.upper()
+
+    # Accept if has version string OR marker keywords
+    has_version = bool(re.search(r"\d+\.\d+\.\d+", text))
+    has_keywords = any(kw in text_upper for kw in ["TRIM", "START", "END"])
+
+    if not (has_version or has_keywords):
+        return None
+
+    # Try to detect type from text, but this is optional
+    if "START" in text_upper:
+        metadata["marker_type"] = "start"
+    elif "END" in text_upper:
+        metadata["marker_type"] = "end"
+    else:
+        # Type will be determined by caller based on position
+        metadata["marker_type"] = "marker"
+
+    # Extract version (vX.Y.Z pattern)
+    version_match = re.search(r"v?(\d+\.\d+\.\d+)", text)
+    if version_match:
+        metadata["version"] = version_match.group(1)
+
+    # Extract timestamp (YYYY-MM-DD HH:MM pattern)
+    ts_match = re.search(r"(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2})", text)
+    if ts_match:
+        metadata["timestamp"] = ts_match.group(1)
+
+    return metadata
+
+
+def detect_markers(
+    video_path: Path,
+    fps: int = 5,  # Lower fps for faster processing (500ms markers = 2.5 frames)
+) -> Tuple[Optional[float], Optional[float], Dict]:
+    """Detect start/end markers using spatiotemporal analysis.
+
+    Strategy:
+    1. Find dark frames (brightness < 40)
+    2. OCR each to find version string (marker identifier)
+    3. First marker = START, last marker = END
+
+    Returns (start_time, end_time, metadata).
+    """
+    frames = extract_frames(video_path, fps=fps)
+    if not frames:
+        return None, None, {}
+
+    # Stage 1: Find dark frame candidates
+    dark_timestamps = detect_dark_frames(frames)
+
+    # Stage 2: Collect marker groups (consecutive frames = same marker)
+    # Group frames that are within 1 second of each other
+    marker_groups = []  # List of (first_timestamp, last_timestamp, metadata)
+    current_group = None
+
+    for timestamp in dark_timestamps:
+        frame_idx = int(timestamp * fps)
+        if 0 <= frame_idx < len(frames):
+            frame = frames[frame_idx][1]
+            marker_meta = extract_marker_metadata(frame)
+
+            if marker_meta:
+                if current_group is None:
+                    # Start new group
+                    current_group = [timestamp, timestamp, marker_meta]
+                elif timestamp - current_group[1] < 1.0:
+                    # Extend current group
+                    current_group[1] = timestamp
+                else:
+                    # Save current group and start new one
+                    marker_groups.append(tuple(current_group))
+                    current_group = [timestamp, timestamp, marker_meta]
+
+    if current_group:
+        marker_groups.append(tuple(current_group))
+
+    # Stage 3: Determine start/end by position
+    start_time = None
+    end_time = None
+    metadata = {}
+
+    if marker_groups:
+        # First group is START (use first frame of group)
+        start_time = marker_groups[0][0]
+        metadata["start"] = marker_groups[0][2]
+        metadata["start"]["marker_type"] = "start"
+
+        # Last group is END (use first frame of group, if different from first group)
+        if len(marker_groups) > 1:
+            end_time = marker_groups[-1][0]
+            metadata["end"] = marker_groups[-1][2]
+            metadata["end"]["marker_type"] = "end"
+
+    # Trim margins: drop first 1.5s after start marker, drop last 1s before end marker
+    if start_time is not None:
+        start_time += 1.5  # Drop first 1.5 seconds
+    if end_time is not None:
+        end_time -= 1.0  # Drop last 1 second
+
+    return start_time, end_time, metadata
+
+
+__all__ = [
+    "extract_frames",
+    "frame_brightness",
+    "is_dark_frame",
+    "detect_dark_frames",
+    "ocr_frame",
+    "extract_marker_metadata",
+    "detect_markers",
+]
+
+# EOF

figrecipe/_dev/browser/_video_trim/_markers.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Marker injection for video trimming.
+
+Injects visual markers with OCR-readable metadata text.
+Uses same async pattern as title_screen which is known to work.
+"""
+
+# Marker identifiers
+MARKER_START_ID = "TRIM_START"
+MARKER_END_ID = "TRIM_END"
+
+# JavaScript to create marker overlay with metadata text
+# Uses async function pattern matching show_title_screen
+MARKER_OVERLAY_JS = """
+async (args) => {
+    const { marker_id, version, timestamp, duration } = args;
+
+    const overlay = document.createElement('div');
+    overlay.id = 'trim-marker-overlay';
+    overlay.style.cssText = `
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100vw;
+        height: 100vh;
+        background: #000000;
+        z-index: 2147483647;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+        font-family: 'Courier New', monospace;
+        color: #FFFFFF;
+    `;
+
+    // Marker ID (top) - OCR-friendly format
+    const idText = document.createElement('div');
+    idText.textContent = '== ' + marker_id + ' ==';
+    idText.style.cssText = `
+        font-size: 72px;
+        font-weight: bold;
+        letter-spacing: 8px;
+        margin-bottom: 60px;
+    `;
+    overlay.appendChild(idText);
+
+    // Version (center)
+    const verText = document.createElement('div');
+    verText.textContent = version;
+    verText.style.cssText = `
+        font-size: 48px;
+        margin-bottom: 40px;
+    `;
+    overlay.appendChild(verText);
+
+    // Timestamp (bottom)
+    const tsText = document.createElement('div');
+    tsText.textContent = timestamp;
+    tsText.style.cssText = `
+        font-size: 36px;
+        opacity: 0.9;
+    `;
+    overlay.appendChild(tsText);
+
+    document.body.appendChild(overlay);
+
+    // Wait for duration
+    await new Promise(r => setTimeout(r, duration));
+
+    overlay.remove();
+    return true;
+}
+"""
+
+
+async def inject_start_marker(
+    page,
+    version: str = "",
+    timestamp: str = "",
+    duration_ms: int = 500,
+) -> None:
+    """Inject start marker with metadata.
+
+    Parameters
+    ----------
+    page : playwright.async_api.Page
+        Playwright page object.
+    version : str
+        Version string to display.
+    timestamp : str
+        Timestamp string to display.
+    duration_ms : int
+        Duration to show marker in milliseconds (default: 500).
+    """
+    args = {
+        "marker_id": MARKER_START_ID,
+        "version": version,
+        "timestamp": timestamp,
+        "duration": duration_ms,
+    }
+    await page.evaluate(MARKER_OVERLAY_JS, args)
+
+
+async def inject_end_marker(
+    page,
+    version: str = "",
+    timestamp: str = "",
+    duration_ms: int = 500,
+) -> None:
+    """Inject end marker with metadata.
+
+    Parameters
+    ----------
+    page : playwright.async_api.Page
+        Playwright page object.
+    version : str
+        Version string to display.
+    timestamp : str
+        Timestamp string to display.
+    duration_ms : int
+        Duration to show marker in milliseconds (default: 500).
+    """
+    args = {
+        "marker_id": MARKER_END_ID,
+        "version": version,
+        "timestamp": timestamp,
+        "duration": duration_ms,
+    }
+    await page.evaluate(MARKER_OVERLAY_JS, args)
+
+
+__all__ = [
+    "MARKER_START_ID",
+    "MARKER_END_ID",
+    "inject_start_marker",
+    "inject_end_marker",
+]
+
+# EOF

figrecipe/_editor/__init__.py

@@ -29,9 +29,11 @@ def edit(
     source: Optional[Union[RecordingFigure, str, Path]] = None,
     style: Optional[Union[str, Dict[str, Any]]] = None,
     port: int = 5050,
+    host: str = "127.0.0.1",
     open_browser: bool = True,
     hot_reload: bool = False,
     working_dir: Optional[Union[str, Path]] = None,
+    desktop: bool = False,
 ) -> Dict[str, Any]:
     """
     Launch interactive GUI editor for figure styling.
@@ -42,8 +44,13 @@ def edit(
     Parameters
     ----------
     source : RecordingFigure, str, Path, or None
-        Either a live RecordingFigure object, path to a .yaml/.png file,
-        or None to create a new blank figure.
+        Figure source. Supports multiple formats:
+        - RecordingFigure: Live figure object
+        - .yaml/.yml: Direct recipe file
+        - .png/.jpg/etc: Image with associated .yaml
+        - Directory: Bundle containing recipe.yaml
+        - .zip: ZIP archive containing recipe.yaml
+        - None: Create new blank figure
     style : str or dict, optional
         Style preset name (e.g., 'SCITEX', 'SCITEX_DARK') or style dict.
         If None, uses the currently loaded global style.
@@ -57,6 +64,9 @@ def edit(
     working_dir : str or Path, optional
         Working directory for file switching feature (default: current directory).
         The file switcher will list recipe files from this directory.
+    desktop : bool, optional
+        Launch as native desktop window using pywebview (default: False).
+        Requires: pip install figrecipe[desktop]
 
     Returns
     -------
@@ -127,16 +137,28 @@ def edit(
         recipe_path=recipe_path,
         style=style_dict,
         port=port,
+        host=host,
         static_png_path=static_png_path,
         hitmap_base64=hitmap_base64,
         color_map=color_map,
         hot_reload=hot_reload,
         working_dir=resolved_working_dir,
+        desktop=desktop,
     )
 
     return editor.run(open_browser=open_browser)
 
 
+def _check_figure_has_content(fig: RecordingFigure) -> bool:
+    """Check if figure has any plot content."""
+    for ax_row in fig._axes:
+        for ax in ax_row:
+            # Check for lines, patches, images, collections
+            if ax.lines or ax.patches or ax.images or ax.collections or ax.texts:
+                return True
+    return False
+
+
 def _resolve_source(source: Optional[Union[RecordingFigure, str, Path]]):
     """
     Resolve source to figure and optional recipe path.
@@ -144,8 +166,13 @@ def _resolve_source(source: Optional[Union[RecordingFigure, str, Path]]):
     Parameters
     ----------
     source : RecordingFigure, str, Path, or None
-        Input source. If None, creates a new blank figure.
-        If PNG path, tries to find associated YAML recipe.
+        Input source. Supports:
+        - None: Creates new blank figure
+        - RecordingFigure: Uses directly
+        - .yaml/.yml: Direct recipe file
+        - .png/.jpg/etc: Image with associated YAML
+        - Directory: Bundle containing recipe.yaml
+        - .zip: ZIP archive containing recipe.yaml
 
     Returns
     -------
@@ -158,16 +185,6 @@ def _resolve_source(source: Optional[Union[RecordingFigure, str, Path]]):
 
         fig, ax = subplots()
         ax.set_title("New Figure")
-        ax.text(
-            0.5,
-            0.5,
-            "Add plots using fr.edit(fig)",
-            ha="center",
-            va="center",
-            transform=ax.transAxes,
-            fontsize=12,
-            color="gray",
-        )
         return fig, None
 
     if isinstance(source, RecordingFigure):
@@ -190,28 +207,11 @@ def _resolve_source(source: Optional[Union[RecordingFigure, str, Path]]):
         )
         return wrapped_fig, None
 
-    # Assume it's a path
-    path = Path(source)
-    if not path.exists():
-        raise FileNotFoundError(f"File not found: {path}")
-
-    # Handle PNG path - find associated YAML
-    if path.suffix.lower() == ".png":
-        yaml_path = path.with_suffix(".yaml")
-        if yaml_path.exists():
-            path = yaml_path
-        else:
-            yml_path = path.with_suffix(".yml")
-            if yml_path.exists():
-                path = yml_path
-            else:
-                raise FileNotFoundError(
-                    f"No recipe found for {path.name}. "
-                    f"Expected {yaml_path.name} or {yml_path.name}"
-                )
-
-    if path.suffix.lower() not in (".yaml", ".yml"):
-        raise ValueError(f"Expected .yaml, .yml, or .png file, got: {path.suffix}")
+    # Assume it's a path - use bundle resolution (handles dir, zip, yaml, png)
+    from .._utils._bundle import resolve_recipe_path
+
+    path, _temp_dir = resolve_recipe_path(source)
+    # Note: temp_dir cleanup handled by reproduce() if ZIP was extracted
 
     # Load recipe and reproduce figure
     from .._reproducer import reproduce