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

scitex/decorators/_pandas_fn.py

@@ -54,9 +54,9 @@ def pandas_fn(func: Callable) -> Callable:
                 except:
                     # If list can't be converted to DataFrame, return as is
                     return data
-            elif hasattr(data, '__class__') and data.__class__.__name__ == 'Tensor':
+            elif hasattr(data, "__class__") and data.__class__.__name__ == "Tensor":
                 return pd.DataFrame(data.detach().cpu().numpy())
-            elif hasattr(data, '__class__') and data.__class__.__name__ == 'DataArray':
+            elif hasattr(data, "__class__") and data.__class__.__name__ == "DataArray":
                 return pd.DataFrame(data.values)
             elif isinstance(data, (int, float, str)):
                 # Don't convert scalars to DataFrames
@@ -73,6 +73,7 @@ def pandas_fn(func: Callable) -> Callable:
 
         # Skip strict assertion for certain types
         import pandas as pd
+
         validated_args = []
         for arg_index, arg in enumerate(converted_args):
             if isinstance(arg, pd.DataFrame):
@@ -80,7 +81,9 @@ def pandas_fn(func: Callable) -> Callable:
             elif isinstance(arg, (int, float, str, type(None), pd.Series)):
                 # Pass through scalars, strings, Series, and None unchanged
                 validated_args.append(arg)
-            elif isinstance(arg, list) and all(isinstance(item, pd.DataFrame) for item in arg):
+            elif isinstance(arg, list) and all(
+                isinstance(item, pd.DataFrame) for item in arg
+            ):
                 # List of DataFrames - pass through as is
                 validated_args.append(arg)
             else:
@@ -95,14 +98,19 @@ def pandas_fn(func: Callable) -> Callable:
 
         # Convert results back to original input types
         import pandas as pd
+
         if isinstance(results, pd.DataFrame):
             if original_object is not None:
                 if isinstance(original_object, list):
                     return results.values.tolist()
                 elif isinstance(original_object, np.ndarray):
                     return results.values
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'Tensor':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "Tensor"
+                ):
                     import torch
+
                     return torch.tensor(results.values)
                 elif isinstance(original_object, pd.Series):
                     return (
@@ -110,8 +118,12 @@ def pandas_fn(func: Callable) -> Callable:
                         if results.shape[1] > 0
                         else pd.Series()
                     )
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'DataArray':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "DataArray"
+                ):
                     import xarray as xr
+
                     return xr.DataArray(results.values)
             return results
 

scitex/decorators/_signal_fn.py

@@ -53,26 +53,40 @@ def signal_fn(func: Callable) -> Callable:
 
         # Convert results back to original input types
         import torch
+
         if isinstance(results, torch.Tensor):
             if original_object is not None:
                 if isinstance(original_object, list):
                     return results.detach().cpu().numpy().tolist()
                 elif isinstance(original_object, np.ndarray):
                     return results.detach().cpu().numpy()
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'DataFrame':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "DataFrame"
+                ):
                     import pandas as pd
+
                     return pd.DataFrame(results.detach().cpu().numpy())
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'Series':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "Series"
+                ):
                     import pandas as pd
+
                     return pd.Series(results.detach().cpu().numpy().flatten())
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'DataArray':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "DataArray"
+                ):
                     import xarray as xr
+
                     return xr.DataArray(results.detach().cpu().numpy())
             return results
 
         # Handle tuple returns (e.g., (signal, frequencies))
         elif isinstance(results, tuple):
             import torch
+
             converted_results = []
             for r in results:
                 if isinstance(r, torch.Tensor):

scitex/decorators/_torch_fn.py

@@ -20,54 +20,55 @@ from ._converters import _return_always, is_nested_decorator, to_torch
 
 def torch_fn(func: Callable) -> Callable:
     """Decorator for PyTorch function compatibility.
-    
+
     Automatically converts inputs to PyTorch tensors and handles various data types
     gracefully. Preserves the original input type in the output.
-    
+
     Features
     --------
     - Converts inputs to PyTorch tensors
-    - Preserves scalar parameters (int, float, bool, str) 
+    - Preserves scalar parameters (int, float, bool, str)
     - Preserves dimension tuples like dim=(0, 1)
     - Handles nested lists/tuples gracefully
     - Automatically converts axis to dim for torch functions
     - Applies device="cuda" if available
     - Returns output in same type as input (numpy->numpy, pandas->pandas, etc.)
-    
+
     Parameters
     ----------
     func : Callable
         The function to decorate
-        
+
     Returns
     -------
     Callable
         The decorated function
-        
+
     Examples
     --------
     >>> @torch_fn
     ... def mean_squared(x, dim=None):
     ...     return (x ** 2).mean(dim=dim)
-    >>> 
+    >>>
     >>> # Works with numpy arrays
     >>> result = mean_squared(np.array([1, 2, 3]))
-    >>> 
+    >>>
     >>> # Works with nested lists
     >>> result = mean_squared([[1, 2], [3, 4]])
-    >>> 
+    >>>
     >>> # Preserves dimension tuples
     >>> result = mean_squared(data, dim=(0, 1))
-    
+
     Notes
     -----
     For optimal performance with batch processing, apply torch_fn before batch_fn:
     @batch_fn
     @torch_fn
     def my_function(x): ...
-    
+
     Or use auto-ordering to handle this automatically.
     """
+
     @wraps(func)
     def wrapper(*args: _Any, **kwargs: _Any) -> _Any:
         # Skip conversion if already in a nested decorator context
@@ -88,6 +89,7 @@ def torch_fn(func: Callable) -> Callable:
         # Skip strict assertion for certain types that may not convert to tensors
         # Instead, convert what we can and pass through what we can't
         import torch
+
         validated_args = []
         for arg_index, arg in enumerate(converted_args):
             if isinstance(arg, torch.Tensor):
@@ -95,7 +97,9 @@ def torch_fn(func: Callable) -> Callable:
             elif isinstance(arg, (int, float, str, type(None))):
                 # Pass through scalars and strings unchanged
                 validated_args.append(arg)
-            elif isinstance(arg, list) and all(isinstance(item, torch.Tensor) for item in arg):
+            elif isinstance(arg, list) and all(
+                isinstance(item, torch.Tensor) for item in arg
+            ):
                 # List of tensors - pass through as is
                 validated_args.append(arg)
             else:
@@ -110,20 +114,33 @@ def torch_fn(func: Callable) -> Callable:
 
         # Convert results back to original input types
         import torch
+
         if isinstance(results, torch.Tensor):
             if original_object is not None:
                 if isinstance(original_object, list):
                     return results.detach().cpu().numpy().tolist()
                 elif isinstance(original_object, np.ndarray):
                     return results.detach().cpu().numpy()
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'DataFrame':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "DataFrame"
+                ):
                     import pandas as pd
+
                     return pd.DataFrame(results.detach().cpu().numpy())
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'Series':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "Series"
+                ):
                     import pandas as pd
+
                     return pd.Series(results.detach().cpu().numpy().flatten())
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'DataArray':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "DataArray"
+                ):
                     import xarray as xr
+
                     return xr.DataArray(results.detach().cpu().numpy())
             return results
 

scitex/decorators/_xarray_fn.py

@@ -43,11 +43,11 @@ def xarray_fn(func: Callable) -> Callable:
                 return xr.DataArray(data)
             elif isinstance(data, list):
                 return xr.DataArray(data)
-            elif hasattr(data, '__class__') and data.__class__.__name__ == 'Tensor':
+            elif hasattr(data, "__class__") and data.__class__.__name__ == "Tensor":
                 return xr.DataArray(data.detach().cpu().numpy())
-            elif hasattr(data, '__class__') and data.__class__.__name__ == 'DataFrame':
+            elif hasattr(data, "__class__") and data.__class__.__name__ == "DataFrame":
                 return xr.DataArray(data.values)
-            elif hasattr(data, '__class__') and data.__class__.__name__ == 'Series':
+            elif hasattr(data, "__class__") and data.__class__.__name__ == "Series":
                 return xr.DataArray(data.values)
             else:
                 return xr.DataArray([data])
@@ -57,29 +57,43 @@ def xarray_fn(func: Callable) -> Callable:
 
         # Assertion to ensure all args are converted to xarray DataArrays
         import xarray as xr
+
         for arg_index, arg in enumerate(converted_args):
-            assert isinstance(
-                arg, xr.DataArray
-            ), f"Argument {arg_index} not converted to DataArray: {type(arg)}"
+            assert isinstance(arg, xr.DataArray), (
+                f"Argument {arg_index} not converted to DataArray: {type(arg)}"
+            )
 
         results = func(*converted_args, **converted_kwargs)
 
         # Convert results back to original input types
         import xarray as xr
+
         if isinstance(results, xr.DataArray):
             if original_object is not None:
                 if isinstance(original_object, list):
                     return results.values.tolist()
                 elif isinstance(original_object, np.ndarray):
                     return results.values
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'Tensor':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "Tensor"
+                ):
                     import torch
+
                     return torch.tensor(results.values)
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'DataFrame':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "DataFrame"
+                ):
                     import pandas as pd
+
                     return pd.DataFrame(results.values)
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'Series':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "Series"
+                ):
                     import pandas as pd
+
                     return pd.Series(results.values.flatten())
             return results
 

scitex/dev/_analyze_code_flow.py

@@ -97,7 +97,6 @@ class CodeFlowAnalyzer:
         sequence_orig = self.sequence
 
         if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
-
             if node.name not in self.skip_functions:
                 # Track all function definitions
                 self.execution_flow.append((depth, node.name, self.sequence))
@@ -158,7 +157,6 @@ class CodeFlowAnalyzer:
         filtered_flow = []
 
         for depth, call, seq in self.execution_flow:
-
             # Start skipping when encountering private method
             if call.startswith(("_", "self._")):
                 skip_until_depth = depth

scitex/dev/plt/__init__.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/dev/plt/__init__.py
+
+"""
+Development plotting utilities with three API layers.
+
+All plotters follow signature: (plt, rng, ax=None) -> (fig, ax)
+
+API Layers:
+-----------
+stx_*  : SciTeX canonical (ArrayLike input, tracked)
+sns_*  : Seaborn-style (DataFrame input, tracked)
+mpl_*  : Matplotlib-style (raw args, tracked)
+
+Usage:
+    from scitex.dev.plt import PLOTTERS_STX, PLOTTERS_SNS, PLOTTERS_MPL
+
+    @stx.session
+    def main(plt=stx.INJECTED, rng_manager=stx.INJECTED):
+        rng = rng_manager("demo")
+
+        # stx_* API (ArrayLike)
+        for name, plotter in PLOTTERS_STX.items():
+            fig, ax = plotter(plt, rng)
+
+        # sns_* API (DataFrame)
+        for name, plotter in PLOTTERS_SNS.items():
+            fig, ax = plotter(plt, rng)
+
+        # mpl_* API (matplotlib-style)
+        for name, plotter in PLOTTERS_MPL.items():
+            fig, ax = plotter(plt, rng)
+"""
+
+# =============================================================================
+# stx_* API Layer - ArrayLike input (25 plotters)
+# =============================================================================
+from .plot_stx_line import plot_stx_line
+from .plot_stx_mean_std import plot_stx_mean_std
+from .plot_stx_mean_ci import plot_stx_mean_ci
+from .plot_stx_median_iqr import plot_stx_median_iqr
+from .plot_stx_shaded_line import plot_stx_shaded_line
+from .plot_stx_box import plot_stx_box
+from .plot_stx_violin import plot_stx_violin
+from .plot_stx_scatter import plot_stx_scatter
+from .plot_stx_bar import plot_stx_bar
+from .plot_stx_barh import plot_stx_barh
+from .plot_stx_errorbar import plot_stx_errorbar
+from .plot_stx_fill_between import plot_stx_fill_between
+from .plot_stx_kde import plot_stx_kde
+from .plot_stx_ecdf import plot_stx_ecdf
+from .plot_stx_heatmap import plot_stx_heatmap
+from .plot_stx_image import plot_stx_image
+from .plot_stx_imshow import plot_stx_imshow
+from .plot_stx_contour import plot_stx_contour
+from .plot_stx_raster import plot_stx_raster
+from .plot_stx_conf_mat import plot_stx_conf_mat
+from .plot_stx_joyplot import plot_stx_joyplot
+from .plot_stx_rectangle import plot_stx_rectangle
+from .plot_stx_fillv import plot_stx_fillv
+from .plot_stx_boxplot import plot_stx_boxplot
+from .plot_stx_violinplot import plot_stx_violinplot
+
+PLOTTERS_STX = {
+    "stx_line": plot_stx_line,
+    "stx_mean_std": plot_stx_mean_std,
+    "stx_mean_ci": plot_stx_mean_ci,
+    "stx_median_iqr": plot_stx_median_iqr,
+    "stx_shaded_line": plot_stx_shaded_line,
+    "stx_box": plot_stx_box,
+    "stx_violin": plot_stx_violin,
+    "stx_scatter": plot_stx_scatter,
+    "stx_bar": plot_stx_bar,
+    "stx_barh": plot_stx_barh,
+    "stx_errorbar": plot_stx_errorbar,
+    "stx_fill_between": plot_stx_fill_between,
+    "stx_kde": plot_stx_kde,
+    "stx_ecdf": plot_stx_ecdf,
+    "stx_heatmap": plot_stx_heatmap,
+    "stx_image": plot_stx_image,
+    "stx_imshow": plot_stx_imshow,
+    "stx_contour": plot_stx_contour,
+    "stx_raster": plot_stx_raster,
+    "stx_conf_mat": plot_stx_conf_mat,
+    "stx_joyplot": plot_stx_joyplot,
+    "stx_rectangle": plot_stx_rectangle,
+    "stx_fillv": plot_stx_fillv,
+    "stx_boxplot": plot_stx_boxplot,
+    "stx_violinplot": plot_stx_violinplot,
+}
+
+# =============================================================================
+# sns_* API Layer - DataFrame input (10 plotters)
+# =============================================================================
+from .plot_sns_boxplot import plot_sns_boxplot
+from .plot_sns_violinplot import plot_sns_violinplot
+from .plot_sns_barplot import plot_sns_barplot
+from .plot_sns_histplot import plot_sns_histplot
+from .plot_sns_kdeplot import plot_sns_kdeplot
+from .plot_sns_scatterplot import plot_sns_scatterplot
+from .plot_sns_lineplot import plot_sns_lineplot
+from .plot_sns_swarmplot import plot_sns_swarmplot
+from .plot_sns_stripplot import plot_sns_stripplot
+from .plot_sns_heatmap import plot_sns_heatmap
+
+PLOTTERS_SNS = {
+    "sns_boxplot": plot_sns_boxplot,
+    "sns_violinplot": plot_sns_violinplot,
+    "sns_barplot": plot_sns_barplot,
+    "sns_histplot": plot_sns_histplot,
+    "sns_kdeplot": plot_sns_kdeplot,
+    "sns_scatterplot": plot_sns_scatterplot,
+    "sns_lineplot": plot_sns_lineplot,
+    "sns_swarmplot": plot_sns_swarmplot,
+    "sns_stripplot": plot_sns_stripplot,
+    "sns_heatmap": plot_sns_heatmap,
+}
+
+# =============================================================================
+# mpl_* API Layer - Matplotlib-style input (26 plotters)
+# =============================================================================
+from .plot_mpl_plot import plot_mpl_plot
+from .plot_mpl_scatter import plot_mpl_scatter
+from .plot_mpl_bar import plot_mpl_bar
+from .plot_mpl_barh import plot_mpl_barh
+from .plot_mpl_hist import plot_mpl_hist
+from .plot_mpl_hist2d import plot_mpl_hist2d
+from .plot_mpl_hexbin import plot_mpl_hexbin
+from .plot_mpl_boxplot import plot_mpl_boxplot
+from .plot_mpl_violinplot import plot_mpl_violinplot
+from .plot_mpl_errorbar import plot_mpl_errorbar
+from .plot_mpl_step import plot_mpl_step
+from .plot_mpl_stem import plot_mpl_stem
+from .plot_mpl_fill import plot_mpl_fill
+from .plot_mpl_fill_between import plot_mpl_fill_between
+from .plot_mpl_stackplot import plot_mpl_stackplot
+from .plot_mpl_contour import plot_mpl_contour
+from .plot_mpl_contourf import plot_mpl_contourf
+from .plot_mpl_imshow import plot_mpl_imshow
+from .plot_mpl_pcolormesh import plot_mpl_pcolormesh
+from .plot_mpl_pie import plot_mpl_pie
+from .plot_mpl_eventplot import plot_mpl_eventplot
+from .plot_mpl_quiver import plot_mpl_quiver
+from .plot_mpl_axhline import plot_mpl_axhline
+from .plot_mpl_axvline import plot_mpl_axvline
+from .plot_mpl_axhspan import plot_mpl_axhspan
+from .plot_mpl_axvspan import plot_mpl_axvspan
+
+PLOTTERS_MPL = {
+    "mpl_plot": plot_mpl_plot,
+    "mpl_scatter": plot_mpl_scatter,
+    "mpl_bar": plot_mpl_bar,
+    "mpl_barh": plot_mpl_barh,
+    "mpl_hist": plot_mpl_hist,
+    "mpl_hist2d": plot_mpl_hist2d,
+    "mpl_hexbin": plot_mpl_hexbin,
+    "mpl_boxplot": plot_mpl_boxplot,
+    "mpl_violinplot": plot_mpl_violinplot,
+    "mpl_errorbar": plot_mpl_errorbar,
+    "mpl_step": plot_mpl_step,
+    "mpl_stem": plot_mpl_stem,
+    "mpl_fill": plot_mpl_fill,
+    "mpl_fill_between": plot_mpl_fill_between,
+    "mpl_stackplot": plot_mpl_stackplot,
+    "mpl_contour": plot_mpl_contour,
+    "mpl_contourf": plot_mpl_contourf,
+    "mpl_imshow": plot_mpl_imshow,
+    "mpl_pcolormesh": plot_mpl_pcolormesh,
+    "mpl_pie": plot_mpl_pie,
+    "mpl_eventplot": plot_mpl_eventplot,
+    "mpl_quiver": plot_mpl_quiver,
+    "mpl_axhline": plot_mpl_axhline,
+    "mpl_axvline": plot_mpl_axvline,
+    "mpl_axhspan": plot_mpl_axhspan,
+    "mpl_axvspan": plot_mpl_axvspan,
+}
+
+# =============================================================================
+# Combined registry
+# =============================================================================
+PLOTTERS = {**PLOTTERS_STX, **PLOTTERS_SNS, **PLOTTERS_MPL}
+
+
+def get_plotter(name):
+    """Get a plotter function by name."""
+    if name in PLOTTERS:
+        return PLOTTERS[name]
+    raise KeyError(f"Unknown plotter: {name}. Available: {list(PLOTTERS.keys())}")
+
+
+def list_plotters():
+    """List all available plotter names."""
+    return list(PLOTTERS.keys())
+
+
+__all__ = [
+    # stx_* plotters (25)
+    "plot_stx_line",
+    "plot_stx_mean_std",
+    "plot_stx_mean_ci",
+    "plot_stx_median_iqr",
+    "plot_stx_shaded_line",
+    "plot_stx_box",
+    "plot_stx_violin",
+    "plot_stx_scatter",
+    "plot_stx_bar",
+    "plot_stx_barh",
+    "plot_stx_errorbar",
+    "plot_stx_fill_between",
+    "plot_stx_kde",
+    "plot_stx_ecdf",
+    "plot_stx_heatmap",
+    "plot_stx_image",
+    "plot_stx_imshow",
+    "plot_stx_contour",
+    "plot_stx_raster",
+    "plot_stx_conf_mat",
+    "plot_stx_joyplot",
+    "plot_stx_rectangle",
+    "plot_stx_fillv",
+    "plot_stx_boxplot",
+    "plot_stx_violinplot",
+    # sns_* plotters (10)
+    "plot_sns_boxplot",
+    "plot_sns_violinplot",
+    "plot_sns_barplot",
+    "plot_sns_histplot",
+    "plot_sns_kdeplot",
+    "plot_sns_scatterplot",
+    "plot_sns_lineplot",
+    "plot_sns_swarmplot",
+    "plot_sns_stripplot",
+    "plot_sns_heatmap",
+    # mpl_* plotters (26)
+    "plot_mpl_plot",
+    "plot_mpl_scatter",
+    "plot_mpl_bar",
+    "plot_mpl_barh",
+    "plot_mpl_hist",
+    "plot_mpl_hist2d",
+    "plot_mpl_hexbin",
+    "plot_mpl_boxplot",
+    "plot_mpl_violinplot",
+    "plot_mpl_errorbar",
+    "plot_mpl_step",
+    "plot_mpl_stem",
+    "plot_mpl_fill",
+    "plot_mpl_fill_between",
+    "plot_mpl_stackplot",
+    "plot_mpl_contour",
+    "plot_mpl_contourf",
+    "plot_mpl_imshow",
+    "plot_mpl_pcolormesh",
+    "plot_mpl_pie",
+    "plot_mpl_eventplot",
+    "plot_mpl_quiver",
+    "plot_mpl_axhline",
+    "plot_mpl_axvline",
+    "plot_mpl_axhspan",
+    "plot_mpl_axvspan",
+    # Registries
+    "PLOTTERS_STX",
+    "PLOTTERS_SNS",
+    "PLOTTERS_MPL",
+    "PLOTTERS",
+    # Helper functions
+    "get_plotter",
+    "list_plotters",
+]
+
+# EOF

scitex/dev/plt/plot_mpl_axhline.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: plot_mpl_axhline.py - mpl_axhline demo
+
+"""mpl_axhline: horizontal line."""
+
+import numpy as np
+
+
+def plot_mpl_axhline(plt, rng, ax=None):
+    """mpl_axhline - horizontal line.
+
+    Demonstrates: ax.mpl_axhline() - identical to ax.axhline()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax._fig_scitex
+
+    ax.plot(rng.uniform(0, 10, 20))
+    ax.mpl_axhline(y=5, color='r', linestyle='--', label='threshold')
+    ax.set_xyt("X", "Y", "mpl_axhline")
+    if hasattr(ax, 'legend') and ax.get_legend_handles_labels()[0]:
+        ax.legend()
+    return fig, ax
+
+
+# EOF

scitex/dev/plt/plot_mpl_axhspan.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: plot_mpl_axhspan.py - mpl_axhspan demo
+
+"""mpl_axhspan: horizontal span."""
+
+import numpy as np
+
+
+def plot_mpl_axhspan(plt, rng, ax=None):
+    """mpl_axhspan - horizontal span.
+
+    Demonstrates: ax.mpl_axhspan() - identical to ax.axhspan()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax._fig_scitex
+
+    ax.plot(rng.uniform(0, 10, 20))
+    ax.mpl_axhspan(3, 7, alpha=0.3, color='yellow', label='range')
+    ax.set_xyt("X", "Y", "mpl_axhspan")
+    if hasattr(ax, 'legend') and ax.get_legend_handles_labels()[0]:
+        ax.legend()
+    return fig, ax
+
+
+# EOF

scitex/dev/plt/plot_mpl_axvline.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: plot_mpl_axvline.py - mpl_axvline demo
+
+"""mpl_axvline: vertical line."""
+
+import numpy as np
+
+
+def plot_mpl_axvline(plt, rng, ax=None):
+    """mpl_axvline - vertical line.
+
+    Demonstrates: ax.mpl_axvline() - identical to ax.axvline()
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.get_figure() if hasattr(ax, "get_figure") else ax._fig_scitex
+
+    ax.plot(rng.uniform(0, 10, 20))
+    ax.mpl_axvline(x=10, color='r', linestyle='--', label='event')
+    ax.set_xyt("X", "Y", "mpl_axvline")
+    if hasattr(ax, 'legend') and ax.get_legend_handles_labels()[0]:
+        ax.legend()
+    return fig, ax
+
+
+# EOF