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

py2docfx/venv/basevenv/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/test_reader.py

@@ -1,145 +0,0 @@
-import os.path
-import sys
-import pathlib
-import unittest
-
-from importlib import import_module
-from importlib_resources.readers import MultiplexedPath, NamespaceReader
-
-
-class MultiplexedPathTest(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.folder = pathlib.Path(__file__).parent / 'namespacedata01'
-
-    def test_init_no_paths(self):
-        with self.assertRaises(FileNotFoundError):
-            MultiplexedPath()
-
-    def test_init_file(self):
-        with self.assertRaises(NotADirectoryError):
-            MultiplexedPath(self.folder / 'binary.file')
-
-    def test_iterdir(self):
-        contents = {path.name for path in MultiplexedPath(self.folder).iterdir()}
-        try:
-            contents.remove('__pycache__')
-        except (KeyError, ValueError):
-            pass
-        self.assertEqual(
-            contents, {'subdirectory', 'binary.file', 'utf-16.file', 'utf-8.file'}
-        )
-
-    def test_iterdir_duplicate(self):
-        data01 = pathlib.Path(__file__).parent.joinpath('data01')
-        contents = {
-            path.name for path in MultiplexedPath(self.folder, data01).iterdir()
-        }
-        for remove in ('__pycache__', '__init__.pyc'):
-            try:
-                contents.remove(remove)
-            except (KeyError, ValueError):
-                pass
-        self.assertEqual(
-            contents,
-            {'__init__.py', 'binary.file', 'subdirectory', 'utf-16.file', 'utf-8.file'},
-        )
-
-    def test_is_dir(self):
-        self.assertEqual(MultiplexedPath(self.folder).is_dir(), True)
-
-    def test_is_file(self):
-        self.assertEqual(MultiplexedPath(self.folder).is_file(), False)
-
-    def test_open_file(self):
-        path = MultiplexedPath(self.folder)
-        with self.assertRaises(FileNotFoundError):
-            path.read_bytes()
-        with self.assertRaises(FileNotFoundError):
-            path.read_text()
-        with self.assertRaises(FileNotFoundError):
-            path.open()
-
-    def test_join_path(self):
-        data01 = pathlib.Path(__file__).parent.joinpath('data01')
-        prefix = str(data01.parent)
-        path = MultiplexedPath(self.folder, data01)
-        self.assertEqual(
-            str(path.joinpath('binary.file'))[len(prefix) + 1 :],
-            os.path.join('namespacedata01', 'binary.file'),
-        )
-        sub = path.joinpath('subdirectory')
-        assert isinstance(sub, MultiplexedPath)
-        assert 'namespacedata01' in str(sub)
-        assert 'data01' in str(sub)
-        self.assertEqual(
-            str(path.joinpath('imaginary'))[len(prefix) + 1 :],
-            os.path.join('namespacedata01', 'imaginary'),
-        )
-        self.assertEqual(path.joinpath(), path)
-
-    def test_join_path_compound(self):
-        path = MultiplexedPath(self.folder)
-        assert not path.joinpath('imaginary/foo.py').exists()
-
-    def test_join_path_common_subdir(self):
-        data01 = pathlib.Path(__file__).parent.joinpath('data01')
-        data02 = pathlib.Path(__file__).parent.joinpath('data02')
-        prefix = str(data01.parent)
-        path = MultiplexedPath(data01, data02)
-        self.assertIsInstance(path.joinpath('subdirectory'), MultiplexedPath)
-        self.assertEqual(
-            str(path.joinpath('subdirectory', 'subsubdir'))[len(prefix) + 1 :],
-            os.path.join('data02', 'subdirectory', 'subsubdir'),
-        )
-
-    def test_repr(self):
-        self.assertEqual(
-            repr(MultiplexedPath(self.folder)),
-            f"MultiplexedPath('{self.folder}')",
-        )
-
-    def test_name(self):
-        self.assertEqual(
-            MultiplexedPath(self.folder).name,
-            os.path.basename(self.folder),
-        )
-
-
-class NamespaceReaderTest(unittest.TestCase):
-    site_dir = str(pathlib.Path(__file__).parent)
-
-    @classmethod
-    def setUpClass(cls):
-        sys.path.append(cls.site_dir)
-
-    @classmethod
-    def tearDownClass(cls):
-        sys.path.remove(cls.site_dir)
-
-    def test_init_error(self):
-        with self.assertRaises(ValueError):
-            NamespaceReader(['path1', 'path2'])
-
-    def test_resource_path(self):
-        namespacedata01 = import_module('namespacedata01')
-        reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations)
-
-        root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01'))
-        self.assertEqual(
-            reader.resource_path('binary.file'), os.path.join(root, 'binary.file')
-        )
-        self.assertEqual(
-            reader.resource_path('imaginary'), os.path.join(root, 'imaginary')
-        )
-
-    def test_files(self):
-        namespacedata01 = import_module('namespacedata01')
-        reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations)
-        root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01'))
-        self.assertIsInstance(reader.files(), MultiplexedPath)
-        self.assertEqual(repr(reader.files()), f"MultiplexedPath('{root}')")
-
-
-if __name__ == '__main__':
-    unittest.main()

py2docfx/venv/basevenv/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/test_resource.py

@@ -1,241 +0,0 @@
-import sys
-import unittest
-import importlib_resources as resources
-import pathlib
-
-from . import data01
-from . import util
-from importlib import import_module
-
-
-class ResourceTests:
-    # Subclasses are expected to set the `data` attribute.
-
-    def test_is_file_exists(self):
-        target = resources.files(self.data) / 'binary.file'
-        self.assertTrue(target.is_file())
-
-    def test_is_file_missing(self):
-        target = resources.files(self.data) / 'not-a-file'
-        self.assertFalse(target.is_file())
-
-    def test_is_dir(self):
-        target = resources.files(self.data) / 'subdirectory'
-        self.assertFalse(target.is_file())
-        self.assertTrue(target.is_dir())
-
-
-class ResourceDiskTests(ResourceTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
-
-class ResourceZipTests(ResourceTests, util.ZipSetup, unittest.TestCase):
-    pass
-
-
-def names(traversable):
-    return {item.name for item in traversable.iterdir()}
-
-
-class ResourceLoaderTests(unittest.TestCase):
-    def test_resource_contents(self):
-        package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C']
-        )
-        self.assertEqual(names(resources.files(package)), {'A', 'B', 'C'})
-
-    def test_is_file(self):
-        package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
-        )
-        self.assertTrue(resources.files(package).joinpath('B').is_file())
-
-    def test_is_dir(self):
-        package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
-        )
-        self.assertTrue(resources.files(package).joinpath('D').is_dir())
-
-    def test_resource_missing(self):
-        package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
-        )
-        self.assertFalse(resources.files(package).joinpath('Z').is_file())
-
-
-class ResourceCornerCaseTests(unittest.TestCase):
-    def test_package_has_no_reader_fallback(self):
-        """
-        Test odd ball packages which:
-        # 1. Do not have a ResourceReader as a loader
-        # 2. Are not on the file system
-        # 3. Are not in a zip file
-        """
-        module = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C']
-        )
-        # Give the module a dummy loader.
-        module.__loader__ = object()
-        # Give the module a dummy origin.
-        module.__file__ = '/path/which/shall/not/be/named'
-        module.__spec__.loader = module.__loader__
-        module.__spec__.origin = module.__file__
-        self.assertFalse(resources.files(module).joinpath('A').is_file())
-
-
-class ResourceFromZipsTest01(util.ZipSetupBase, unittest.TestCase):
-    ZIP_MODULE = 'data01'
-
-    def test_is_submodule_resource(self):
-        submodule = import_module('data01.subdirectory')
-        self.assertTrue(resources.files(submodule).joinpath('binary.file').is_file())
-
-    def test_read_submodule_resource_by_name(self):
-        self.assertTrue(
-            resources.files('data01.subdirectory').joinpath('binary.file').is_file()
-        )
-
-    def test_submodule_contents(self):
-        submodule = import_module('data01.subdirectory')
-        self.assertEqual(
-            names(resources.files(submodule)), {'__init__.py', 'binary.file'}
-        )
-
-    def test_submodule_contents_by_name(self):
-        self.assertEqual(
-            names(resources.files('data01.subdirectory')),
-            {'__init__.py', 'binary.file'},
-        )
-
-    def test_as_file_directory(self):
-        with resources.as_file(resources.files('data01')) as data:
-            assert data.name == 'data01'
-            assert data.is_dir()
-            assert data.joinpath('subdirectory').is_dir()
-            assert len(list(data.iterdir()))
-        assert not data.parent.exists()
-
-
-class ResourceFromZipsTest02(util.ZipSetupBase, unittest.TestCase):
-    ZIP_MODULE = 'data02'
-
-    def test_unrelated_contents(self):
-        """
-        Test thata zip with two unrelated subpackages return
-        distinct resources. Ref python/importlib_resources#44.
-        """
-        self.assertEqual(
-            names(resources.files('data02.one')),
-            {'__init__.py', 'resource1.txt'},
-        )
-        self.assertEqual(
-            names(resources.files('data02.two')),
-            {'__init__.py', 'resource2.txt'},
-        )
-
-
-class DeletingZipsTest(util.ZipSetupBase, unittest.TestCase):
-    """Having accessed resources in a zip file should not keep an open
-    reference to the zip.
-    """
-
-    def test_iterdir_does_not_keep_open(self):
-        [item.name for item in resources.files('data01').iterdir()]
-
-    def test_is_file_does_not_keep_open(self):
-        resources.files('data01').joinpath('binary.file').is_file()
-
-    def test_is_file_failure_does_not_keep_open(self):
-        resources.files('data01').joinpath('not-present').is_file()
-
-    @unittest.skip("Desired but not supported.")
-    def test_as_file_does_not_keep_open(self):  # pragma: no cover
-        resources.as_file(resources.files('data01') / 'binary.file')
-
-    def test_entered_path_does_not_keep_open(self):
-        """
-        Mimic what certifi does on import to make its bundle
-        available for the process duration.
-        """
-        resources.as_file(resources.files('data01') / 'binary.file').__enter__()
-
-    def test_read_binary_does_not_keep_open(self):
-        resources.files('data01').joinpath('binary.file').read_bytes()
-
-    def test_read_text_does_not_keep_open(self):
-        resources.files('data01').joinpath('utf-8.file').read_text(encoding='utf-8')
-
-
-class ResourceFromNamespaceTests:
-    def test_is_submodule_resource(self):
-        self.assertTrue(
-            resources.files(import_module('namespacedata01'))
-            .joinpath('binary.file')
-            .is_file()
-        )
-
-    def test_read_submodule_resource_by_name(self):
-        self.assertTrue(
-            resources.files('namespacedata01').joinpath('binary.file').is_file()
-        )
-
-    def test_submodule_contents(self):
-        contents = names(resources.files(import_module('namespacedata01')))
-        try:
-            contents.remove('__pycache__')
-        except KeyError:
-            pass
-        self.assertEqual(
-            contents, {'subdirectory', 'binary.file', 'utf-8.file', 'utf-16.file'}
-        )
-
-    def test_submodule_contents_by_name(self):
-        contents = names(resources.files('namespacedata01'))
-        try:
-            contents.remove('__pycache__')
-        except KeyError:
-            pass
-        self.assertEqual(
-            contents, {'subdirectory', 'binary.file', 'utf-8.file', 'utf-16.file'}
-        )
-
-    def test_submodule_sub_contents(self):
-        contents = names(resources.files(import_module('namespacedata01.subdirectory')))
-        try:
-            contents.remove('__pycache__')
-        except KeyError:
-            pass
-        self.assertEqual(contents, {'binary.file'})
-
-    def test_submodule_sub_contents_by_name(self):
-        contents = names(resources.files('namespacedata01.subdirectory'))
-        try:
-            contents.remove('__pycache__')
-        except KeyError:
-            pass
-        self.assertEqual(contents, {'binary.file'})
-
-
-class ResourceFromNamespaceDiskTests(ResourceFromNamespaceTests, unittest.TestCase):
-    site_dir = str(pathlib.Path(__file__).parent)
-
-    @classmethod
-    def setUpClass(cls):
-        sys.path.append(cls.site_dir)
-
-    @classmethod
-    def tearDownClass(cls):
-        sys.path.remove(cls.site_dir)
-
-
-class ResourceFromNamespaceZipTests(
-    util.ZipSetupBase,
-    ResourceFromNamespaceTests,
-    unittest.TestCase,
-):
-    ZIP_MODULE = 'namespacedata01'
-
-
-if __name__ == '__main__':
-    unittest.main()

py2docfx/venv/basevenv/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/util.py

@@ -1,164 +0,0 @@
-import abc
-import importlib
-import io
-import sys
-import types
-import pathlib
-import contextlib
-
-from . import data01
-from ..abc import ResourceReader
-from .compat.py39 import import_helper, os_helper
-from . import zip as zip_
-
-
-from importlib.machinery import ModuleSpec
-
-
-class Reader(ResourceReader):
-    def __init__(self, **kwargs):
-        vars(self).update(kwargs)
-
-    def get_resource_reader(self, package):
-        return self
-
-    def open_resource(self, path):
-        self._path = path
-        if isinstance(self.file, Exception):
-            raise self.file
-        return self.file
-
-    def resource_path(self, path_):
-        self._path = path_
-        if isinstance(self.path, Exception):
-            raise self.path
-        return self.path
-
-    def is_resource(self, path_):
-        self._path = path_
-        if isinstance(self.path, Exception):
-            raise self.path
-
-        def part(entry):
-            return entry.split('/')
-
-        return any(
-            len(parts) == 1 and parts[0] == path_ for parts in map(part, self._contents)
-        )
-
-    def contents(self):
-        if isinstance(self.path, Exception):
-            raise self.path
-        yield from self._contents
-
-
-def create_package_from_loader(loader, is_package=True):
-    name = 'testingpackage'
-    module = types.ModuleType(name)
-    spec = ModuleSpec(name, loader, origin='does-not-exist', is_package=is_package)
-    module.__spec__ = spec
-    module.__loader__ = loader
-    return module
-
-
-def create_package(file=None, path=None, is_package=True, contents=()):
-    return create_package_from_loader(
-        Reader(file=file, path=path, _contents=contents),
-        is_package,
-    )
-
-
-class CommonTests(metaclass=abc.ABCMeta):
-    """
-    Tests shared by test_open, test_path, and test_read.
-    """
-
-    @abc.abstractmethod
-    def execute(self, package, path):
-        """
-        Call the pertinent legacy API function (e.g. open_text, path)
-        on package and path.
-        """
-
-    def test_package_name(self):
-        """
-        Passing in the package name should succeed.
-        """
-        self.execute(data01.__name__, 'utf-8.file')
-
-    def test_package_object(self):
-        """
-        Passing in the package itself should succeed.
-        """
-        self.execute(data01, 'utf-8.file')
-
-    def test_string_path(self):
-        """
-        Passing in a string for the path should succeed.
-        """
-        path = 'utf-8.file'
-        self.execute(data01, path)
-
-    def test_pathlib_path(self):
-        """
-        Passing in a pathlib.PurePath object for the path should succeed.
-        """
-        path = pathlib.PurePath('utf-8.file')
-        self.execute(data01, path)
-
-    def test_importing_module_as_side_effect(self):
-        """
-        The anchor package can already be imported.
-        """
-        del sys.modules[data01.__name__]
-        self.execute(data01.__name__, 'utf-8.file')
-
-    def test_missing_path(self):
-        """
-        Attempting to open or read or request the path for a
-        non-existent path should succeed if open_resource
-        can return a viable data stream.
-        """
-        bytes_data = io.BytesIO(b'Hello, world!')
-        package = create_package(file=bytes_data, path=FileNotFoundError())
-        self.execute(package, 'utf-8.file')
-        self.assertEqual(package.__loader__._path, 'utf-8.file')
-
-    def test_extant_path(self):
-        # Attempting to open or read or request the path when the
-        # path does exist should still succeed. Does not assert
-        # anything about the result.
-        bytes_data = io.BytesIO(b'Hello, world!')
-        # any path that exists
-        path = __file__
-        package = create_package(file=bytes_data, path=path)
-        self.execute(package, 'utf-8.file')
-        self.assertEqual(package.__loader__._path, 'utf-8.file')
-
-    def test_useless_loader(self):
-        package = create_package(file=FileNotFoundError(), path=FileNotFoundError())
-        with self.assertRaises(FileNotFoundError):
-            self.execute(package, 'utf-8.file')
-
-
-class ZipSetupBase:
-    ZIP_MODULE = 'data01'
-
-    def setUp(self):
-        self.fixtures = contextlib.ExitStack()
-        self.addCleanup(self.fixtures.close)
-
-        self.fixtures.enter_context(import_helper.isolated_modules())
-
-        temp_dir = self.fixtures.enter_context(os_helper.temp_dir())
-        modules = pathlib.Path(temp_dir) / 'zipped modules.zip'
-        src_path = pathlib.Path(__file__).parent.joinpath(self.ZIP_MODULE)
-        self.fixtures.enter_context(
-            import_helper.DirsOnSysPath(str(zip_.make_zip_file(src_path, modules)))
-        )
-
-        self.data = importlib.import_module(self.ZIP_MODULE)
-
-
-class ZipSetup(ZipSetupBase):
-    pass

py2docfx/venv/basevenv/Lib/site-packages/setuptools/_vendor/importlib_resources/tests/zip.py

@@ -1,32 +0,0 @@
-"""
-Generate zip test data files.
-"""
-
-import contextlib
-import os
-import pathlib
-import zipfile
-
-import zipp
-
-
-def make_zip_file(src, dst):
-    """
-    Zip the files in src into a new zipfile at dst.
-    """
-    with zipfile.ZipFile(dst, 'w') as zf:
-        for src_path, rel in walk(src):
-            dst_name = src.name / pathlib.PurePosixPath(rel.as_posix())
-            zf.write(src_path, dst_name)
-        zipp.CompleteDirs.inject(zf)
-    return dst
-
-
-def walk(datapath):
-    for dirpath, dirnames, filenames in os.walk(datapath):
-        with contextlib.suppress(ValueError):
-            dirnames.remove('__pycache__')
-        for filename in filenames:
-            res = pathlib.Path(dirpath) / filename
-            rel = res.relative_to(datapath)
-            yield res, rel

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

@@ -1,36 +0,0 @@
-"""Read resources contained within a package."""
-
-from ._common import (
-    as_file,
-    files,
-    Package,
-    Anchor,
-)
-
-from .functional import (
-    contents,
-    is_resource,
-    open_binary,
-    open_text,
-    path,
-    read_binary,
-    read_text,
-)
-
-from .abc import ResourceReader
-
-
-__all__ = [
-    'Package',
-    'Anchor',
-    'ResourceReader',
-    'as_file',
-    'files',
-    'contents',
-    'is_resource',
-    'open_binary',
-    'open_text',
-    'path',
-    'read_binary',
-    'read_text',
-]