Adapt to importlib_resources

importlib_resources/functional.py

@@ -1,9 +1,6 @@
 """Simplified function-based API for importlib.resources
-
-
 """
 
-import os
 import warnings
 
 from ._common import files, as_file

importlib_resources/tests/test_functional.py

@@ -3,21 +3,21 @@
 
 from test.support.warnings_helper import ignore_warnings, check_warnings
 
-import importlib.resources
+import importlib_resources as resources
 
 # Since the functional API forwards to Traversable, we only test
 # filesystem resources here -- not zip files, namespace packages etc.
 # We do test for two kinds of Anchor, though.
 
 
 class StringAnchorMixin:
-    anchor01 = 'test.test_importlib.resources.data01'
-    anchor02 = 'test.test_importlib.resources.data02'
+    anchor01 = 'importlib_resources.tests.data01'
+    anchor02 = 'importlib_resources.tests.data02'
 
 
 class ModuleAnchorMixin:
-    from test.test_importlib.resources import data01 as anchor01
-    from test.test_importlib.resources import data02 as anchor02
+    from . import data01 as anchor01
+    from . import data02 as anchor02
 
 
 class FunctionalAPIBase():
@@ -34,39 +34,39 @@ def _gen_resourcetxt_path_parts(self):
 
     def test_read_text(self):
         self.assertEqual(
-            importlib.resources.read_text(self.anchor01, 'utf-8.file'),
+            resources.read_text(self.anchor01, 'utf-8.file'),
             'Hello, UTF-8 world!\n',
         )
         self.assertEqual(
-            importlib.resources.read_text(
+            resources.read_text(
                 self.anchor02, 'subdirectory', 'subsubdir', 'resource.txt',
                 encoding='utf-8',
             ),
             'a resource',
         )
         for path_parts in self._gen_resourcetxt_path_parts():
             self.assertEqual(
-                importlib.resources.read_text(
+                resources.read_text(
                     self.anchor02, *path_parts, encoding='utf-8',
                 ),
                 'a resource',
             )
         # Use generic OSError, since e.g. attempting to read a directory can
         # fail with PermissionError rather than IsADirectoryError
         with self.assertRaises(OSError):
-            importlib.resources.read_text(self.anchor01)
+            resources.read_text(self.anchor01)
         with self.assertRaises(OSError):
-            importlib.resources.read_text(self.anchor01, 'no-such-file')
+            resources.read_text(self.anchor01, 'no-such-file')
         with self.assertRaises(UnicodeDecodeError):
-            importlib.resources.read_text(self.anchor01, 'utf-16.file')
+            resources.read_text(self.anchor01, 'utf-16.file')
         self.assertEqual(
-            importlib.resources.read_text(
+            resources.read_text(
                 self.anchor01, 'binary.file', encoding='latin1',
             ),
             '\x00\x01\x02\x03',
         )
         self.assertEqual(
-            importlib.resources.read_text(
+            resources.read_text(
                 self.anchor01, 'utf-16.file',
                 errors='backslashreplace',
             ),
@@ -77,38 +77,38 @@ def test_read_text(self):
 
     def test_read_binary(self):
         self.assertEqual(
-            importlib.resources.read_binary(self.anchor01, 'utf-8.file'),
+            resources.read_binary(self.anchor01, 'utf-8.file'),
             b'Hello, UTF-8 world!\n',
         )
         for path_parts in self._gen_resourcetxt_path_parts():
             self.assertEqual(
-                importlib.resources.read_binary(self.anchor02, *path_parts),
+                resources.read_binary(self.anchor02, *path_parts),
                 b'a resource',
             )
 
     def test_open_text(self):
-        with importlib.resources.open_text(self.anchor01, 'utf-8.file') as f:
+        with resources.open_text(self.anchor01, 'utf-8.file') as f:
             self.assertEqual(f.read(), 'Hello, UTF-8 world!\n')
         for path_parts in self._gen_resourcetxt_path_parts():
-            with importlib.resources.open_text(
+            with resources.open_text(
                 self.anchor02, *path_parts,
                 encoding='utf-8',
             ) as f:
                 self.assertEqual(f.read(), 'a resource')
         # Use generic OSError, since e.g. attempting to read a directory can
         # fail with PermissionError rather than IsADirectoryError
         with self.assertRaises(OSError):
-            importlib.resources.open_text(self.anchor01)
+            resources.open_text(self.anchor01)
         with self.assertRaises(OSError):
-            importlib.resources.open_text(self.anchor01, 'no-such-file')
-        with importlib.resources.open_text(self.anchor01, 'utf-16.file') as f:
+            resources.open_text(self.anchor01, 'no-such-file')
+        with resources.open_text(self.anchor01, 'utf-16.file') as f:
             with self.assertRaises(UnicodeDecodeError):
                 f.read()
-        with importlib.resources.open_text(
+        with resources.open_text(
             self.anchor01, 'binary.file', encoding='latin1',
         ) as f:
             self.assertEqual(f.read(), '\x00\x01\x02\x03')
-        with importlib.resources.open_text(
+        with resources.open_text(
             self.anchor01, 'utf-16.file',
             errors='backslashreplace',
         ) as f:
@@ -120,24 +120,24 @@ def test_open_text(self):
             )
 
     def test_open_binary(self):
-        with importlib.resources.open_binary(self.anchor01, 'utf-8.file') as f:
+        with resources.open_binary(self.anchor01, 'utf-8.file') as f:
             self.assertEqual(f.read(), b'Hello, UTF-8 world!\n')
         for path_parts in self._gen_resourcetxt_path_parts():
-            with importlib.resources.open_binary(
+            with resources.open_binary(
                 self.anchor02, *path_parts,
             ) as f:
                 self.assertEqual(f.read(), b'a resource')
 
     def test_path(self):
-        with importlib.resources.path(self.anchor01, 'utf-8.file') as path:
-            with open(str(path)) as f:
+        with resources.path(self.anchor01, 'utf-8.file') as path:
+            with open(str(path), encoding='utf-8') as f:
                 self.assertEqual(f.read(), 'Hello, UTF-8 world!\n')
-        with importlib.resources.path(self.anchor01) as path:
-            with open(os.path.join(path, 'utf-8.file')) as f:
+        with resources.path(self.anchor01) as path:
+            with open(os.path.join(path, 'utf-8.file'), encoding='utf-8') as f:
                 self.assertEqual(f.read(), 'Hello, UTF-8 world!\n')
 
     def test_is_resource(self):
-        is_resource = importlib.resources.is_resource
+        is_resource = resources.is_resource
         self.assertTrue(is_resource(self.anchor01, 'utf-8.file'))
         self.assertFalse(is_resource(self.anchor01, 'no_such_file'))
         self.assertFalse(is_resource(self.anchor01))
@@ -146,24 +146,25 @@ def test_is_resource(self):
             self.assertTrue(is_resource(self.anchor02, *path_parts))
 
     def test_contents(self):
-        is_resource = importlib.resources.is_resource
         with check_warnings((".*contents.*", DeprecationWarning)):
-            c = importlib.resources.contents(self.anchor01)
+            c = resources.contents(self.anchor01)
         self.assertGreaterEqual(
             set(c),
             {'utf-8.file', 'utf-16.file', 'binary.file', 'subdirectory'},
         )
-        with (self.assertRaises(OSError),
+        with (
+            self.assertRaises(OSError),
             check_warnings((".*contents.*", DeprecationWarning)),
         ):
-            importlib.resources.contents(self.anchor01, 'utf-8.file')
+            list(resources.contents(self.anchor01, 'utf-8.file'))
         for path_parts in self._gen_resourcetxt_path_parts():
-            with (self.assertRaises(OSError),
+            with (
+                self.assertRaises(OSError),
                 check_warnings((".*contents.*", DeprecationWarning)),
             ):
-                importlib.resources.contents(self.anchor01, *path_parts)
+                list(resources.contents(self.anchor01, *path_parts))
         with check_warnings((".*contents.*", DeprecationWarning)):
-            c = importlib.resources.contents(self.anchor01, 'subdirectory')
+            c = resources.contents(self.anchor01, 'subdirectory')
         self.assertGreaterEqual(
             set(c),
             {'binary.file'},
@@ -172,13 +173,13 @@ def test_contents(self):
     @ignore_warnings(category=DeprecationWarning)
     def test_common_errors(self):
         for func in (
-            importlib.resources.read_text,
-            importlib.resources.read_binary,
-            importlib.resources.open_text,
-            importlib.resources.open_binary,
-            importlib.resources.path,
-            importlib.resources.is_resource,
-            importlib.resources.contents,
+            resources.read_text,
+            resources.read_binary,
+            resources.open_text,
+            resources.open_binary,
+            resources.path,
+            resources.is_resource,
+            resources.contents,
         ):
             with self.subTest(func=func):
                 # Rejecting None anchor
@@ -193,8 +194,8 @@ def test_common_errors(self):
 
     def test_text_errors(self):
         for func in (
-            importlib.resources.read_text,
-            importlib.resources.open_text,
+            resources.read_text,
+            resources.open_text,
         ):
             with self.subTest(func=func):
                 # Multiple path arguments need explicit encoding argument.