scitex 2.13.0__py3-none-any.whl → 2.15.1__py3-none-any.whl

scitex/dev/cv/_compose.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-08
+# File: src/scitex/dev/cv/_compose.py
+"""Video composition utilities using ffmpeg.
+
+Provides tools for:
+- Converting images to video clips
+- Concatenating videos
+- Composing opening + content + closing
+"""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Union
+
+
+def _check_ffmpeg() -> bool:
+    """Check if ffmpeg is available."""
+    try:
+        subprocess.run(
+            ["ffmpeg", "-version"],
+            capture_output=True,
+            check=True,
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def image_to_video(
+    image_path: Union[str, Path],
+    output_path: Union[str, Path],
+    duration: float = 3.0,
+    fps: int = 30,
+    fade_in: float = 0.5,
+    fade_out: float = 0.5,
+    resolution: Optional[str] = None,
+) -> Path:
+    """Convert a static image to a video clip.
+
+    Parameters
+    ----------
+    image_path : str or Path
+        Input image path.
+    output_path : str or Path
+        Output video path.
+    duration : float
+        Duration in seconds.
+    fps : int
+        Frames per second.
+    fade_in : float
+        Fade-in duration in seconds.
+    fade_out : float
+        Fade-out duration in seconds.
+    resolution : str, optional
+        Output resolution (e.g., "1920x1080").
+
+    Returns
+    -------
+    Path
+        Path to output video.
+    """
+    if not _check_ffmpeg():
+        raise RuntimeError("ffmpeg not found. Install with: apt install ffmpeg")
+
+    image_path = Path(image_path)
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Build filter chain
+    filters = []
+
+    # Duration loop
+    filters.append("loop=loop=-1:size=1")
+
+    # Scale if resolution specified
+    if resolution:
+        filters.append(f"scale={resolution}")
+
+    # Fade effects
+    if fade_in > 0:
+        filters.append(f"fade=t=in:st=0:d={fade_in}")
+    if fade_out > 0:
+        fade_out_start = duration - fade_out
+        filters.append(f"fade=t=out:st={fade_out_start}:d={fade_out}")
+
+    # Trim to duration
+    filters.append(f"trim=duration={duration}")
+
+    filter_str = ",".join(filters)
+
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(image_path),
+        "-vf",
+        filter_str,
+        "-c:v",
+        "libx264",
+        "-pix_fmt",
+        "yuv420p",
+        "-r",
+        str(fps),
+        "-preset",
+        "fast",
+        "-crf",
+        "23",
+        str(output_path),
+    ]
+
+    result = subprocess.run(cmd, capture_output=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffmpeg failed: {result.stderr.decode()}")
+
+    return output_path
+
+
+def concatenate_videos(
+    video_paths: List[Union[str, Path]],
+    output_path: Union[str, Path],
+    transition: str = "none",
+    transition_duration: float = 0.5,
+) -> Path:
+    """Concatenate multiple videos.
+
+    Parameters
+    ----------
+    video_paths : list
+        List of input video paths.
+    output_path : str or Path
+        Output video path.
+    transition : str
+        Transition type: "none", "fade", "dissolve".
+    transition_duration : float
+        Transition duration in seconds.
+
+    Returns
+    -------
+    Path
+        Path to output video.
+    """
+    if not _check_ffmpeg():
+        raise RuntimeError("ffmpeg not found. Install with: apt install ffmpeg")
+
+    if not video_paths:
+        raise ValueError("No videos to concatenate")
+
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Create concat file
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+        for vp in video_paths:
+            f.write(f"file '{Path(vp).absolute()}'\n")
+        concat_file = f.name
+
+    try:
+        if transition == "none":
+            # Simple concatenation
+            cmd = [
+                "ffmpeg",
+                "-y",
+                "-f",
+                "concat",
+                "-safe",
+                "0",
+                "-i",
+                concat_file,
+                "-c:v",
+                "libx264",
+                "-pix_fmt",
+                "yuv420p",
+                "-preset",
+                "fast",
+                "-crf",
+                "23",
+                str(output_path),
+            ]
+        else:
+            # Use filter_complex for transitions
+            # Build input list and filter
+            inputs = []
+            filter_parts = []
+
+            for i, vp in enumerate(video_paths):
+                inputs.extend(["-i", str(vp)])
+
+            # For fade/dissolve, use xfade filter
+            if len(video_paths) == 2:
+                filter_str = f"[0:v][1:v]xfade=transition={transition}:duration={transition_duration}:offset=0[outv]"
+                cmd = [
+                    "ffmpeg",
+                    "-y",
+                    *inputs,
+                    "-filter_complex",
+                    filter_str,
+                    "-map",
+                    "[outv]",
+                    "-c:v",
+                    "libx264",
+                    "-pix_fmt",
+                    "yuv420p",
+                    "-preset",
+                    "fast",
+                    str(output_path),
+                ]
+            else:
+                # Fall back to simple concat for >2 videos
+                cmd = [
+                    "ffmpeg",
+                    "-y",
+                    "-f",
+                    "concat",
+                    "-safe",
+                    "0",
+                    "-i",
+                    concat_file,
+                    "-c:v",
+                    "libx264",
+                    "-pix_fmt",
+                    "yuv420p",
+                    "-preset",
+                    "fast",
+                    "-crf",
+                    "23",
+                    str(output_path),
+                ]
+
+        result = subprocess.run(cmd, capture_output=True)
+        if result.returncode != 0:
+            raise RuntimeError(f"ffmpeg failed: {result.stderr.decode()}")
+
+    finally:
+        Path(concat_file).unlink(missing_ok=True)
+
+    return output_path
+
+
+def compose(
+    content: Union[str, Path],
+    output: Union[str, Path],
+    opening: Optional[Union[str, Path]] = None,
+    closing: Optional[Union[str, Path]] = None,
+    opening_duration: float = 3.0,
+    closing_duration: float = 3.0,
+    transition: str = "fade",
+    transition_duration: float = 0.5,
+) -> Path:
+    """Compose a full video with opening, content, and closing.
+
+    Parameters
+    ----------
+    content : str or Path
+        Main content video path.
+    output : str or Path
+        Output video path.
+    opening : str or Path, optional
+        Opening image or video. If image, converts to video.
+    closing : str or Path, optional
+        Closing image or video. If image, converts to video.
+    opening_duration : float
+        Duration for opening if it's an image.
+    closing_duration : float
+        Duration for closing if it's an image.
+    transition : str
+        Transition type: "none", "fade", "dissolve".
+    transition_duration : float
+        Transition duration in seconds.
+
+    Returns
+    -------
+    Path
+        Path to output video.
+    """
+    videos_to_concat = []
+    temp_files = []
+
+    try:
+        # Process opening
+        if opening:
+            opening = Path(opening)
+            if opening.suffix.lower() in [".png", ".jpg", ".jpeg", ".webp"]:
+                # Convert image to video
+                temp_opening = Path(tempfile.mktemp(suffix=".mp4"))
+                temp_files.append(temp_opening)
+                image_to_video(opening, temp_opening, duration=opening_duration)
+                videos_to_concat.append(temp_opening)
+            else:
+                videos_to_concat.append(opening)
+
+        # Add main content
+        videos_to_concat.append(Path(content))
+
+        # Process closing
+        if closing:
+            closing = Path(closing)
+            if closing.suffix.lower() in [".png", ".jpg", ".jpeg", ".webp"]:
+                # Convert image to video
+                temp_closing = Path(tempfile.mktemp(suffix=".mp4"))
+                temp_files.append(temp_closing)
+                image_to_video(closing, temp_closing, duration=closing_duration)
+                videos_to_concat.append(temp_closing)
+            else:
+                videos_to_concat.append(closing)
+
+        # Concatenate all
+        return concatenate_videos(
+            videos_to_concat,
+            output,
+            transition=transition,
+            transition_duration=transition_duration,
+        )
+
+    finally:
+        # Cleanup temp files
+        for tf in temp_files:
+            tf.unlink(missing_ok=True)
+
+
+__all__ = [
+    "image_to_video",
+    "concatenate_videos",
+    "compose",
+]
+
+# EOF

scitex/dev/cv/_title_card.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-08
+# File: src/scitex/dev/cv/_title_card.py
+"""Title card generation using matplotlib.
+
+Creates opening/closing title cards as images or short videos
+with consistent SciTeX branding.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# SciTeX brand colors (using matplotlib-compatible RGBA tuples)
+SCITEX_COLORS = {
+    "primary": "#1a1a2e",
+    "secondary": "#16213e",
+    "accent": "#4da6ff",
+    "text": "#ffffff",
+    "text_muted": (1.0, 1.0, 1.0, 0.7),  # White with 70% opacity
+    "text_dim": (1.0, 1.0, 1.0, 0.5),  # White with 50% opacity
+}
+
+
+def _create_gradient_background(
+    width: int = 1920,
+    height: int = 1080,
+    color1: str = "#1a1a2e",
+    color2: str = "#16213e",
+    angle: float = 135,
+) -> np.ndarray:
+    """Create a gradient background.
+
+    Parameters
+    ----------
+    width : int
+        Image width in pixels.
+    height : int
+        Image height in pixels.
+    color1, color2 : str
+        Hex colors for gradient.
+    angle : float
+        Gradient angle in degrees.
+
+    Returns
+    -------
+    np.ndarray
+        RGB image array (height, width, 3).
+    """
+    import matplotlib.colors as mcolors
+
+    # Convert hex to RGB
+    c1 = np.array(mcolors.to_rgb(color1))
+    c2 = np.array(mcolors.to_rgb(color2))
+
+    # Create gradient
+    angle_rad = np.radians(angle)
+    x = np.linspace(0, 1, width)
+    y = np.linspace(0, 1, height)
+    xx, yy = np.meshgrid(x, y)
+
+    # Gradient along angle direction
+    t = xx * np.cos(angle_rad) + yy * np.sin(angle_rad)
+    t = (t - t.min()) / (t.max() - t.min())
+
+    # Interpolate colors
+    img = np.zeros((height, width, 3))
+    for i in range(3):
+        img[:, :, i] = c1[i] + t * (c2[i] - c1[i])
+
+    return img
+
+
+def create_title_card(
+    title: str,
+    subtitle: str = "",
+    timestamp: str = "",
+    output_path: Optional[str] = None,
+    width: int = 1920,
+    height: int = 1080,
+    dpi: int = 100,
+    background: str = "gradient",
+    title_fontsize: int = 72,
+    subtitle_fontsize: int = 36,
+    timestamp_fontsize: int = 18,
+) -> Path:
+    """Create a title card image.
+
+    Parameters
+    ----------
+    title : str
+        Main title text.
+    subtitle : str, optional
+        Subtitle text.
+    timestamp : str, optional
+        Timestamp text. If empty, uses current datetime.
+    output_path : str, optional
+        Output file path. Auto-generated if None.
+    width, height : int
+        Image dimensions in pixels.
+    dpi : int
+        Output DPI.
+    background : str
+        Background style: "gradient", "solid", or hex color.
+    title_fontsize : int
+        Title font size in points.
+    subtitle_fontsize : int
+        Subtitle font size in points.
+    timestamp_fontsize : int
+        Timestamp font size in points.
+
+    Returns
+    -------
+    Path
+        Path to generated image.
+    """
+    # Set up figure
+    fig_width = width / dpi
+    fig_height = height / dpi
+    fig, ax = plt.subplots(figsize=(fig_width, fig_height), dpi=dpi)
+
+    # Background
+    if background == "gradient":
+        bg = _create_gradient_background(width, height)
+        ax.imshow(bg, extent=[0, 1, 0, 1], aspect="auto")
+    elif background == "solid":
+        ax.set_facecolor(SCITEX_COLORS["primary"])
+    else:
+        ax.set_facecolor(background)
+
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    ax.axis("off")
+
+    # Title
+    ax.text(
+        0.5,
+        0.55,
+        title,
+        ha="center",
+        va="center",
+        fontsize=title_fontsize,
+        fontweight="bold",
+        color=SCITEX_COLORS["text"],
+        transform=ax.transAxes,
+    )
+
+    # Subtitle
+    if subtitle:
+        ax.text(
+            0.5,
+            0.42,
+            subtitle,
+            ha="center",
+            va="center",
+            fontsize=subtitle_fontsize,
+            fontweight="normal",
+            color=SCITEX_COLORS["text_muted"],
+            transform=ax.transAxes,
+        )
+
+    # Timestamp
+    ts = timestamp or datetime.now().strftime("%Y-%m-%d %H:%M")
+    ax.text(
+        0.5,
+        0.30,
+        ts,
+        ha="center",
+        va="center",
+        fontsize=timestamp_fontsize,
+        fontfamily="monospace",
+        color=SCITEX_COLORS["text_dim"],
+        transform=ax.transAxes,
+    )
+
+    # Save
+    if output_path is None:
+        output_path = f"/tmp/title_card_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Save with exact dimensions (no bbox_inches='tight' to preserve size)
+    fig.savefig(
+        output_path,
+        facecolor=SCITEX_COLORS["primary"],
+        edgecolor="none",
+        dpi=dpi,
+    )
+    plt.close(fig)
+
+    return output_path
+
+
+def create_opening(
+    title: str,
+    subtitle: str = "Part of SciTeX",
+    timestamp: str = "",
+    output_path: Optional[str] = None,
+    product: str = "SciTeX",
+    version: str = "",
+    **kwargs,
+) -> Path:
+    """Create an opening title card with SciTeX branding.
+
+    Parameters
+    ----------
+    title : str
+        Main title (e.g., "Demo: Feature X").
+    subtitle : str
+        Subtitle (default: "Part of SciTeX").
+    timestamp : str
+        Timestamp. Uses current datetime if empty.
+    output_path : str, optional
+        Output file path.
+    product : str
+        Product name (e.g., "FigRecipe", "SciTeX").
+    version : str
+        Version string (e.g., "v2.1.2").
+    **kwargs
+        Additional arguments passed to create_title_card.
+
+    Returns
+    -------
+    Path
+        Path to generated image.
+    """
+    if version:
+        subtitle = f"{product} {version}"
+    elif subtitle == "Part of SciTeX" and product != "SciTeX":
+        subtitle = f"Part of SciTeX - {product}"
+
+    if output_path is None:
+        output_path = f"/tmp/opening_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+
+    return create_title_card(
+        title=title,
+        subtitle=subtitle,
+        timestamp=timestamp,
+        output_path=output_path,
+        **kwargs,
+    )
+
+
+def create_closing(
+    output_path: Optional[str] = None,
+    product: str = "SciTeX",
+    tagline: str = "Automated Science",
+    url: str = "https://scitex.ai",
+    width: int = 1920,
+    height: int = 1080,
+    dpi: int = 100,
+) -> Path:
+    """Create a closing branding card.
+
+    Parameters
+    ----------
+    output_path : str, optional
+        Output file path.
+    product : str
+        Main product name.
+    tagline : str
+        Tagline text.
+    url : str
+        Website URL.
+    width, height : int
+        Image dimensions.
+    dpi : int
+        Output DPI.
+
+    Returns
+    -------
+    Path
+        Path to generated image.
+    """
+    fig_width = width / dpi
+    fig_height = height / dpi
+    fig, ax = plt.subplots(figsize=(fig_width, fig_height), dpi=dpi)
+
+    # Gradient background
+    bg = _create_gradient_background(width, height)
+    ax.imshow(bg, extent=[0, 1, 0, 1], aspect="auto")
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    ax.axis("off")
+
+    # Product name
+    ax.text(
+        0.5,
+        0.55,
+        product,
+        ha="center",
+        va="center",
+        fontsize=72,
+        fontweight="bold",
+        color=SCITEX_COLORS["text"],
+        transform=ax.transAxes,
+    )
+
+    # Tagline
+    ax.text(
+        0.5,
+        0.42,
+        tagline,
+        ha="center",
+        va="center",
+        fontsize=28,
+        color=SCITEX_COLORS["text_muted"],
+        transform=ax.transAxes,
+    )
+
+    # URL
+    ax.text(
+        0.5,
+        0.30,
+        url,
+        ha="center",
+        va="center",
+        fontsize=24,
+        color=SCITEX_COLORS["accent"],
+        transform=ax.transAxes,
+    )
+
+    # Save with exact dimensions
+    if output_path is None:
+        output_path = f"/tmp/closing_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    fig.savefig(
+        output_path,
+        facecolor=SCITEX_COLORS["primary"],
+        edgecolor="none",
+        dpi=dpi,
+    )
+    plt.close(fig)
+
+    return output_path
+
+
+__all__ = [
+    "create_title_card",
+    "create_opening",
+    "create_closing",
+]
+
+# EOF