Merge branch 'issue41' into 'master'

Split open() and read() into separate binary and text versions

Closes python#41 and python#42

See merge request python-devs/importlib_resources!45

Author: warsaw

importlib_resources/__init__.py

@@ -2,13 +2,15 @@
 
 import sys
 
-__version__ = '0.1.0'
+__version__ = '0.2'
 
 
 if sys.version_info >= (3,):
     from importlib_resources._py3 import (
-        contents, is_resource, open, path, read, Package, Resource)
+        Package, Resource, contents, is_resource, open_binary, open_text, path,
+        read_binary, read_text)
     from importlib_resources.abc import ResourceReader
 else:
     from importlib_resources._py2 import (
-        contents, is_resource, open, path, read)
+        contents, is_resource, open_binary, open_text, path, read_binary,
+        read_text)

importlib_resources/_py2.py

@@ -3,10 +3,9 @@
 import tempfile
 
 from ._compat import FileNotFoundError
-from ._util import _wrap_file
 from contextlib import contextmanager
 from importlib import import_module
-from io import BytesIO, open as io_open
+from io import BytesIO, TextIOWrapper, open as io_open
 from pathlib2 import Path
 from zipfile import ZipFile
 
@@ -34,21 +33,48 @@ def _normalize_path(path):
         return file_name
 
 
-def open(package, resource, encoding=None, errors=None):
-    """Return a file-like object opened for reading of the resource."""
+def open_binary(package, resource):
+    """Return a file-like object opened for binary reading of the resource."""
+    resource = _normalize_path(resource)
+    package = _get_package(package)
+    # Using pathlib doesn't work well here due to the lack of 'strict' argument
+    # for pathlib.Path.resolve() prior to Python 3.6.
+    package_path = os.path.dirname(package.__file__)
+    relative_path = os.path.join(package_path, resource)
+    full_path = os.path.abspath(relative_path)
+    try:
+        return io_open(full_path, 'rb')
+    except IOError:
+        # This might be a package in a zip file.  zipimport provides a loader
+        # with a functioning get_data() method, however we have to strip the
+        # archive (i.e. the .zip file's name) off the front of the path.  This
+        # is because the zipimport loader in Python 2 doesn't actually follow
+        # PEP 302.  It should allow the full path, but actually requires that
+        # the path be relative to the zip file.
+        try:
+            loader = package.__loader__
+            full_path = relative_path[len(loader.archive)+1:]
+            data = loader.get_data(full_path)
+        except (IOError, AttributeError):
+            package_name = package.__name__
+            message = '{!r} resource not found in {!r}'.format(
+                resource, package_name)
+            raise FileNotFoundError(message)
+        else:
+            return BytesIO(data)
+
+
+def open_text(package, resource, encoding='utf-8', errors='strict'):
+    """Return a file-like object opened for text reading of the resource."""
     resource = _normalize_path(resource)
     package = _get_package(package)
     # Using pathlib doesn't work well here due to the lack of 'strict' argument
     # for pathlib.Path.resolve() prior to Python 3.6.
     package_path = os.path.dirname(package.__file__)
     relative_path = os.path.join(package_path, resource)
     full_path = os.path.abspath(relative_path)
-    if encoding is None:
-        args = dict(mode='rb')
-    else:
-        args = dict(mode='r', encoding=encoding, errors=errors)
     try:
-        return io_open(full_path, **args)
+        return io_open(full_path, mode='r', encoding=encoding, errors=errors)
     except IOError:
         # This might be a package in a zip file.  zipimport provides a loader
         # with a functioning get_data() method, however we have to strip the
@@ -66,23 +92,27 @@ def open(package, resource, encoding=None, errors=None):
                 resource, package_name)
             raise FileNotFoundError(message)
         else:
-            return _wrap_file(BytesIO(data), encoding, errors)
+            return TextIOWrapper(BytesIO(data), encoding, errors)
+
+
+def read_binary(package, resource):
+    """Return the binary contents of the resource."""
+    resource = _normalize_path(resource)
+    package = _get_package(package)
+    with open_binary(package, resource) as fp:
+        return fp.read()
 
 
-def read(package, resource, encoding='utf-8', errors='strict'):
+def read_text(package, resource, encoding='utf-8', errors='strict'):
     """Return the decoded string of the resource.
 
     The decoding-related arguments have the same semantics as those of
     bytes.decode().
     """
     resource = _normalize_path(resource)
     package = _get_package(package)
-    # Note this is **not** builtins.open()!
-    with open(package, resource) as binary_file:
-        contents = binary_file.read()
-        if encoding is None:
-            return contents
-        return contents.decode(encoding=encoding, errors=errors)
+    with open_text(package, resource, encoding, errors) as fp:
+        return fp.read()
 
 
 @contextmanager
@@ -106,9 +136,8 @@ def path(package, resource):
     if file_path.exists():
         yield file_path
     else:
-        # Note this is **not** builtins.open()!
-        with open(package, resource) as fileobj:
-            data = fileobj.read()
+        with open_binary(package, resource) as fp:
+            data = fp.read()
         # Not using tempfile.NamedTemporaryFile as it leads to deeper 'try'
         # blocks due to the need to close the temporary file to work on Windows
         # properly.

importlib_resources/_py3.py

@@ -3,7 +3,6 @@
 import tempfile
 
 from . import abc as resources_abc
-from ._util import _wrap_file
 from builtins import open as builtins_open
 from contextlib import contextmanager
 from importlib import import_module
@@ -13,7 +12,7 @@
 from types import ModuleType
 from typing import Iterator, Optional, Set, Union   # noqa: F401
 from typing import cast
-from typing.io import IO
+from typing.io import BinaryIO, TextIO
 from zipfile import ZipFile
 
 
@@ -60,27 +59,54 @@ def _get_resource_reader(
     return None
 
 
-def open(package: Package,
-         resource: Resource,
-         encoding: str = None,
-         errors: str = None) -> IO:
-    """Return a file-like object opened for reading of the resource."""
+def open_binary(package: Package, resource: Resource) -> BinaryIO:
+    """Return a file-like object opened for binary reading of the resource."""
     resource = _normalize_path(resource)
     package = _get_package(package)
     reader = _get_resource_reader(package)
     if reader is not None:
-        return _wrap_file(reader.open_resource(resource), encoding, errors)
+        return reader.open_resource(resource)
+    # Using pathlib doesn't work well here due to the lack of 'strict'
+    # argument for pathlib.Path.resolve() prior to Python 3.6.
+    absolute_package_path = os.path.abspath(package.__spec__.origin)
+    package_path = os.path.dirname(absolute_package_path)
+    full_path = os.path.join(package_path, resource)
+    try:
+        return builtins_open(full_path, mode='rb')
+    except IOError:
+        # Just assume the loader is a resource loader; all the relevant
+        # importlib.machinery loaders are and an AttributeError for
+        # get_data() will make it clear what is needed from the loader.
+        loader = cast(ResourceLoader, package.__spec__.loader)
+        try:
+            data = loader.get_data(full_path)
+        except IOError:
+            package_name = package.__spec__.name
+            message = '{!r} resource not found in {!r}'.format(
+                resource, package_name)
+            raise FileNotFoundError(message)
+        else:
+            return BytesIO(data)
+
+
+def open_text(package: Package,
+              resource: Resource,
+              encoding: str = 'utf-8',
+              errors: str = 'strict') -> TextIO:
+    """Return a file-like object opened for text reading of the resource."""
+    resource = _normalize_path(resource)
+    package = _get_package(package)
+    reader = _get_resource_reader(package)
+    if reader is not None:
+        return TextIOWrapper(reader.open_resource(resource), encoding, errors)
     # Using pathlib doesn't work well here due to the lack of 'strict'
     # argument for pathlib.Path.resolve() prior to Python 3.6.
     absolute_package_path = os.path.abspath(package.__spec__.origin)
     package_path = os.path.dirname(absolute_package_path)
     full_path = os.path.join(package_path, resource)
-    if encoding is None:
-        args = dict(mode='rb')
-    else:
-        args = dict(mode='r', encoding=encoding, errors=errors)
     try:
-        return builtins_open(full_path, **args)   # type: ignore
+        return builtins_open(
+            full_path, mode='r', encoding=encoding, errors=errors)
     except IOError:
         # Just assume the loader is a resource loader; all the relevant
         # importlib.machinery loaders are and an AttributeError for
@@ -94,29 +120,30 @@ def open(package: Package,
                 resource, package_name)
             raise FileNotFoundError(message)
         else:
-            return _wrap_file(BytesIO(data), encoding, errors)
+            return TextIOWrapper(BytesIO(data), encoding, errors)
+
+
+def read_binary(package: Package, resource: Resource) -> bytes:
+    """Return the binary contents of the resource."""
+    resource = _normalize_path(resource)
+    package = _get_package(package)
+    with open_binary(package, resource) as fp:
+        return fp.read()
 
 
-def read(package: Package,
-         resource: Resource,
-         encoding: str = 'utf-8',
-         errors: str = 'strict') -> Union[str, bytes]:
+def read_text(package: Package,
+              resource: Resource,
+              encoding: str = 'utf-8',
+              errors: str = 'strict') -> str:
     """Return the decoded string of the resource.
 
     The decoding-related arguments have the same semantics as those of
     bytes.decode().
     """
     resource = _normalize_path(resource)
     package = _get_package(package)
-    # Note this is **not** builtins.open()!
-    with open(package, resource) as binary_file:
-        if encoding is None:
-            return binary_file.read()
-        # Decoding from io.TextIOWrapper() instead of str.decode() in hopes
-        # that the former will be smarter about memory usage.
-        text_file = TextIOWrapper(
-            binary_file, encoding=encoding, errors=errors)
-        return text_file.read()
+    with open_text(package, resource, encoding, errors) as fp:
+        return fp.read()
 
 
 @contextmanager
@@ -145,8 +172,8 @@ def path(package: Package, resource: Resource) -> Iterator[Path]:
     if file_path.exists():
         yield file_path
     else:
-        with open(package, resource) as file:
-            data = file.read()
+        with open_binary(package, resource) as fp:
+            data = fp.read()
         # Not using tempfile.NamedTemporaryFile as it leads to deeper 'try'
         # blocks due to the need to close the temporary file to work on
         # Windows properly.