pax_global_header00006660000000000000000000000064146072273540014524gustar00rootroot0000000000000052 comment=fc7dd9db28dde3647b7913f02bcb9922d76f0251 matplotlib-inline-0.1.7/000077500000000000000000000000001460722735400151545ustar00rootroot00000000000000matplotlib-inline-0.1.7/.github/000077500000000000000000000000001460722735400165145ustar00rootroot00000000000000matplotlib-inline-0.1.7/.github/dependabot.yml000066400000000000000000000007661460722735400213550ustar00rootroot00000000000000# To get started with Dependabot version updates, you'll need to specify which # package ecosystems to update and where the package manifests are located. # Please see the documentation for all configuration options: # https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates version: 2 updates: - package-ecosystem: "pip" # See documentation for possible values directory: "/" # Location of package manifests schedule: interval: "weekly" matplotlib-inline-0.1.7/.github/workflows/000077500000000000000000000000001460722735400205515ustar00rootroot00000000000000matplotlib-inline-0.1.7/.github/workflows/main.yml000066400000000000000000000016451460722735400222260ustar00rootroot00000000000000name: Tests on: push: branches: - main pull_request: branches: - main defaults: run: shell: bash -l {0} jobs: run: runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: os: [ubuntu-latest] python-version: ["3.9", "3.10", "3.11", "3.12"] steps: - name: Checkout uses: actions/checkout@v2 - name: Setup conda uses: conda-incubator/setup-miniconda@v2 with: python-version: ${{ matrix.python-version }} mamba-version: "*" auto-activate-base: false channels: conda-forge - name: Install dependencies run: mamba install ipython matplotlib flake8 - name: Install package run: pip install . - name: Test installation run: python -c 'from matplotlib_inline.backend_inline import show' - name: Test flake8 run: flake8 matplotlib_inline --ignore=E501,W504,W503 matplotlib-inline-0.1.7/.gitignore000066400000000000000000000000421460722735400171400ustar00rootroot00000000000000*.egg-info dist build __pycache__ matplotlib-inline-0.1.7/LICENSE000066400000000000000000000030021460722735400161540ustar00rootroot00000000000000BSD 3-Clause License Copyright (c) 2019-2022, IPython Development Team. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. matplotlib-inline-0.1.7/README.md000066400000000000000000000015741460722735400164420ustar00rootroot00000000000000# Matplotlib Inline Back-end for IPython and Jupyter This package provides support for matplotlib to display figures directly inline in the Jupyter notebook and related clients, as shown below. ## Installation With conda: ```bash conda install -c conda-forge matplotlib-inline ``` With pip: ```bash pip install matplotlib-inline ``` ## Usage Note that in current versions of JupyterLab and Jupyter Notebook, the explicit use of the `%matplotlib inline` directive is not needed anymore, though other third-party clients may still require it. This will produce a figure immediately below: ```python %matplotlib inline import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 3*np.pi, 500) plt.plot(x, np.sin(x**2)) plt.title('A simple chirp'); ``` ## License Licensed under the terms of the BSD 3-Clause License, by the IPython Development Team (see `LICENSE` file). matplotlib-inline-0.1.7/SECURITY.md000066400000000000000000000005041460722735400167440ustar00rootroot00000000000000# Security Policy ## Reporting a Vulnerability All IPython and Jupyter security are handled via security@ipython.org. You can find more information on the Jupyter website. https://jupyter.org/security ## Tidelift You can report security concerns for IPython via the [Tidelift platform](https://tidelift.com/security). matplotlib-inline-0.1.7/matplotlib_inline/000077500000000000000000000000001460722735400206615ustar00rootroot00000000000000matplotlib-inline-0.1.7/matplotlib_inline/__init__.py000066400000000000000000000001131460722735400227650ustar00rootroot00000000000000from . import backend_inline, config # noqa __version__ = "0.1.7" # noqa matplotlib-inline-0.1.7/matplotlib_inline/backend_inline.py000066400000000000000000000261321460722735400241640ustar00rootroot00000000000000"""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 matplotlib-inline-0.1.7/matplotlib_inline/config.py000066400000000000000000000075071460722735400225110ustar00rootroot00000000000000"""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) matplotlib-inline-0.1.7/pyproject.toml000066400000000000000000000026461460722735400201000ustar00rootroot00000000000000[build-system] build-backend = "setuptools.build_meta" requires = ["setuptools"] [project] name = "matplotlib-inline" description = "Inline Matplotlib backend for Jupyter" authors = [ {name = "IPython Development Team", email = "ipython-dev@python.org"}, ] classifiers = [ "Development Status :: 5 - Production/Stable", "Framework :: IPython", "Framework :: Jupyter", "Framework :: Jupyter :: JupyterLab", "Framework :: Jupyter :: JupyterLab :: 3", "Framework :: Jupyter :: JupyterLab :: 4", "Intended Audience :: Developers", "Intended Audience :: Science/Research", "License :: OSI Approved :: BSD License", "Programming Language :: Python", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Topic :: Multimedia :: Graphics", ] dependencies = ["traitlets"] dynamic = ["version"] keywords = [ "ipython", "jupyter", "matplotlib", "python", ] license = {file = "LICENSE"} readme = "README.md" requires-python = ">=3.8" [project.entry-points."matplotlib.backend"] inline = "matplotlib_inline.backend_inline" [project.urls] Homepage = "https://github.com/ipython/matplotlib-inline" [tool.setuptools.dynamic] version = {attr = "matplotlib_inline.__version__"} matplotlib-inline-0.1.7/setup.py000066400000000000000000000001341460722735400166640ustar00rootroot00000000000000# setup.py shim for use with applications that require it. __import__("setuptools").setup()