img: substitute Image for Image_OLD

Steve Canny · Steve Canny · commit e8d7b558d5b7 · 2014-03-01T01:35:31.000-08:00
Remove now-dead code
diff --git a/docx/image/__init__.py b/docx/image/__init__.py
@@ -9,22 +9,11 @@
     absolute_import, division, print_function, unicode_literals
 )
 
-import hashlib
-import os
-
-try:
-    from PIL import Image as PIL_Image
-except ImportError:
-    import Image as PIL_Image
-
-from docx.compat import BytesIO, is_string
 from docx.image.bmp import Bmp
 from docx.image.gif import Gif
 from docx.image.jpeg import Exif, Jfif
 from docx.image.png import Png
 from docx.image.tiff import Tiff
-from docx.opc.constants import CONTENT_TYPE as CT
-from docx.shared import lazyproperty
 
 
 SIGNATURES = (
@@ -38,175 +27,3 @@
     (Tiff, 0, b'II*\x00'),  # little-endian (Intel) TIFF
     (Bmp,  0, b'BM'),
 )
-
-
-class Image_OLD(object):
-    """
-    A helper object that knows how to analyze an image file.
-    """
-    def __init__(
-            self, blob, filename, content_type, px_width, px_height,
-            horz_dpi, vert_dpi):
-        super(Image_OLD, self).__init__()
-        self._blob = blob
-        self._filename = filename
-        self._content_type = content_type
-        self._px_width = px_width
-        self._px_height = px_height
-        self._horz_dpi = horz_dpi
-        self._vert_dpi = vert_dpi
-
-    @property
-    def blob(self):
-        """
-        The bytes of the image 'file'
-        """
-        return self._blob
-
-    @property
-    def content_type(self):
-        """
-        The MIME type of the image, e.g. 'image/png'.
-        """
-        return self._content_type
-
-    @lazyproperty
-    def ext(self):
-        """
-        The file extension for the image. If an actual one is available from
-        a load filename it is used. Otherwise a canonical extension is
-        assigned based on the content type.
-        """
-        return os.path.splitext(self._filename)[1][1:]
-
-    @property
-    def filename(self):
-        """
-        Original image file name, if loaded from disk, or a generic filename
-        if loaded from an anonymous stream.
-        """
-        return self._filename
-
-    @classmethod
-    def from_blob(cls, blob):
-        stream = BytesIO(blob)
-        return cls._from_stream(stream, blob)
-
-    @classmethod
-    def from_file(cls, image_descriptor):
-        """
-        Return a new |Image| instance loaded from the image file identified
-        by *image_descriptor*, a path or file-like object.
-        """
-        if is_string(image_descriptor):
-            path = image_descriptor
-            with open(path, 'rb') as f:
-                blob = f.read()
-                stream = BytesIO(blob)
-            filename = os.path.basename(path)
-        else:
-            stream = image_descriptor
-            stream.seek(0)
-            blob = stream.read()
-            filename = None
-        return cls._from_stream(stream, blob, filename)
-
-    @property
-    def horz_dpi(self):
-        """
-        The horizontal dots per inch (dpi) of the image, defaults to 72 when
-        no dpi information is stored in the image, as is often the case.
-        """
-        return self._horz_dpi
-
-    @property
-    def px_width(self):
-        """
-        The horizontal pixel dimension of the image
-        """
-        return self._px_width
-
-    @property
-    def px_height(self):
-        """
-        The vertical pixel dimension of the image
-        """
-        return self._px_height
-
-    @lazyproperty
-    def sha1(self):
-        """
-        SHA1 hash digest of the image blob
-        """
-        return hashlib.sha1(self._blob).hexdigest()
-
-    @property
-    def vert_dpi(self):
-        """
-        The vertical dots per inch (dpi) of the image, defaults to 72 when no
-        dpi information is stored in the image.
-        """
-        return self._vert_dpi
-
-    @classmethod
-    def _analyze_image(cls, stream):
-        pil_image = cls._open_pillow_image(stream)
-        content_type = cls._format_content_type(pil_image.format)
-        px_width, px_height = pil_image.size
-        try:
-            horz_dpi, vert_dpi = pil_image.info.get('dpi')
-        except:
-            horz_dpi, vert_dpi = (72, 72)
-        return content_type, px_width, px_height, horz_dpi, vert_dpi
-
-    @classmethod
-    def _def_mime_ext(cls, mime_type):
-        """
-        Return the default file extension, e.g. ``'.png'``, corresponding to
-        *mime_type*. Raises |KeyError| for unsupported image types.
-        """
-        content_type_extensions = {
-            CT.BMP: '.bmp', CT.GIF: '.gif', CT.JPEG: '.jpg', CT.PNG: '.png',
-            CT.TIFF: '.tiff', CT.X_WMF: '.wmf'
-        }
-        return content_type_extensions[mime_type]
-
-    @classmethod
-    def _format_content_type(cls, format):
-        """
-        Return the content type string (MIME type for images) corresponding
-        to the Pillow image format string *format*.
-        """
-        format_content_types = {
-            'BMP': CT.BMP, 'GIF': CT.GIF, 'JPEG': CT.JPEG, 'PNG': CT.PNG,
-            'TIFF': CT.TIFF, 'WMF': CT.X_WMF
-        }
-        return format_content_types[format]
-
-    @classmethod
-    def _from_stream(cls, stream, blob, filename=None):
-        content_type, px_width, px_height, horz_dpi, vert_dpi = (
-            cls._analyze_image(stream)
-        )
-        if filename is None:
-            filename = 'image%s' % cls._def_mime_ext(content_type)
-        return cls(
-            blob, filename, content_type, px_width, px_height, horz_dpi,
-            vert_dpi
-        )
-
-    @classmethod
-    def _open_pillow_image(cls, stream):
-        """
-        Return a Pillow ``Image`` instance loaded from the image file-like
-        object *stream*. The image is validated to confirm it is a supported
-        image type.
-        """
-        stream.seek(0)
-        pil_image = PIL_Image.open(stream)
-        try:
-            cls._format_content_type(pil_image.format)
-        except KeyError:
-            tmpl = "unsupported image format '%s'"
-            raise ValueError(tmpl % (pil_image.format))
-        return pil_image
diff --git a/docx/package.py b/docx/package.py
@@ -6,10 +6,11 @@
 
 from __future__ import absolute_import, print_function, unicode_literals
 
+from docx.image.image import Image
 from docx.opc.constants import RELATIONSHIP_TYPE as RT
 from docx.opc.package import OpcPackage
 from docx.opc.packuri import PackURI
-from docx.parts.image import Image_OLD, ImagePart
+from docx.parts.image import ImagePart
 from docx.shared import lazyproperty
 
 
@@ -72,7 +73,7 @@ def get_or_add_image_part(self, image_descriptor):
         *image_descriptor*, newly created if a matching one is not present in
         the collection.
         """
-        image = Image_OLD.from_file(image_descriptor)
+        image = Image.from_file(image_descriptor)
         matching_image_part = self._get_by_sha1(image.sha1)
         if matching_image_part is not None:
             return matching_image_part
diff --git a/docx/parts/image.py b/docx/parts/image.py
@@ -10,7 +10,7 @@
 
 import hashlib
 
-from docx.image import Image_OLD
+from docx.image.image import Image
 from docx.opc.package import Part
 from docx.shared import Emu, Inches
 
@@ -70,7 +70,7 @@ def from_image(cls, image, partname):
     @property
     def image(self):
         if self._image is None:
-            self._image = Image_OLD.from_blob(self.blob)
+            self._image = Image.from_blob(self.blob)
         return self._image
 
     @classmethod
diff --git a/features/img-characterize-image.feature b/features/img-characterize-image.feature
@@ -3,7 +3,6 @@ Feature: Characterize an image file
   As a programmer using the advanced python-docx API
   I need a way to determine the image content type and size
 
-  @wip
   Scenario Outline: Characterize an image file
     Given the image file '<filename>'
      When I construct an image using the image path
diff --git a/tests/image/test_image.py b/tests/image/test_image.py
@@ -9,7 +9,6 @@
 import pytest
 
 from docx.compat import BytesIO
-from docx.image import Image_OLD
 from docx.image.bmp import Bmp
 from docx.image.exceptions import UnrecognizedImageError
 from docx.image.gif import Gif
@@ -98,6 +97,20 @@ def it_knows_the_sha1_of_its_image(self):
         image = Image(blob, None, None)
         assert image.sha1 == '4921e7002ddfba690a937d54bda226a7b8bdeb68'
 
+    def it_correctly_characterizes_known_images(self, known_image_fixture):
+        image_path, characteristics = known_image_fixture
+        ext, content_type, px_width, px_height, horz_dpi, vert_dpi = (
+            characteristics
+        )
+        with open(test_file(image_path), 'rb') as stream:
+            image = Image.from_file(stream)
+            assert image.content_type == content_type
+            assert image.ext == ext
+            assert image.px_width == px_width
+            assert image.px_height == px_height
+            assert image.horz_dpi == horz_dpi
+            assert image.vert_dpi == vert_dpi
+
     # fixtures -------------------------------------------------------
 
     @pytest.fixture
@@ -191,6 +204,23 @@ def image_header_(self, request):
     def Image__init_(self, request):
         return initializer_mock(request, Image)
 
+    @pytest.fixture(params=[0, 1, 2, 3, 4, 5, 6, 7, 8])
+    def known_image_fixture(self, request):
+        cases = (
+            ('python.bmp',       ('bmp',  CT.BMP,   211,   71,  96,  96)),
+            ('sonic.gif',        ('gif',  CT.GIF,   290,  360,  72,  72)),
+            ('python-icon.jpeg', ('jpg',  CT.JPEG,  204,  204,  72,  72)),
+            ('300-dpi.jpg',      ('jpg',  CT.JPEG, 1504, 1936, 300, 300)),
+            ('monty-truth.png',  ('png',  CT.PNG,   150,  214,  72,  72)),
+            ('150-dpi.png',      ('png',  CT.PNG,   901, 1350, 150, 150)),
+            ('300-dpi.png',      ('png',  CT.PNG,   860,  579, 300, 300)),
+            ('72-dpi.tiff',      ('tiff', CT.TIFF,   48,   48,  72,  72)),
+            ('300-dpi.TIF',      ('tiff', CT.TIFF, 2464, 3248, 300, 300)),
+            # ('CVS_LOGO.WMF',     ('wmf',  CT.X_WMF, 149,   59,  72,  72)),
+        )
+        image_filename, characteristics = cases[request.param]
+        return image_filename, characteristics
+
     @pytest.fixture
     def stream_(self, request):
         return instance_mock(request, BytesIO)
@@ -253,66 +283,3 @@ def it_knows_the_horz_and_vert_dpi_of_the_image(self):
         image_header = BaseImageHeader(None, None, horz_dpi, vert_dpi)
         assert image_header.horz_dpi == horz_dpi
         assert image_header.vert_dpi == vert_dpi
-
-
-class DescribeImage_OLD(object):
-
-    def it_can_construct_from_an_image_path(self):
-        image_file_path = test_file('monty-truth.png')
-        image = Image_OLD.from_file(image_file_path)
-        assert isinstance(image, Image_OLD)
-        assert image.sha1 == '79769f1e202add2e963158b532e36c2c0f76a70c'
-        assert image.filename == 'monty-truth.png'
-
-    def it_can_construct_from_an_image_stream(self):
-        image_file_path = test_file('monty-truth.png')
-        with open(image_file_path, 'rb') as image_file_stream:
-            image = Image_OLD.from_file(image_file_stream)
-        assert isinstance(image, Image_OLD)
-        assert image.sha1 == '79769f1e202add2e963158b532e36c2c0f76a70c'
-        assert image.filename == 'image.png'
-
-    def it_knows_the_extension_of_a_file_based_image(self):
-        image_file_path = test_file('monty-truth.png')
-        image = Image_OLD.from_file(image_file_path)
-        assert image.ext == 'png'
-
-    def it_knows_the_extension_of_a_stream_based_image(self):
-        image_file_path = test_file('monty-truth.png')
-        with open(image_file_path, 'rb') as image_file_stream:
-            image = Image_OLD.from_file(image_file_stream)
-        assert image.ext == 'png'
-
-    def it_correctly_characterizes_a_few_known_images(
-            self, known_image_fixture):
-        image_path, characteristics = known_image_fixture
-        ext, content_type, px_width, px_height, horz_dpi, vert_dpi = (
-            characteristics
-        )
-        with open(test_file(image_path), 'rb') as stream:
-            image = Image_OLD.from_file(stream)
-            assert image.ext == ext
-            assert image.content_type == content_type
-            assert image.px_width == px_width
-            assert image.px_height == px_height
-            assert image.horz_dpi == horz_dpi
-            assert image.vert_dpi == vert_dpi
-
-    # fixtures -------------------------------------------------------
-
-    @pytest.fixture(params=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-    def known_image_fixture(self, request):
-        cases = (
-            ('python.bmp',       ('bmp',  CT.BMP,   211,   71,  72,  72)),
-            ('sonic.gif',        ('gif',  CT.GIF,   290,  360,  72,  72)),
-            ('python-icon.jpeg', ('jpg',  CT.JPEG,  204,  204,  72,  72)),
-            ('300-dpi.jpg',      ('jpg',  CT.JPEG, 1504, 1936, 300, 300)),
-            ('monty-truth.png',  ('png',  CT.PNG,   150,  214,  72,  72)),
-            ('150-dpi.png',      ('png',  CT.PNG,   901, 1350, 150, 150)),
-            ('300-dpi.png',      ('png',  CT.PNG,   860,  579, 300, 300)),
-            ('72-dpi.tiff',      ('tiff', CT.TIFF,   48,   48,  72,  72)),
-            ('300-dpi.TIF',      ('tiff', CT.TIFF, 2464, 3248, 300, 300)),
-            ('CVS_LOGO.WMF',     ('wmf',  CT.X_WMF, 149,   59,  72,  72)),
-        )
-        image_filename, characteristics = cases[request.param]
-        return image_filename, characteristics
diff --git a/tests/parts/test_image.py b/tests/parts/test_image.py
@@ -8,7 +8,7 @@
 
 import pytest
 
-from docx.image import Image_OLD
+from docx.image.image import Image
 from docx.opc.constants import CONTENT_TYPE as CT, RELATIONSHIP_TYPE as RT
 from docx.opc.package import PartFactory
 from docx.opc.packuri import PackURI
@@ -68,7 +68,7 @@ def blob_(self, request):
     @pytest.fixture(params=['loaded', 'new'])
     def dimensions_fixture(self, request):
         image_file_path = test_file('monty-truth.png')
-        image = Image_OLD.from_file(image_file_path)
+        image = Image.from_file(image_file_path)
         expected_cx, expected_cy = 1905000, 2717800
 
         # case 1: image part is loaded by PartFactory w/no Image inst
@@ -102,7 +102,7 @@ def from_image_fixture(self, image_, partname_, ImagePart__init__):
 
     @pytest.fixture
     def image_(self, request):
-        return instance_mock(request, Image_OLD)
+        return instance_mock(request, Image)
 
     @pytest.fixture
     def ImagePart__init__(self, request):
diff --git a/tests/test_package.py b/tests/test_package.py
