Ejemplo n.º 1
0
def test_restrict_dict():
    d = {'foo': 'bar', 1: 2}
    d1 = cbook.restrict_dict(d, ['foo', 1])
    assert d1 == d
    d2 = cbook.restrict_dict(d, ['bar', 2])
    assert d2 == {}
    d3 = cbook.restrict_dict(d, {'foo': 1})
    assert d3 == {'foo': 'bar'}
    d4 = cbook.restrict_dict(d, {})
    assert d4 == {}
    d5 = cbook.restrict_dict(d, {'foo', 2})
    assert d5 == {'foo': 'bar'}
    # check that d was not modified
    assert d == {'foo': 'bar', 1: 2}
Ejemplo n.º 2
0
def test_restrict_dict():
    d = {'foo': 'bar', 1: 2}
    d1 = cbook.restrict_dict(d, ['foo', 1])
    assert_equal(d1, d)
    d2 = cbook.restrict_dict(d, ['bar', 2])
    assert_equal(d2, {})
    d3 = cbook.restrict_dict(d, {'foo': 1})
    assert_equal(d3, {'foo': 'bar'})
    d4 = cbook.restrict_dict(d, {})
    assert_equal(d4, {})
    d5 = cbook.restrict_dict(d, set(['foo', 2]))
    assert_equal(d5, {'foo': 'bar'})
    # check that d was not modified
    assert_equal(d, {'foo': 'bar', 1: 2})
Ejemplo n.º 3
0
def test_restrict_dict():
    d = {'foo': 'bar', 1: 2}
    d1 = cbook.restrict_dict(d, ['foo', 1])
    assert_equal(d1, d)
    d2 = cbook.restrict_dict(d, ['bar', 2])
    assert_equal(d2, {})
    d3 = cbook.restrict_dict(d, {'foo': 1})
    assert_equal(d3, {'foo': 'bar'})
    d4 = cbook.restrict_dict(d, {})
    assert_equal(d4, {})
    d5 = cbook.restrict_dict(d, set(['foo', 2]))
    assert_equal(d5, {'foo': 'bar'})
    # check that d was not modified
    assert_equal(d, {'foo': 'bar', 1: 2})
Ejemplo n.º 4
0
def test_restrict_dict():
    d = {"foo": "bar", 1: 2}
    d1 = cbook.restrict_dict(d, ["foo", 1])
    assert d1 == d
    d2 = cbook.restrict_dict(d, ["bar", 2])
    assert d2 == {}
    d3 = cbook.restrict_dict(d, {"foo": 1})
    assert d3 == {"foo": "bar"}
    d4 = cbook.restrict_dict(d, {})
    assert d4 == {}
    d5 = cbook.restrict_dict(d, {"foo", 2})
    assert d5 == {"foo": "bar"}
    # check that d was not modified
    assert d == {"foo": "bar", 1: 2}
Ejemplo n.º 5
0
def test_restrict_dict():
    d = {'foo': 'bar', 1: 2}
    d1 = cbook.restrict_dict(d, ['foo', 1])
    assert d1 == d
    d2 = cbook.restrict_dict(d, ['bar', 2])
    assert d2 == {}
    d3 = cbook.restrict_dict(d, {'foo': 1})
    assert d3 == {'foo': 'bar'}
    d4 = cbook.restrict_dict(d, {})
    assert d4 == {}
    d5 = cbook.restrict_dict(d, {'foo', 2})
    assert d5 == {'foo': 'bar'}
    # check that d was not modified
    assert d == {'foo': 'bar', 1: 2}
Ejemplo n.º 6
0
def test_restrict_dict():
    d = {"foo": "bar", 1: 2}
    d1 = cbook.restrict_dict(d, ["foo", 1])
    assert_equal(d1, d)
    d2 = cbook.restrict_dict(d, ["bar", 2])
    assert_equal(d2, {})
    d3 = cbook.restrict_dict(d, {"foo": 1})
    assert_equal(d3, {"foo": "bar"})
    d4 = cbook.restrict_dict(d, {})
    assert_equal(d4, {})
    d5 = cbook.restrict_dict(d, set(["foo", 2]))
    assert_equal(d5, {"foo": "bar"})
    # check that d was not modified
    assert_equal(d, {"foo": "bar", 1: 2})
Ejemplo n.º 7
0
        def print_jpg(self, filename_or_obj, *args, **kwargs):
            """
            Supported kwargs:

            *quality*: The image quality, on a scale from 1 (worst) to
                95 (best). The default is 95, if not given in the
                matplotlibrc file in the savefig.jpeg_quality parameter.
                Values above 95 should be avoided; 100 completely
                disables the JPEG quantization stage.

            *optimize*: If present, indicates that the encoder should
                make an extra pass over the image in order to select
                optimal encoder settings.

            *progressive*: If present, indicates that this image
                should be stored as a progressive JPEG file.
            """
            buf, size = self.print_to_buffer()
            if kwargs.pop("dryrun", False):
                return
            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
            options = restrict_dict(kwargs, ['quality', 'optimize',
                                             'progressive'])

            if 'quality' not in options:
                options['quality'] = rcParams['savefig.jpeg_quality']

            return image.save(filename_or_obj, format='jpeg', **options)
Ejemplo n.º 8
0
        def print_jpg(self, filename_or_obj, *args, **kwargs):
            """
            Supported kwargs:

            *quality*: The image quality, on a scale from 1 (worst) to
                95 (best). The default is 95, if not given in the
                matplotlibrc file in the savefig.jpeg_quality parameter.
                Values above 95 should be avoided; 100 completely
                disables the JPEG quantization stage.

            *optimize*: If present, indicates that the encoder should
                make an extra pass over the image in order to select
                optimal encoder settings.

            *progressive*: If present, indicates that this image
                should be stored as a progressive JPEG file.
            """
            buf, size = self.print_to_buffer()
            if kwargs.pop("dryrun", False):
                return
            # The image is "pasted" onto a white background image to safely
            # handle any transparency
            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
            rgba = mcolors.to_rgba(rcParams.get('savefig.facecolor', 'white'))
            color = tuple([int(x * 255.0) for x in rgba[:3]])
            background = Image.new('RGB', size, color)
            background.paste(image, image)
            options = restrict_dict(kwargs,
                                    ['quality', 'optimize', 'progressive'])

            if 'quality' not in options:
                options['quality'] = rcParams['savefig.jpeg_quality']

            return background.save(filename_or_obj, format='jpeg', **options)
Ejemplo n.º 9
0
        def print_jpg(self, filename_or_obj, *args, **kwargs):
            """
            Supported kwargs:

            *quality*: The image quality, on a scale from 1 (worst) to
                95 (best). The default is 95, if not given in the
                matplotlibrc file in the savefig.jpeg_quality parameter.
                Values above 95 should be avoided; 100 completely
                disables the JPEG quantization stage.

            *optimize*: If present, indicates that the encoder should
                make an extra pass over the image in order to select
                optimal encoder settings.

            *progressive*: If present, indicates that this image
                should be stored as a progressive JPEG file.
            """
            buf, size = self.print_to_buffer()
            if kwargs.pop("dryrun", False):
                return
            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
            options = restrict_dict(kwargs, ['quality', 'optimize',
                                             'progressive'])

            if 'quality' not in options:
                options['quality'] = rcParams['savefig.jpeg_quality']

            return image.save(filename_or_obj, format='jpeg', **options)
Ejemplo n.º 10
0
        def print_jpg(self, filename_or_obj, *args, **kwargs):
            """
            Supported kwargs:

            *quality*: The image quality, on a scale from 1 (worst) to
                95 (best). The default is 95, if not given in the
                matplotlibrc file in the savefig.jpeg_quality parameter.
                Values above 95 should be avoided; 100 completely
                disables the JPEG quantization stage.

            *optimize*: If present, indicates that the encoder should
                make an extra pass over the image in order to select
                optimal encoder settings.

            *progressive*: If present, indicates that this image
                should be stored as a progressive JPEG file.
            """
            buf, size = self.print_to_buffer()
            if kwargs.pop("dryrun", False):
                return
            # The image is "pasted" onto a white background image to safely
            # handle any transparency
            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
            color = mcolors.colorConverter.to_rgb(
                rcParams.get('savefig.facecolor', 'white'))
            color = tuple([int(x * 255.0) for x in color])
            background = Image.new('RGB', size, color)
            background.paste(image, image)
            options = restrict_dict(kwargs, ['quality', 'optimize',
                                             'progressive'])

            if 'quality' not in options:
                options['quality'] = rcParams['savefig.jpeg_quality']

            return background.save(filename_or_obj, format='jpeg', **options)
Ejemplo n.º 11
0
def test_restrict_dict():
    d = {'foo': 'bar', 1: 2}
    with pytest.warns(cbook.deprecation.MatplotlibDeprecationWarning) as rec:
        d1 = cbook.restrict_dict(d, ['foo', 1])
        assert d1 == d
        d2 = cbook.restrict_dict(d, ['bar', 2])
        assert d2 == {}
        d3 = cbook.restrict_dict(d, {'foo': 1})
        assert d3 == {'foo': 'bar'}
        d4 = cbook.restrict_dict(d, {})
        assert d4 == {}
        d5 = cbook.restrict_dict(d, {'foo', 2})
        assert d5 == {'foo': 'bar'}
    assert len(rec) == 5
    # check that d was not modified
    assert d == {'foo': 'bar', 1: 2}
Ejemplo n.º 12
0
def test_restrict_dict():
    d = {'foo': 'bar', 1: 2}
    with pytest.warns(cbook.deprecation.MatplotlibDeprecationWarning) as rec:
        d1 = cbook.restrict_dict(d, ['foo', 1])
        assert d1 == d
        d2 = cbook.restrict_dict(d, ['bar', 2])
        assert d2 == {}
        d3 = cbook.restrict_dict(d, {'foo': 1})
        assert d3 == {'foo': 'bar'}
        d4 = cbook.restrict_dict(d, {})
        assert d4 == {}
        d5 = cbook.restrict_dict(d, {'foo', 2})
        assert d5 == {'foo': 'bar'}
    assert len(rec) == 5
    # check that d was not modified
    assert d == {'foo': 'bar', 1: 2}
Ejemplo n.º 13
0
    def _print_image(self, filename, format, *args, **kwargs):
        if self.flags() & gtk.REALIZED == 0:
            # for self.window(for pixmap) and has a side effect of altering
            # figure width,height (via configure-event?)
            gtk.DrawingArea.realize(self)

        width, height = self.get_width_height()
        pixmap = gdk.Pixmap(self.window, width, height)
        self._renderer.set_pixmap(pixmap)
        self._render_figure(pixmap, width, height)

        # jpg colors don't match the display very well, png colors match
        # better
        pixbuf = gdk.Pixbuf(gdk.COLORSPACE_RGB, 0, 8, width, height)
        pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0,
                                 width, height)

        # set the default quality, if we are writing a JPEG.
        # http://www.pygtk.org/docs/pygtk/class-gdkpixbuf.html#method-gdkpixbuf--save
        options = cbook.restrict_dict(kwargs, ['quality'])
        if format in ['jpg', 'jpeg']:
            if 'quality' not in options:
                options['quality'] = rcParams['savefig.jpeg_quality']

            options['quality'] = str(options['quality'])

        if is_string_like(filename):
            try:
                pixbuf.save(filename, format, options=options)
            except gobject.GError as exc:
                error_msg_gtk('Save figure failure:\n%s' % (exc, ),
                              parent=self)
        elif is_writable_file_like(filename):
            if hasattr(pixbuf, 'save_to_callback'):

                def save_callback(buf, data=None):
                    data.write(buf)

                try:
                    pixbuf.save_to_callback(save_callback,
                                            format,
                                            user_data=filename,
                                            options=options)
                except gobject.GError as exc:
                    error_msg_gtk('Save figure failure:\n%s' % (exc, ),
                                  parent=self)
            else:
                raise ValueError(
                    "Saving to a Python file-like object is only supported by PyGTK >= 2.8"
                )
        else:
            raise ValueError("filename must be a path or a file-like object")
Ejemplo n.º 14
0
    def _print_image(self, filename, format, *args, **kwargs):
        if self.flags() & gtk.REALIZED == 0:
            # for self.window(for pixmap) and has a side effect of altering
            # figure width,height (via configure-event?)
            gtk.DrawingArea.realize(self)

        width, height = self.get_width_height()
        pixmap = gdk.Pixmap(self.window, width, height)
        self._renderer.set_pixmap(pixmap)
        self._render_figure(pixmap, width, height)

        # jpg colors don't match the display very well, png colors match
        # better
        pixbuf = gdk.Pixbuf(gdk.COLORSPACE_RGB, 0, 8, width, height)
        pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0, width, height)

        # set the default quality, if we are writing a JPEG.
        # http://www.pygtk.org/docs/pygtk/class-gdkpixbuf.html#method-gdkpixbuf--save
        options = cbook.restrict_dict(kwargs, ["quality"])
        if format in ["jpg", "jpeg"]:
            if "quality" not in options:
                options["quality"] = rcParams["savefig.jpeg_quality"]

            options["quality"] = str(options["quality"])

        if is_string_like(filename):
            try:
                pixbuf.save(filename, format, options=options)
            except gobject.GError as exc:
                error_msg_gtk("Save figure failure:\n%s" % (exc,), parent=self)
        elif is_writable_file_like(filename):
            if hasattr(pixbuf, "save_to_callback"):

                def save_callback(buf, data=None):
                    data.write(buf)

                try:
                    pixbuf.save_to_callback(save_callback, format, user_data=filename, options=options)
                except gobject.GError as exc:
                    error_msg_gtk("Save figure failure:\n%s" % (exc,), parent=self)
            else:
                raise ValueError("Saving to a Python file-like object is only supported by PyGTK >= 2.8")
        else:
            raise ValueError("filename must be a path or a file-like object")
Ejemplo n.º 15
0
    def _print_image(self, filename, format, *args, **kwargs):
        width, height = self.get_width_height()
        pixmap = gtk.gdk.Pixmap(None, width, height, depth=24)
        self._render_figure(pixmap, width, height)

        # jpg colors don't match the display very well, png colors match
        # better
        pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, 0, 8, width, height)
        pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0, width, height)

        # set the default quality, if we are writing a JPEG.
        # http://www.pygtk.org/docs/pygtk/class-gdkpixbuf.html#method-gdkpixbuf--save
        options = restrict_dict(kwargs, ["quality"])
        if format in ["jpg", "jpeg"]:
            if "quality" not in options:
                options["quality"] = rcParams["savefig.jpeg_quality"]
            options["quality"] = str(options["quality"])

        pixbuf.save(filename, format, options=options)
Ejemplo n.º 16
0
    def _print_image(self, filename, format, *args, **kwargs):
        width, height = self.get_width_height()
        pixmap = gtk.gdk.Pixmap(None, width, height, depth=24)
        self._render_figure(pixmap, width, height)

        # jpg colors don't match the display very well, png colors match
        # better
        pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, 0, 8, width, height)
        pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0,
                                 width, height)

        # set the default quality, if we are writing a JPEG.
        # http://www.pygtk.org/docs/pygtk/class-gdkpixbuf.html#method-gdkpixbuf--save
        options = restrict_dict(kwargs, ['quality'])
        if format in ['jpg', 'jpeg']:
            if 'quality' not in options:
                options['quality'] = rcParams['savefig.jpeg_quality']
            options['quality'] = str(options['quality'])

        pixbuf.save(filename, format, options=options)