prezo 0.3.1__py3-none-any.whl

prezo/images/processor.py

@@ -0,0 +1,139 @@
+"""Image processing for slide content."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from prezo.parser import ImageRef, Slide
+
+    from .ascii import AsciiRenderer
+
+# Default dimensions for rendered images
+DEFAULT_IMAGE_WIDTH = 60
+DEFAULT_IMAGE_HEIGHT = 15
+
+
+def get_inline_renderer() -> AsciiRenderer:
+    """Get a renderer suitable for inline display in markdown.
+
+    Terminal-specific protocols (Kitty, iTerm2, Sixel, colored half-blocks)
+    use ANSI escape sequences that get escaped by Textual's Markdown widget.
+    For inline display, we use plain ASCII art which renders correctly.
+    """
+    from .ascii import AsciiRenderer
+
+    return AsciiRenderer(detailed=True)
+
+
+def resolve_image_path(image_path: str, presentation_path: Path | None) -> Path | None:
+    """Resolve an image path relative to the presentation file.
+
+    Args:
+        image_path: Path as written in markdown (can be relative or absolute).
+        presentation_path: Path to the presentation file.
+
+    Returns:
+        Resolved absolute path, or None if unresolvable.
+
+    """
+    # Handle URLs (not supported yet)
+    if image_path.startswith(("http://", "https://", "data:")):
+        return None
+
+    path = Path(image_path)
+
+    # If absolute, use as-is
+    if path.is_absolute():
+        return path if path.exists() else None
+
+    # If relative, resolve against presentation directory
+    if presentation_path:
+        resolved = presentation_path.parent / path
+        if resolved.exists():
+            return resolved
+
+    # Try current directory as fallback
+    if path.exists():
+        return path.absolute()
+
+    return None
+
+
+def render_image(
+    image_ref: ImageRef,
+    presentation_path: Path | None,
+    *,
+    width: int = DEFAULT_IMAGE_WIDTH,
+    height: int = DEFAULT_IMAGE_HEIGHT,
+) -> str:
+    """Render a single image reference as text for inline display.
+
+    Args:
+        image_ref: The image reference to render.
+        presentation_path: Path to the presentation file for relative paths.
+        width: Target width in characters.
+        height: Target height in lines.
+
+    Returns:
+        Rendered image as text, or a placeholder if rendering fails.
+
+    Note:
+        Always uses HalfBlockRenderer for inline display since terminal-specific
+        protocols (Kitty, iTerm2, Sixel) use escape sequences that get escaped
+        by Textual's Markdown widget.
+
+    """
+    resolved_path = resolve_image_path(image_ref.path, presentation_path)
+
+    if resolved_path is None:
+        # Return a placeholder for unresolvable images
+        alt = image_ref.alt or "image"
+        return f"[Image: {alt}]"
+
+    renderer = get_inline_renderer()
+    return renderer.render(resolved_path, width, height)
+
+
+def process_slide_images(
+    slide: Slide,
+    presentation_path: Path | None,
+    *,
+    width: int = DEFAULT_IMAGE_WIDTH,
+    height: int = DEFAULT_IMAGE_HEIGHT,
+) -> str:
+    """Process a slide's content, rendering images inline.
+
+    Replaces markdown image syntax with rendered half-block versions.
+    Uses HalfBlockRenderer which displays 2 pixels per character using
+    Unicode half-block characters with true color support.
+
+    Args:
+        slide: The slide to process.
+        presentation_path: Path to the presentation file.
+        width: Target width for images in characters.
+        height: Target height for images in lines.
+
+    Returns:
+        Slide content with images replaced by rendered versions.
+
+    """
+    if not slide.images:
+        return slide.content
+
+    # Process images in reverse order to preserve positions
+    content = slide.content
+    for image_ref in reversed(slide.images):
+        rendered = render_image(
+            image_ref,
+            presentation_path,
+            width=width,
+            height=height,
+        )
+
+        # Wrap in code block for proper display in markdown
+        wrapped = f"\n```\n{rendered}\n```\n"
+        content = content[: image_ref.start] + wrapped + content[image_ref.end :]
+
+    return content

prezo/images/sixel.py

@@ -0,0 +1,180 @@
+"""Sixel graphics image renderer."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class SixelRenderer:
+    """Render images using Sixel graphics."""
+
+    @property
+    def name(self) -> str:
+        """Get the renderer name."""
+        return "sixel"
+
+    def supports_inline(self) -> bool:
+        """Sixel supports inline images."""
+        return True
+
+    def render(self, path: Path, width: int, height: int) -> str:
+        """Render an image using Sixel graphics.
+
+        Args:
+            path: Path to the image file.
+            width: Target width in characters.
+            height: Target height in lines.
+
+        Returns:
+            Sixel escape sequence string to display the image.
+
+        """
+        try:
+            return self._render_with_libsixel(path, width, height)
+        except ImportError:
+            # libsixel not available, try PIL-based fallback
+            try:
+                return self._render_with_pil(path, width, height)
+            except Exception:
+                from .ascii import AsciiRenderer
+
+                return AsciiRenderer()._render_placeholder(path, width, height)
+        except Exception:
+            from .ascii import AsciiRenderer
+
+            return AsciiRenderer()._render_placeholder(path, width, height)
+
+    def _render_with_libsixel(self, path: Path, width: int, height: int) -> str:
+        """Render using libsixel-python."""
+        import libsixel
+        from PIL import Image
+
+        # Load and resize image
+        img = Image.open(path)
+        img = img.convert("RGB")
+
+        # Calculate pixel dimensions
+        # Assume ~10 pixels per character width, ~20 per height
+        pixel_width = width * 10
+        pixel_height = height * 20
+
+        # Maintain aspect ratio
+        aspect = img.width / img.height
+        if pixel_width / pixel_height > aspect:
+            pixel_width = int(pixel_height * aspect)
+        else:
+            pixel_height = int(pixel_width / aspect)
+
+        img = img.resize((pixel_width, pixel_height))
+
+        # Convert to sixel
+        output = libsixel.encoder()
+        output.setopt(libsixel.SIXEL_OPTFLAG_WIDTH, str(pixel_width))
+        output.setopt(libsixel.SIXEL_OPTFLAG_HEIGHT, str(pixel_height))
+
+        # Encode to sixel string
+        # This is a simplified approach - actual libsixel usage may vary
+        data = img.tobytes()
+        return output.encode(data, pixel_width, pixel_height)
+
+    def _render_with_pil(self, path: Path, width: int, height: int) -> str:
+        """Render using pure PIL (simplified sixel encoder).
+
+        This is a basic sixel encoder for terminals that support sixel
+        but when libsixel is not available.
+
+        """
+        from PIL import Image
+
+        img = Image.open(path)
+        img = img.convert("P", palette=Image.ADAPTIVE, colors=256)
+
+        # Calculate pixel dimensions
+        pixel_width = width * 8
+        pixel_height = height * 16
+
+        # Maintain aspect ratio
+        aspect = img.width / img.height
+        if pixel_width / pixel_height > aspect:
+            pixel_width = int(pixel_height * aspect)
+        else:
+            pixel_height = int(pixel_width / aspect)
+
+        # Make height divisible by 6 (sixel row height)
+        pixel_height = (pixel_height // 6) * 6
+
+        img = img.resize((pixel_width, pixel_height))
+
+        # Get palette
+        palette = img.getpalette()
+        pixels = list(img.getdata())
+
+        # Build sixel output
+        output = []
+
+        # Start sixel sequence
+        output.append("\x1bPq")
+
+        # Define colors from palette
+        if palette:
+            for i in range(256):
+                r = palette[i * 3]
+                g = palette[i * 3 + 1]
+                b = palette[i * 3 + 2]
+                # Convert to percentages
+                r_pct = int(r / 255 * 100)
+                g_pct = int(g / 255 * 100)
+                b_pct = int(b / 255 * 100)
+                output.append(f"#{i};2;{r_pct};{g_pct};{b_pct}")
+
+        # Encode pixels in sixel format
+        # Each sixel row is 6 pixels high
+        for row in range(0, pixel_height, 6):
+            # For each color used in this row
+            colors_in_row: dict[int, list[int]] = {}
+
+            for y in range(6):
+                if row + y >= pixel_height:
+                    break
+                for x in range(pixel_width):
+                    pixel_idx = (row + y) * pixel_width + x
+                    if pixel_idx < len(pixels):
+                        color = pixels[pixel_idx]
+                        if color not in colors_in_row:
+                            colors_in_row[color] = [0] * pixel_width
+                        colors_in_row[color][x] |= 1 << y
+
+            # Output each color's sixels for this row
+            for color, sixels in colors_in_row.items():
+                output.append(f"#{color}")
+                output.extend(chr(s + 63) for s in sixels)
+                output.append("$")  # Carriage return
+
+            output.append("-")  # New line
+
+        # End sixel sequence
+        output.append("\x1b\\")
+
+        return "".join(output)
+
+
+def is_sixel_available() -> bool:
+    """Check if sixel rendering is available."""
+    try:
+        import libsixel  # noqa: F401
+
+        return True
+    except ImportError:
+        pass
+
+    try:
+        from PIL import Image  # noqa: F401
+
+        return True
+    except ImportError:
+        pass
+
+    return False