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

scitex/plt/utils/_metadata/_artists/_extract.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/plt/utils/_metadata/_artists/_extract.py
+
+"""
+Main artist extraction function.
+
+Orchestrates extraction of all artist types from matplotlib axes.
+"""
+
+from typing import List
+
+from ._base import create_extraction_context
+from ._collections import extract_collections
+from ._images import extract_images
+from ._lines import extract_lines
+from ._patches import extract_patches
+from ._text import extract_text
+
+
+def _extract_artists(ax) -> List[dict]:
+    """
+    Extract artist information including properties and CSV column mapping.
+
+    Uses matplotlib terminology: each drawable element is an Artist.
+    Only includes artists that were explicitly created via scitex tracking,
+    not internal artists created by matplotlib functions.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        The axes to extract artists from
+
+    Returns
+    -------
+    list
+        List of artist dictionaries with:
+        - id: unique identifier
+        - artist_class: matplotlib class name (Line2D, PathCollection, etc.)
+        - label: legend label
+        - style: color, linestyle, linewidth, etc.
+        - data_ref: CSV column mapping (matches columns_actual exactly)
+    """
+    ctx = create_extraction_context(ax)
+    artists = []
+
+    # Extract different artist types
+    artists.extend(extract_lines(ctx))
+    artists.extend(extract_patches(ctx))
+    artists.extend(extract_collections(ctx))
+    artists.extend(extract_images(ctx))
+    artists.extend(extract_text(ctx))
+
+    return artists
+
+
+# EOF

scitex/plt/utils/_metadata/_artists/_images.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/plt/utils/_metadata/_artists/_images.py
+
+"""
+Image artist extraction.
+
+Handles AxesImage (imshow, matshow) extraction.
+"""
+
+from typing import List
+
+from ._base import ExtractionContext
+
+
+def extract_images(ctx: ExtractionContext) -> List[dict]:
+    """Extract image artists from axes."""
+    artists = []
+
+    for i, img in enumerate(ctx.mpl_ax.images):
+        artist = _extract_image(ctx, i, img)
+        if artist:
+            artists.append(artist)
+
+    return artists
+
+
+def _extract_image(ctx: ExtractionContext, index: int, img) -> dict:
+    """Extract AxesImage artist."""
+    artist = {}
+    img_type = type(img).__name__
+
+    scitex_id = getattr(img, "_scitex_id", None)
+    label = img.get_label() if hasattr(img, "get_label") else ""
+
+    if scitex_id:
+        artist["id"] = scitex_id
+    elif label and not label.startswith("_"):
+        artist["id"] = label
+    else:
+        artist["id"] = f"image_{index}"
+
+    # Semantic layer
+    artist["mark"] = "image"
+    artist["role"] = "image"
+
+    artist["legend_included"] = False
+    artist["zorder"] = img.get_zorder()
+
+    # Backend layer
+    backend = {
+        "name": "matplotlib",
+        "artist_class": img_type,
+        "props": {},
+    }
+
+    try:
+        cmap = img.get_cmap()
+        if cmap:
+            backend["props"]["cmap"] = cmap.name
+    except (ValueError, TypeError, AttributeError):
+        pass
+
+    try:
+        backend["props"]["vmin"] = float(img.norm.vmin) if img.norm else None
+        backend["props"]["vmax"] = float(img.norm.vmax) if img.norm else None
+    except (ValueError, TypeError, AttributeError):
+        pass
+
+    try:
+        backend["props"]["interpolation"] = img.get_interpolation()
+    except (ValueError, TypeError, AttributeError):
+        pass
+
+    artist["backend"] = backend
+
+    return artist
+
+
+# EOF

scitex/plt/utils/_metadata/_artists/_lines.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/plt/utils/_metadata/_artists/_lines.py
+
+"""
+Line2D artist extraction.
+
+Handles extraction of line plots, including special handling for
+boxplot, violin, and stem semantic components.
+"""
+
+from typing import List, Optional, Tuple
+
+from ._base import ExtractionContext, color_to_hex
+
+
+def extract_lines(ctx: ExtractionContext) -> List[dict]:
+    """Extract Line2D artists from axes."""
+    from .._csv import _get_csv_column_names
+
+    artists = []
+
+    for i, line in enumerate(ctx.mpl_ax.lines):
+        scitex_id = getattr(line, "_scitex_id", None)
+        label = line.get_label()
+
+        # Determine semantic type for special plot types
+        semantic_type, semantic_id, box_idx = _get_line_semantic_info(
+            ctx, i, line, scitex_id, label
+        )
+
+        # Skip internal artists for certain plot types
+        if _should_skip_line(ctx, scitex_id, label, semantic_type):
+            continue
+
+        artist = _build_line_artist(
+            ctx, i, line, scitex_id, label, semantic_type, semantic_id, box_idx
+        )
+
+        # Add data_ref for non-semantic lines
+        if not semantic_type:
+            trace_id = _get_trace_id_for_line(ctx, i, scitex_id, artist.get("id"))
+            artist["data_ref"] = _get_csv_column_names(trace_id, ctx.ax_row, ctx.ax_col)
+        elif ctx.is_stem and scitex_id:
+            artist["data_ref"] = _get_csv_column_names(
+                scitex_id, ctx.ax_row, ctx.ax_col
+            )
+            if semantic_type == "stem_baseline":
+                artist["derived"] = True
+                artist["data_ref"]["derived_from"] = "y=0"
+
+        # Add boxplot statistics
+        if (
+            semantic_type == "boxplot_median"
+            and box_idx is not None
+            and box_idx < len(ctx.boxplot_stats)
+        ):
+            artist["stats"] = ctx.boxplot_stats[box_idx]
+
+        artists.append(artist)
+
+    return artists
+
+
+def _get_line_semantic_info(
+    ctx: ExtractionContext,
+    index: int,
+    line,
+    scitex_id: Optional[str],
+    label: str,
+) -> Tuple[Optional[str], Optional[str], Optional[int]]:
+    """Get semantic type info for a line."""
+    semantic_type = None
+    semantic_id = None
+    box_idx = None
+
+    # Stem detection
+    if ctx.is_stem:
+        semantic_type, semantic_id = _detect_stem_semantic(line, index)
+
+    # Boxplot detection for unlabeled lines
+    if (
+        ctx.skip_unlabeled
+        and not scitex_id
+        and label.startswith("_")
+        and ctx.is_boxplot
+        and ctx.num_boxes > 0
+    ):
+        semantic_type, semantic_id, box_idx = _detect_boxplot_semantic(
+            ctx.num_boxes, index
+        )
+    elif (
+        ctx.skip_unlabeled and not scitex_id and label.startswith("_") and ctx.is_violin
+    ):
+        semantic_type = "violin_component"
+        semantic_id = f"violin_line_{index}"
+
+    return semantic_type, semantic_id, box_idx
+
+
+def _detect_stem_semantic(line, index: int) -> Tuple[str, str]:
+    """Detect stem plot semantic type."""
+    marker = line.get_marker()
+    linestyle = line.get_linestyle()
+
+    if marker and marker != "None" and linestyle == "None":
+        return "stem_marker", "stem_markers"
+    elif linestyle and linestyle != "None":
+        ydata = line.get_ydata()
+        if len(ydata) >= 2 and len(set(ydata)) == 1:
+            return "stem_baseline", "stem_baseline"
+        else:
+            return "stem_stem", "stem_lines"
+    else:
+        return "stem_component", f"stem_{index}"
+
+
+def _detect_boxplot_semantic(num_boxes: int, index: int) -> Tuple[str, str, int]:
+    """Detect boxplot semantic type based on line index."""
+    total_whiskers = 2 * num_boxes
+    total_caps = 2 * num_boxes
+    total_medians = num_boxes
+
+    if index < total_whiskers:
+        box_idx = index // 2
+        whisker_idx = index % 2
+        return "boxplot_whisker", f"box_{box_idx}_whisker_{whisker_idx}", box_idx
+    elif index < total_whiskers + total_caps:
+        cap_i = index - total_whiskers
+        box_idx = cap_i // 2
+        cap_idx = cap_i % 2
+        return "boxplot_cap", f"box_{box_idx}_cap_{cap_idx}", box_idx
+    elif index < total_whiskers + total_caps + total_medians:
+        box_idx = index - total_whiskers - total_caps
+        return "boxplot_median", f"box_{box_idx}_median", box_idx
+    else:
+        flier_idx = index - total_whiskers - total_caps - total_medians
+        box_idx = flier_idx if flier_idx < num_boxes else num_boxes - 1
+        return "boxplot_flier", f"box_{box_idx}_flier", box_idx
+
+
+def _should_skip_line(
+    ctx: ExtractionContext,
+    scitex_id: Optional[str],
+    label: str,
+    semantic_type: Optional[str],
+) -> bool:
+    """Check if line should be skipped."""
+    if ctx.skip_unlabeled and not scitex_id and label.startswith("_"):
+        # Allow boxplot, violin, stem semantic types
+        if ctx.is_boxplot or ctx.is_violin or ctx.is_stem:
+            return False
+        return True
+    return False
+
+
+def _build_line_artist(
+    ctx: ExtractionContext,
+    index: int,
+    line,
+    scitex_id: Optional[str],
+    label: str,
+    semantic_type: Optional[str],
+    semantic_id: Optional[str],
+    box_idx: Optional[int],
+) -> dict:
+    """Build artist dict for a line."""
+    artist = {}
+
+    # ID assignment
+    if semantic_id and ctx.is_stem:
+        artist["id"] = semantic_id
+        if scitex_id:
+            artist["group_id"] = scitex_id
+    elif scitex_id:
+        artist["id"] = scitex_id
+    elif semantic_id:
+        artist["id"] = semantic_id
+    elif not label.startswith("_"):
+        artist["id"] = label
+    else:
+        artist["id"] = f"line_{index}"
+
+    # Semantic layer
+    artist["mark"] = "line"
+    if semantic_type:
+        artist["role"] = semantic_type
+
+    # Legend
+    if not label.startswith("_"):
+        artist["label"] = label
+        artist["legend_included"] = True
+    else:
+        artist["legend_included"] = False
+
+    artist["zorder"] = line.get_zorder()
+
+    # Backend layer
+    backend = {
+        "name": "matplotlib",
+        "artist_class": type(line).__name__,
+        "props": {},
+    }
+
+    color_hex = color_to_hex(line.get_color())
+    if color_hex:
+        backend["props"]["color"] = color_hex
+
+    backend["props"]["linestyle"] = line.get_linestyle()
+    backend["props"]["linewidth_pt"] = line.get_linewidth()
+
+    marker = line.get_marker()
+    if marker and marker != "None" and marker != "none":
+        backend["props"]["marker"] = marker
+        backend["props"]["markersize_pt"] = line.get_markersize()
+    else:
+        backend["props"]["marker"] = None
+
+    artist["backend"] = backend
+
+    return artist
+
+
+def _get_trace_id_for_line(
+    ctx: ExtractionContext,
+    index: int,
+    scitex_id: Optional[str],
+    artist_id: str,
+) -> str:
+    """Get trace ID for data_ref."""
+    if scitex_id:
+        return scitex_id
+
+    # Try to find from history
+    if hasattr(ctx.ax_for_detection, "history"):
+        plot_records = []
+        for record_id, record in ctx.ax_for_detection.history.items():
+            if isinstance(record, tuple) and len(record) >= 2:
+                if record[1] == "plot":
+                    tracking_id = record[0]
+                    if tracking_id.startswith("ax_"):
+                        parts = tracking_id.split("_")
+                        if len(parts) >= 4:
+                            trace_id = "_".join(parts[3:])
+                        else:
+                            trace_id = parts[-1]
+                    elif tracking_id.startswith("plot_"):
+                        trace_id = (
+                            tracking_id[5:] if len(tracking_id) > 5 else str(index)
+                        )
+                    else:
+                        trace_id = tracking_id
+                    plot_records.append(trace_id)
+
+        if plot_records and index < len(plot_records):
+            return plot_records[index]
+
+    return artist_id
+
+
+# EOF

scitex/plt/utils/_metadata/_artists/_patches.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/plt/utils/_metadata/_artists/_patches.py
+
+"""
+Patch artist extraction.
+
+Handles Rectangle (bar, hist), Wedge (pie), and Polygon patches.
+"""
+
+from typing import List, Optional
+
+from ._base import ExtractionContext, color_to_hex
+
+
+def extract_patches(ctx: ExtractionContext) -> List[dict]:
+    """Extract patch artists from axes."""
+    artists = []
+
+    # Collect rectangles
+    rectangles = []
+    for i, patch in enumerate(ctx.mpl_ax.patches):
+        patch_type = type(patch).__name__
+        if patch_type == "Rectangle":
+            rectangles.append((i, patch))
+        elif patch_type == "Wedge":
+            artist = _extract_wedge(ctx, i, patch)
+            if artist:
+                artists.append(artist)
+        elif "Poly" in patch_type:
+            artist = _extract_polygon(ctx, i, patch)
+            if artist:
+                artists.append(artist)
+
+    # Extract rectangles (bar/hist)
+    if rectangles:
+        bar_artists = _extract_rectangles(ctx, rectangles)
+        artists.extend(bar_artists)
+
+    return artists
+
+
+def _extract_rectangles(ctx: ExtractionContext, rectangles: List[tuple]) -> List[dict]:
+    """Extract Rectangle patches (bar/hist)."""
+    from .._csv import _get_csv_column_names
+
+    artists = []
+    is_bar = ctx.plot_type in ("bar", "barh")
+    is_hist = ctx.plot_type == "hist"
+
+    # Get trace_id from history
+    trace_id_for_bars = _get_bar_trace_id(ctx)
+
+    bar_count = 0
+    for rect_idx, (i, patch) in enumerate(rectangles):
+        scitex_id = getattr(patch, "_scitex_id", None)
+        label = patch.get_label() if hasattr(patch, "get_label") else ""
+
+        # Skip internal patches for non-bar/hist types
+        if not (is_bar or is_hist):
+            if (
+                ctx.skip_unlabeled
+                and not scitex_id
+                and (not label or label.startswith("_"))
+            ):
+                continue
+
+        artist = {}
+
+        # Generate unique ID
+        base_id = scitex_id or (
+            label if label and not label.startswith("_") else trace_id_for_bars or "bar"
+        )
+        artist["id"] = f"{base_id}_{bar_count}"
+        artist["group_id"] = base_id
+
+        # Semantic layer
+        artist["mark"] = "bar"
+        if is_hist:
+            artist["role"] = "hist_bin"
+        else:
+            artist["role"] = "bar_body"
+
+        # Legend
+        if label and not label.startswith("_") and bar_count == 0:
+            artist["label"] = label
+            artist["legend_included"] = True
+        else:
+            artist["legend_included"] = False
+
+        artist["zorder"] = patch.get_zorder()
+
+        # Backend layer
+        backend = {
+            "name": "matplotlib",
+            "artist_class": type(patch).__name__,
+            "props": {},
+        }
+
+        try:
+            backend["props"]["facecolor"] = color_to_hex(patch.get_facecolor())
+        except (ValueError, TypeError):
+            pass
+
+        try:
+            backend["props"]["edgecolor"] = color_to_hex(patch.get_edgecolor())
+        except (ValueError, TypeError):
+            pass
+
+        try:
+            backend["props"]["linewidth_pt"] = patch.get_linewidth()
+        except (ValueError, TypeError):
+            pass
+
+        artist["backend"] = backend
+
+        # Geometry
+        try:
+            artist["geometry"] = {
+                "x": patch.get_x(),
+                "y": patch.get_y(),
+                "width": patch.get_width(),
+                "height": patch.get_height(),
+            }
+        except (ValueError, TypeError, AttributeError):
+            pass
+
+        # Data reference
+        if trace_id_for_bars:
+            artist["data_ref"] = _get_csv_column_names(
+                trace_id_for_bars, ctx.ax_row, ctx.ax_col
+            )
+            artist["data_ref"]["row_index"] = bar_count
+
+        bar_count += 1
+        artists.append(artist)
+
+    return artists
+
+
+def _get_bar_trace_id(ctx: ExtractionContext) -> Optional[str]:
+    """Get trace ID for bar/hist from history."""
+    if hasattr(ctx.ax_for_detection, "history"):
+        for record in ctx.ax_for_detection.history.values():
+            if isinstance(record, tuple) and len(record) >= 2:
+                method_name = record[1]
+                if method_name in ("bar", "barh", "hist"):
+                    return record[0]
+    return None
+
+
+def _extract_wedge(ctx: ExtractionContext, index: int, patch) -> dict:
+    """Extract Wedge (pie) patch."""
+    artist = {}
+    scitex_id = getattr(patch, "_scitex_id", None)
+    label = patch.get_label() if hasattr(patch, "get_label") else ""
+
+    if scitex_id:
+        artist["id"] = scitex_id
+    elif label and not label.startswith("_"):
+        artist["id"] = label
+    else:
+        artist["id"] = f"wedge_{index}"
+
+    artist["mark"] = "wedge"
+    artist["role"] = "pie_slice"
+
+    if label and not label.startswith("_"):
+        artist["label"] = label
+        artist["legend_included"] = True
+    else:
+        artist["legend_included"] = False
+
+    artist["zorder"] = patch.get_zorder()
+
+    # Backend layer
+    backend = {
+        "name": "matplotlib",
+        "artist_class": type(patch).__name__,
+        "props": {},
+    }
+
+    try:
+        backend["props"]["facecolor"] = color_to_hex(patch.get_facecolor())
+    except (ValueError, TypeError):
+        pass
+
+    try:
+        backend["props"]["edgecolor"] = color_to_hex(patch.get_edgecolor())
+    except (ValueError, TypeError):
+        pass
+
+    artist["backend"] = backend
+
+    # Geometry
+    try:
+        artist["geometry"] = {
+            "theta1": patch.theta1,
+            "theta2": patch.theta2,
+            "r": patch.r,
+        }
+    except (ValueError, TypeError, AttributeError):
+        pass
+
+    return artist
+
+
+def _extract_polygon(ctx: ExtractionContext, index: int, patch) -> dict:
+    """Extract Polygon patch."""
+    artist = {}
+    scitex_id = getattr(patch, "_scitex_id", None)
+    label = patch.get_label() if hasattr(patch, "get_label") else ""
+
+    if scitex_id:
+        artist["id"] = scitex_id
+    elif label and not label.startswith("_"):
+        artist["id"] = label
+    else:
+        artist["id"] = f"polygon_{index}"
+
+    artist["mark"] = "polygon"
+    artist["legend_included"] = False
+    artist["zorder"] = patch.get_zorder()
+
+    # Backend layer
+    backend = {
+        "name": "matplotlib",
+        "artist_class": type(patch).__name__,
+        "props": {},
+    }
+
+    try:
+        backend["props"]["facecolor"] = color_to_hex(patch.get_facecolor())
+    except (ValueError, TypeError):
+        pass
+
+    try:
+        backend["props"]["edgecolor"] = color_to_hex(patch.get_edgecolor())
+    except (ValueError, TypeError):
+        pass
+
+    artist["backend"] = backend
+
+    return artist
+
+
+# EOF