scitex 2.5.0__py3-none-any.whl → 2.7.3__py3-none-any.whl

scitex/plt/utils/_scitex_config.py

@@ -17,10 +17,10 @@ import pandas as pd
 
 class SciTeXConfig:
     """Central configuration manager for the SciTeX ecosystem"""
-    
+
     def __init__(self, config_path: Optional[str] = None):
         """Initialize SciTeX configuration
-        
+
         Parameters
         ----------
         config_path : str, optional
@@ -28,153 +28,153 @@ class SciTeXConfig:
         """
         self.config_path = config_path or os.path.expanduser("~/.scitex/config.yaml")
         self.config = self._load_config()
-        
+
     def _load_config(self) -> Dict[str, Any]:
         """Load configuration from file or create default"""
         if os.path.exists(self.config_path):
-            with open(self.config_path, 'r') as f:
+            with open(self.config_path, "r") as f:
                 return yaml.safe_load(f) or {}
         else:
             return self._create_default_config()
-    
+
     def _create_default_config(self) -> Dict[str, Any]:
         """Create default SciTeX ecosystem configuration"""
         default_config = {
-            'scitex_ecosystem': {
-                'version': '1.0.0',
-                'core_engine': 'claude_code',
-                'emacs_integration': True,
-                'auto_workflow': True
+            "scitex_ecosystem": {
+                "version": "1.0.0",
+                "core_engine": "claude_code",
+                "emacs_integration": True,
+                "auto_workflow": True,
             },
-            
-            'paths': {
-                'scitex_paper': '~/proj/SciTeX-Paper/',
-                'scitex_code': '~/proj/SciTeX-Code/',
-                'sigmacro': '~/proj/SigMacro/',
-                'emacs_claude': '~/proj/emacs-claude-code/',
-                'scitex_data': '~/data/',
-                'output': '~/output/'
+            "paths": {
+                "scitex_paper": "~/proj/SciTeX-Paper/",
+                "scitex_code": "~/proj/SciTeX-Code/",
+                "sigmacro": "~/proj/SigMacro/",
+                "emacs_claude": "~/proj/emacs-claude-code/",
+                "scitex_data": "~/data/",
+                "output": "~/output/",
             },
-            
-            'scitex': {
-                'auto_metadata': True,
-                'yaml_export': True,
-                'csv_export': True,
-                'tracking_enabled': True,
-                'default_journal': 'nature'
+            "scitex": {
+                "auto_metadata": True,
+                "yaml_export": True,
+                "csv_export": True,
+                "tracking_enabled": True,
+                "default_journal": "nature",
             },
-            
-            'ai_integration': {
-                'claude_code_enabled': True,
-                'auto_code_generation': True,
-                'auto_manuscript_writing': True,
-                'ai_assisted_analysis': True,
-                'emacs_claude_integration': True
+            "ai_integration": {
+                "claude_code_enabled": True,
+                "auto_code_generation": True,
+                "auto_manuscript_writing": True,
+                "ai_assisted_analysis": True,
+                "emacs_claude_integration": True,
             },
-            
-            'publication': {
-                'default_journal': 'nature',
-                'auto_formatting': True,
-                'latex_compilation': True,
-                'submission_package': True,
-                'reproducibility_level': 'full'
+            "publication": {
+                "default_journal": "nature",
+                "auto_formatting": True,
+                "latex_compilation": True,
+                "submission_package": True,
+                "reproducibility_level": "full",
+            },
+            "workflow": {
+                "auto_save_metadata": True,
+                "auto_export_yaml": True,
+                "auto_generate_methods": True,
+                "auto_create_figures": True,
+                "ai_quality_check": True,
             },
-            
-            'workflow': {
-                'auto_save_metadata': True,
-                'auto_export_yaml': True,
-                'auto_generate_methods': True,
-                'auto_create_figures': True,
-                'ai_quality_check': True
-            }
         }
-        
+
         # Create config directory and save
         os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
         self.save_config(default_config)
         return default_config
-    
+
     def save_config(self, config: Dict[str, Any] = None):
         """Save configuration to file"""
         config_to_save = config or self.config
-        with open(self.config_path, 'w') as f:
-            yaml.dump(config_to_save, f, default_flow_style=False, sort_keys=False, indent=2)
-    
+        with open(self.config_path, "w") as f:
+            yaml.dump(
+                config_to_save, f, default_flow_style=False, sort_keys=False, indent=2
+            )
+
     def get_scitex_paths(self) -> Dict[str, str]:
         """Get expanded SciTeX ecosystem paths"""
         paths = {}
-        for key, path in self.config.get('paths', {}).items():
+        for key, path in self.config.get("paths", {}).items():
             paths[key] = os.path.expanduser(path)
         return paths
-    
+
     def setup_scitex_directories(self):
         """Create SciTeX ecosystem directory structure"""
         paths = self.get_scitex_paths()
-        
+
         # Create main directories
         for path_name, path in paths.items():
             os.makedirs(path, exist_ok=True)
-            
+
         # Create SciTeX-Paper subdirectories
-        scitex_paper = paths.get('scitex_paper')
+        scitex_paper = paths.get("scitex_paper")
         if scitex_paper:
-            subdirs = ['figures', 'data', 'metadata', 'code', 'sections', 'manuscripts']
+            subdirs = ["figures", "data", "metadata", "code", "sections", "manuscripts"]
             for subdir in subdirs:
                 os.makedirs(os.path.join(scitex_paper, subdir), exist_ok=True)
-    
+
     def get_ai_settings(self) -> Dict[str, Any]:
         """Get AI integration settings"""
-        return self.config.get('ai_integration', {})
-    
+        return self.config.get("ai_integration", {})
+
     def get_publication_settings(self) -> Dict[str, Any]:
         """Get publication workflow settings"""
-        return self.config.get('publication', {})
-    
+        return self.config.get("publication", {})
+
     def is_emacs_claude_enabled(self) -> bool:
         """Check if Emacs-Claude integration is enabled"""
-        return self.config.get('ai_integration', {}).get('emacs_claude_integration', False)
-    
+        return self.config.get("ai_integration", {}).get(
+            "emacs_claude_integration", False
+        )
+
     def get_default_journal(self) -> str:
         """Get default target journal"""
-        return self.config.get('publication', {}).get('default_journal', 'nature')
-    
+        return self.config.get("publication", {}).get("default_journal", "nature")
+
     def enable_ai_workflow(self):
         """Enable full AI-powered workflow"""
-        self.config['ai_integration']['claude_code_enabled'] = True
-        self.config['ai_integration']['auto_code_generation'] = True
-        self.config['ai_integration']['auto_manuscript_writing'] = True
-        self.config['workflow']['ai_quality_check'] = True
+        self.config["ai_integration"]["claude_code_enabled"] = True
+        self.config["ai_integration"]["auto_code_generation"] = True
+        self.config["ai_integration"]["auto_manuscript_writing"] = True
+        self.config["workflow"]["ai_quality_check"] = True
         self.save_config()
-    
+
     def create_project_config(self, project_name: str, project_path: str):
         """Create project-specific configuration"""
         project_config = {
-            'project': {
-                'name': project_name,
-                'path': project_path,
-                'created': str(pd.Timestamp.now()),
-                'scitex_version': '1.0.0'
+            "project": {
+                "name": project_name,
+                "path": project_path,
+                "created": str(pd.Timestamp.now()),
+                "scitex_version": "1.0.0",
             },
-            'inherit_from': self.config_path,
-            'overrides': {
-                'paths': {
-                    'output': os.path.join(project_path, 'output'),
-                    'data': os.path.join(project_path, 'data'),
-                    'figures': os.path.join(project_path, 'figures')
+            "inherit_from": self.config_path,
+            "overrides": {
+                "paths": {
+                    "output": os.path.join(project_path, "output"),
+                    "data": os.path.join(project_path, "data"),
+                    "figures": os.path.join(project_path, "figures"),
                 }
-            }
+            },
         }
-        
-        project_config_path = os.path.join(project_path, '.scitex_project.yaml')
-        with open(project_config_path, 'w') as f:
+
+        project_config_path = os.path.join(project_path, ".scitex_project.yaml")
+        with open(project_config_path, "w") as f:
             yaml.dump(project_config, f, default_flow_style=False, indent=2)
-        
+
         return project_config_path
 
 
 # Global configuration instance
 _scitex_config = None
 
+
 def get_scitex_config() -> SciTeXConfig:
     """Get global SciTeX configuration instance"""
     global _scitex_config
@@ -186,39 +186,39 @@ def get_scitex_config() -> SciTeXConfig:
 def configure_scitex_ecosystem():
     """Configure the complete SciTeX ecosystem"""
     config = get_scitex_config()
-    
+
     print("🚀 Configuring SciTeX Ecosystem...")
-    print("="*50)
-    
+    print("=" * 50)
+
     # Setup directories
     config.setup_scitex_directories()
     paths = config.get_scitex_paths()
-    
+
     print("📁 Directory Structure:")
     for name, path in paths.items():
         status = "✅" if os.path.exists(path) else "❌"
         print(f"  {status} {name}: {path}")
-    
+
     # Check AI integration
     print("\n🤖 AI Integration:")
     ai_settings = config.get_ai_settings()
     for setting, enabled in ai_settings.items():
         status = "✅" if enabled else "❌"
         print(f"  {status} {setting}")
-    
+
     # Check Emacs-Claude integration
-    emacs_claude_path = paths.get('emacs_claude')
+    emacs_claude_path = paths.get("emacs_claude")
     if emacs_claude_path and os.path.exists(emacs_claude_path):
         print(f"\n💻 Emacs-Claude Integration: ✅ {emacs_claude_path}")
     else:
         print(f"\n💻 Emacs-Claude Integration: ❌ Not found")
-    
+
     print(f"\n📋 Configuration saved: {config.config_path}")
     print("\n🎯 SciTeX Ecosystem Ready!")
-    
+
     return config
 
 
 if __name__ == "__main__":
     # Setup the complete ecosystem
-    configure_scitex_ecosystem()
+    configure_scitex_ecosystem()

scitex/plt/utils/metadata/__init__.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: scitex/plt/utils/metadata/__init__.py
+
+"""
+Figure metadata collection package.
+
+This package provides utilities to collect comprehensive metadata from matplotlib
+figures and axes for embedding in saved images.
+
+Public API
+----------
+collect_figure_metadata : function
+    Main function to collect all metadata from a figure
+collect_recipe_metadata : function
+    Collect metadata with reconstruction recipe
+assert_csv_json_consistency : function
+    Assert CSV columns match JSON metadata
+verify_csv_json_consistency : function
+    Verify CSV-JSON consistency and return detailed results
+export_editable_figure : function
+    Export figure with geometry data for interactive editing (schema v0.3)
+"""
+
+# Import public API from core module
+from ._core import collect_figure_metadata
+from ._data_linkage import (
+    assert_csv_json_consistency,
+    verify_csv_json_consistency,
+    collect_recipe_metadata,
+)
+from ._geometry_extraction import (
+    extract_axes_bbox_px,
+    data_to_axes_px,
+    extract_line_geometry,
+    extract_scatter_geometry,
+    extract_polygon_geometry,
+    extract_rectangle_geometry,
+    extract_bar_group_geometry,
+    extract_text_geometry,
+    extract_image_geometry,
+)
+from ._editable_export import export_editable_figure
+
+__all__ = [
+    "collect_figure_metadata",
+    "collect_recipe_metadata",
+    "assert_csv_json_consistency",
+    "verify_csv_json_consistency",
+    "export_editable_figure",
+    # Geometry extraction
+    "extract_axes_bbox_px",
+    "data_to_axes_px",
+    "extract_line_geometry",
+    "extract_scatter_geometry",
+    "extract_polygon_geometry",
+    "extract_rectangle_geometry",
+    "extract_bar_group_geometry",
+    "extract_text_geometry",
+    "extract_image_geometry",
+]

scitex/plt/utils/metadata/_artist_extraction.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: scitex/plt/utils/metadata/_artist_extraction.py
+
+"""
+Artist extraction orchestration.
+
+This module provides the main _extract_artists function that coordinates extraction
+of all artist types from matplotlib axes.
+"""
+
+from ._plot_type_detection import _detect_plot_type
+from ._line_artists import _extract_line_artists, _extract_line_collection_artists
+from ._collection_artists import (
+    _extract_scatter_artists,
+    _extract_hist2d_hexbin_artists,
+    _extract_violin_body_artists,
+)
+from ._patch_artists import _extract_rectangle_artists, _extract_wedge_artists
+from ._image_text_artists import _extract_image_artists, _extract_text_artists
+
+
+def _extract_artists(ax) -> list:
+    """
+    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 (top-level calls),
+    not internal artists created by matplotlib functions like boxplot() which internally
+    call plot() multiple times.
+
+    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)
+    """
+    artists = []
+
+    # Get axes position for CSV column naming
+    ax_row, ax_col = 0, 0
+    if hasattr(ax, "_scitex_metadata") and "position_in_grid" in ax._scitex_metadata:
+        pos = ax._scitex_metadata["position_in_grid"]
+        ax_row, ax_col = pos[0], pos[1]
+
+    # Get the raw matplotlib axes for accessing artists
+    mpl_ax = ax._axis_mpl if hasattr(ax, "_axis_mpl") else ax
+
+    # Try to find scitex wrapper for plot type detection and history access
+    ax_for_detection = ax
+    if not hasattr(ax, 'history') and hasattr(mpl_ax, '_scitex_wrapper'):
+        ax_for_detection = mpl_ax._scitex_wrapper
+
+    # Detect plot type
+    plot_type, method = _detect_plot_type(ax_for_detection)
+
+    # Plot types where internal line artists should be hidden
+    internal_plot_types = {
+        "boxplot", "violin", "hist", "bar", "image", "heatmap", "kde", "ecdf",
+        "errorbar", "fill", "stem", "contour", "pie", "quiver", "stream"
+    }
+    skip_unlabeled = plot_type in internal_plot_types
+
+    # Extract Line2D artists
+    line_artists = _extract_line_artists(
+        mpl_ax, ax_for_detection, plot_type, method, ax_row, ax_col, skip_unlabeled
+    )
+    artists.extend(line_artists)
+
+    # Extract PathCollection artists (scatter points)
+    scatter_artists = _extract_scatter_artists(mpl_ax, ax_row, ax_col)
+    artists.extend(scatter_artists)
+
+    # Extract Rectangle patches (bar/barh/hist)
+    rectangle_artists = _extract_rectangle_artists(
+        mpl_ax, ax_for_detection, plot_type, ax_row, ax_col, skip_unlabeled
+    )
+    artists.extend(rectangle_artists)
+
+    # Extract Wedge patches (pie charts)
+    wedge_artists = _extract_wedge_artists(mpl_ax)
+    artists.extend(wedge_artists)
+
+    # Extract QuadMesh and PolyCollection (hist2d, hexbin)
+    hist2d_hexbin_artists = _extract_hist2d_hexbin_artists(mpl_ax, ax_for_detection, plot_type)
+    artists.extend(hist2d_hexbin_artists)
+
+    # Extract violin body (PolyCollection)
+    violin_body_artists = _extract_violin_body_artists(mpl_ax, plot_type)
+    artists.extend(violin_body_artists)
+
+    # Extract AxesImage (imshow)
+    image_artists = _extract_image_artists(mpl_ax)
+    artists.extend(image_artists)
+
+    # Extract Text artists (annotations)
+    text_artists = _extract_text_artists(mpl_ax)
+    artists.extend(text_artists)
+
+    # Extract LineCollection artists (errorbar lines, etc.)
+    linecollection_artists = _extract_line_collection_artists(
+        mpl_ax, ax_for_detection, plot_type, method, ax_row, ax_col
+    )
+    artists.extend(linecollection_artists)
+
+    return artists
+
+
+# Backward compatibility alias
+_extract_traces = _extract_artists

scitex/plt/utils/metadata/_axes_metadata.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: scitex/plt/utils/metadata/_axes_metadata.py
+
+"""
+Axes-level metadata collection.
+
+This module provides functions to collect comprehensive metadata for individual
+axes objects, including dimensions, axis info, and plot content.
+"""
+
+from typing import Dict
+from ._dimensions import _extract_axes_dimensions, _extract_axis_info
+from ._label_parsing import _parse_label_unit
+
+
+def _collect_single_axes_metadata(fig, ax, ax_index: int) -> dict:
+    """
+    Collect metadata for a single axes object.
+
+    Parameters
+    ----------
+    fig : matplotlib.figure.Figure
+        The parent figure
+    ax : matplotlib.axes.Axes
+        The axes to collect metadata from
+    ax_index : int
+        Index of this axes in the figure (for position tracking)
+
+    Returns
+    -------
+    dict
+        Metadata dictionary for this axes containing:
+        - size_mm, size_inch, size_px
+        - position_ratio
+        - position_in_grid
+        - margins_mm, margins_inch
+        - bbox_mm, bbox_inch, bbox_px
+        - xaxis, yaxis (axis info)
+    """
+    # Extract dimension information
+    ax_metadata = _extract_axes_dimensions(fig, ax, ax_index)
+
+    # Extract axes labels and units
+    ax_metadata["xaxis"] = _extract_axis_info(ax, "xaxis")
+    ax_metadata["yaxis"] = _extract_axis_info(ax, "yaxis")
+
+    return ax_metadata
+
+
+def _collect_all_axes_metadata(all_axes, fig, grid_shape) -> dict:
+    """
+    Collect metadata for all axes in a figure.
+
+    Parameters
+    ----------
+    all_axes : list
+        List of (ax, row, col) tuples
+    fig : matplotlib.figure.Figure
+        The parent figure
+    grid_shape : tuple
+        (n_rows, n_cols) shape of the axes grid
+
+    Returns
+    -------
+    dict
+        Nested dictionary with ax_00, ax_01, etc. keys containing axes metadata
+    """
+    from ._plot_content import _extract_artists, _extract_legend_info
+
+    axes_metadata = {}
+
+    for ax_index, (ax_item, row, col) in enumerate(all_axes):
+        # Get the underlying matplotlib axes
+        mpl_ax = ax_item._axis_mpl if hasattr(ax_item, "_axis_mpl") else ax_item
+
+        # Use ax_item (wrapper) for metadata, mpl_ax for matplotlib properties
+        ax_data = _collect_single_axes_metadata(fig, ax_item, ax_index)
+
+        # Store position in grid
+        ax_data["position_in_grid"] = [row, col]
+
+        # Extract plot content (artists and legend)
+        ax_data["artists"] = _extract_artists(ax_item)
+        legend_info = _extract_legend_info(mpl_ax)
+        if legend_info:
+            ax_data["legend"] = legend_info
+
+        # Store with formatted key: ax_00, ax_01, ax_10, etc.
+        ax_key = f"ax_{row:02d}_{col:02d}"
+        axes_metadata[ax_key] = ax_data
+
+    return axes_metadata