scitex 2.1.3__py3-none-any.whl → 2.3.0__py3-none-any.whl

scitex/io/utils/h5_to_zarr.py

@@ -35,7 +35,7 @@ from typing import Optional, Union, Dict, Any, List, Tuple
 import warnings
 from tqdm import tqdm
 
-from ...errors import (
+from scitex.errors import (
     IOError as SciTeXIOError,
     FileFormatError,
     PathNotFoundError,

scitex/linalg/_distance.py

@@ -6,8 +6,8 @@
 import numpy as np
 import scipy.spatial.distance as _distance
 
-from ..decorators._numpy_fn import numpy_fn
-from ..decorators._wrap import wrap
+from scitex.decorators._numpy_fn import numpy_fn
+from scitex.decorators._wrap import wrap
 
 
 @numpy_fn

scitex/linalg/_geometric_median.py

@@ -10,7 +10,7 @@ This script does XYZ.
 
 import torch
 from geom_median.torch import compute_geometric_median
-from ..decorators import torch_fn
+from scitex.decorators import torch_fn
 
 # @torch_fn
 # def geometric_median(xx, dim=-1):

scitex/logging/README.md

@@ -231,7 +231,7 @@ logger.success("Extra emphasis", c="light_green")  # Light green
 
 **Available Colors**:
 - Basic: `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`, `grey`
-- Light variants: `light_red`, `light_green`, `light_yellow`, `light_blue`, `light_magenta`, `light_cyan`
+- Light variants: `light_red`, `light_green`, `light_yellow`, `lightblue`, `light_magenta`, `light_cyan`
 
 **Use Cases**:
 - Highlight critical information in INFO logs: `logger.info("msg", c="red")`

scitex/logging/_Tee.py

@@ -35,8 +35,8 @@ import re
 import sys
 from typing import Any, TextIO
 
-from ..str._clean_path import clean_path
-from ..str._printc import printc
+from scitex.str._clean_path import clean_path
+from scitex.str._printc import printc
 
 """Functions & Classes"""
 def _get_logger():

scitex/logging/_formatters.py

@@ -60,7 +60,7 @@ class SciTeXConsoleFormatter(logging.Formatter):
         "light_red": "\033[91m",
         "light_green": "\033[92m",
         "light_yellow": "\033[93m",
-        "light_blue": "\033[94m",
+        "lightblue": "\033[94m",
         "light_magenta": "\033[95m",
         "light_cyan": "\033[96m",
     }
@@ -90,7 +90,14 @@ class SciTeXConsoleFormatter(logging.Formatter):
         # Use parent formatter to apply template
         formatted = super().format(record)
 
-        if hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
+        # Check if we can use colors (stdout is a tty and not closed)
+        try:
+            use_colors = hasattr(sys.stdout, "isatty") and sys.stdout.isatty()
+        except ValueError:
+            # stdout/stderr is closed
+            use_colors = False
+
+        if use_colors:
             # Check for custom color override
             custom_color = getattr(record, "color", None)
 

scitex/logging/_logger.py

@@ -16,6 +16,7 @@ __FILE__ = __file__
 """Enhanced logger class for SciTeX."""
 
 import logging
+import pprint as _pprint
 
 from ._levels import FAIL, SUCCESS
 
@@ -31,10 +32,46 @@ class SciTeXLogger(logging.Logger):
         sep=None,
         n_sep=40,
         c=None,
+        pprint=False,
         *args,
         **kwargs,
     ):
-        """Internal method to log with indent, separator, and color support."""
+        """Internal method to log with indent, separator, color, and pprint support.
+
+        Args:
+            level: Logging level
+            message: Message to log
+            indent: Number of spaces to indent
+            sep: Separator character (e.g., '=', '-')
+            n_sep: Number of separator characters
+            c: Color code
+            pprint: If True, format message using pprint for better readability
+            *args: Additional arguments
+            **kwargs: Additional keyword arguments
+        """
+        # Apply pprint formatting if requested
+        if pprint:
+            # If message is a string, keep it as is
+            # Otherwise, format it with pprint
+            if not isinstance(message, str):
+                # Convert DotDict to regular dict for better pprint support
+                # Exclude private keys (starting with _) by default
+                if hasattr(message, 'to_dict'):
+                    message = message.to_dict(include_private=False)
+                message = _pprint.pformat(message, indent=2, width=80, compact=False)
+
+            # For multi-line messages, indent all lines after the first
+            # to align with the log level prefix (e.g., "INFO: ") plus any indent
+            if '\n' in message:
+                lines = message.split('\n')
+                # Calculate the indent needed:
+                # - 6 chars for "INFO: " or "ERRO: " prefix
+                # - Plus the indent parameter for additional spacing
+                total_indent = 6 + indent
+                prefix_indent = ' ' * total_indent
+                # Join lines with proper indentation
+                message = lines[0] + '\n' + '\n'.join(prefix_indent + line for line in lines[1:])
+
         # Add separator lines if requested
         if sep is not None:
             separator = sep * n_sep
@@ -51,27 +88,27 @@ class SciTeXLogger(logging.Logger):
         self._log(level, message, args, **kwargs)
 
     def debug(
-        self, message, *args, indent=0, sep=None, n_sep=40, c=None, **kwargs
+        self, message, *args, indent=0, sep=None, n_sep=40, c=None, pprint=False, **kwargs
     ):
-        """Log a debug message with optional indent, separator, and color."""
+        """Log a debug message with optional indent, separator, color, and pprint."""
         if self.isEnabledFor(logging.DEBUG):
             self._log_with_indent(
-                logging.DEBUG, message, indent, sep, n_sep, c, *args, **kwargs
+                logging.DEBUG, message, indent, sep, n_sep, c, pprint, *args, **kwargs
             )
 
     def info(
-        self, message, *args, indent=0, sep=None, n_sep=40, c=None, **kwargs
+        self, message, *args, indent=0, sep=None, n_sep=40, c=None, pprint=False, **kwargs
     ):
-        """Log an info message with optional indent, separator, and color."""
+        """Log an info message with optional indent, separator, color, and pprint."""
         if self.isEnabledFor(logging.INFO):
             self._log_with_indent(
-                logging.INFO, message, indent, sep, n_sep, c, *args, **kwargs
+                logging.INFO, message, indent, sep, n_sep, c, pprint, *args, **kwargs
             )
 
     def warning(
-        self, message, *args, indent=0, sep=None, n_sep=40, c=None, **kwargs
+        self, message, *args, indent=0, sep=None, n_sep=40, c=None, pprint=False, **kwargs
     ):
-        """Log a warning message with optional indent, separator, and color."""
+        """Log a warning message with optional indent, separator, color, and pprint."""
         if self.isEnabledFor(logging.WARNING):
             self._log_with_indent(
                 logging.WARNING,
@@ -80,23 +117,24 @@ class SciTeXLogger(logging.Logger):
                 sep,
                 n_sep,
                 c,
+                pprint,
                 *args,
                 **kwargs,
             )
 
     def error(
-        self, message, *args, indent=0, sep=None, n_sep=40, c=None, **kwargs
+        self, message, *args, indent=0, sep=None, n_sep=40, c=None, pprint=False, **kwargs
     ):
-        """Log an error message with optional indent, separator, and color."""
+        """Log an error message with optional indent, separator, color, and pprint."""
         if self.isEnabledFor(logging.ERROR):
             self._log_with_indent(
-                logging.ERROR, message, indent, sep, n_sep, c, *args, **kwargs
+                logging.ERROR, message, indent, sep, n_sep, c, pprint, *args, **kwargs
             )
 
     def critical(
-        self, message, *args, indent=0, sep=None, n_sep=40, c=None, **kwargs
+        self, message, *args, indent=0, sep=None, n_sep=40, c=None, pprint=False, **kwargs
     ):
-        """Log a critical message with optional indent, separator, and color."""
+        """Log a critical message with optional indent, separator, color, and pprint."""
         if self.isEnabledFor(logging.CRITICAL):
             self._log_with_indent(
                 logging.CRITICAL,
@@ -105,26 +143,27 @@ class SciTeXLogger(logging.Logger):
                 sep,
                 n_sep,
                 c,
+                pprint,
                 *args,
                 **kwargs,
             )
 
     def success(
-        self, message, *args, indent=0, sep=None, n_sep=40, c=None, **kwargs
+        self, message, *args, indent=0, sep=None, n_sep=40, c=None, pprint=False, **kwargs
     ):
-        """Log a success message with optional indent, separator, and color."""
+        """Log a success message with optional indent, separator, color, and pprint."""
         if self.isEnabledFor(SUCCESS):
             self._log_with_indent(
-                SUCCESS, message, indent, sep, n_sep, c, *args, **kwargs
+                SUCCESS, message, indent, sep, n_sep, c, pprint, *args, **kwargs
             )
 
     def fail(
-        self, message, *args, indent=0, sep=None, n_sep=40, c=None, **kwargs
+        self, message, *args, indent=0, sep=None, n_sep=40, c=None, pprint=False, **kwargs
     ):
-        """Log a failure message with optional indent, separator, and color."""
+        """Log a failure message with optional indent, separator, color, and pprint."""
         if self.isEnabledFor(FAIL):
             self._log_with_indent(
-                FAIL, message, indent, sep, n_sep, c, *args, **kwargs
+                FAIL, message, indent, sep, n_sep, c, pprint, *args, **kwargs
             )
 
     def to(self, file_path, level=None, mode="w"):

scitex/ml/__init__.py

@@ -11,7 +11,7 @@ Usage:
 """
 
 # Re-export everything from ai module
-from ..ai import *  # noqa: F403,F401
+from scitex.ai import *  # noqa: F403,F401
 
 __all__ = [
     "classification",

scitex/nn/_Filters.py

@@ -36,12 +36,12 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
-from ..dsp.utils import build_bandpass_filters, init_bandpass_filters
-from ..dsp.utils._ensure_3d import ensure_3d
-from ..dsp.utils._ensure_even_len import ensure_even_len
-from ..dsp.utils._zero_pad import zero_pad
-from ..dsp.utils.filter import design_filter
-from ..gen._to_even import to_even
+from scitex.dsp.utils import build_bandpass_filters, init_bandpass_filters
+from scitex.dsp.utils._ensure_3d import ensure_3d
+from scitex.dsp.utils._ensure_even_len import ensure_even_len
+from scitex.dsp.utils._zero_pad import zero_pad
+from scitex.dsp.utils.filter import design_filter
+from scitex.gen._to_even import to_even
 
 
 class BaseFilter1D(nn.Module):

scitex/nn/_Spectrogram.py

@@ -8,7 +8,7 @@ import torch.nn.functional as F
 import numpy as np
 import matplotlib.pyplot as plt
 import scitex
-from ..decorators import numpy_fn, torch_fn
+from scitex.decorators import numpy_fn, torch_fn
 
 
 class Spectrogram(nn.Module):

scitex/nn/_Wavelet.py

@@ -13,8 +13,8 @@ import numpy as np
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from ..gen._to_even import to_even
-from ..gen._to_odd import to_odd
+from scitex.gen._to_even import to_even
+from scitex.gen._to_odd import to_odd
 
 
 class Wavelet(nn.Module):

scitex/pd/_force_df.py

@@ -12,7 +12,7 @@ __DIR__ = os.path.dirname(__FILE__)
 import numpy as np
 import pandas as pd
 
-from ..types import is_listed_X
+from scitex.types import is_listed_X
 
 
 def force_df(data, filler=np.nan):

scitex/plt/README.md

@@ -1580,7 +1580,7 @@ manuscript.generate_submission_package()  # Journal-ready submission
 ## Best Practices
 
 1. **Always use tracking** - It's enabled by default, don't disable it
-2. **Assign unique IDs** - Use the `id` parameter for easy data identification  
+2. **Assign unique IDs** - Use the `id` parameter for easy data identification
 3. **Separate styling from metadata** - Use `set_xyt()` for labels, `set_meta()` for scientific metadata
 4. **Structure experimental details** - Use dictionaries for machine-readable experimental parameters
 5. **Include comprehensive keywords** - Enable AI agents to categorize and process figures automatically
@@ -1590,6 +1590,31 @@ manuscript.generate_submission_package()  # Journal-ready submission
 9. **Use figure-level metadata** - Apply `set_figure_meta()` for multi-panel comprehensive descriptions
 10. **Export YAML for reproducibility** - All metadata automatically preserved for AI agent processing
 
+### ⚠️ File Format Best Practices
+
+**NEVER use JPEG for scientific figures!**
+
+JPEG uses lossy compression that creates visible artifacts around text, lines, and sharp edges.
+
+**Use these formats:**
+- **PNG** ✅ Lossless raster (perfect for figures with text/lines)
+- **PDF** ✅ Vector format (infinite zoom, required by journals)
+- **JPEG** ❌ NEVER for scientific plots (only for photographs)
+
+```python
+# Correct - Publication-ready formats
+scitex.io.save(fig, 'figure.png', dpi=300, auto_crop=True)  # Lossless
+scitex.io.save(fig, 'figure.pdf')                           # Vector
+
+# Wrong - Creates artifacts around text and lines
+# scitex.io.save(fig, 'figure.jpg')  # ❌ NEVER do this!
+```
+
+**Auto-cropping** is enabled by default and preserves:
+- Image quality (PNG: lossless, PDF: vector)
+- DPI metadata (300 DPI for publication)
+- Scitex metadata (version, style, dimensions, padding, etc.)
+
 ### SciTeX Ecosystem Workflow
 ```python
 # Optimal workflow for AI-powered scientific automation

scitex/plt/__init__.py

@@ -9,14 +9,61 @@ __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 """Scitex plt module."""
 
+# Register Arial fonts eagerly (before lazy imports)
+import matplotlib.font_manager as fm
+import matplotlib as mpl
+
+_arial_enabled = False
+try:
+    fm.findfont("Arial", fallback_to_default=False)
+    _arial_enabled = True
+except Exception:
+    # Search for Arial font files and register them
+    arial_paths = [
+        f for f in fm.findSystemFonts()
+        if os.path.basename(f).lower().startswith("arial")
+    ]
+
+    if arial_paths:
+        for path in arial_paths:
+            try:
+                fm.fontManager.addfont(path)
+            except Exception:
+                pass
+
+        # Verify Arial is now available
+        try:
+            fm.findfont("Arial", fallback_to_default=False)
+            _arial_enabled = True
+        except Exception:
+            pass
+
+# Configure matplotlib to use Arial if available
+if _arial_enabled:
+    mpl.rcParams["font.family"] = "Arial"
+    mpl.rcParams["font.sans-serif"] = ["Arial", "Helvetica", "DejaVu Sans", "Liberation Sans"]
+else:
+    # Warn about missing Arial
+    try:
+        from scitex.logging import getLogger
+        _logger = getLogger(__name__)
+        _logger.warning(
+            "Arial font not found. Using fallback fonts (Helvetica/DejaVu Sans). "
+            "For publication figures with Arial: sudo apt-get install ttf-mscorefonts-installer && fc-cache -fv"
+        )
+    except:
+        pass  # Skip warning if logging not available
+
 from ._tpl import termplot
 from . import color
 from . import utils
 from . import ax
+from . import presets
 
 # Lazy import for subplots to avoid circular dependencies
 _subplots = None
 _figure = None
+_crop = None
 
 def subplots(*args, **kwargs):
     """Lazy-loaded subplots function."""
@@ -38,13 +85,56 @@ def figure(*args, **kwargs):
         _figure = _figure_func
     return _figure(*args, **kwargs)
 
+def crop(input_path, output_path=None, margin=12, overwrite=False, verbose=False):
+    """
+    Auto-crop a figure to its content area.
+
+    This function automatically detects the content area of a saved figure
+    and crops it, removing excess whitespace. Designed for publication figures
+    created with large margins.
+
+    Parameters
+    ----------
+    input_path : str
+        Path to the input image
+    output_path : str, optional
+        Path to save cropped image. If None and overwrite=True, overwrites input.
+        If None and overwrite=False, adds '_cropped' suffix.
+    margin : int, optional
+        Margin in pixels around content (default: 12, ~1mm at 300 DPI)
+    overwrite : bool, optional
+        Overwrite input file (default: False)
+    verbose : bool, optional
+        Print detailed information (default: False)
+
+    Returns
+    -------
+    str
+        Path to the saved cropped image
+
+    Examples
+    --------
+    >>> fig, ax = stx.plt.subplots(**stx.plt.presets.SCITEX_STYLE)
+    >>> ax.plot([1, 2, 3], [1, 2, 3])
+    >>> stx.io.save(fig, "figure.png")
+    >>> stx.plt.crop("figure.png", "figure_cropped.png")  # 1mm margin
+    """
+    global _crop
+    if _crop is None:
+        from .utils._crop import crop as _crop_func
+        _crop = _crop_func
+    return _crop(input_path, output_path, margin, overwrite, verbose)
+
 def tight_layout(**kwargs):
     """
-    Wrapper for matplotlib.pyplot.tight_layout that suppresses the layout change warning.
+    Wrapper for matplotlib.pyplot.tight_layout that handles colorbar layout compatibility.
+
+    This function calls tight_layout on the current figure and gracefully handles:
+    1. UserWarning: "The figure layout has changed to tight" - informational only
+    2. RuntimeError: Colorbar layout incompatibility - occurs when colorbars exist with old engine
 
-    This function calls tight_layout on the current figure and suppresses the common
-    UserWarning: "The figure layout has changed to tight" which is informational
-    and typically not actionable.
+    When a colorbar layout error occurs, the function silently continues as the layout
+    is still functional even if the engine cannot be changed.
 
     Parameters
     ----------
@@ -56,7 +146,14 @@ def tight_layout(**kwargs):
 
     with warnings.catch_warnings():
         warnings.filterwarnings("ignore", message="The figure layout has changed to tight")
-        plt.tight_layout(**kwargs)
+        try:
+            plt.tight_layout(**kwargs)
+        except RuntimeError as e:
+            # Silently handle colorbar layout engine incompatibility
+            # This occurs when colorbars were created before tight_layout is called
+            # The layout is still usable, so we can safely ignore this error
+            if "Colorbar layout" not in str(e):
+                raise
 
 
 def colorbar(mappable=None, cax=None, ax=None, **kwargs):
@@ -109,6 +206,7 @@ __all__ = [
     "tight_layout",
     "utils",
     "color",
+    "presets",
 ]
 
 def __getattr__(name):

scitex/plt/_subplots/_AxesWrapper.py

@@ -127,7 +127,8 @@ class AxesWrapper:
             array_compatible[idx] = ax
         return array_compatible.reshape(self._axes_scitex.shape)
 
-    def legend(self, loc="upper left"):
+    def legend(self, loc="best"):
+        """Add legend to all axes with 'best' automatic placement by default."""
         return [ax.legend(loc=loc) for ax in self._axes_scitex.flat]
 
     @property

scitex/plt/_subplots/_AxisWrapperMixins/_AdjustmentMixin.py

@@ -60,7 +60,7 @@ class AdjustmentMixin:
             tight_layout=tight_layout
         )
 
-    def legend(self, *args, loc: str = "upper left", **kwargs) -> None:
+    def legend(self, *args, loc: str = "best", check_overlap: bool = False, **kwargs) -> None:
         """Places legend at specified location, with support for outside positions.
 
         Parameters
@@ -68,13 +68,18 @@ class AdjustmentMixin:
         *args : tuple
             Positional arguments (handles, labels) as in matplotlib
         loc : str
-            Legend position. Standard matplotlib positions plus:
+            Legend position. Default is "best" (matplotlib auto-placement).
+            Standard matplotlib positions plus:
+            - "best": Matplotlib automatic placement (default)
             - "outer": Automatically place legend outside plot area (right side)
             - "separate": Save legend as a separate figure file
             - upper/lower/center variants: e.g. "upper right out", "lower left out"
             - directional shortcuts: "right", "left", "upper", "lower"
             - center variants: "center right out", "center left out"
             - alternative formats: "right upper out", "left lower out" etc.
+        check_overlap : bool
+            If True, checks for overlap between legend and data after placement.
+            Issues warning with suggestion if significant overlap detected.
         **kwargs : dict
             Additional keyword arguments passed to legend()
             For "separate": can include 'filename' (default: 'legend.png')
@@ -202,10 +207,94 @@ class AdjustmentMixin:
             "lower out": ("upper center", (0.5, -0.25)),
         }
 
+        # Place the legend
         if loc in outside_positions:
             location, bbox = outside_positions[loc]
-            return self._axis_mpl.legend(*args, loc=location, bbox_to_anchor=bbox, **kwargs)
-        return self._axis_mpl.legend(*args, loc=loc, **kwargs)
+            legend_obj = self._axis_mpl.legend(*args, loc=location, bbox_to_anchor=bbox, **kwargs)
+        else:
+            legend_obj = self._axis_mpl.legend(*args, loc=loc, **kwargs)
+
+        # Check for overlap if requested
+        if check_overlap and legend_obj is not None:
+            self._check_legend_overlap(legend_obj)
+
+        return legend_obj
+
+    def _check_legend_overlap(self, legend_obj):
+        """Check if legend overlaps with plotted data and issue warning if needed.
+
+        Parameters
+        ----------
+        legend_obj : matplotlib.legend.Legend
+            The legend object to check for overlap
+        """
+        import warnings
+        import matplotlib.transforms as transforms
+
+        try:
+            # Get the legend's bounding box in display coordinates
+            fig = self._axis_mpl.get_figure()
+            fig.canvas.draw()  # Force draw to get accurate bounding boxes
+
+            legend_bbox = legend_obj.get_window_extent(fig.canvas.get_renderer())
+
+            # Convert to axis coordinates for easier comparison
+            inv_transform = self._axis_mpl.transData.inverted()
+            legend_bbox_data = legend_bbox.transformed(inv_transform)
+
+            # Get data bounding boxes for all artists (lines, scatter, etc.)
+            data_bboxes = []
+
+            for line in self._axis_mpl.get_lines():
+                if line.get_visible():
+                    try:
+                        data = line.get_xydata()
+                        if len(data) > 0:
+                            data_bboxes.append(data)
+                    except:
+                        pass
+
+            for collection in self._axis_mpl.collections:
+                if collection.get_visible():
+                    try:
+                        offsets = collection.get_offsets()
+                        if len(offsets) > 0:
+                            data_bboxes.append(offsets)
+                    except:
+                        pass
+
+            # Check for overlap
+            if data_bboxes:
+                import numpy as np
+                all_data = np.vstack(data_bboxes)
+
+                # Count how many data points fall within legend bbox
+                x_overlap = (all_data[:, 0] >= legend_bbox_data.x0) & (all_data[:, 0] <= legend_bbox_data.x1)
+                y_overlap = (all_data[:, 1] >= legend_bbox_data.y0) & (all_data[:, 1] <= legend_bbox_data.y1)
+                overlap_points = np.sum(x_overlap & y_overlap)
+
+                # Calculate overlap percentage
+                overlap_pct = (overlap_points / len(all_data)) * 100
+
+                # Warn if significant overlap (>5% of data points)
+                if overlap_pct > 5:
+                    warnings.warn(
+                        f"Legend overlaps with {overlap_pct:.1f}% of data points. "
+                        f"Consider using:\n"
+                        f"  - ax.legend(loc='outer')  # Place outside plot area\n"
+                        f"  - ax.legend(loc='separate')  # Save as separate file\n"
+                        f"  - Manually adjust with loc='upper left', 'lower right', etc.",
+                        UserWarning,
+                        stacklevel=3
+                    )
+                    return True  # Overlap detected
+
+        except Exception as e:
+            # Silently fail if overlap detection doesn't work
+            # (Some plot types may not support this)
+            pass
+
+        return False  # No significant overlap
 
     def set_xyt(
         self,

scitex/plt/_subplots/_AxisWrapperMixins/_MatplotlibPlotMixin.py

@@ -17,8 +17,8 @@ import numpy as np
 import pandas as pd
 from scipy.stats import gaussian_kde
 
-from ....pd import to_xyz
-from ....types import ArrayLike
+from scitex.pd import to_xyz
+from scitex.types import ArrayLike
 
 
 class MatplotlibPlotMixin:
@@ -92,15 +92,25 @@ class MatplotlibPlotMixin:
 
         # Plotting with pure matplotlib methods under non-tracking context
         with self._no_tracking():
+            # Get line width from kwargs or use default (0.2mm for KDE)
+            from scitex.plt.utils import mm_to_pt
+            if 'linewidth' not in kwargs and 'lw' not in kwargs:
+                kwargs['linewidth'] = mm_to_pt(0.2)  # Default 0.2mm for KDE
+
+            # Set default color to black (customizable via color kwarg)
+            if 'color' not in kwargs and 'c' not in kwargs:
+                kwargs['color'] = 'black'
+
             # Filled Line
             if fill:
                 self._axis_mpl.fill_between(
                     xx,
                     density,
+                    **kwargs,
                 )
             # Simple Line
             else:
-                self._axis_mpl.plot(xx, density)
+                self._axis_mpl.plot(xx, density, **kwargs)
 
         # Tracking
         tracked_dict = {