Suppress bunch of self-deprecation warnings

And exclude these deprecated modules from coverage report

IPython/core/tests/test_display.py

@@ -1,511 +1,515 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 import os
 import warnings
 
 from unittest import mock
 
 import pytest
 
 from IPython import display
 from IPython.core.getipython import get_ipython
 from IPython.utils.io import capture_output
 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
 from IPython import paths as ipath
 from IPython.testing.tools import AssertNotPrints
 
 import IPython.testing.decorators as dec
 
 def test_image_size():
     """Simple test for display.Image(args, width=x,height=y)"""
     thisurl = 'http://www.google.fr/images/srpr/logo3w.png'
     img = display.Image(url=thisurl, width=200, height=200)
     assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, metadata={'width':200, 'height':200})
     assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, width=200)
     assert '<img src="%s" width="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl)
     assert '<img src="%s"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, unconfined=True)
     assert '<img src="%s" class="unconfined"/>' % (thisurl) == img._repr_html_()
 
 
 def test_image_mimes():
     fmt = get_ipython().display_formatter.format
     for format in display.Image._ACCEPTABLE_EMBEDDINGS:
         mime = display.Image._MIMETYPES[format]
         img = display.Image(b'garbage', format=format)
         data, metadata = fmt(img)
         assert sorted(data) == sorted([mime, "text/plain"])
 
 
 def test_geojson():
 
     gj = display.GeoJSON(data={
             "type": "Feature",
             "geometry": {
                 "type": "Point",
                 "coordinates": [-81.327, 296.038]
             },
             "properties": {
                 "name": "Inca City"
             }
         },
         url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
         layer_options={
             "basemap_id": "celestia_mars-shaded-16k_global",
             "attribution": "Celestia/praesepe",
             "minZoom": 0,
             "maxZoom": 18,
         },
     )
     assert "<IPython.core.display.GeoJSON object>" == str(gj)
 
 
 def test_retina_png():
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.png"), retina=True)
     assert img.height == 1
     assert img.width == 1
     data, md = img._repr_png_()
     assert md["width"] == 1
     assert md["height"] == 1
 
 
 def test_embed_svg_url():
     import gzip
     from io import BytesIO
     svg_data = b'<svg><circle x="0" y="0" r="1"/></svg>'
     url = 'http://test.com/circle.svg'
 
     gzip_svg = BytesIO()
     with gzip.open(gzip_svg, 'wb') as fp:
         fp.write(svg_data)
     gzip_svg = gzip_svg.getvalue()
 
     def mocked_urlopen(*args, **kwargs):
         class MockResponse:
             def __init__(self, svg):
                 self._svg_data = svg
                 self.headers = {'content-type': 'image/svg+xml'}
 
             def read(self):
                 return self._svg_data
 
         if args[0] == url:
             return MockResponse(svg_data)
         elif args[0] == url + "z":
             ret = MockResponse(gzip_svg)
             ret.headers["content-encoding"] = "gzip"
             return ret
         return MockResponse(None)
 
     with mock.patch('urllib.request.urlopen', side_effect=mocked_urlopen):
         svg = display.SVG(url=url)
         assert svg._repr_svg_().startswith("<svg") is True
         svg = display.SVG(url=url + "z")
         assert svg._repr_svg_().startswith("<svg") is True
 
 
 def test_retina_jpeg():
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.jpg"), retina=True)
     assert img.height == 1
     assert img.width == 1
     data, md = img._repr_jpeg_()
     assert md["width"] == 1
     assert md["height"] == 1
 
 
 def test_base64image():
     display.Image("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAWJLR0QAiAUdSAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB94BCRQnOqNu0b4AAAAKSURBVAjXY2AAAAACAAHiIbwzAAAAAElFTkSuQmCC")
 
 def test_image_filename_defaults():
     '''test format constraint, and validity of jpeg and png'''
     tpath = ipath.get_ipython_package_dir()
     pytest.raises(
         ValueError,
         display.Image,
         filename=os.path.join(tpath, "testing/tests/badformat.zip"),
         embed=True,
     )
     pytest.raises(ValueError, display.Image)
     pytest.raises(
         ValueError,
         display.Image,
         data="this is not an image",
         format="badformat",
         embed=True,
     )
     # check boths paths to allow packages to test at build and install time
     imgfile = os.path.join(tpath, 'core/tests/2x2.png')
     img = display.Image(filename=imgfile)
     assert "png" == img.format
     assert img._repr_png_() is not None
     img = display.Image(
         filename=os.path.join(tpath, "testing/tests/logo.jpg"), embed=False
     )
     assert "jpeg" == img.format
     assert img._repr_jpeg_() is None
 
 def _get_inline_config():
     from matplotlib_inline.config import InlineBackend
     return InlineBackend.instance()
 
 
 @dec.skip_without("ipykernel")
 @dec.skip_without("matplotlib")
 def test_set_matplotlib_close():
     cfg = _get_inline_config()
     cfg.close_figures = False
-    display.set_matplotlib_close()
+    with pytest.deprecated_call():
+        display.set_matplotlib_close()
     assert cfg.close_figures
-    display.set_matplotlib_close(False)
+    with pytest.deprecated_call():
+        display.set_matplotlib_close(False)
     assert not cfg.close_figures
 
 _fmt_mime_map = {
     'png': 'image/png',
     'jpeg': 'image/jpeg',
     'pdf': 'application/pdf',
     'retina': 'image/png',
     'svg': 'image/svg+xml',
 }
 
 @dec.skip_without('matplotlib')
 def test_set_matplotlib_formats():
     from matplotlib.figure import Figure
     formatters = get_ipython().display_formatter.formatters
     for formats in [
         ('png',),
         ('pdf', 'svg'),
         ('jpeg', 'retina', 'png'),
         (),
     ]:
         active_mimes = {_fmt_mime_map[fmt] for fmt in formats}
-        display.set_matplotlib_formats(*formats)
+        with pytest.deprecated_call():
+            display.set_matplotlib_formats(*formats)
         for mime, f in formatters.items():
             if mime in active_mimes:
                 assert Figure in f
             else:
                 assert Figure not in f
 
 
 @dec.skip_without("ipykernel")
 @dec.skip_without("matplotlib")
 def test_set_matplotlib_formats_kwargs():
     from matplotlib.figure import Figure
     ip = get_ipython()
     cfg = _get_inline_config()
     cfg.print_figure_kwargs.update(dict(foo='bar'))
     kwargs = dict(dpi=150)
-    display.set_matplotlib_formats('png', **kwargs)
-    formatter = ip.display_formatter.formatters['image/png']
+    with pytest.deprecated_call():
+        display.set_matplotlib_formats("png", **kwargs)
+    formatter = ip.display_formatter.formatters["image/png"]
     f = formatter.lookup_by_type(Figure)
     formatter_kwargs = f.keywords
     expected = kwargs
     expected["base64"] = True
     expected["fmt"] = "png"
     expected.update(cfg.print_figure_kwargs)
     assert formatter_kwargs == expected
 
 def test_display_available():
     """
     Test that display is available without import
 
     We don't really care if it's in builtin or anything else, but it should
     always be available.
     """
     ip = get_ipython()
     with AssertNotPrints('NameError'):
         ip.run_cell('display')
     try:
         ip.run_cell('del display')
     except NameError:
         pass # it's ok, it might be in builtins
     # even if deleted it should be back
     with AssertNotPrints('NameError'):
         ip.run_cell('display')
 
 def test_textdisplayobj_pretty_repr():
     p = display.Pretty("This is a simple test")
     assert repr(p) == "<IPython.core.display.Pretty object>"
     assert p.data == "This is a simple test"
 
     p._show_mem_addr = True
     assert repr(p) == object.__repr__(p)
 
 
 def test_displayobject_repr():
     h = display.HTML("<br />")
     assert repr(h) == "<IPython.core.display.HTML object>"
     h._show_mem_addr = True
     assert repr(h) == object.__repr__(h)
     h._show_mem_addr = False
     assert repr(h) == "<IPython.core.display.HTML object>"
 
     j = display.Javascript("")
     assert repr(j) == "<IPython.core.display.Javascript object>"
     j._show_mem_addr = True
     assert repr(j) == object.__repr__(j)
     j._show_mem_addr = False
     assert repr(j) == "<IPython.core.display.Javascript object>"
 
 @mock.patch('warnings.warn')
 def test_encourage_iframe_over_html(m_warn):
     display.HTML()
     m_warn.assert_not_called()
 
     display.HTML('<br />')
     m_warn.assert_not_called()
 
     display.HTML('<html><p>Lots of content here</p><iframe src="http://a.com"></iframe>')
     m_warn.assert_not_called()
 
     display.HTML('<iframe src="http://a.com"></iframe>')
     m_warn.assert_called_with('Consider using IPython.display.IFrame instead')
 
     m_warn.reset_mock()
     display.HTML('<IFRAME SRC="http://a.com"></IFRAME>')
     m_warn.assert_called_with('Consider using IPython.display.IFrame instead')
 
 def test_progress():
     p = display.ProgressBar(10)
     assert "0/10" in repr(p)
     p.html_width = "100%"
     p.progress = 5
     assert (
         p._repr_html_() == "<progress style='width:100%' max='10' value='5'></progress>"
     )
 
 
 def test_progress_iter():
     with capture_output(display=False) as captured:
         for i in display.ProgressBar(5):
             out = captured.stdout
             assert "{0}/5".format(i) in out
     out = captured.stdout
     assert "5/5" in out
 
 
 def test_json():
     d = {'a': 5}
     lis = [d]
     metadata = [
         {'expanded': False, 'root': 'root'},
         {'expanded': True,  'root': 'root'},
         {'expanded': False, 'root': 'custom'},
         {'expanded': True,  'root': 'custom'},
     ]
     json_objs = [
         display.JSON(d),
         display.JSON(d, expanded=True),
         display.JSON(d, root='custom'),
         display.JSON(d, expanded=True, root='custom'),
     ]
     for j, md in zip(json_objs, metadata):
         assert j._repr_json_() == (d, md)
 
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         j = display.JSON(json.dumps(d))
         assert len(w) == 1
         assert j._repr_json_() == (d, metadata[0])
 
     json_objs = [
         display.JSON(lis),
         display.JSON(lis, expanded=True),
         display.JSON(lis, root='custom'),
         display.JSON(lis, expanded=True, root='custom'),
     ]
     for j, md in zip(json_objs, metadata):
         assert j._repr_json_() == (lis, md)
 
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         j = display.JSON(json.dumps(lis))
         assert len(w) == 1
         assert j._repr_json_() == (lis, metadata[0])
 
 
 def test_video_embedding():
     """use a tempfile, with dummy-data, to ensure that video embedding doesn't crash"""
     v = display.Video("http://ignored")
     assert not v.embed
     html = v._repr_html_()
     assert 'src="data:' not in html
     assert 'src="http://ignored"' in html
 
     with pytest.raises(ValueError):
         v = display.Video(b'abc')
 
     with NamedFileInTemporaryDirectory('test.mp4') as f:
         f.write(b'abc')
         f.close()
 
         v = display.Video(f.name)
         assert not v.embed
         html = v._repr_html_()
         assert 'src="data:' not in html
 
         v = display.Video(f.name, embed=True)
         html = v._repr_html_()
         assert 'src="data:video/mp4;base64,YWJj"' in html
 
         v = display.Video(f.name, embed=True, mimetype='video/other')
         html = v._repr_html_()
         assert 'src="data:video/other;base64,YWJj"' in html
 
         v = display.Video(b'abc', embed=True, mimetype='video/mp4')
         html = v._repr_html_()
         assert 'src="data:video/mp4;base64,YWJj"' in html
 
         v = display.Video(u'YWJj', embed=True, mimetype='video/xyz')
         html = v._repr_html_()
         assert 'src="data:video/xyz;base64,YWJj"' in html
 
 def test_html_metadata():
     s = "<h1>Test</h1>"
     h = display.HTML(s, metadata={"isolated": True})
     assert h._repr_html_() == (s, {"isolated": True})
 
 
 def test_display_id():
     ip = get_ipython()
     with mock.patch.object(ip.display_pub, 'publish') as pub:
         handle = display.display('x')
         assert handle is None
         handle = display.display('y', display_id='secret')
         assert isinstance(handle, display.DisplayHandle)
         handle2 = display.display('z', display_id=True)
         assert isinstance(handle2, display.DisplayHandle)
     assert handle.display_id != handle2.display_id
 
     assert pub.call_count == 3
     args, kwargs = pub.call_args_list[0]
     assert args == ()
     assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
         'metadata': {},
     }
     args, kwargs = pub.call_args_list[1]
     assert args == ()
     assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
         'metadata': {},
         'transient': {
             'display_id': handle.display_id,
         },
     }
     args, kwargs = pub.call_args_list[2]
     assert args == ()
     assert kwargs == {
         'data': {
             'text/plain': repr('z')
         },
         'metadata': {},
         'transient': {
             'display_id': handle2.display_id,
         },
     }
 
 
 def test_update_display():
     ip = get_ipython()
     with mock.patch.object(ip.display_pub, 'publish') as pub:
         with pytest.raises(TypeError):
             display.update_display('x')
         display.update_display('x', display_id='1')
         display.update_display('y', display_id='2')
     args, kwargs = pub.call_args_list[0]
     assert args == ()
     assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
         'metadata': {},
         'transient': {
             'display_id': '1',
         },
         'update': True,
     }
     args, kwargs = pub.call_args_list[1]
     assert args == ()
     assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
         'metadata': {},
         'transient': {
             'display_id': '2',
         },
         'update': True,
     }
 
 
 def test_display_handle():
     ip = get_ipython()
     handle = display.DisplayHandle()
     assert isinstance(handle.display_id, str)
     handle = display.DisplayHandle("my-id")
     assert handle.display_id == "my-id"
     with mock.patch.object(ip.display_pub, "publish") as pub:
         handle.display("x")
         handle.update("y")
 
     args, kwargs = pub.call_args_list[0]
     assert args == ()
     assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
         'metadata': {},
         'transient': {
             'display_id': handle.display_id,
         }
     }
     args, kwargs = pub.call_args_list[1]
     assert args == ()
     assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
         'metadata': {},
         'transient': {
             'display_id': handle.display_id,
         },
         'update': True,
     }
 
 
 def test_image_alt_tag():
     """Simple test for display.Image(args, alt=x,)"""
     thisurl = "http://example.com/image.png"
     img = display.Image(url=thisurl, alt="an image")
     assert '<img src="%s" alt="an image"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, unconfined=True, alt="an image")
     assert (
         '<img src="%s" class="unconfined" alt="an image"/>' % (thisurl)
         == img._repr_html_()
     )
     img = display.Image(url=thisurl, alt='>"& <')
     assert '<img src="%s" alt="&gt;&quot;&amp; &lt;"/>' % (thisurl) == img._repr_html_()
 
     img = display.Image(url=thisurl, metadata={"alt": "an image"})
     assert img.alt == "an image"
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.png"), alt="an image")
     assert img.alt == "an image"
     _, md = img._repr_png_()
     assert md["alt"] == "an image"
 
 
 def test_image_bad_filename_raises_proper_exception():
     with pytest.raises(FileNotFoundError):
         display.Image("/this/file/does/not/exist/")._repr_png_()

IPython/core/tests/test_pylabtools.py

@@ -1,274 +1,274 b''
 """Tests for pylab tools module.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 from binascii import a2b_base64
 from io import BytesIO
 
 import pytest
 
 matplotlib = pytest.importorskip("matplotlib")
 matplotlib.use('Agg')
 from matplotlib.figure import Figure
 
 from matplotlib import pyplot as plt
 from matplotlib_inline import backend_inline
 import numpy as np
 
 from IPython.core.getipython import get_ipython
 from IPython.core.interactiveshell import InteractiveShell
 from IPython.core.display import _PNG, _JPEG
 from .. import pylabtools as pt
 
 from IPython.testing import decorators as dec
 
 
 def test_figure_to_svg():
     # simple empty-figure test
     fig = plt.figure()
     assert pt.print_figure(fig, "svg") is None
 
     plt.close('all')
 
     # simple check for at least svg-looking output
     fig = plt.figure()
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
     svg = pt.print_figure(fig, "svg")[:100].lower()
     assert "doctype svg" in svg
 
 
 def _check_pil_jpeg_bytes():
     """Skip if PIL can't write JPEGs to BytesIO objects"""
     # PIL's JPEG plugin can't write to BytesIO objects
     # Pillow fixes this
     from PIL import Image
     buf = BytesIO()
     img = Image.new("RGB", (4,4))
     try:
         img.save(buf, 'jpeg')
     except Exception as e:
         ename = e.__class__.__name__
         raise pytest.skip("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e)) from e
 
 @dec.skip_without("PIL.Image")
 def test_figure_to_jpeg():
     _check_pil_jpeg_bytes()
     # simple check for at least jpeg-looking output
     fig = plt.figure()
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
     jpeg = pt.print_figure(fig, 'jpeg', pil_kwargs={'optimize': 50})[:100].lower()
     assert jpeg.startswith(_JPEG)
 
 def test_retina_figure():
     # simple empty-figure test
     fig = plt.figure()
     assert pt.retina_figure(fig) == None
     plt.close('all')
 
     fig = plt.figure()
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
     png, md = pt.retina_figure(fig)
     assert png.startswith(_PNG)
     assert "width" in md
     assert "height" in md
 
 
 _fmt_mime_map = {
     'png': 'image/png',
     'jpeg': 'image/jpeg',
     'pdf': 'application/pdf',
     'retina': 'image/png',
     'svg': 'image/svg+xml',
 }
 
 def test_select_figure_formats_str():
     ip = get_ipython()
     for fmt, active_mime in _fmt_mime_map.items():
         pt.select_figure_formats(ip, fmt)
         for mime, f in ip.display_formatter.formatters.items():
             if mime == active_mime:
                 assert Figure in f
             else:
                 assert Figure not in f
 
 def test_select_figure_formats_kwargs():
     ip = get_ipython()
-    kwargs = dict(quality=10, bbox_inches='tight')
-    pt.select_figure_formats(ip, 'png', **kwargs)
-    formatter = ip.display_formatter.formatters['image/png']
+    kwargs = dict(bbox_inches="tight")
+    pt.select_figure_formats(ip, "png", **kwargs)
+    formatter = ip.display_formatter.formatters["image/png"]
     f = formatter.lookup_by_type(Figure)
     cell = f.keywords
     expected = kwargs
     expected["base64"] = True
     expected["fmt"] = "png"
     assert cell == expected
 
     # check that the formatter doesn't raise
     fig = plt.figure()
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
     formatter.enabled = True
     png = formatter(fig)
     assert isinstance(png, str)
     png_bytes = a2b_base64(png)
     assert png_bytes.startswith(_PNG)
 
 def test_select_figure_formats_set():
     ip = get_ipython()
     for fmts in [
         {'png', 'svg'},
         ['png'],
         ('jpeg', 'pdf', 'retina'),
         {'svg'},
     ]:
         active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
         pt.select_figure_formats(ip, fmts)
         for mime, f in ip.display_formatter.formatters.items():
             if mime in active_mimes:
                 assert Figure in f
             else:
                 assert Figure not in f
 
 def test_select_figure_formats_bad():
     ip = get_ipython()
     with pytest.raises(ValueError):
         pt.select_figure_formats(ip, 'foo')
     with pytest.raises(ValueError):
         pt.select_figure_formats(ip, {'png', 'foo'})
     with pytest.raises(ValueError):
         pt.select_figure_formats(ip, ['retina', 'pdf', 'bar', 'bad'])
 
 def test_import_pylab():
     ns = {}
     pt.import_pylab(ns, import_all=False)
     assert "plt" in ns
     assert ns["np"] == np
 
 
 from traitlets.config import Config
 
 
 class TestPylabSwitch(object):
     class Shell(InteractiveShell):
         def init_history(self):
             """Sets up the command history, and starts regular autosaves."""
             self.config.HistoryManager.hist_file = ":memory:"
             super().init_history()
 
         def enable_gui(self, gui):
             pass
 
     def setup(self):
         import matplotlib
         def act_mpl(backend):
             matplotlib.rcParams['backend'] = backend
 
         # Save rcParams since they get modified
         self._saved_rcParams = matplotlib.rcParams
         self._saved_rcParamsOrig = matplotlib.rcParamsOrig
         matplotlib.rcParams = dict(backend='Qt4Agg')
         matplotlib.rcParamsOrig = dict(backend='Qt4Agg')
 
         # Mock out functions
         self._save_am = pt.activate_matplotlib
         pt.activate_matplotlib = act_mpl
         self._save_ip = pt.import_pylab
         pt.import_pylab = lambda *a,**kw:None
         self._save_cis = backend_inline.configure_inline_support
         backend_inline.configure_inline_support = lambda *a, **kw: None
 
     def teardown(self):
         pt.activate_matplotlib = self._save_am
         pt.import_pylab = self._save_ip
         backend_inline.configure_inline_support = self._save_cis
         import matplotlib
         matplotlib.rcParams = self._saved_rcParams
         matplotlib.rcParamsOrig = self._saved_rcParamsOrig
 
     def test_qt(self):
 
         s = self.Shell()
         gui, backend = s.enable_matplotlib(None)
         assert gui == "qt"
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib("inline")
         assert gui == "inline"
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib("qt")
         assert gui == "qt"
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib("inline")
         assert gui == "inline"
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib()
         assert gui == "qt"
         assert s.pylab_gui_select == "qt"
 
     def test_inline(self):
         s = self.Shell()
         gui, backend = s.enable_matplotlib("inline")
         assert gui == "inline"
         assert s.pylab_gui_select == None
 
         gui, backend = s.enable_matplotlib("inline")
         assert gui == "inline"
         assert s.pylab_gui_select == None
 
         gui, backend = s.enable_matplotlib("qt")
         assert gui == "qt"
         assert s.pylab_gui_select == "qt"
 
     def test_inline_twice(self):
         "Using '%matplotlib inline' twice should not reset formatters"
 
         ip = self.Shell()
         gui, backend = ip.enable_matplotlib("inline")
         assert gui == "inline"
 
         fmts =  {'png'}
         active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
         pt.select_figure_formats(ip, fmts)
 
         gui, backend = ip.enable_matplotlib("inline")
         assert gui == "inline"
 
         for mime, f in ip.display_formatter.formatters.items():
             if mime in active_mimes:
                 assert Figure in f
             else:
                 assert Figure not in f
 
     def test_qt_gtk(self):
         s = self.Shell()
         gui, backend = s.enable_matplotlib("qt")
         assert gui == "qt"
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib("gtk")
         assert gui == "qt"
         assert s.pylab_gui_select == "qt"
 
 
 def test_no_gui_backends():
     for k in ['agg', 'svg', 'pdf', 'ps']:
         assert k not in pt.backend2gui
 
 
 def test_figure_no_canvas():
     fig = Figure()
     fig.canvas = None
     pt.print_figure(fig)

codecov.yml

@@ -1,8 +1,20 b''
 coverage:
   status:
     patch: off
     project:
       default:
         target: auto
 codecov:
   require_ci_to_pass: false
+
+ignore:
+  - IPython/kernel/*
+  - IPython/consoleapp.py
+  - IPython/core/inputsplitter.py
+  - IPython/lib/inputhook*.py
+  - IPython/lib/kernel.py
+  - IPython/utils/jsonutil.py
+  - IPython/utils/localinterfaces.py
+  - IPython/utils/log.py
+  - IPython/utils/signatures.py
+  - IPython/utils/traitlets.py

pytest.ini

@@ -1,43 +1,47 b''
 [pytest]
 addopts = --durations=10
     -p IPython.testing.plugin.pytest_ipdoctest --ipdoctest-modules
     --ignore=docs
     --ignore=examples
     --ignore=htmlcov
     --ignore=ipython_kernel
     --ignore=ipython_parallel
     --ignore=results
     --ignore=tmp
     --ignore=tools
     --ignore=traitlets
     --ignore=IPython/core/tests/daft_extension
     --ignore=IPython/sphinxext
     --ignore=IPython/terminal/pt_inputhooks
     --ignore=IPython/__main__.py
     --ignore=IPython/config.py
     --ignore=IPython/frontend.py
     --ignore=IPython/html.py
     --ignore=IPython/nbconvert.py
     --ignore=IPython/nbformat.py
     --ignore=IPython/parallel.py
     --ignore=IPython/qt.py
     --ignore=IPython/external/qt_for_kernel.py
     --ignore=IPython/html/widgets/widget_link.py
     --ignore=IPython/html/widgets/widget_output.py
-    --ignore=IPython/lib/inputhookglut.py
-    --ignore=IPython/lib/inputhookgtk.py
-    --ignore=IPython/lib/inputhookgtk3.py
-    --ignore=IPython/lib/inputhookgtk4.py
-    --ignore=IPython/lib/inputhookpyglet.py
-    --ignore=IPython/lib/inputhookqt4.py
-    --ignore=IPython/lib/inputhookwx.py
     --ignore=IPython/terminal/console.py
     --ignore=IPython/terminal/ptshell.py
     --ignore=IPython/utils/_process_cli.py
     --ignore=IPython/utils/_process_posix.py
     --ignore=IPython/utils/_process_win32.py
     --ignore=IPython/utils/_process_win32_controller.py
     --ignore=IPython/utils/daemonize.py
     --ignore=IPython/utils/eventful.py
+
+    --ignore=IPython/kernel
+    --ignore=IPython/consoleapp.py
+    --ignore=IPython/core/inputsplitter.py
+    --ignore-glob=IPython/lib/inputhook*.py
+    --ignore=IPython/lib/kernel.py
+    --ignore=IPython/utils/jsonutil.py
+    --ignore=IPython/utils/localinterfaces.py
+    --ignore=IPython/utils/log.py
+    --ignore=IPython/utils/signatures.py
+    --ignore=IPython/utils/traitlets.py
 doctest_optionflags = NORMALIZE_WHITESPACE ELLIPSIS
 ipdoctest_optionflags = NORMALIZE_WHITESPACE ELLIPSIS