Python image.Image类代码示例

    def test_switches_backend(self):
        """
        Tests that calling an operation will switch backend if the current
        backend doesn't support it
        """
        def say_hello(backend):
            return "Hello world!"

        self.FakeBackend.operations = {
            'say_hello': say_hello,
        }

        def say_goodbye(backend):
            return "Goodbye!"

        self.AnotherFakeBackend.operations = {
            'say_goodbye': say_goodbye,
        }

        image = Image(self.FakeBackend(), 'jpeg')
        self.assertIsInstance(image.backend, self.FakeBackend)

        image.say_goodbye()
        self.assertIsInstance(image.backend, self.AnotherFakeBackend)

        image.say_hello()
        self.assertIsInstance(image.backend, self.FakeBackend)

    def test_register_backend(self):
        """
        Tests basic usage of register_backend
        """
        Image.register_backend(self.FakeBackend)

        self.assertEqual(Image.backends, [self.FakeBackend])

    def test_register_backend_multiple(self):
        """
        Tests register_backend can register multiple backends
        """
        Image.register_backend(self.FakeBackend)
        Image.register_backend(self.AnotherFakeBackend)

        self.assertEqual(Image.backends, [self.FakeBackend, self.AnotherFakeBackend])

    def test_save_as_foo(self):
        image = Image()
        image.save_as_jpeg = mock.MagicMock()

        with self.assertRaises(ValueError):
            image.save("foo", "outfile")

        self.assertFalse(image.save_as_jpeg.mock_calls)

    def test_register_backend_removes_duplicates(self):
        """
        Tests register_backend won't insert the same backend more than once
        """
        Image.register_backend(self.FakeBackend)
        Image.register_backend(self.FakeBackend)

        self.assertEqual(Image.backends, [self.FakeBackend])

    def test_raises_error_on_invalid_header(self):
        import imghdr

        f = io.BytesIO()
        f.write(b'Not an image')
        f.seek(0)

        with self.assertRaises(UnrecognisedImageFormatError) as e:
            Image.open(f)

    def test_register_loader(self):
        """
        Tests basic usage of register_loader
        """
        Image.register_loader('jpeg', self.FakeBackend)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (0, self.FakeBackend),
            ],
        })

    def test_register_loader_priority(self):
        """
        Tests that register_loader saves priority
        """
        Image.register_loader('jpeg', self.FakeBackend, priority=100)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (100, self.FakeBackend),
            ],
        })

def has_jpeg_support():
    wagtail_jpg = os.path.join(os.path.dirname(__file__), 'check_files', 'wagtail.jpg')
    succeeded = True

    with open(wagtail_jpg, 'rb') as f:
        try:
            Image.open(f)
        except (IOError, Image.LoaderError):
            succeeded = False

    return succeeded

    def test_image_format_detection(self):
        Image.loaders = {
            'png': [
                (0, self.FakeBackend),
            ],
            'jpeg': [
                (100, self.AnotherFakeBackend),
            ],
        }

        self.assertIsInstance(Image.open('tests/images/transparent.png').backend, self.FakeBackend)
        self.assertIsInstance(Image.open('tests/images/flower.jpg').backend, self.AnotherFakeBackend)

    def test_register_loader_priority_multiple(self):
        """
        Tests that register_loader keeps the loaders list sorted by priority
        """
        Image.register_loader('jpeg', self.FakeBackend, priority=100)
        Image.register_loader('jpeg', self.AnotherFakeBackend, priority=200)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (100, self.FakeBackend),
                (200, self.AnotherFakeBackend),
            ],
        })

    def test_register_loader_priority_same(self):
        """
        Tests that new loaders are placed after loaders that have the same
        priority
        """
        Image.register_loader('jpeg', self.FakeBackend)
        Image.register_loader('jpeg', self.AnotherFakeBackend)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (0, self.FakeBackend),
                (0, self.AnotherFakeBackend),
            ],
        })

    def test_register_loader_different_extension_at_same_time_with_priority(self):
        """
        Tests that register_loader saves priority when using multipe extensions
        """
        Image.register_loader(['jpeg', 'gif'], self.FakeBackend, priority=100)

        self.assertEqual(Image.loaders, {
            'jpeg': [
                (100, self.FakeBackend),
            ],
            'gif': [
                (100, self.FakeBackend),
            ],
        })

    def test_image_detect_stream(self):
        Image.loaders = {
            'png': [
                (0, self.FakeBackend),
            ],
            'jpeg': [
                (100, self.AnotherFakeBackend),
            ],
        }

        with open('tests/images/transparent.png', 'rb') as f:
            self.assertIsInstance(Image.open(f).backend, self.FakeBackend)
        with open('tests/images/flower.jpg', 'rb') as f:
            self.assertIsInstance(Image.open(f).backend, self.AnotherFakeBackend)

    def test_return_value_gets_passed_back(self):
        """
        Tests that the return value of the underlying function gets passed back
        to the caller
        """
        def myop(backend):
            return "Hello world!"

        self.FakeBackend.operations = {
            'test': myop,
        }

        image = Image(self.FakeBackend(), 'jpeg')

        self.assertEqual(image.test(), "Hello world!")