py2docfx 0.1.9.dev1897607__py3-none-any.whl → 0.1.9.dev1917798__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/test_files.py

@@ -1,117 +0,0 @@
-import textwrap
-import unittest
-import warnings
-import importlib
-import contextlib
-
-import importlib_resources as resources
-from ..abc import Traversable
-from . import data01
-from . import util
-from . import _path
-from .compat.py39 import os_helper
-from .compat.py312 import import_helper
-
-
-@contextlib.contextmanager
-def suppress_known_deprecation():
-    with warnings.catch_warnings(record=True) as ctx:
-        warnings.simplefilter('default', category=DeprecationWarning)
-        yield ctx
-
-
-class FilesTests:
-    def test_read_bytes(self):
-        files = resources.files(self.data)
-        actual = files.joinpath('utf-8.file').read_bytes()
-        assert actual == b'Hello, UTF-8 world!\n'
-
-    def test_read_text(self):
-        files = resources.files(self.data)
-        actual = files.joinpath('utf-8.file').read_text(encoding='utf-8')
-        assert actual == 'Hello, UTF-8 world!\n'
-
-    def test_traversable(self):
-        assert isinstance(resources.files(self.data), Traversable)
-
-    def test_joinpath_with_multiple_args(self):
-        files = resources.files(self.data)
-        binfile = files.joinpath('subdirectory', 'binary.file')
-        self.assertTrue(binfile.is_file())
-
-    def test_old_parameter(self):
-        """
-        Files used to take a 'package' parameter. Make sure anyone
-        passing by name is still supported.
-        """
-        with suppress_known_deprecation():
-            resources.files(package=self.data)
-
-
-class OpenDiskTests(FilesTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
-
-class OpenZipTests(FilesTests, util.ZipSetup, unittest.TestCase):
-    pass
-
-
-class OpenNamespaceTests(FilesTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
-
-        self.data = namespacedata01
-
-
-class OpenNamespaceZipTests(FilesTests, util.ZipSetup, unittest.TestCase):
-    ZIP_MODULE = 'namespacedata01'
-
-
-class SiteDir:
-    def setUp(self):
-        self.fixtures = contextlib.ExitStack()
-        self.addCleanup(self.fixtures.close)
-        self.site_dir = self.fixtures.enter_context(os_helper.temp_dir())
-        self.fixtures.enter_context(import_helper.DirsOnSysPath(self.site_dir))
-        self.fixtures.enter_context(import_helper.isolated_modules())
-
-
-class ModulesFilesTests(SiteDir, unittest.TestCase):
-    def test_module_resources(self):
-        """
-        A module can have resources found adjacent to the module.
-        """
-        spec = {
-            'mod.py': '',
-            'res.txt': 'resources are the best',
-        }
-        _path.build(spec, self.site_dir)
-        import mod
-
-        actual = resources.files(mod).joinpath('res.txt').read_text(encoding='utf-8')
-        assert actual == spec['res.txt']
-
-
-class ImplicitContextFilesTests(SiteDir, unittest.TestCase):
-    def test_implicit_files(self):
-        """
-        Without any parameter, files() will infer the location as the caller.
-        """
-        spec = {
-            'somepkg': {
-                '__init__.py': textwrap.dedent(
-                    """
-                    import importlib_resources as res
-                    val = res.files().joinpath('res.txt').read_text(encoding='utf-8')
-                    """
-                ),
-                'res.txt': 'resources are the best',
-            },
-        }
-        _path.build(spec, self.site_dir)
-        assert importlib.import_module('somepkg').val == 'resources are the best'
-
-
-if __name__ == '__main__':
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/test_functional.py

@@ -1,242 +0,0 @@
-import unittest
-import os
-import contextlib
-
-try:
-    from test.support.warnings_helper import ignore_warnings, check_warnings
-except ImportError:
-    # older Python versions
-    from test.support import ignore_warnings, check_warnings
-
-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 = 'importlib_resources.tests.data01'
-    anchor02 = 'importlib_resources.tests.data02'
-
-
-class ModuleAnchorMixin:
-    from . import data01 as anchor01
-    from . import data02 as anchor02
-
-
-class FunctionalAPIBase:
-    def _gen_resourcetxt_path_parts(self):
-        """Yield various names of a text file in anchor02, each in a subTest"""
-        for path_parts in (
-            ('subdirectory', 'subsubdir', 'resource.txt'),
-            ('subdirectory/subsubdir/resource.txt',),
-            ('subdirectory/subsubdir', 'resource.txt'),
-        ):
-            with self.subTest(path_parts=path_parts):
-                yield path_parts
-
-    def test_read_text(self):
-        self.assertEqual(
-            resources.read_text(self.anchor01, 'utf-8.file'),
-            'Hello, UTF-8 world!\n',
-        )
-        self.assertEqual(
-            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(
-                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):
-            resources.read_text(self.anchor01)
-        with self.assertRaises(OSError):
-            resources.read_text(self.anchor01, 'no-such-file')
-        with self.assertRaises(UnicodeDecodeError):
-            resources.read_text(self.anchor01, 'utf-16.file')
-        self.assertEqual(
-            resources.read_text(
-                self.anchor01,
-                'binary.file',
-                encoding='latin1',
-            ),
-            '\x00\x01\x02\x03',
-        )
-        self.assertEqual(
-            resources.read_text(
-                self.anchor01,
-                'utf-16.file',
-                errors='backslashreplace',
-            ),
-            'Hello, UTF-16 world!\n'.encode('utf-16').decode(
-                errors='backslashreplace',
-            ),
-        )
-
-    def test_read_binary(self):
-        self.assertEqual(
-            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(
-                resources.read_binary(self.anchor02, *path_parts),
-                b'a resource',
-            )
-
-    def test_open_text(self):
-        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 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):
-            resources.open_text(self.anchor01)
-        with self.assertRaises(OSError):
-            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 resources.open_text(
-            self.anchor01,
-            'binary.file',
-            encoding='latin1',
-        ) as f:
-            self.assertEqual(f.read(), '\x00\x01\x02\x03')
-        with resources.open_text(
-            self.anchor01,
-            'utf-16.file',
-            errors='backslashreplace',
-        ) as f:
-            self.assertEqual(
-                f.read(),
-                'Hello, UTF-16 world!\n'.encode('utf-16').decode(
-                    errors='backslashreplace',
-                ),
-            )
-
-    def test_open_binary(self):
-        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 resources.open_binary(
-                self.anchor02,
-                *path_parts,
-            ) as f:
-                self.assertEqual(f.read(), b'a resource')
-
-    def test_path(self):
-        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 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 = 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))
-        self.assertFalse(is_resource(self.anchor01, 'subdirectory'))
-        for path_parts in self._gen_resourcetxt_path_parts():
-            self.assertTrue(is_resource(self.anchor02, *path_parts))
-
-    def test_contents(self):
-        with check_warnings((".*contents.*", DeprecationWarning)):
-            c = resources.contents(self.anchor01)
-        self.assertGreaterEqual(
-            set(c),
-            {'utf-8.file', 'utf-16.file', 'binary.file', 'subdirectory'},
-        )
-        with contextlib.ExitStack() as cm:
-            cm.enter_context(self.assertRaises(OSError))
-            cm.enter_context(check_warnings((".*contents.*", DeprecationWarning)))
-
-            list(resources.contents(self.anchor01, 'utf-8.file'))
-
-        for path_parts in self._gen_resourcetxt_path_parts():
-            with contextlib.ExitStack() as cm:
-                cm.enter_context(self.assertRaises(OSError))
-                cm.enter_context(check_warnings((".*contents.*", DeprecationWarning)))
-
-                list(resources.contents(self.anchor01, *path_parts))
-        with check_warnings((".*contents.*", DeprecationWarning)):
-            c = resources.contents(self.anchor01, 'subdirectory')
-        self.assertGreaterEqual(
-            set(c),
-            {'binary.file'},
-        )
-
-    @ignore_warnings(category=DeprecationWarning)
-    def test_common_errors(self):
-        for func in (
-            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
-                with self.assertRaises(TypeError):
-                    func(None)
-                # Rejecting invalid anchor type
-                with self.assertRaises((TypeError, AttributeError)):
-                    func(1234)
-                # Unknown module
-                with self.assertRaises(ModuleNotFoundError):
-                    func('$missing module$')
-
-    def test_text_errors(self):
-        for func in (
-            resources.read_text,
-            resources.open_text,
-        ):
-            with self.subTest(func=func):
-                # Multiple path arguments need explicit encoding argument.
-                with self.assertRaises(TypeError):
-                    func(
-                        self.anchor02,
-                        'subdirectory',
-                        'subsubdir',
-                        'resource.txt',
-                    )
-
-
-class FunctionalAPITest_StringAnchor(
-    unittest.TestCase,
-    FunctionalAPIBase,
-    StringAnchorMixin,
-):
-    pass
-
-
-class FunctionalAPITest_ModuleAnchor(
-    unittest.TestCase,
-    FunctionalAPIBase,
-    ModuleAnchorMixin,
-):
-    pass

py2docfx/venv/venv1/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/test_open.py

@@ -1,89 +0,0 @@
-import unittest
-
-import importlib_resources as resources
-from . import data01
-from . import util
-
-
-class CommonBinaryTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        target = resources.files(package).joinpath(path)
-        with target.open('rb'):
-            pass
-
-
-class CommonTextTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        target = resources.files(package).joinpath(path)
-        with target.open(encoding='utf-8'):
-            pass
-
-
-class OpenTests:
-    def test_open_binary(self):
-        target = resources.files(self.data) / 'binary.file'
-        with target.open('rb') as fp:
-            result = fp.read()
-            self.assertEqual(result, bytes(range(4)))
-
-    def test_open_text_default_encoding(self):
-        target = resources.files(self.data) / 'utf-8.file'
-        with target.open(encoding='utf-8') as fp:
-            result = fp.read()
-            self.assertEqual(result, 'Hello, UTF-8 world!\n')
-
-    def test_open_text_given_encoding(self):
-        target = resources.files(self.data) / 'utf-16.file'
-        with target.open(encoding='utf-16', errors='strict') as fp:
-            result = fp.read()
-        self.assertEqual(result, 'Hello, UTF-16 world!\n')
-
-    def test_open_text_with_errors(self):
-        """
-        Raises UnicodeError without the 'errors' argument.
-        """
-        target = resources.files(self.data) / 'utf-16.file'
-        with target.open(encoding='utf-8', errors='strict') as fp:
-            self.assertRaises(UnicodeError, fp.read)
-        with target.open(encoding='utf-8', errors='ignore') as fp:
-            result = fp.read()
-        self.assertEqual(
-            result,
-            'H\x00e\x00l\x00l\x00o\x00,\x00 '
-            '\x00U\x00T\x00F\x00-\x001\x006\x00 '
-            '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00',
-        )
-
-    def test_open_binary_FileNotFoundError(self):
-        target = resources.files(self.data) / 'does-not-exist'
-        with self.assertRaises(FileNotFoundError):
-            target.open('rb')
-
-    def test_open_text_FileNotFoundError(self):
-        target = resources.files(self.data) / 'does-not-exist'
-        with self.assertRaises(FileNotFoundError):
-            target.open(encoding='utf-8')
-
-
-class OpenDiskTests(OpenTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
-
-class OpenDiskNamespaceTests(OpenTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
-
-        self.data = namespacedata01
-
-
-class OpenZipTests(OpenTests, util.ZipSetup, unittest.TestCase):
-    pass
-
-
-class OpenNamespaceZipTests(OpenTests, util.ZipSetup, unittest.TestCase):
-    ZIP_MODULE = 'namespacedata01'
-
-
-if __name__ == '__main__':
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/test_path.py

@@ -1,65 +0,0 @@
-import io
-import pathlib
-import unittest
-
-import importlib_resources as resources
-from . import data01
-from . import util
-
-
-class CommonTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        with resources.as_file(resources.files(package).joinpath(path)):
-            pass
-
-
-class PathTests:
-    def test_reading(self):
-        """
-        Path should be readable and a pathlib.Path instance.
-        """
-        target = resources.files(self.data) / 'utf-8.file'
-        with resources.as_file(target) as path:
-            self.assertIsInstance(path, pathlib.Path)
-            self.assertTrue(path.name.endswith("utf-8.file"), repr(path))
-            self.assertEqual('Hello, UTF-8 world!\n', path.read_text(encoding='utf-8'))
-
-
-class PathDiskTests(PathTests, unittest.TestCase):
-    data = data01
-
-    def test_natural_path(self):
-        """
-        Guarantee the internal implementation detail that
-        file-system-backed resources do not get the tempdir
-        treatment.
-        """
-        target = resources.files(self.data) / 'utf-8.file'
-        with resources.as_file(target) as path:
-            assert 'data' in str(path)
-
-
-class PathMemoryTests(PathTests, unittest.TestCase):
-    def setUp(self):
-        file = io.BytesIO(b'Hello, UTF-8 world!\n')
-        self.addCleanup(file.close)
-        self.data = util.create_package(
-            file=file, path=FileNotFoundError("package exists only in memory")
-        )
-        self.data.__spec__.origin = None
-        self.data.__spec__.has_location = False
-
-
-class PathZipTests(PathTests, util.ZipSetup, unittest.TestCase):
-    def test_remove_in_context_manager(self):
-        """
-        It is not an error if the file that was temporarily stashed on the
-        file system is removed inside the `with` stanza.
-        """
-        target = resources.files(self.data) / 'utf-8.file'
-        with resources.as_file(target) as path:
-            path.unlink()
-
-
-if __name__ == '__main__':
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/test_read.py

@@ -1,97 +0,0 @@
-import unittest
-import importlib_resources as resources
-
-from . import data01
-from . import util
-from importlib import import_module
-
-
-class CommonBinaryTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        resources.files(package).joinpath(path).read_bytes()
-
-
-class CommonTextTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        resources.files(package).joinpath(path).read_text(encoding='utf-8')
-
-
-class ReadTests:
-    def test_read_bytes(self):
-        result = resources.files(self.data).joinpath('binary.file').read_bytes()
-        self.assertEqual(result, bytes(range(4)))
-
-    def test_read_text_default_encoding(self):
-        result = (
-            resources.files(self.data)
-            .joinpath('utf-8.file')
-            .read_text(encoding='utf-8')
-        )
-        self.assertEqual(result, 'Hello, UTF-8 world!\n')
-
-    def test_read_text_given_encoding(self):
-        result = (
-            resources.files(self.data)
-            .joinpath('utf-16.file')
-            .read_text(encoding='utf-16')
-        )
-        self.assertEqual(result, 'Hello, UTF-16 world!\n')
-
-    def test_read_text_with_errors(self):
-        """
-        Raises UnicodeError without the 'errors' argument.
-        """
-        target = resources.files(self.data) / 'utf-16.file'
-        self.assertRaises(UnicodeError, target.read_text, encoding='utf-8')
-        result = target.read_text(encoding='utf-8', errors='ignore')
-        self.assertEqual(
-            result,
-            'H\x00e\x00l\x00l\x00o\x00,\x00 '
-            '\x00U\x00T\x00F\x00-\x001\x006\x00 '
-            '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00',
-        )
-
-
-class ReadDiskTests(ReadTests, unittest.TestCase):
-    data = data01
-
-
-class ReadZipTests(ReadTests, util.ZipSetup, unittest.TestCase):
-    def test_read_submodule_resource(self):
-        submodule = import_module('data01.subdirectory')
-        result = resources.files(submodule).joinpath('binary.file').read_bytes()
-        self.assertEqual(result, bytes(range(4, 8)))
-
-    def test_read_submodule_resource_by_name(self):
-        result = (
-            resources.files('data01.subdirectory').joinpath('binary.file').read_bytes()
-        )
-        self.assertEqual(result, bytes(range(4, 8)))
-
-
-class ReadNamespaceTests(ReadTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
-
-        self.data = namespacedata01
-
-
-class ReadNamespaceZipTests(ReadTests, util.ZipSetup, unittest.TestCase):
-    ZIP_MODULE = 'namespacedata01'
-
-    def test_read_submodule_resource(self):
-        submodule = import_module('namespacedata01.subdirectory')
-        result = resources.files(submodule).joinpath('binary.file').read_bytes()
-        self.assertEqual(result, bytes(range(12, 16)))
-
-    def test_read_submodule_resource_by_name(self):
-        result = (
-            resources.files('namespacedata01.subdirectory')
-            .joinpath('binary.file')
-            .read_bytes()
-        )
-        self.assertEqual(result, bytes(range(12, 16)))
-
-
-if __name__ == '__main__':
-    unittest.main()