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

scitex/benchmark/profiler.py

@@ -18,16 +18,16 @@ from contextlib import contextmanager
 
 class FunctionProfiler:
     """Profile individual function calls."""
-    
+
     def __init__(self):
         self.profiles = {}
         self.call_counts = {}
         self.total_times = {}
-    
+
     def profile(self, func: Callable) -> Callable:
         """
         Decorator to profile a function.
-        
+
         Example
         -------
         >>> profiler = FunctionProfiler()
@@ -35,46 +35,47 @@ class FunctionProfiler:
         ... def my_function(x):
         ...     return x ** 2
         """
+
         @wraps(func)
         def wrapper(*args, **kwargs):
             # Create profiler for this call
             pr = cProfile.Profile()
             pr.enable()
-            
+
             # Call function
             start_time = time.time()
             result = func(*args, **kwargs)
             end_time = time.time()
-            
+
             pr.disable()
-            
+
             # Store results
             func_name = func.__name__
             if func_name not in self.profiles:
                 self.profiles[func_name] = []
                 self.call_counts[func_name] = 0
                 self.total_times[func_name] = 0.0
-            
+
             self.profiles[func_name].append(pr)
             self.call_counts[func_name] += 1
-            self.total_times[func_name] += (end_time - start_time)
-            
+            self.total_times[func_name] += end_time - start_time
+
             return result
-        
+
         return wrapper
-    
+
     def get_stats(self, func_name: str) -> Optional[pstats.Stats]:
         """Get profiling statistics for a function."""
         if func_name not in self.profiles:
             return None
-        
+
         # Combine all profiles for this function
         combined = pstats.Stats(self.profiles[func_name][0])
         for pr in self.profiles[func_name][1:]:
             combined.add(pr)
-        
+
         return combined
-    
+
     def print_stats(self, func_name: Optional[str] = None, top_n: int = 10):
         """Print profiling statistics."""
         if func_name:
@@ -83,31 +84,33 @@ class FunctionProfiler:
                 print(f"\nProfile for {func_name}:")
                 print(f"Total calls: {self.call_counts[func_name]}")
                 print(f"Total time: {self.total_times[func_name]:.3f}s")
-                print(f"Avg time per call: {self.total_times[func_name]/self.call_counts[func_name]:.3f}s")
+                print(
+                    f"Avg time per call: {self.total_times[func_name] / self.call_counts[func_name]:.3f}s"
+                )
                 print("\nDetailed stats:")
-                stats.sort_stats('cumulative').print_stats(top_n)
+                stats.sort_stats("cumulative").print_stats(top_n)
         else:
             # Print all functions
             for name in self.profiles:
                 self.print_stats(name, top_n)
-    
+
     def get_report(self) -> Dict[str, Any]:
         """Get a summary report of all profiled functions."""
         report = {}
         for func_name in self.profiles:
             stats = self.get_stats(func_name)
-            
+
             # Get top time consumers
             s = io.StringIO()
-            stats.sort_stats('cumulative').print_stats(10, s)
-            
+            stats.sort_stats("cumulative").print_stats(10, s)
+
             report[func_name] = {
-                'call_count': self.call_counts[func_name],
-                'total_time': self.total_times[func_name],
-                'avg_time': self.total_times[func_name] / self.call_counts[func_name],
-                'profile': s.getvalue()
+                "call_count": self.call_counts[func_name],
+                "total_time": self.total_times[func_name],
+                "avg_time": self.total_times[func_name] / self.call_counts[func_name],
+                "profile": s.getvalue(),
             }
-        
+
         return report
 
 
@@ -118,7 +121,7 @@ _global_profiler = FunctionProfiler()
 def profile_function(func: Callable) -> Callable:
     """
     Decorator to profile a function using the global profiler.
-    
+
     Example
     -------
     >>> @profile_function
@@ -142,7 +145,7 @@ def print_profile_stats(func_name: Optional[str] = None):
 def profile_block(name: str):
     """
     Context manager for profiling a code block.
-    
+
     Example
     -------
     >>> with profile_block("data_processing"):
@@ -152,18 +155,18 @@ def profile_block(name: str):
     pr = cProfile.Profile()
     pr.enable()
     start_time = time.time()
-    
+
     try:
         yield
     finally:
         pr.disable()
         end_time = time.time()
-        
+
         print(f"\nProfile for block '{name}':")
         print(f"Total time: {end_time - start_time:.3f}s")
-        
+
         s = io.StringIO()
-        ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
+        ps = pstats.Stats(pr, stream=s).sort_stats("cumulative")
         ps.print_stats(10)
         print(s.getvalue())
 
@@ -171,14 +174,14 @@ def profile_block(name: str):
 def profile_module(module_name: str, pattern: str = "*") -> Dict[str, Any]:
     """
     Profile all matching functions in a module.
-    
+
     Parameters
     ----------
     module_name : str
         Name of module to profile
     pattern : str
         Pattern to match function names
-        
+
     Returns
     -------
     dict
@@ -186,81 +189,80 @@ def profile_module(module_name: str, pattern: str = "*") -> Dict[str, Any]:
     """
     import importlib
     import fnmatch
-    
+
     module = importlib.import_module(module_name)
     profiler = FunctionProfiler()
-    
+
     # Wrap all matching functions
     wrapped_functions = []
     for name in dir(module):
         if fnmatch.fnmatch(name, pattern):
             obj = getattr(module, name)
-            if callable(obj) and not name.startswith('_'):
+            if callable(obj) and not name.startswith("_"):
                 # Replace with profiled version
                 profiled = profiler.profile(obj)
                 setattr(module, name, profiled)
                 wrapped_functions.append(name)
-    
+
     print(f"Profiling {len(wrapped_functions)} functions in {module_name}")
     print(f"Wrapped: {', '.join(wrapped_functions)}")
     print("\nRun your code now. Call get_profile_report() when done.")
-    
+
     return profiler
 
 
 class LineProfiler:
     """
     Line-by-line profiler for detailed analysis.
-    
+
     Note: This is a simplified version. For production use,
     consider using the line_profiler package.
     """
-    
+
     def __init__(self):
         self.timings = {}
-    
+
     def profile_lines(self, func: Callable) -> Callable:
         """Profile a function line by line."""
         import inspect
-        
+
         @wraps(func)
         def wrapper(*args, **kwargs):
             # Get source lines
             source_lines = inspect.getsourcelines(func)[0]
             line_times = {}
-            
+
             # This is a simplified implementation
             # Real line profiling requires bytecode instrumentation
             start_time = time.time()
             result = func(*args, **kwargs)
             end_time = time.time()
-            
+
             # Store timing
             func_name = func.__name__
             if func_name not in self.timings:
                 self.timings[func_name] = []
-            
-            self.timings[func_name].append({
-                'total_time': end_time - start_time,
-                'source': source_lines
-            })
-            
+
+            self.timings[func_name].append(
+                {"total_time": end_time - start_time, "source": source_lines}
+            )
+
             return result
-        
+
         return wrapper
-    
+
     def print_timings(self, func_name: str):
         """Print line timings for a function."""
         if func_name not in self.timings:
             print(f"No timings for {func_name}")
             return
-        
+
         timing = self.timings[func_name][-1]  # Most recent
         print(f"\nLine timings for {func_name}:")
         print(f"Total time: {timing['total_time']:.3f}s")
         print("\nSource code:")
-        for i, line in enumerate(timing['source']):
-            print(f"{i+1:4d}: {line.rstrip()}")
+        for i, line in enumerate(timing["source"]):
+            print(f"{i + 1:4d}: {line.rstrip()}")
 
 
 # Memory profiling utilities
@@ -268,6 +270,7 @@ def get_memory_usage():
     """Get current memory usage in MB."""
     try:
         import psutil
+
         process = psutil.Process()
         return process.memory_info().rss / 1024 / 1024
     except ImportError:
@@ -278,14 +281,14 @@ def get_memory_usage():
 def track_memory(name: str):
     """
     Track memory usage for a code block.
-    
+
     Example
     -------
     >>> with track_memory("data_loading"):
     ...     data = load_large_dataset()
     """
     start_mem = get_memory_usage()
-    
+
     try:
         yield
     finally:
@@ -294,4 +297,4 @@ def track_memory(name: str):
             print(f"\nMemory usage for '{name}':")
             print(f"Start: {start_mem:.1f} MB")
             print(f"End: {end_mem:.1f} MB")
-            print(f"Delta: {end_mem - start_mem:+.1f} MB")
+            print(f"Delta: {end_mem - start_mem:+.1f} MB")

scitex/bridge/__init__.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: ./src/scitex/bridge/__init__.py
+# Time-stamp: "2024-12-09 09:30:00 (ywatanabe)"
+"""
+SciTeX Bridge Module - Cross-module adapters and transformations.
+
+This module provides the official API for connecting SciTeX modules:
+- stats ↔ plt: Statistical results to plot annotations
+- stats ↔ vis: Statistical results to vis annotations
+- plt ↔ vis: Matplotlib figures to vis FigureModel
+
+Design Principles:
+- Bridge functions use only public APIs of each module
+- All transformations go through schema validation
+- Single source of truth for cross-module conventions
+- Protocol versioning for forward/backward compatibility
+
+Protocol Version: 1.0.0
+
+Coordinate Conventions:
+- plt bridge: Uses axes coordinates (0-1 normalized)
+- vis bridge: Uses data coordinates (actual x/y values)
+- See COORDINATE_SYSTEMS for full definitions
+
+Usage:
+    from scitex.bridge import (
+        # Protocol version
+        BRIDGE_PROTOCOL_VERSION,
+        check_protocol_compatibility,
+
+        # Stats to Plt
+        add_stat_to_axes,
+        extract_stats_from_axes,
+
+        # Stats to Vis
+        stat_result_to_annotation,
+        add_stats_to_figure_model,
+
+        # Plt to Vis
+        figure_to_vis_model,
+        axes_to_vis_axes,
+        tracking_to_plot_configs,
+    )
+"""
+
+# Stats ↔ Plt bridges
+from scitex.bridge._stats_plt import (
+    add_stat_to_axes,
+    extract_stats_from_axes,
+    format_stat_for_plot,
+)
+
+# Stats ↔ Vis bridges
+from scitex.bridge._stats_vis import (
+    stat_result_to_annotation,
+    add_stats_to_figure_model,
+    position_stat_annotation,
+)
+
+# Plt ↔ Vis bridges
+from scitex.bridge._plt_vis import (
+    figure_to_vis_model,
+    axes_to_vis_axes,
+    tracking_to_plot_configs,
+    collect_figure_data,
+)
+
+# High-level helpers
+from scitex.bridge._helpers import (
+    add_stats_from_results,
+)
+
+# Protocol versioning
+from scitex.bridge._protocol import (
+    BRIDGE_PROTOCOL_VERSION,
+    ProtocolInfo,
+    check_protocol_compatibility,
+    add_protocol_metadata,
+    extract_protocol_metadata,
+    COORDINATE_SYSTEMS,
+)
+
+__all__ = [
+    # Protocol
+    "BRIDGE_PROTOCOL_VERSION",
+    "ProtocolInfo",
+    "check_protocol_compatibility",
+    "add_protocol_metadata",
+    "extract_protocol_metadata",
+    "COORDINATE_SYSTEMS",
+    # Stats ↔ Plt
+    "add_stat_to_axes",
+    "extract_stats_from_axes",
+    "format_stat_for_plot",
+    # Stats ↔ Vis
+    "stat_result_to_annotation",
+    "add_stats_to_figure_model",
+    "position_stat_annotation",
+    # Plt ↔ Vis
+    "figure_to_vis_model",
+    "axes_to_vis_axes",
+    "tracking_to_plot_configs",
+    "collect_figure_data",
+    # High-level helpers
+    "add_stats_from_results",
+]
+
+
+# EOF

scitex/bridge/_helpers.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: ./src/scitex/bridge/_helpers.py
+# Time-stamp: "2024-12-09 11:00:00 (ywatanabe)"
+"""
+High-level helper functions for cross-module operations.
+
+These helpers provide a unified API for common workflows that span
+multiple modules, abstracting away backend-specific details.
+"""
+
+from typing import Union, List, Optional, Literal
+
+from scitex.schema import StatResult
+
+
+def add_stats_from_results(
+    target,
+    stat_results: Union[StatResult, List[StatResult]],
+    backend: Literal["auto", "plt", "vis"] = "auto",
+    format_style: str = "asterisk",
+    **kwargs,
+):
+    """
+    Add statistical results to a figure or axes, auto-detecting backend.
+
+    This is a high-level helper that works with both matplotlib axes
+    and vis FigureModel, choosing the appropriate bridge function.
+
+    Parameters
+    ----------
+    target : matplotlib.axes.Axes, scitex.plt.AxisWrapper, or FigureModel
+        The target to add statistics to
+    stat_results : StatResult or List[StatResult]
+        Statistical result(s) to add
+    backend : {"auto", "plt", "vis"}
+        Backend to use. "auto" detects from target type:
+        - matplotlib axes or scitex AxisWrapper → "plt"
+        - FigureModel → "vis"
+    format_style : str
+        Format style for stat text ("asterisk", "compact", "detailed", "publication")
+    **kwargs
+        Additional arguments passed to the backend-specific function:
+        - plt: passed to add_stat_to_axes (x, y, transform, etc.)
+        - vis: passed to add_stats_to_figure_model (axes_index, auto_position, etc.)
+
+    Returns
+    -------
+    target
+        The modified target (for chaining)
+
+    Examples
+    --------
+    >>> # With matplotlib axes
+    >>> fig, ax = plt.subplots()
+    >>> stat = create_stat_result("pearson", "r", 0.85, 0.001)
+    >>> add_stats_from_results(ax, stat)
+
+    >>> # With vis FigureModel
+    >>> model = FigureModel(width_mm=170, height_mm=120, axes=[{}])
+    >>> add_stats_from_results(model, [stat1, stat2], backend="vis")
+
+    Notes
+    -----
+    Coordinate conventions differ between backends:
+    - plt: uses axes coordinates (0-1 normalized) by default
+    - vis: uses data coordinates
+
+    For precise control, use the backend-specific functions directly:
+    - scitex.bridge.add_stat_to_axes (plt backend)
+    - scitex.bridge.add_stats_to_figure_model (vis backend)
+    """
+    # Normalize to list
+    if isinstance(stat_results, StatResult):
+        stat_results = [stat_results]
+
+    # Auto-detect backend
+    if backend == "auto":
+        backend = _detect_backend(target)
+
+    # Dispatch to appropriate function
+    if backend == "plt":
+        from scitex.bridge._stats_plt import add_stat_to_axes
+
+        for stat in stat_results:
+            add_stat_to_axes(target, stat, format_style=format_style, **kwargs)
+
+    elif backend == "vis":
+        from scitex.bridge._stats_vis import add_stats_to_figure_model
+
+        add_stats_to_figure_model(
+            target,
+            stat_results,
+            format_style=format_style,
+            **kwargs,
+        )
+
+    else:
+        raise ValueError(f"Unknown backend: {backend}. Use 'auto', 'plt', or 'vis'.")
+
+    return target
+
+
+def _detect_backend(target) -> Literal["plt", "vis"]:
+    """
+    Detect the appropriate backend from target type.
+
+    Parameters
+    ----------
+    target : any
+        The target object
+
+    Returns
+    -------
+    str
+        "plt" or "vis"
+    """
+    # Check for vis FigureModel
+    try:
+        from scitex.fig.model import FigureModel
+        if isinstance(target, FigureModel):
+            return "vis"
+    except ImportError:
+        pass
+
+    # Check for matplotlib axes
+    try:
+        import matplotlib.axes
+        if isinstance(target, matplotlib.axes.Axes):
+            return "plt"
+    except ImportError:
+        pass
+
+    # Check for scitex plt wrappers
+    if hasattr(target, "_axes_mpl"):
+        return "plt"
+    if hasattr(target, "_axes_scitex"):
+        return "plt"
+
+    # Default to plt (most common case)
+    return "plt"
+
+
+__all__ = [
+    "add_stats_from_results",
+]
+
+
+# EOF