fixed subscription table

.venv/lib/python3.12/site-packages/matplotlib_inline/__init__.py

@@ -0,0 +1,2 @@
+from . import backend_inline, config  # noqa
+__version__ = "0.1.7"  # noqa

.venv/lib/python3.12/site-packages/matplotlib_inline/backend_inline.py

@@ -0,0 +1,311 @@
+"""A matplotlib backend for publishing figures via display_data"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the BSD 3-Clause License.
+
+import matplotlib
+from matplotlib import colors
+from matplotlib.backends import backend_agg
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+from matplotlib._pylab_helpers import Gcf
+from matplotlib.figure import Figure
+
+from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.getipython import get_ipython
+from IPython.core.pylabtools import select_figure_formats
+from IPython.display import display
+
+from .config import InlineBackend
+
+
+def new_figure_manager(num, *args, FigureClass=Figure, **kwargs):
+    """
+    Return a new figure manager for a new figure instance.
+
+    This function is part of the API expected by Matplotlib backends.
+    """
+    return new_figure_manager_given_figure(num, FigureClass(*args, **kwargs))
+
+
+def new_figure_manager_given_figure(num, figure):
+    """
+    Return a new figure manager for a given figure instance.
+
+    This function is part of the API expected by Matplotlib backends.
+    """
+    manager = backend_agg.new_figure_manager_given_figure(num, figure)
+
+    # Hack: matplotlib FigureManager objects in interacive backends (at least
+    # in some of them) monkeypatch the figure object and add a .show() method
+    # to it.  This applies the same monkeypatch in order to support user code
+    # that might expect `.show()` to be part of the official API of figure
+    # objects.  For further reference:
+    # https://github.com/ipython/ipython/issues/1612
+    # https://github.com/matplotlib/matplotlib/issues/835
+
+    if not hasattr(figure, 'show'):
+        # Queue up `figure` for display
+        figure.show = lambda *a: display(
+            figure, metadata=_fetch_figure_metadata(figure))
+
+    # If matplotlib was manually set to non-interactive mode, this function
+    # should be a no-op (otherwise we'll generate duplicate plots, since a user
+    # who set ioff() manually expects to make separate draw/show calls).
+    if not matplotlib.is_interactive():
+        return manager
+
+    # ensure current figure will be drawn, and each subsequent call
+    # of draw_if_interactive() moves the active figure to ensure it is
+    # drawn last
+    try:
+        show._to_draw.remove(figure)
+    except ValueError:
+        # ensure it only appears in the draw list once
+        pass
+    # Queue up the figure for drawing in next show() call
+    show._to_draw.append(figure)
+    show._draw_called = True
+
+    return manager
+
+
+def show(close=None, block=None):
+    """Show all figures as SVG/PNG payloads sent to the IPython clients.
+
+    Parameters
+    ----------
+    close : bool, optional
+        If true, a ``plt.close('all')`` call is automatically issued after
+        sending all the figures. If this is set, the figures will entirely
+        removed from the internal list of figures.
+    block : Not used.
+        The `block` parameter is a Matplotlib experimental parameter.
+        We accept it in the function signature for compatibility with other
+        backends.
+    """
+    if close is None:
+        close = InlineBackend.instance().close_figures
+    try:
+        for figure_manager in Gcf.get_all_fig_managers():
+            display(
+                figure_manager.canvas.figure,
+                metadata=_fetch_figure_metadata(figure_manager.canvas.figure)
+            )
+    finally:
+        show._to_draw = []
+        # only call close('all') if any to close
+        # close triggers gc.collect, which can be slow
+        if close and Gcf.get_all_fig_managers():
+            matplotlib.pyplot.close('all')
+
+
+# This flag will be reset by draw_if_interactive when called
+show._draw_called = False
+# list of figures to draw when flush_figures is called
+show._to_draw = []
+
+
+def flush_figures():
+    """Send all figures that changed
+
+    This is meant to be called automatically and will call show() if, during
+    prior code execution, there had been any calls to draw_if_interactive.
+
+    This function is meant to be used as a post_execute callback in IPython,
+    so user-caused errors are handled with showtraceback() instead of being
+    allowed to raise.  If this function is not called from within IPython,
+    then these exceptions will raise.
+    """
+    if not show._draw_called:
+        return
+
+    try:
+        if InlineBackend.instance().close_figures:
+            # ignore the tracking, just draw and close all figures
+            try:
+                return show(True)
+            except Exception as e:
+                # safely show traceback if in IPython, else raise
+                ip = get_ipython()
+                if ip is None:
+                    raise e
+                else:
+                    ip.showtraceback()
+                    return
+
+        # exclude any figures that were closed:
+        active = set([fm.canvas.figure for fm in Gcf.get_all_fig_managers()])
+        for fig in [fig for fig in show._to_draw if fig in active]:
+            try:
+                display(fig, metadata=_fetch_figure_metadata(fig))
+            except Exception as e:
+                # safely show traceback if in IPython, else raise
+                ip = get_ipython()
+                if ip is None:
+                    raise e
+                else:
+                    ip.showtraceback()
+                    return
+    finally:
+        # clear flags for next round
+        show._to_draw = []
+        show._draw_called = False
+
+
+# Changes to matplotlib in version 1.2 requires a mpl backend to supply a default
+# figurecanvas. This is set here to a Agg canvas
+# See https://github.com/matplotlib/matplotlib/pull/1125
+FigureCanvas = FigureCanvasAgg
+
+
+def configure_inline_support(shell, backend):
+    """Configure an IPython shell object for matplotlib use.
+
+    Parameters
+    ----------
+    shell : InteractiveShell instance
+
+    backend : matplotlib backend
+    """
+    # If using our svg payload backend, register the post-execution
+    # function that will pick up the results for display.  This can only be
+    # done with access to the real shell object.
+
+    cfg = InlineBackend.instance(parent=shell)
+    cfg.shell = shell
+    if cfg not in shell.configurables:
+        shell.configurables.append(cfg)
+
+    if backend in ('inline', 'module://matplotlib_inline.backend_inline'):
+        shell.events.register('post_execute', flush_figures)
+
+        # Save rcParams that will be overwrittern
+        shell._saved_rcParams = {}
+        for k in cfg.rc:
+            shell._saved_rcParams[k] = matplotlib.rcParams[k]
+        # load inline_rc
+        matplotlib.rcParams.update(cfg.rc)
+        new_backend_name = "inline"
+    else:
+        try:
+            shell.events.unregister('post_execute', flush_figures)
+        except ValueError:
+            pass
+        if hasattr(shell, '_saved_rcParams'):
+            matplotlib.rcParams.update(shell._saved_rcParams)
+            del shell._saved_rcParams
+        new_backend_name = "other"
+
+    # only enable the formats once -> don't change the enabled formats (which the user may
+    # has changed) when getting another "%matplotlib inline" call.
+    # See https://github.com/ipython/ipykernel/issues/29
+    cur_backend = getattr(configure_inline_support, "current_backend", "unset")
+    if new_backend_name != cur_backend:
+        # Setup the default figure format
+        select_figure_formats(shell, cfg.figure_formats, **cfg.print_figure_kwargs)
+        configure_inline_support.current_backend = new_backend_name
+
+
+def _enable_matplotlib_integration():
+    """Enable extra IPython matplotlib integration when we are loaded as the matplotlib backend."""
+    from matplotlib import get_backend
+    ip = get_ipython()
+    backend = get_backend()
+    if ip and backend in ('inline', 'module://matplotlib_inline.backend_inline'):
+        from IPython.core.pylabtools import activate_matplotlib
+        try:
+            activate_matplotlib(backend)
+            configure_inline_support(ip, backend)
+        except (ImportError, AttributeError):
+            # bugs may cause a circular import on Python 2
+            def configure_once(*args):
+                activate_matplotlib(backend)
+                configure_inline_support(ip, backend)
+                ip.events.unregister('post_run_cell', configure_once)
+            ip.events.register('post_run_cell', configure_once)
+
+
+_enable_matplotlib_integration()
+
+
+def _fetch_figure_metadata(fig):
+    """Get some metadata to help with displaying a figure."""
+    # determine if a background is needed for legibility
+    if _is_transparent(fig.get_facecolor()):
+        # the background is transparent
+        ticksLight = _is_light([label.get_color()
+                                for axes in fig.axes
+                                for axis in (axes.xaxis, axes.yaxis)
+                                for label in axis.get_ticklabels()])
+        if ticksLight.size and (ticksLight == ticksLight[0]).all():
+            # there are one or more tick labels, all with the same lightness
+            return {'needs_background': 'dark' if ticksLight[0] else 'light'}
+
+    return None
+
+
+def _is_light(color):
+    """Determines if a color (or each of a sequence of colors) is light (as
+    opposed to dark). Based on ITU BT.601 luminance formula (see
+    https://stackoverflow.com/a/596241)."""
+    rgbaArr = colors.to_rgba_array(color)
+    return rgbaArr[:, :3].dot((.299, .587, .114)) > .5
+
+
+def _is_transparent(color):
+    """Determine transparency from alpha."""
+    rgba = colors.to_rgba(color)
+    return rgba[3] < .5
+
+
+def set_matplotlib_formats(*formats, **kwargs):
+    """Select figure formats for the inline backend. Optionally pass quality for JPEG.
+
+    For example, this enables PNG and JPEG output with a JPEG quality of 90%::
+
+        In [1]: set_matplotlib_formats('png', 'jpeg', quality=90)
+
+    To set this in your config files use the following::
+
+        c.InlineBackend.figure_formats = {'png', 'jpeg'}
+        c.InlineBackend.print_figure_kwargs.update({'quality' : 90})
+
+    Parameters
+    ----------
+    *formats : strs
+        One or more figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
+    **kwargs
+        Keyword args will be relayed to ``figure.canvas.print_figure``.
+    """
+    # build kwargs, starting with InlineBackend config
+    cfg = InlineBackend.instance()
+    kw = {}
+    kw.update(cfg.print_figure_kwargs)
+    kw.update(**kwargs)
+    shell = InteractiveShell.instance()
+    select_figure_formats(shell, formats, **kw)
+
+
+def set_matplotlib_close(close=True):
+    """Set whether the inline backend closes all figures automatically or not.
+
+    By default, the inline backend used in the IPython Notebook will close all
+    matplotlib figures automatically after each cell is run. This means that
+    plots in different cells won't interfere. Sometimes, you may want to make
+    a plot in one cell and then refine it in later cells. This can be accomplished
+    by::
+
+        In [1]: set_matplotlib_close(False)
+
+    To set this in your config files use the following::
+
+        c.InlineBackend.close_figures = False
+
+    Parameters
+    ----------
+    close : bool
+        Should all matplotlib figures be automatically closed after each cell is
+        run?
+    """
+    cfg = InlineBackend.instance()
+    cfg.close_figures = close

.venv/lib/python3.12/site-packages/matplotlib_inline/config.py

@@ -0,0 +1,100 @@
+"""Configurable for configuring the IPython inline backend
+
+This module does not import anything from matplotlib.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the BSD 3-Clause License.
+
+from traitlets.config.configurable import SingletonConfigurable
+from traitlets import (
+    Dict, Instance, Set, Bool, TraitError, Unicode
+)
+
+
+# Configurable for inline backend options
+def pil_available():
+    """Test if PIL/Pillow is available"""
+    out = False
+    try:
+        from PIL import Image  # noqa
+        out = True
+    except ImportError:
+        pass
+    return out
+
+
+# Inherit from InlineBackendConfig for deprecation purposes
+class InlineBackendConfig(SingletonConfigurable):
+    pass
+
+
+class InlineBackend(InlineBackendConfig):
+    """An object to store configuration of the inline backend."""
+
+    # While we are deprecating overriding matplotlib defaults out of the
+    # box, this structure should remain here (empty) for API compatibility
+    # and the use of other tools that may need it. Specifically Spyder takes
+    # advantage of it.
+    # See https://github.com/ipython/ipython/issues/10383 for details.
+    rc = Dict(
+        {},
+        help="""Dict to manage matplotlib configuration defaults in the inline
+        backend. As of v0.1.4 IPython/Jupyter do not override defaults out of
+        the box, but third-party tools may use it to manage rc data. To change
+        personal defaults for matplotlib,  use matplotlib's configuration
+        tools, or customize this class in your `ipython_config.py` file for
+        IPython/Jupyter-specific usage.""").tag(config=True)
+
+    figure_formats = Set(
+        {'png'},
+        help="""A set of figure formats to enable: 'png',
+                'retina', 'jpeg', 'svg', 'pdf'.""").tag(config=True)
+
+    def _update_figure_formatters(self):
+        if self.shell is not None:
+            from IPython.core.pylabtools import select_figure_formats
+            select_figure_formats(self.shell, self.figure_formats, **self.print_figure_kwargs)
+
+    def _figure_formats_changed(self, name, old, new):
+        if 'jpg' in new or 'jpeg' in new:
+            if not pil_available():
+                raise TraitError("Requires PIL/Pillow for JPG figures")
+        self._update_figure_formatters()
+
+    figure_format = Unicode(help="""The figure format to enable (deprecated
+                                         use `figure_formats` instead)""").tag(config=True)
+
+    def _figure_format_changed(self, name, old, new):
+        if new:
+            self.figure_formats = {new}
+
+    print_figure_kwargs = Dict(
+        {'bbox_inches': 'tight'},
+        help="""Extra kwargs to be passed to fig.canvas.print_figure.
+
+        Logical examples include: bbox_inches, quality (for jpeg figures), etc.
+        """
+    ).tag(config=True)
+    _print_figure_kwargs_changed = _update_figure_formatters
+
+    close_figures = Bool(
+        True,
+        help="""Close all figures at the end of each cell.
+
+        When True, ensures that each cell starts with no active figures, but it
+        also means that one must keep track of references in order to edit or
+        redraw figures in subsequent cells. This mode is ideal for the notebook,
+        where residual plots from other cells might be surprising.
+
+        When False, one must call figure() to create new figures. This means
+        that gcf() and getfigs() can reference figures created in other cells,
+        and the active figure can continue to be edited with pylab/pyplot
+        methods that reference the current active figure. This mode facilitates
+        iterative editing of figures, and behaves most consistently with
+        other matplotlib backends, but figure barriers between cells must
+        be explicit.
+        """).tag(config=True)
+
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
+                     allow_none=True)