Merge pull request python#215 from python/bugfix/bpo-42129-no-reader-fallback

jaraco · web-flow · commit 225f5b7caf9d · 2021-02-28T13:59:31.000-05:00
Add a reader fallback even for forward port.
diff --git a/CHANGES.rst b/CHANGES.rst
@@ -1,3 +1,13 @@
+v5.0.2
+======
+
+* #214: Added ``_adapters`` module to ensure that degenerate
+  ``files`` behavior can be made available for legacy loaders
+  whose resource readers don't implement it. Fixes issue where
+  backport compatibility module was masking this fallback
+  behavior only to discover the defect when applying changes to
+  CPython.
+
 v5.0.1
 ======
 
diff --git a/importlib_resources/_adapters.py b/importlib_resources/_adapters.py
@@ -0,0 +1,90 @@
+from contextlib import suppress
+
+from . import abc
+
+
+class SpecLoaderAdapter:
+    """
+    Adapt a package spec to adapt the underlying loader.
+    """
+
+    def __init__(self, spec, adapter=lambda spec: spec.loader):
+        self.spec = spec
+        self.loader = adapter(spec)
+
+    def __getattr__(self, name):
+        return getattr(self.spec, name)
+
+
+class TraversableResourcesLoader:
+    """
+    Adapt a loader to provide TraversableResources.
+    """
+
+    def __init__(self, spec):
+        self.spec = spec
+
+    def get_resource_reader(self, name):
+        return DegenerateFiles(self.spec)._native()
+
+
+class DegenerateFiles:
+    """
+    Adapter for an existing or non-existant resource reader
+    to provide a degenerate .files().
+    """
+
+    class Path(abc.Traversable):
+        def iterdir(self):
+            return iter(())
+
+        def read_bytes(self):
+            raise ValueError()
+
+        def read_text(self):
+            raise ValueError()
+
+        def is_dir(self):
+            return False
+
+        is_file = exists = is_dir  # type: ignore
+
+        def joinpath(self, other):
+            return DegenerateFiles.Path()
+
+        __truediv__ = joinpath
+
+        def name(self):
+            return ''
+
+        def open(self):
+            raise ValueError()
+
+    def __init__(self, spec):
+        self.spec = spec
+
+    @property
+    def _reader(self):
+        with suppress(AttributeError):
+            return self.spec.loader.get_resource_reader(self.spec.name)
+
+    def _native(self):
+        """
+        Return the native reader if it supports files().
+        """
+        reader = self._reader
+        return reader if hasattr(reader, 'files') else self
+
+    def __getattr__(self, attr):
+        return getattr(self._reader, attr)
+
+    def files(self):
+        return DegenerateFiles.Path()
+
+
+def wrap_spec(package):
+    """
+    Construct a package spec with traversable compatibility
+    on the spec/loader/reader.
+    """
+    return SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader)
diff --git a/importlib_resources/_common.py b/importlib_resources/_common.py
@@ -9,7 +9,7 @@
 from typing import Union, Any, Optional
 from .abc import ResourceReader
 
-from ._compat import package_spec
+from ._compat import wrap_spec
 
 Package = Union[types.ModuleType, str]
 
@@ -63,7 +63,7 @@ def get_package(package):
     Raise an exception if the resolved module is not a package.
     """
     resolved = resolve(package)
-    if package_spec(resolved).submodule_search_locations is None:
+    if wrap_spec(resolved).submodule_search_locations is None:
         raise TypeError('{!r} is not a package'.format(package))
     return resolved
 
@@ -73,7 +73,7 @@ def from_package(package):
     Return a Traversable object for the given package.
 
     """
-    spec = package_spec(package)
+    spec = wrap_spec(package)
     reader = spec.loader.get_resource_reader(spec.name)
     return reader.files()
 
diff --git a/importlib_resources/_compat.py b/importlib_resources/_compat.py
@@ -1,9 +1,10 @@
+# flake8: noqa
+
 import abc
 import sys
+import pathlib
 from contextlib import suppress
 
-# flake8: noqa
-
 try:
     from zipfile import Path as ZipPath  # type: ignore
 except ImportError:
@@ -24,16 +25,7 @@ def runtime_checkable(cls):  # type: ignore
     Protocol = abc.ABC  # type: ignore
 
 
-class TraversableResourcesAdapter:
-    def __init__(self, spec):
-        self.spec = spec
-        self.loader = LoaderAdapter(spec)
-
-    def __getattr__(self, name):
-        return getattr(self.spec, name)
-
-
-class LoaderAdapter:
+class TraversableResourcesLoader:
     """
     Adapt loaders to provide TraversableResources and other
     compatibility.
@@ -47,7 +39,7 @@ def path(self):
         return self.spec.origin
 
     def get_resource_reader(self, name):
-        from . import readers
+        from . import readers, _adapters
 
         def _zip_reader(spec):
             with suppress(AttributeError):
@@ -65,6 +57,10 @@ def _native_reader(spec):
             reader = _available_reader(spec)
             return reader if hasattr(reader, 'files') else None
 
+        def _file_reader(spec):
+            if pathlib.Path(self.path).exists():
+                return readers.FileReader(self)
+
         return (
             # native reader if it supplies 'files'
             _native_reader(self.spec)
@@ -76,14 +72,16 @@ def _native_reader(spec):
             _namespace_reader(self.spec)
             or
             # local FileReader
-            readers.FileReader(self)
+            _file_reader(self.spec)
+            or _adapters.DegenerateFiles(self.spec)
         )
 
 
-def package_spec(package):
+def wrap_spec(package):
     """
-    Construct a minimal package spec suitable for
-    matching the interfaces this library relies upon
-    in later Python versions.
+    Construct a package spec with traversable compatibility
+    on the spec/loader/reader.
     """
-    return TraversableResourcesAdapter(package.__spec__)
+    from . import _adapters
+
+    return _adapters.SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader)
