img: add Png.from_stream()

Steve Canny · Steve Canny · commit 82ced1b731c4 · 2014-02-27T12:08:33.000-08:00
diff --git a/docx/image/helpers.py b/docx/image/helpers.py
@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+from __future__ import absolute_import, division, print_function
+
+
+class StreamReader(object):
+    """
+    Wraps a file-like object to provide access to structured data from a
+    binary file. Byte-order is configurable. *base_offset* is added to any
+    base value provided to calculate actual location for reads.
+    """
diff --git a/docx/image/image.py b/docx/image/image.py
@@ -45,4 +45,4 @@ def _from_stream(cls, stream, blob, filename=None):
         # import at execution time to avoid circular import
         from docx.image import image_cls_that_can_parse
         ImageSubclass = image_cls_that_can_parse(stream)
-        return ImageSubclass(stream, blob, filename)
+        return ImageSubclass.from_stream(stream, blob, filename)
diff --git a/docx/image/png.py b/docx/image/png.py
@@ -2,10 +2,29 @@
 
 from __future__ import absolute_import, division, print_function
 
+from .helpers import StreamReader
 from .image import Image
 
 
 class Png(Image):
     """
     Image header parser for PNG images
     """
+    @classmethod
+    def from_stream(cls, stream, blob, filename):
+        """
+        Return a |Png| instance having header properties parsed from image in
+        *stream*.
+        """
+        stream_rdr = StreamReader(stream, '>')
+        attrs = cls._parse_png_headers(stream_rdr)
+        cx, cy = attrs.pop('px_width'), attrs.pop('px_height')
+        return Png(blob, filename, cx, cy, attrs)
+
+    @classmethod
+    def _parse_png_headers(cls, stream):
+        """
+        Return a dict of field, value pairs parsed from the PNG chunks in
+        *stream*.
+        """
+        raise NotImplementedError
diff --git a/tests/image/test_image.py b/tests/image/test_image.py
@@ -79,14 +79,16 @@ def it_can_construct_from_an_image_stream(self, from_stream_fixture):
          image_cls_) = from_stream_fixture
         image = Image._from_stream(stream_, blob_, filename_)
         image_cls_that_can_parse_.assert_called_once_with(stream_)
-        image_cls_.assert_called_once_with(stream_, blob_, filename_)
+        image_cls_.from_stream.assert_called_once_with(
+            stream_, blob_, filename_
+        )
         assert image is image_
 
     # fixtures -------------------------------------------------------
 
     @pytest.fixture
     def blob_(self, request):
-        return instance_mock(request, str)
+        return instance_mock(request, bytes)
 
     @pytest.fixture
     def BytesIO_(self, request, stream_):
@@ -135,7 +137,9 @@ def image_(self, request):
 
     @pytest.fixture
     def image_cls_(self, request, image_):
-        return loose_mock(request, return_value=image_)
+        image_cls_ = loose_mock(request)
+        image_cls_.from_stream.return_value = image_
+        return image_cls_
 
     @pytest.fixture
     def image_cls_that_can_parse_(self, request, image_cls_):
diff --git a/tests/image/test_png.py b/tests/image/test_png.py
@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+"""
+Test suite for docx.image.png module
+"""
+
+from __future__ import absolute_import, print_function
+
+import pytest
+
+from docx.compat import BytesIO
+from docx.image.helpers import StreamReader
+from docx.image.png import Png
+
+from ..unitutil import (
+    initializer_mock, class_mock, instance_mock, method_mock
+)
+
+
+class DescribePng(object):
+
+    def it_can_construct_from_a_png_stream(self, from_stream_fixture):
+        # fixture ----------------------
+        (stream_, blob_, filename_, StreamReader_, _parse_png_headers_,
+         stream_rdr_, Png__init__, cx, cy, attrs, png_) = from_stream_fixture
+        # exercise ---------------------
+        png = Png.from_stream(stream_, blob_, filename_)
+        # verify -----------------------
+        StreamReader_.assert_called_once_with(stream_, '>')
+        _parse_png_headers_.assert_called_once_with(stream_rdr_)
+        Png__init__.assert_called_once_with(blob_, filename_, cx, cy, attrs)
+        assert isinstance(png, Png)
+
+    # fixtures -------------------------------------------------------
+
+    @pytest.fixture
+    def attrs(self):
+        return dict()
+
+    @pytest.fixture
+    def blob_(self, request):
+        return instance_mock(request, bytes)
+
+    @pytest.fixture
+    def filename_(self, request):
+        return instance_mock(request, str)
+
+    @pytest.fixture
+    def from_stream_fixture(
+            self, stream_, blob_, filename_, StreamReader_,
+            _parse_png_headers_, stream_rdr_, Png__init__, attrs, png_):
+        cx, cy = 42, 24
+        attrs.update({'px_width': cx, 'px_height': cy})
+        return (
+            stream_, blob_, filename_, StreamReader_, _parse_png_headers_,
+            stream_rdr_, Png__init__, cx, cy, attrs, png_
+        )
+
+    @pytest.fixture
+    def Png__init__(self, request):
+        return initializer_mock(request, Png)
+
+    @pytest.fixture
+    def _parse_png_headers_(self, request, attrs):
+        return method_mock(
+            request, Png, '_parse_png_headers', return_value=attrs
+        )
+
+    @pytest.fixture
+    def png_(self, request):
+        return instance_mock(request, Png)
+
+    @pytest.fixture
+    def StreamReader_(self, request, stream_rdr_):
+        return class_mock(
+            request, 'docx.image.png.StreamReader', return_value=stream_rdr_
+        )
+
+    @pytest.fixture
+    def stream_(self, request):
+        return instance_mock(request, BytesIO)
+
+    @pytest.fixture
+    def stream_rdr_(self, request):
+        return instance_mock(request, StreamReader)
