aptapy 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

aptapy/_version.py

@@ -1 +1 @@
-__version__ = "0.1.1"
+__version__ = "0.2.0"

aptapy/hist.py

@@ -0,0 +1,226 @@
+# Copyright (C) 2025 Luca Baldini (luca.baldini@pi.infn.it)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Histogram facilities.
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Sequence
+
+import numpy as np
+
+from .plotting import matplotlib, plt, setup_axes
+from .typing_ import ArrayLike
+
+
+class AbstractHistogram(ABC):
+
+    """Abstract base class for an n-dimensional histogram.
+
+    Arguments
+    ---------
+    edges : n-dimensional sequence of arrays
+        the bin edges on the different axes.
+
+    labels : sequence of strings
+        the text labels for the different axes.
+    """
+
+    DEFAULT_PLOT_OPTIONS = {}
+
+    def __init__(self, edges: Sequence[np.ndarray], labels: List[str]) -> None:
+        """Constructor.
+        """
+        # Edges are fixed once and forever, so we create a copy. Also, no matter
+        # which kind of sequence we are passing, we turn the thing into a tuple.
+        self._edges = tuple(np.asarray(item, dtype=float).copy() for item in edges)
+        self._num_axes = len(self._edges)
+
+        # And a few basic checks on the input arguments.
+        for item in self._edges:
+            if item.ndim != 1:
+                raise ValueError(f"Bin edges {item} are not a 1-dimensional array.")
+            if item.size < 2:
+                raise ValueError(f"Bin edges {item} have less than 2 entries.")
+            if np.any(np.diff(item) <= 0):
+                raise ValueError(f"Bin edges {item} not strictly increasing.")
+        if labels is not None and len(labels) > self._num_axes + 1:
+            raise ValueError(f"Too many labels {labels} for {self._num_axes} axes.")
+
+        # Go ahead and create all the necessary data structures.
+        self._shape = tuple(item.size - 1 for item in self._edges)
+        self._sumw = np.zeros(self._shape, dtype=float)
+        self._sumw2 = np.zeros(self._shape, dtype=float)
+        self._labels = labels
+
+    @property
+    def content(self) -> np.ndarray:
+        """Return the bin contents.
+        """
+        return self._sumw
+
+    @property
+    def errors(self) -> np.ndarray:
+        """Return the bin errors.
+        """
+        return np.sqrt(self._sumw2)
+
+    def bin_edges(self, axis: int = 0) -> np.ndarray:
+        """Return a view on the binning for specific axis.
+        """
+        return self._edges[axis].view()
+
+    def bin_centers(self, axis: int = 0) -> np.ndarray:
+        """Return the bin centers for a specific axis.
+        """
+        return 0.5 * (self._edges[axis][1:] + self._edges[axis][:-1])
+
+    def bin_widths(self, axis: int = 0) -> np.ndarray:
+        """Return the bin widths for a specific axis.
+        """
+        return np.diff(self._edges[axis])
+
+    def fill(self, *values: ArrayLike, weights: ArrayLike = None) -> "AbstractHistogram":
+        """Fill the histogram from unbinned data.
+
+        Note this method is returning the histogram instance, so that the function
+        call can be chained.
+        """
+        values = np.vstack(values).T
+        sumw, _ = np.histogramdd(values, bins=self._edges, weights=weights)
+        if weights is None:
+            sumw2 = sumw
+        else:
+            sumw2, _ = np.histogramdd(values, bins=self._edges, weights=weights**2.)
+        self._sumw += sumw
+        self._sumw2 += sumw2
+        return self
+
+    def copy(self) -> "AbstractHistogram":
+        """Create a full copy of a histogram.
+        """
+        # pylint: disable=protected-access
+        # Note we really need the * in the constructor, here, as the abstract
+        # base class is never instantiated, and the arguments are unpacked in the
+        # constructors of all the derived classes.
+        histogram = self.__class__(*self._edges, *self._labels)
+        histogram._sumw = self._sumw.copy()
+        histogram._sumw2 = self._sumw2.copy()
+        return histogram
+
+    def _check_compat(self, other: "AbstractHistogram") -> None:
+        """Check whether two histogram objects are compatible with each other,
+        meaning, e.g., that they can be summed or subtracted.
+        """
+        # pylint: disable=protected-access
+        if not isinstance(other, AbstractHistogram):
+            raise TypeError(f"{other} is not a histogram.")
+        if self._num_axes != other._num_axes or self._shape != other._shape:
+            raise ValueError("Histogram dimensionality/shape mismatch.")
+        for edges in zip(self._edges, other._edges):
+            if not np.allclose(*edges):
+                raise ValueError("Histogram bin edges differ.")
+
+    def __iadd__(self, other: "AbstractHistogram") -> "AbstractHistogram":
+        """Histogram addition (in place).
+        """
+        self._check_compat(other)
+        self._sumw += other._sumw
+        self._sumw2 += other._sumw2
+        return self
+
+    def __add__(self, other: "AbstractHistogram") -> "AbstractHistogram":
+        """Histogram addition.
+        """
+        histogram = self.copy()
+        histogram += other
+        return histogram
+
+    def __isub__(self, other: "AbstractHistogram") -> "AbstractHistogram":
+        """Histogram subtraction (in place).
+        """
+        self._check_compat(other)
+        self._sumw -= other._sumw
+        self._sumw2 += other._sumw2
+        return self
+
+    def __sub__(self, other: "AbstractHistogram") -> "AbstractHistogram":
+        """Histogram subtraction.
+        """
+        histogram = self.copy()
+        histogram -= other
+        return histogram
+
+    @abstractmethod
+    def _do_plot(self, axes, **kwargs) -> None:
+        pass
+
+    def plot(self, axes=None, **kwargs) -> None:
+        """Plot the histogram.
+        """
+        if axes is None:
+            axes = plt.gca()
+        for key, value in self.DEFAULT_PLOT_OPTIONS.items():
+            kwargs.setdefault(key, value)
+        self._do_plot(axes, **kwargs)
+
+    def __repr__(self) -> str:
+        """String representation of the histogram.
+        """
+        return f"{self.__class__.__name__}({self._num_axes} axes, shape={self._shape})"
+
+
+class Histogram1d(AbstractHistogram):
+
+    """One-dimensional histogram.
+    """
+
+    DEFAULT_PLOT_OPTIONS = dict(linewidth=1.25, alpha=0.4, histtype="stepfilled")
+
+    def __init__(self, xedges: np.ndarray, xlabel: str = "", ylabel: str = "Entries/bin") -> None:
+        """Constructor.
+        """
+        super().__init__((xedges, ), [xlabel, ylabel])
+
+    def _do_plot(self, axes: matplotlib.axes._axes.Axes, **kwargs) -> None:
+        """Overloaded make_plot() method.
+        """
+        axes.hist(self.bin_centers(0), self._edges[0], weights=self.content, **kwargs)
+        setup_axes(axes, xlabel=self._labels[0], ylabel=self._labels[1])
+
+
+class Histogram2d(AbstractHistogram):
+
+    """Two-dimensional histogram.
+    """
+
+    DEFAULT_PLOT_OPTIONS = dict(cmap=plt.get_cmap('hot'))
+
+    def __init__(self, xedges, yedges, xlabel='', ylabel='', zlabel='Entries/bin') -> None:
+        """Constructor.
+        """
+        super().__init__((xedges, yedges), [xlabel, ylabel, zlabel])
+
+    def _do_plot(self, axes: matplotlib.axes._axes.Axes, logz: bool = False, **kwargs) -> None:
+        """Overloaded make_plot() method.
+        """
+        # pylint: disable=arguments-differ
+        if logz:
+            vmin = kwargs.pop('vmin', None)
+            vmax = kwargs.pop('vmax', None)
+            kwargs.setdefault('norm', matplotlib.colors.LogNorm(vmin, vmax))
+        mappable = axes.pcolormesh(*self._edges, self.content.T, **kwargs)
+        plt.colorbar(mappable, ax=axes, label=self._labels[2])
+        setup_axes(axes, xlabel=self._labels[0], ylabel=self._labels[1])

aptapy/modeling.py

@@ -37,11 +37,11 @@ class Format(str, enum.Enum):
     """Small enum class to control string formatting.
 
     This is leveraging the custom formatting of the uncertainties package, where
-    a trailing 'P' means "pretty print" and a trailing "L" means LaTeX.
+    a trailing `P` means "pretty print" and a trailing `L` means "LaTeX".
     """
 
-    PRETTY = 'P'
-    LATEX = 'L'
+    PRETTY = "P"
+    LATEX = "L"
 
 
 @dataclass
@@ -80,7 +80,7 @@ class FitParameter:
         """
         return not np.isinf(self.minimum) or not np.isinf(self.maximum)
 
-    def copy(self, name: str) -> 'FitParameter':
+    def copy(self, name: str) -> "FitParameter":
         """Create a copy of the parameter object with a new name.
 
         This is necessary because we define the fit parameters of the actual model as
@@ -139,24 +139,24 @@ class FitParameter:
         """String formatting.
         """
         # Keep in mind Python passes an empty string explicitly when you call
-        # f'{parameter}', so we can't really assign a default value to spec.
+        # f"{parameter}", so we can't really assign a default value to spec.
         if self.error is not None:
             param = format(self.ufloat(), spec)
             if spec.endswith(Format.LATEX):
-                param = f'${param}$'
+                param = f"${param}$"
         else:
             spec = spec.rstrip(Format.PRETTY).rstrip(Format.LATEX)
             param = format(self.value, spec)
-        text = f'{self._name.title()}: {param}'
+        text = f"{self._name.title()}: {param}"
         info = []
         if self._frozen:
-            info.append('frozen')
+            info.append("frozen")
         if not np.isinf(self.minimum):
-            info.append(f'min={self.minimum}')
+            info.append(f"min={self.minimum}")
         if not np.isinf(self.maximum):
-            info.append(f'max={self.maximum}')
+            info.append(f"max={self.maximum}")
         if info:
-            text = f'{text} ({", ".join(info)})'
+            text = f"{text} ({', '.join(info)})"
         return text
 
     def __str__(self) -> str:
@@ -191,12 +191,12 @@ class FitStatus:
         """String formatting.
         """
         if self.chisquare is None:
-            return 'N/A'
+            return "N/A"
         if spec.endswith(Format.LATEX):
-            return f'$\\chi^2$ = {self.chisquare:.2f} / {self.dof} dof'
+            return f"$\\chi^2$ = {self.chisquare:.2f} / {self.dof} dof"
         if spec.endswith(Format.PRETTY):
-            return f'χ² = {self.chisquare:.2f} / {self.dof} dof'
-        return f'chisquare = {self.chisquare:.2f} / {self.dof} dof'
+            return f"χ² = {self.chisquare:.2f} / {self.dof} dof"
+        return f"chisquare = {self.chisquare:.2f} / {self.dof} dof"
 
     def __str__(self) -> str:
         """String formatting.
@@ -337,7 +337,7 @@ class AbstractFitModel(ABC):
         # print out an error message.
         unknown_parameter_names = set(constraints) - set(parameter_names)
         if unknown_parameter_names:
-            raise ValueError(f'Cannot freeze unknown parameters {unknown_parameter_names}')
+            raise ValueError(f"Cannot freeze unknown parameters {unknown_parameter_names}")
 
         # Now we need to build the signature for the new function, starting from  a
         # clean copy of the parameter for the independent variable...
@@ -353,8 +353,8 @@ class AbstractFitModel(ABC):
         @functools.wraps(model_function)
         def wrapper(x, *args):
             if len(args) != num_free_parameters:
-                raise TypeError(f'Frozen wrapper got {len(args)} parameters instead of ' \
-                                f'{num_free_parameters} ({free_parameter_names})')
+                raise TypeError(f"Frozen wrapper got {len(args)} parameters instead of " \
+                                f"{num_free_parameters} ({free_parameter_names})")
             parameter_dict = {**dict(zip(free_parameter_names, args)), **constraints}
             return model_function(x, *[parameter_dict[name] for name in parameter_names])
 
@@ -379,7 +379,7 @@ class AbstractFitModel(ABC):
         # (And, since we are at it, make sure we have enough degrees of freedom.)
         self.status.dof = int(mask.sum() - len(self))
         if self.status.dof < 0:
-            raise RuntimeError(f'{self.name()} has no degrees of freedom')
+            raise RuntimeError(f"{self.name()} has no degrees of freedom")
         xdata = xdata[mask]
         ydata = ydata[mask]
         if not isinstance(sigma, Number):
@@ -444,10 +444,10 @@ class AbstractFitModel(ABC):
     def __format__(self, spec: str) -> str:
         """String formatting.
         """
-        text = f'{self.__class__.__name__} ({format(self.status, spec)})\n'
+        text = f"{self.__class__.__name__} ({format(self.status, spec)})\n"
         for parameter in self._parameters:
-            text = f'{text}{format(parameter, spec)}\n'
-        return text.strip('\n')
+            text = f"{text}{format(parameter, spec)}\n"
+        return text.strip("\n")
 
     def __str__(self):
         """String formatting.

aptapy/plotting.py

@@ -27,11 +27,48 @@ DEFAULT_FIGURE_WIDTH = 8.
 DEFAULT_FIGURE_HEIGHT = 6.
 DEFAULT_FIGURE_SIZE = (DEFAULT_FIGURE_WIDTH, DEFAULT_FIGURE_HEIGHT)
 DEFAULT_COLOR_CYCLE = [
-    '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b',
-    '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'
+    "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b",
+    "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"
 ]
 
 
+def setup_axes(axes, **kwargs):
+    """Setup a generic axes object.
+    """
+    if kwargs.get('logx'):
+        axes.set_xscale('log')
+    if kwargs.get('logy'):
+        axes.set_yscale('log')
+    xticks = kwargs.get('xticks')
+    if xticks is not None:
+        axes.set_xticks(xticks)
+    yticks = kwargs.get('yticks')
+    if yticks is not None:
+        axes.set_yticks(yticks)
+    xlabel = kwargs.get('xlabel')
+    if xlabel is not None:
+        axes.set_xlabel(xlabel)
+    ylabel = kwargs.get('ylabel')
+    if ylabel is not None:
+        axes.set_ylabel(ylabel)
+    xmin, xmax, ymin, ymax = [kwargs.get(key) for key in ('xmin', 'xmax', 'ymin', 'ymax')]
+    # Set axis limits individually to avoid passing None to axes.axis()
+    if xmin is not None or xmax is not None:
+        axes.set_xlim(left=xmin, right=xmax)
+    if ymin is not None or ymax is not None:
+        axes.set_ylim(bottom=ymin, top=ymax)
+    if kwargs.get('grids'):
+        axes.grid(which='both')
+    if kwargs.get('legend'):
+        axes.legend()
+
+
+def setup_gca(**kwargs):
+    """Setup the axes for the current plot.
+    """
+    setup_axes(plt.gca(), **kwargs)
+
+
 def _set(key: str, value: Any):
     """Set the value for a single matplotlib parameter.
 
@@ -42,9 +79,9 @@ def _set(key: str, value: Any):
     try:
         matplotlib.rcParams[key] = value
     except KeyError:
-        logger.warning(f'Unknown matplotlib rc param {key}, skipping...')
+        logger.warning(f"Unknown matplotlib rc param {key}, skipping...")
     except ValueError as exception:
-        logger.warning(f'{exception}, skipping...')
+        logger.warning(f"{exception}, skipping...")
 
 
 def configure() -> None:
@@ -54,433 +91,433 @@ def configure() -> None:
     # pylint:disable=too-many-statements
 
     # Backends
-    _set('interactive', False)
-    _set('timezone', 'UTC')
+    _set("interactive", False)
+    _set("timezone", "UTC")
 
     # Lines
     # See https://matplotlib.org/stable/api/artist_api.html#module-matplotlib.lines
-    _set('lines.linewidth', 1.5)  # line width in points
-    _set('lines.linestyle', '-')  # solid line
-    _set('lines.color', 'C0')  # has no affect on plot(); see axes.prop_cycle
-    _set('lines.marker', 'None')  # the default marker
-    _set('lines.markerfacecolor', 'auto')  # the default marker face color
-    _set('lines.markeredgecolor', 'auto')  # the default marker edge color
-    _set('lines.markeredgewidth', 1.0)  # the line width around the marker symbol
-    _set('lines.markersize', 6)  # marker size, in points
-    _set('lines.dash_joinstyle', 'round')  # {miter, round, bevel}
-    _set('lines.dash_capstyle', 'butt')  # {butt, round, projecting}
-    _set('lines.solid_joinstyle', 'round')  # {miter, round, bevel}
-    _set('lines.solid_capstyle', 'projecting')  # {butt, round, projecting}
-    _set('lines.antialiased', True)  # render lines in antialiased (no jaggies)
+    _set("lines.linewidth", 1.5)  # line width in points
+    _set("lines.linestyle", "-")  # solid line
+    _set("lines.color", "C0")  # has no affect on plot(); see axes.prop_cycle
+    _set("lines.marker", "None")  # the default marker
+    _set("lines.markerfacecolor", "auto")  # the default marker face color
+    _set("lines.markeredgecolor", "auto")  # the default marker edge color
+    _set("lines.markeredgewidth", 1.0)  # the line width around the marker symbol
+    _set("lines.markersize", 6)  # marker size, in points
+    _set("lines.dash_joinstyle", "round")  # {miter, round, bevel}
+    _set("lines.dash_capstyle", "butt")  # {butt, round, projecting}
+    _set("lines.solid_joinstyle", "round")  # {miter, round, bevel}
+    _set("lines.solid_capstyle", "projecting")  # {butt, round, projecting}
+    _set("lines.antialiased", True)  # render lines in antialiased (no jaggies)
     # The three standard dash patterns. These are scaled by the linewidth.
-    _set('lines.dashed_pattern', (3.7, 1.6))
-    _set('lines.dashdot_pattern', (6.4, 1.6, 1, 1.6))
-    _set('lines.dotted_pattern', (1, 1.65))
-    _set('lines.scale_dashes', True)
-    _set('markers.fillstyle', 'full')  # {full, left, right, bottom, top, none}
-    _set('pcolor.shading', 'auto')
+    _set("lines.dashed_pattern", (3.7, 1.6))
+    _set("lines.dashdot_pattern", (6.4, 1.6, 1, 1.6))
+    _set("lines.dotted_pattern", (1, 1.65))
+    _set("lines.scale_dashes", True)
+    _set("markers.fillstyle", "full")  # {full, left, right, bottom, top, none}
+    _set("pcolor.shading", "auto")
     # Whether to snap the mesh to pixel boundaries. This is provided solely to allow
     # old test images to remain unchanged. Set to False to obtain the previous behavior.
-    _set('pcolormesh.snap', True)
+    _set("pcolormesh.snap", True)
 
     # Patches are graphical objects that fill 2D space, like polygons or circles.
     # See https://matplotlib.org/stable/api/artist_api.html#module-matplotlib.patches
-    _set('patch.linewidth', 1.0)  # edge width in points.
-    _set('patch.facecolor', 'C0')
+    _set("patch.linewidth", 1.0)  # edge width in points.
+    _set("patch.facecolor", "C0")
     # By default, Patches and Collections do not draw edges. This value is only used
     # if facecolor is "none" (an Artist without facecolor and edgecolor would be
     # invisible) or if patch.force_edgecolor is True.
-    _set('patch.edgecolor', 'black')
+    _set("patch.edgecolor", "black")
     # By default, Patches and Collections do not draw edges. Set this to True to draw
     # edges with patch.edgedcolor as the default edgecolor. This is mainly relevant
     # for styles.
-    _set('patch.force_edgecolor', False)
-    _set('patch.antialiased', True)  # render patches in antialiased (no jaggies)
+    _set("patch.force_edgecolor", True)
+    _set("patch.antialiased", True)  # render patches in antialiased (no jaggies)
 
     # Hatches
-    _set('hatch.color', 'black')
-    _set('hatch.linewidth', 1.0)
-
-    # Boxplot---we don't really use these much, but you never know...
-    _set('boxplot.notch', False)
-    _set('boxplot.vertical', True)
-    _set('boxplot.whiskers', 1.5)
-    _set('boxplot.bootstrap', None)
-    _set('boxplot.patchartist', False)
-    _set('boxplot.showmeans', False)
-    _set('boxplot.showcaps', True)
-    _set('boxplot.showbox', True)
-    _set('boxplot.showfliers', True)
-    _set('boxplot.meanline', False)
-    _set('boxplot.flierprops.color', 'black')
-    _set('boxplot.flierprops.marker', 'o')
-    _set('boxplot.flierprops.markerfacecolor', 'none')
-    _set('boxplot.flierprops.markeredgecolor', 'black')
-    _set('boxplot.flierprops.markeredgewidth', 1.0)
-    _set('boxplot.flierprops.markersize', 6)
-    _set('boxplot.flierprops.linestyle', 'none')
-    _set('boxplot.flierprops.linewidth', 1.0)
-    _set('boxplot.boxprops.color', 'black')
-    _set('boxplot.boxprops.linewidth', 1.0)
-    _set('boxplot.boxprops.linestyle', '-')
-    _set('boxplot.whiskerprops.color', 'black')
-    _set('boxplot.whiskerprops.linewidth', 1.0)
-    _set('boxplot.whiskerprops.linestyle', '-')
-    _set('boxplot.capprops.color', 'black')
-    _set('boxplot.capprops.linewidth', 1.0)
-    _set('boxplot.capprops.linestyle', '-')
-    _set('boxplot.medianprops.color', 'C1')
-    _set('boxplot.medianprops.linewidth', 1.0)
-    _set('boxplot.medianprops.linestyle', '-')
-    _set('boxplot.meanprops.color', 'C2')
-    _set('boxplot.meanprops.marker', '^')
-    _set('boxplot.meanprops.markerfacecolor', 'C2')
-    _set('boxplot.meanprops.markeredgecolor', 'C2')
-    _set('boxplot.meanprops.markersize', 6)
-    _set('boxplot.meanprops.linestyle', '--')
-    _set('boxplot.meanprops.linewidth', 1.0)
+    _set("hatch.color", "black")
+    _set("hatch.linewidth", 1.0)
+
+    # Boxplot---we don"t really use these much, but you never know...
+    _set("boxplot.notch", False)
+    _set("boxplot.vertical", True)
+    _set("boxplot.whiskers", 1.5)
+    _set("boxplot.bootstrap", None)
+    _set("boxplot.patchartist", False)
+    _set("boxplot.showmeans", False)
+    _set("boxplot.showcaps", True)
+    _set("boxplot.showbox", True)
+    _set("boxplot.showfliers", True)
+    _set("boxplot.meanline", False)
+    _set("boxplot.flierprops.color", "black")
+    _set("boxplot.flierprops.marker", "o")
+    _set("boxplot.flierprops.markerfacecolor", "none")
+    _set("boxplot.flierprops.markeredgecolor", "black")
+    _set("boxplot.flierprops.markeredgewidth", 1.0)
+    _set("boxplot.flierprops.markersize", 6)
+    _set("boxplot.flierprops.linestyle", "none")
+    _set("boxplot.flierprops.linewidth", 1.0)
+    _set("boxplot.boxprops.color", "black")
+    _set("boxplot.boxprops.linewidth", 1.0)
+    _set("boxplot.boxprops.linestyle", "-")
+    _set("boxplot.whiskerprops.color", "black")
+    _set("boxplot.whiskerprops.linewidth", 1.0)
+    _set("boxplot.whiskerprops.linestyle", "-")
+    _set("boxplot.capprops.color", "black")
+    _set("boxplot.capprops.linewidth", 1.0)
+    _set("boxplot.capprops.linestyle", "-")
+    _set("boxplot.medianprops.color", "C1")
+    _set("boxplot.medianprops.linewidth", 1.0)
+    _set("boxplot.medianprops.linestyle", "-")
+    _set("boxplot.meanprops.color", "C2")
+    _set("boxplot.meanprops.marker", "^")
+    _set("boxplot.meanprops.markerfacecolor", "C2")
+    _set("boxplot.meanprops.markeredgecolor", "C2")
+    _set("boxplot.meanprops.markersize", 6)
+    _set("boxplot.meanprops.linestyle", "--")
+    _set("boxplot.meanprops.linewidth", 1.0)
 
     # The font properties used by `text.Text`.
     # See https://matplotlib.org/stable/api/font_manager_api.html
     # Note that for font.serif, font.sans-serif, and font.monospace, the first element
     # of the list (a DejaVu font) will always be used because DejaVu is shipped with
     # Matplotlib and is thus guaranteed to be available.
-    _set('font.family', 'sans-serif')
-    _set('font.style', 'normal')  # {normal (or roman), italic,  oblique}
-    _set('font.variant', 'normal')  # {normal, small-caps}
+    _set("font.family", "sans-serif")
+    _set("font.style", "normal")  # {normal (or roman), italic,  oblique}
+    _set("font.variant", "normal")  # {normal, small-caps}
     # The font.weight property has effectively 13 values: normal, bold, bolder, lighter,
     # 100, 200, 300, ..., 900. Normal is the same as 400, and bold is 700. bolder and
     # lighter are relative values with respect to the current weight.
-    _set('font.weight', 'normal')
-    _set('font.stretch', 'normal')  # Currently not implemented.
+    _set("font.weight", "normal")
+    _set("font.stretch", "normal")  # Currently not implemented.
     # The font.size property is the default font size for text, given in points. 10 pt
     # is the standard value. Special text sizes can be defined relative to font.size,
     # using the following values: xx-small, x-small, small, medium, large, x-large,
     # xx-large, larger, or smaller
-    _set('font.size', 14.0)
+    _set("font.size", 14.0)
 
     ## The text properties used by `text.Text`.
     ## See https://matplotlib.org/stable/api/artist_api.html#module-matplotlib.text
-    _set('text.color', 'black')
+    _set("text.color", "black")
     # FreeType hinting flag {default, no_autohint, force_autohint, no_hinting}
-    _set('text.hinting', 'force_autohint')
+    _set("text.hinting", "force_autohint")
     # Specifies the amount of softness for hinting in the horizontal direction.
     # A value of 1 will hint to full pixels. A value of 2 will hint to half pixels etc.
-    _set('text.hinting_factor', 8)
+    _set("text.hinting_factor", 8)
     # Specifies the scaling factor for kerning values. This is provided solely to
     # allow old test images to remain unchanged. Set to 6 to obtain previous behavior.
     # Values  other than 0 or 6 have no defined meaning.
-    _set('text.kerning_factor', 0)
-    _set('text.antialiased', True)  # This only affects raster outputs.
+    _set("text.kerning_factor", 0)
+    _set("text.antialiased", True)  # This only affects raster outputs.
     # Use mathtext if there is an even number of unescaped dollar signs.
-    _set('text.parse_math', True)
+    _set("text.parse_math", True)
 
     # LaTeX
     # See https://matplotlib.org/stable/users/explain/text/usetex.html
-    _set('text.usetex', False)  # use latex for all text handling.
+    _set("text.usetex", False)  # use latex for all text handling.
     # Font set can be {dejavusans, dejavuserif, cm, stixsans, custom}, where
     # "custom" is defined by the mathtext.bf, .cal, .it, ..., settings which map
     # a TeX font name to a fontconfig font pattern.
-    _set('mathtext.fontset', 'dejavusans')
-    _set('mathtext.fallback', 'cm')
-    _set('mathtext.default', 'it')
+    _set("mathtext.fontset", "dejavusans")
+    _set("mathtext.fallback", "cm")
+    _set("mathtext.default", "it")
 
     # Axes
     # See https://matplotlib.org/stable/api/axes_api.html#module-matplotlib.axes
-    _set('axes.facecolor', 'white')  # axes background color
-    _set('axes.edgecolor', 'black')  # axes edge color
-    _set('axes.linewidth', 1.2)  # edge line width
-    _set('axes.grid', True)  # display grid or not
-    _set('axes.grid.axis', 'both')  # which axis the grid should apply to
-    _set('axes.grid.which', 'major')  # grid lines at {major, minor, both} ticks
-    _set('axes.titlelocation', 'center')  # alignment of the title: {left, right, center}
-    _set('axes.titlesize', 'large')  # font size of the axes title
-    _set('axes.titleweight', 'normal')  # font weight of title
+    _set("axes.facecolor", "white")  # axes background color
+    _set("axes.edgecolor", "black")  # axes edge color
+    _set("axes.linewidth", 1.2)  # edge line width
+    _set("axes.grid", True)  # display grid or not
+    _set("axes.grid.axis", "both")  # which axis the grid should apply to
+    _set("axes.grid.which", "major")  # grid lines at {major, minor, both} ticks
+    _set("axes.titlelocation", "center")  # alignment of the title: {left, right, center}
+    _set("axes.titlesize", "large")  # font size of the axes title
+    _set("axes.titleweight", "normal")  # font weight of title
     # Color of the axes title, auto falls back tO text.color as default value
-    _set('axes.titlecolor', 'auto')
-    _set('axes.titley', None)  # position title (axes relative units).  None implies auto
-    _set('axes.titlepad', 6.0)  # pad between axes and title in points
-    _set('axes.labelsize', 'medium')  # font size of the x and y labels
-    _set('axes.labelpad', 4.0)  # space between label and axis
-    _set('axes.labelweight', 'normal')  # weight of the x and y labels
-    _set('axes.labelcolor', 'black')
+    _set("axes.titlecolor", "auto")
+    _set("axes.titley", None)  # position title (axes relative units).  None implies auto
+    _set("axes.titlepad", 6.0)  # pad between axes and title in points
+    _set("axes.labelsize", "medium")  # font size of the x and y labels
+    _set("axes.labelpad", 4.0)  # space between label and axis
+    _set("axes.labelweight", "normal")  # weight of the x and y labels
+    _set("axes.labelcolor", "black")
     # Draw axis gridlines and ticks:
     # - below patches (True)
-    # - above patches but below lines ('line')
+    # - above patches but below lines ("line")
     # - above all (False)
-    _set('axes.axisbelow', 'line')
+    _set("axes.axisbelow", "line")
     # Use scientific notation if log10 of the axis range is smaller than the
     # first or larger than the second
-    _set('axes.formatter.limits', (-5, 6))
-    _set('axes.formatter.use_locale', False)
+    _set("axes.formatter.limits", (-5, 6))
+    _set("axes.formatter.use_locale", False)
      # When True, use mathtext for scientific notation.
-    _set('axes.formatter.use_mathtext', False)
+    _set("axes.formatter.use_mathtext", False)
     # Minimum exponent to format in scientific notation
-    _set('axes.formatter.min_exponent', 0)
+    _set("axes.formatter.min_exponent", 0)
     # If True, the tick label formatter will default to labeling ticks relative
     # to an offset when the data range is small compared to the minimum absolute
     # value of the data.
-    _set('axes.formatter.useoffset', True)
+    _set("axes.formatter.useoffset", True)
     # When useoffset is True, the offset will be used when it can remove
     # at least this number of significant digits from tick labels.
-    _set('axes.formatter.offset_threshold', 4)
-    _set('axes.spines.left', True)  # display axis spines
-    _set('axes.spines.bottom', True)
-    _set('axes.spines.top', True)
-    _set('axes.spines.right', True)
+    _set("axes.formatter.offset_threshold", 4)
+    _set("axes.spines.left", True)  # display axis spines
+    _set("axes.spines.bottom", True)
+    _set("axes.spines.top", True)
+    _set("axes.spines.right", True)
     # use Unicode for the minus symbol rather than hyphen.  See
     # https://en.wikipedia.org/wiki/Plus_and_minus_signs#Character_codes
-    _set('axes.unicode_minus', True)
-    _set('axes.prop_cycle', cycler('color', DEFAULT_COLOR_CYCLE))
-    _set('axes.xmargin', .05)  # x margin.  See `axes.Axes.margins`
-    _set('axes.ymargin', .05)  # y margin.  See `axes.Axes.margins`
-    _set('axes.zmargin', .05)  # z margin.  See `axes.Axes.margins`
+    _set("axes.unicode_minus", True)
+    _set("axes.prop_cycle", cycler("color", DEFAULT_COLOR_CYCLE))
+    _set("axes.xmargin", .05)  # x margin.  See `axes.Axes.margins`
+    _set("axes.ymargin", .05)  # y margin.  See `axes.Axes.margins`
+    _set("axes.zmargin", .05)  # z margin.  See `axes.Axes.margins`
     # If "data", use axes.xmargin and axes.ymargin as is.
     # If "round_numbers", after application of margins, axis limits are further expanded
     # to the nearest "round" number.
-    _set('axes.autolimit_mode', 'data')
-    _set('polaraxes.grid', True)   # display grid on polar axes
-    _set('axes3d.grid', True)   # display grid on 3D axes
+    _set("axes.autolimit_mode", "data")
+    _set("polaraxes.grid", True)   # display grid on polar axes
+    _set("axes3d.grid", True)   # display grid on 3D axes
     # Automatically add margin when manually setting 3D axis limits
-    _set('axes3d.automargin', False)
-    _set('axes3d.xaxis.panecolor', (0.95, 0.95, 0.95, 0.5))  # background pane on 3D axes
-    _set('axes3d.yaxis.panecolor', (0.90, 0.90, 0.90, 0.5))  # background pane on 3D axes
-    _set('axes3d.zaxis.panecolor', (0.925, 0.925, 0.925, 0.5))  # background pane on 3D axes
-    _set('axes3d.mouserotationstyle', 'arcball')  # {azel, trackball, sphere, arcball}
-    _set('axes3d.trackballsize', 0.667)  # trackball diameter, in units of the Axes bbox
-    # trackball border width, in units of the Axes bbox (only for 'sphere' and 'arcball' style)
-    _set('axes3d.trackballborder', 0.2)
+    _set("axes3d.automargin", False)
+    _set("axes3d.xaxis.panecolor", (0.95, 0.95, 0.95, 0.5))  # background pane on 3D axes
+    _set("axes3d.yaxis.panecolor", (0.90, 0.90, 0.90, 0.5))  # background pane on 3D axes
+    _set("axes3d.zaxis.panecolor", (0.925, 0.925, 0.925, 0.5))  # background pane on 3D axes
+    _set("axes3d.mouserotationstyle", "arcball")  # {azel, trackball, sphere, arcball}
+    _set("axes3d.trackballsize", 0.667)  # trackball diameter, in units of the Axes bbox
+    # trackball border width, in units of the Axes bbox (only for "sphere" and "arcball" style)
+    _set("axes3d.trackballborder", 0.2)
 
     # Axis
-    _set('xaxis.labellocation', 'center')  # {left, right, center}
-    _set('yaxis.labellocation', 'center')  # {bottom, top, center}
+    _set("xaxis.labellocation", "center")  # {left, right, center}
+    _set("yaxis.labellocation", "center")  # {bottom, top, center}
 
     # Dates
     # These control the default format strings used in AutoDateFormatter.
-    _set('date.autoformatter.year', '%Y')
-    _set('date.autoformatter.month', '%Y-%m')
-    _set('date.autoformatter.day', '%Y-%m-%d')
-    _set('date.autoformatter.hour', '%m-%d %H')
-    _set('date.autoformatter.minute', '%d %H:%M')
-    _set('date.autoformatter.second', '%H:%M:%S')
-    _set('date.autoformatter.microsecond', '%M:%S.%f')
-    # The reference date for Matplotlib's internal date representation
+    _set("date.autoformatter.year", "%Y")
+    _set("date.autoformatter.month", "%Y-%m")
+    _set("date.autoformatter.day", "%Y-%m-%d")
+    _set("date.autoformatter.hour", "%m-%d %H")
+    _set("date.autoformatter.minute", "%d %H:%M")
+    _set("date.autoformatter.second", "%H:%M:%S")
+    _set("date.autoformatter.microsecond", "%M:%S.%f")
+    # The reference date for Matplotlib"s internal date representation
     # See https://matplotlib.org/stable/gallery/ticks/date_precision_and_epochs.html
-    _set('date.epoch', '1970-01-01T00:00:00')
-    _set('date.converter', 'auto')  # {auto, concise}
+    _set("date.epoch", "1970-01-01T00:00:00")
+    _set("date.converter", "auto")  # {auto, concise}
     # For auto converter whether to use interval_multiples:
-    _set('date.interval_multiples', True)
+    _set("date.interval_multiples", True)
 
     # Ticks
     # See https://matplotlib.org/stable/api/axis_api.html#matplotlib.axis.Tick
-    _set('xtick.top', False)  # draw ticks on the top side
-    _set('xtick.bottom', True)  # draw ticks on the bottom side
-    _set('xtick.labeltop', False)  # draw label on the top
-    _set('xtick.labelbottom', True)  # draw label on the bottom
-    _set('xtick.major.size', 3.5)  # major tick size in points
-    _set('xtick.minor.size', 2)  # minor tick size in points
-    _set('xtick.major.width', 0.8)  # major tick width in points
-    _set('xtick.minor.width', 0.6)  # minor tick width in points
-    _set('xtick.major.pad', 3.5)  # distance to major tick label in points
-    _set('xtick.minor.pad', 3.4)  # distance to the minor tick label in points
-    _set('xtick.color', 'black')  # color of the ticks
+    _set("xtick.top", False)  # draw ticks on the top side
+    _set("xtick.bottom", True)  # draw ticks on the bottom side
+    _set("xtick.labeltop", False)  # draw label on the top
+    _set("xtick.labelbottom", True)  # draw label on the bottom
+    _set("xtick.major.size", 3.5)  # major tick size in points
+    _set("xtick.minor.size", 2)  # minor tick size in points
+    _set("xtick.major.width", 0.8)  # major tick width in points
+    _set("xtick.minor.width", 0.6)  # minor tick width in points
+    _set("xtick.major.pad", 3.5)  # distance to major tick label in points
+    _set("xtick.minor.pad", 3.4)  # distance to the minor tick label in points
+    _set("xtick.color", "black")  # color of the ticks
     # Color of the tick labels or inherit from xtick.color
-    _set('xtick.labelcolor', 'inherit')
-    _set('xtick.labelsize', 'medium')  # font size of the tick labels
-    _set('xtick.direction', 'out')  # direction: {in, out, inout}
-    _set('xtick.minor.visible', False)  # visibility of minor ticks on x-axis
-    _set('xtick.major.top', True)  # draw x axis top major ticks
-    _set('xtick.major.bottom', True)  # draw x axis bottom major ticks
-    _set('xtick.minor.top', True)  # draw x axis top minor ticks
-    _set('xtick.minor.bottom', True)  # draw x axis bottom minor ticks
-    _set('xtick.minor.ndivs', 'auto')  # number of minor ticks between the major ticks on x-axis
-    _set('xtick.alignment', 'center')  # alignment of xticks
-    _set('ytick.left', True)  # draw ticks on the left side
-    _set('ytick.right', False)  # draw ticks on the right side
-    _set('ytick.labelleft', True)  # draw tick labels on the left side
-    _set('ytick.labelright', False)  # draw tick labels on the right side
-    _set('ytick.major.size', 3.5)  # major tick size in points
-    _set('ytick.minor.size', 2)  # minor tick size in points
-    _set('ytick.major.width', 0.8)  # major tick width in points
-    _set('ytick.minor.width', 0.6)  # minor tick width in points
-    _set('ytick.major.pad', 3.5)  # distance to major tick label in points
-    _set('ytick.minor.pad', 3.4)  # distance to the minor tick label in points
-    _set('ytick.color', 'black')  # color of the ticks
-    _set('ytick.labelcolor', 'inherit')  # color of the tick labels or inherit from ytick.color
-    _set('ytick.labelsize', 'medium')  # font size of the tick labels
-    _set('ytick.direction', 'out')  # direction: {in, out, inout}
-    _set('ytick.minor.visible', False)  # visibility of minor ticks on y-axis
-    _set('ytick.major.left', True)  # draw y axis left major ticks
-    _set('ytick.major.right', True)  # draw y axis right major ticks
-    _set('ytick.minor.left', True)  # draw y axis left minor ticks
-    _set('ytick.minor.right', True)  # draw y axis right minor ticks
-    _set('ytick.minor.ndivs', 'auto')  # number of minor ticks between the major ticks on y-axis
-    _set('ytick.alignment', 'center_baseline')  # alignment of yticks
+    _set("xtick.labelcolor", "inherit")
+    _set("xtick.labelsize", "medium")  # font size of the tick labels
+    _set("xtick.direction", "out")  # direction: {in, out, inout}
+    _set("xtick.minor.visible", False)  # visibility of minor ticks on x-axis
+    _set("xtick.major.top", True)  # draw x axis top major ticks
+    _set("xtick.major.bottom", True)  # draw x axis bottom major ticks
+    _set("xtick.minor.top", True)  # draw x axis top minor ticks
+    _set("xtick.minor.bottom", True)  # draw x axis bottom minor ticks
+    _set("xtick.minor.ndivs", "auto")  # number of minor ticks between the major ticks on x-axis
+    _set("xtick.alignment", "center")  # alignment of xticks
+    _set("ytick.left", True)  # draw ticks on the left side
+    _set("ytick.right", False)  # draw ticks on the right side
+    _set("ytick.labelleft", True)  # draw tick labels on the left side
+    _set("ytick.labelright", False)  # draw tick labels on the right side
+    _set("ytick.major.size", 3.5)  # major tick size in points
+    _set("ytick.minor.size", 2)  # minor tick size in points
+    _set("ytick.major.width", 0.8)  # major tick width in points
+    _set("ytick.minor.width", 0.6)  # minor tick width in points
+    _set("ytick.major.pad", 3.5)  # distance to major tick label in points
+    _set("ytick.minor.pad", 3.4)  # distance to the minor tick label in points
+    _set("ytick.color", "black")  # color of the ticks
+    _set("ytick.labelcolor", "inherit")  # color of the tick labels or inherit from ytick.color
+    _set("ytick.labelsize", "medium")  # font size of the tick labels
+    _set("ytick.direction", "out")  # direction: {in, out, inout}
+    _set("ytick.minor.visible", False)  # visibility of minor ticks on y-axis
+    _set("ytick.major.left", True)  # draw y axis left major ticks
+    _set("ytick.major.right", True)  # draw y axis right major ticks
+    _set("ytick.minor.left", True)  # draw y axis left minor ticks
+    _set("ytick.minor.right", True)  # draw y axis right minor ticks
+    _set("ytick.minor.ndivs", "auto")  # number of minor ticks between the major ticks on y-axis
+    _set("ytick.alignment", "center_baseline")  # alignment of yticks
 
     # Grids
-    _set('grid.color', '#c0c0c0')  # grid color
-    _set('grid.linestyle', '--')  # line style
-    _set('grid.linewidth', 0.8)  # in points
-    _set('grid.alpha', 0.8)  # transparency, between 0.0 and 1.0
+    _set("grid.color", "#c0c0c0")  # grid color
+    _set("grid.linestyle", "--")  # line style
+    _set("grid.linewidth", 0.8)  # in points
+    _set("grid.alpha", 0.8)  # transparency, between 0.0 and 1.0
 
 
     # Legends
-    _set('legend.loc', 'best')
-    _set('legend.frameon', True)  # if True, draw the legend on a background patch
-    _set('legend.framealpha', 0.75)  # legend patch transparency
-    _set('legend.facecolor', 'inherit')  # inherit from axes.facecolor; or color spec
-    _set('legend.edgecolor', '#a0a0a0')  # background patch boundary color
+    _set("legend.loc", "best")
+    _set("legend.frameon", True)  # if True, draw the legend on a background patch
+    _set("legend.framealpha", 0.75)  # legend patch transparency
+    _set("legend.facecolor", "inherit")  # inherit from axes.facecolor; or color spec
+    _set("legend.edgecolor", "#a0a0a0")  # background patch boundary color
     # If True, use a rounded box for the legend background, else a rectangle
-    _set('legend.fancybox', True)
-    _set('legend.shadow', False)  # if True, give background a shadow effect
-    _set('legend.numpoints', 1)  # the number of marker points in the legend line
-    _set('legend.scatterpoints', 1)  # number of scatter points
-    _set('legend.markerscale', 1.0)  # the relative size of legend markers vs. original
-    _set('legend.fontsize', 'small')
-    _set('legend.labelcolor', None)
-    _set('legend.title_fontsize', None)  # None sets to the same as the default axes.
+    _set("legend.fancybox", True)
+    _set("legend.shadow", False)  # if True, give background a shadow effect
+    _set("legend.numpoints", 1)  # the number of marker points in the legend line
+    _set("legend.scatterpoints", 1)  # number of scatter points
+    _set("legend.markerscale", 1.0)  # the relative size of legend markers vs. original
+    _set("legend.fontsize", "small")
+    _set("legend.labelcolor", None)
+    _set("legend.title_fontsize", None)  # None sets to the same as the default axes.
     # Dimensions as fraction of font size:
-    _set('legend.borderpad', 0.4)  # border whitespace
-    _set('legend.labelspacing', 0.5)  # the vertical space between the legend entries
-    _set('legend.handlelength', 2.0)  # the length of the legend lines
-    _set('legend.handleheight', 0.7)  # the height of the legend handle
-    _set('legend.handletextpad', 0.8)  # the space between the legend line and legend text
-    _set('legend.borderaxespad', 0.5)  # the border between the axes and legend edge
-    _set('legend.columnspacing', 2.0)  # column separation
+    _set("legend.borderpad", 0.4)  # border whitespace
+    _set("legend.labelspacing", 0.5)  # the vertical space between the legend entries
+    _set("legend.handlelength", 2.0)  # the length of the legend lines
+    _set("legend.handleheight", 0.7)  # the height of the legend handle
+    _set("legend.handletextpad", 0.8)  # the space between the legend line and legend text
+    _set("legend.borderaxespad", 0.5)  # the border between the axes and legend edge
+    _set("legend.columnspacing", 2.0)  # column separation
 
     # Figures
     ## See https://matplotlib.org/stable/api/figure_api.html#matplotlib.figure.Figure
-    _set('figure.titlesize', 'large')  # size of the figure title
-    _set('figure.titleweight', 'normal')  # weight of the figure title
-    _set('figure.labelsize', 'large')  # size of the figure label
-    _set('figure.labelweight', 'normal')  # weight of the figure label
-    _set('figure.figsize', DEFAULT_FIGURE_SIZE)  # figure size in inches
-    _set('figure.dpi', 100)  # figure dots per inch
-    _set('figure.facecolor', 'white')  # figure face color
-    _set('figure.edgecolor', 'white')  # figure edge color
-    _set('figure.frameon', True)  # enable figure frame
-    _set('figure.max_open_warning', 20)
-    _set('figure.raise_window', True)  # Raise the GUI window to front when show() is called
+    _set("figure.titlesize", "large")  # size of the figure title
+    _set("figure.titleweight", "normal")  # weight of the figure title
+    _set("figure.labelsize", "large")  # size of the figure label
+    _set("figure.labelweight", "normal")  # weight of the figure label
+    _set("figure.figsize", DEFAULT_FIGURE_SIZE)  # figure size in inches
+    _set("figure.dpi", 100)  # figure dots per inch
+    _set("figure.facecolor", "white")  # figure face color
+    _set("figure.edgecolor", "white")  # figure edge color
+    _set("figure.frameon", True)  # enable figure frame
+    _set("figure.max_open_warning", 20)
+    _set("figure.raise_window", True)  # Raise the GUI window to front when show() is called
     # The figure subplot parameters.
     # All dimensions are a fraction of the figure width and height.
-    _set('figure.subplot.left', 0.125)  # the left side of the subplots of the figure
-    _set('figure.subplot.right', 0.97)  # the right side of the subplots of the figure
-    _set('figure.subplot.bottom', 0.11)  # the bottom of the subplots of the figure
-    _set('figure.subplot.top', 0.96)  # the top of the subplots of the figure
+    _set("figure.subplot.left", 0.125)  # the left side of the subplots of the figure
+    _set("figure.subplot.right", 0.97)  # the right side of the subplots of the figure
+    _set("figure.subplot.bottom", 0.11)  # the bottom of the subplots of the figure
+    _set("figure.subplot.top", 0.96)  # the top of the subplots of the figure
     # Amount of width reserved for space between subplots, expressed as a fraction
     # of the average axis width.
-    _set('figure.subplot.wspace', 0.2)
+    _set("figure.subplot.wspace", 0.2)
     # Amount of height reserved for space between subplots, expressed as a fraction
     # of the average axis height
-    _set('figure.subplot.hspace', 0.2)
+    _set("figure.subplot.hspace", 0.2)
     # When True, automatically adjust subplot parameters to make the plot fit the figure
     # using `tight_layout`
-    _set('figure.autolayout', False)
+    _set("figure.autolayout", False)
      # When True, automatically make plot elements fit on the figure.
      # (Not compatible with `autolayout`, above).
-    _set('figure.constrained_layout.use', False)
+    _set("figure.constrained_layout.use", False)
     # Padding (in inches) around axes; defaults to 3/72 inches, i.e. 3 points.
-    _set('figure.constrained_layout.h_pad', 0.04167)
-    _set('figure.constrained_layout.w_pad', 0.04167)
+    _set("figure.constrained_layout.h_pad", 0.04167)
+    _set("figure.constrained_layout.w_pad", 0.04167)
     # Spacing between subplots, relative to the subplot sizes.  Much smaller than for
     # tight_layout (figure.subplot.hspace, figure.subplot.wspace) as constrained_layout
     # already takes surrounding texts (titles, labels, # ticklabels) into account.
-    _set('figure.constrained_layout.hspace', 0.02)
-    _set('figure.constrained_layout.wspace', 0.02)
+    _set("figure.constrained_layout.hspace", 0.02)
+    _set("figure.constrained_layout.wspace", 0.02)
 
     # Images
-    _set('image.aspect', 'equal')   # {equal, auto} or a number
-    _set('image.interpolation', 'auto')  # see help(imshow) for options
-    _set('image.interpolation_stage', 'auto')  # see help(imshow) for options
-    _set('image.cmap', 'viridis')  # A colormap name (plasma, magma, etc.)
-    _set('image.lut', 256)  # the size of the colormap lookup table
-    _set('image.origin', 'upper')  # {lower, upper}
-    _set('image.resample', True)
+    _set("image.aspect", "equal")   # {equal, auto} or a number
+    _set("image.interpolation", "auto")  # see help(imshow) for options
+    _set("image.interpolation_stage", "auto")  # see help(imshow) for options
+    _set("image.cmap", "viridis")  # A colormap name (plasma, magma, etc.)
+    _set("image.lut", 256)  # the size of the colormap lookup table
+    _set("image.origin", "upper")  # {lower, upper}
+    _set("image.resample", True)
     # When True, all the images on a set of axes are combined into a single composite
     # image before saving a figure as a vector graphics file, such as a PDF.
-    _set('image.composite_image', True)
+    _set("image.composite_image", True)
 
     # Various plots.
-    _set('contour.negative_linestyle', 'dashed')  # string or on-off ink sequence
-    _set('contour.corner_mask', True)  # {True, False}
-    _set('contour.linewidth', None)
-    _set('contour.algorithm', 'mpl2014')  # {mpl2005, mpl2014, serial, threaded}
-    _set('errorbar.capsize', 0)  # length of end cap on error bars in pixels
-    _set('hist.bins', 10)  # The default number of histogram bins or 'auto'.
-    _set('scatter.marker', 'o')  # The default marker type for scatter plots.
-    _set('scatter.edgecolors', 'face')  # The default edge colors for scatter plots.
+    _set("contour.negative_linestyle", "dashed")  # string or on-off ink sequence
+    _set("contour.corner_mask", True)  # {True, False}
+    _set("contour.linewidth", None)
+    _set("contour.algorithm", "mpl2014")  # {mpl2005, mpl2014, serial, threaded}
+    _set("errorbar.capsize", 0)  # length of end cap on error bars in pixels
+    _set("hist.bins", 10)  # The default number of histogram bins or "auto".
+    _set("scatter.marker", "o")  # The default marker type for scatter plots.
+    _set("scatter.edgecolors", "face")  # The default edge colors for scatter plots.
 
     # Paths
     # When True, simplify paths by removing "invisible" points to reduce file size
     # and increase rendering speed
-    _set('path.simplify', True)
+    _set("path.simplify", True)
     # The threshold of similarity below which vertices will be removed in
     # the simplification process.
-    _set('path.simplify_threshold', 0.111111111111)
+    _set("path.simplify_threshold", 0.111111111111)
     # When True, rectilinear axis-aligned paths will be snapped to the nearest pixel
     # when certain criteria are met. When False, paths will never be snapped.
-    _set('path.snap', True)
+    _set("path.snap", True)
     # May be None, or a tuple of the form: path.sketch: (scale, length, randomness)
     # - scale is the amplitude of the wiggle perpendicular to the line (in pixels).
     # - length is the length of the wiggle along the line (in pixels).
     # - randomness is the factor by which the length is randomly scaled.
-    _set('path.sketch', None)
+    _set("path.sketch", None)
 
     # Saving figures...
     # The default savefig parameters can be different from the display parameters
-    _set('savefig.dpi', 300)  # figure dots per inch or 'figure'
-    _set('savefig.facecolor', 'auto')  # figure face color when saving
-    _set('savefig.edgecolor', 'auto')  # figure edge color when saving
-    _set('savefig.format', 'png')  # {png, ps, pdf, svg}
-    _set('savefig.bbox', 'standard')  # {tight, standard}
-    _set('savefig.pad_inches', 0.1)  # padding to be used, when bbox is set to 'tight'
+    _set("savefig.dpi", 300)  # figure dots per inch or "figure"
+    _set("savefig.facecolor", "auto")  # figure face color when saving
+    _set("savefig.edgecolor", "auto")  # figure edge color when saving
+    _set("savefig.format", "png")  # {png, ps, pdf, svg}
+    _set("savefig.bbox", "standard")  # {tight, standard}
+    _set("savefig.pad_inches", 0.1)  # padding to be used, when bbox is set to "tight"
     # Default directory in savefig dialog, gets updated after interactive saves,
-    # unless set to the empty string (i.e. the current directory); use '.' to start
+    # unless set to the empty string (i.e. the current directory); use "." to start
     # at the current directory but update after interactive saves
-    _set('savefig.directory', '')
+    _set("savefig.directory", "")
     # Whether figures are saved with a transparent background by default
-    _set('savefig.transparent', False)
+    _set("savefig.transparent", False)
     # Orientation of saved figure, for PostScript output only
-    _set('savefig.orientation', 'portrait')
-    _set('macosx.window_mode', 'system')
-    _set('tk.window_focus', False)  # Maintain shell focus for TkAgg
+    _set("savefig.orientation", "portrait")
+    _set("macosx.window_mode", "system")
+    _set("tk.window_focus", False)  # Maintain shell focus for TkAgg
     # Integer from 0 to 9, 0 disables compression (good for debugging)
-    _set('pdf.compression', 6)
-    _set('pdf.fonttype', 3)  # Output Type 3 (Type3) or Type 42 (TrueType)
-    _set('pdf.use14corefonts', False)
-    _set('pdf.inheritcolor', False)
-    _set('svg.image_inline', True)  # Write raster image data directly into the SVG file
+    _set("pdf.compression", 6)
+    _set("pdf.fonttype", 3)  # Output Type 3 (Type3) or Type 42 (TrueType)
+    _set("pdf.use14corefonts", False)
+    _set("pdf.inheritcolor", False)
+    _set("svg.image_inline", True)  # Write raster image data directly into the SVG file
     # How to handle SVG fonts:
     # - path: embed characters as paths -- supported by most SVG renderers
     # - None: assume fonts are installed on the machine where the SVG will be viewed.
-    _set('svg.fonttype', 'path')
-    _set('svg.hashsalt', None)  # If not None, use this string as hash salt instead of uuid4
+    _set("svg.fonttype", "path")
+    _set("svg.hashsalt", None)  # If not None, use this string as hash salt instead of uuid4
     # If not None, use this string as the value for the `id` attribute in the top <svg> tag
-    _set('svg.id', None)
+    _set("svg.id", None)
     # See https://matplotlib.org/stable/tutorials/text/pgf.html for more information.
-    _set('pgf.rcfonts', True)
-    _set('pgf.texsystem', 'xelatex')
-    _set('docstring.hardcopy', False)  # set this when you want to generate hardcopy docstring
+    _set("pgf.rcfonts", True)
+    _set("pgf.texsystem", "xelatex")
+    _set("docstring.hardcopy", False)  # set this when you want to generate hardcopy docstring
 
     # Animations
     # How to display the animation as HTML in the IPython notebook:
-    # - 'html5' uses HTML5 video tag
-    # - 'jshtml' creates a JavaScript animation
-    _set('animation.html', 'none')
-    _set('animation.writer', 'ffmpeg')  # MovieWriter 'backend' to use
-    _set('animation.codec', 'h264')  # Codec to use for writing movie
+    # - "html5" uses HTML5 video tag
+    # - "jshtml" creates a JavaScript animation
+    _set("animation.html", "none")
+    _set("animation.writer", "ffmpeg")  # MovieWriter "backend" to use
+    _set("animation.codec", "h264")  # Codec to use for writing movie
     # Controls size/quality trade-off for movie.
     # -1 implies let utility auto-determine
-    _set('animation.bitrate', -1)
-    _set('animation.frame_format', 'png')  # Controls frame format used by temp files
+    _set("animation.bitrate", -1)
+    _set("animation.frame_format", "png")  # Controls frame format used by temp files
     # Path to ffmpeg binary. Unqualified paths are resolved by subprocess.Popen.
-    _set('animation.ffmpeg_path', 'ffmpeg')
-    # Path to ImageMagick's convert binary. Unqualified paths are resolved by
+    _set("animation.ffmpeg_path", "ffmpeg")
+    # Path to ImageMagick"s convert binary. Unqualified paths are resolved by
     # subprocess.Popen, except that on Windows, we look up an install of
     # ImageMagick in the registry (as convert is also the name of a system tool).
-    _set('animation.convert_path', 'convert')
+    _set("animation.convert_path", "convert")
     # Limit, in MB, of size of base64 encoded animation in HTML (i.e. IPython notebook)
-    _set('animation.embed_limit', 20.0)
+    _set("animation.embed_limit", 20.0)
 
 
 configure()

{aptapy-0.1.1.dist-info → aptapy-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aptapy
-Version: 0.1.1
+Version: 0.2.0
 Summary: Statistical tools for online monitoring and analysis
 Project-URL: Homepage, https://github.com/lucabaldini/aptapy
 Project-URL: Issues, https://github.com/lucabaldini/aptapy/issues

aptapy-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+aptapy/__init__.py,sha256=a7Au1ukdeJbjiIZ-UL-qZE1xk-d2WnKKkoqjg_0SzqA,1707
+aptapy/_version.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+aptapy/hist.py,sha256=5fiaYEnSQ7b_jSsZdRvXrIGr2vTMlW_55jkFpE8L3Sw,8158
+aptapy/modeling.py,sha256=V8DVfmwFyUfy9-YZXd9Hz5rlyGEy12xoyn-oJ4ss3W0,18236
+aptapy/plotting.py,sha256=ZixAVF83qIuITjzQJBUvMNCK-REilzyAt0vxgcMbCOk,27125
+aptapy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aptapy/typing_.py,sha256=JIbEqKI8kn_fd90yDt0JmI1AojjmLhAEB_1RfMFxLx4,807
+aptapy-0.2.0.dist-info/METADATA,sha256=yvpj0nK8DKrbXcccDPqKeiruxJYAGEK0FYaIKa4UpS0,41456
+aptapy-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aptapy-0.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+aptapy-0.2.0.dist-info/RECORD,,

aptapy-0.1.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-aptapy/__init__.py,sha256=a7Au1ukdeJbjiIZ-UL-qZE1xk-d2WnKKkoqjg_0SzqA,1707
-aptapy/_version.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
-aptapy/modeling.py,sha256=Ba-kHfvwjSc5oM3XZGsxN5wAONQZaKmICQa-P65qxNE,18234
-aptapy/plotting.py,sha256=Pv0uo7fqoKYmyFmX2CiSRujzTkYNKiUsW7ZHSBWQowE,25991
-aptapy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aptapy/typing_.py,sha256=JIbEqKI8kn_fd90yDt0JmI1AojjmLhAEB_1RfMFxLx4,807
-aptapy-0.1.1.dist-info/METADATA,sha256=bJ44czUH6kc516OHBIbge9neKPWTm3jAyz2fBEvPUkY,41456
-aptapy-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aptapy-0.1.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-aptapy-0.1.1.dist-info/RECORD,,