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/functional.py

@@ -1,81 +0,0 @@
-"""Simplified function-based API for importlib.resources"""
-
-import warnings
-
-from ._common import files, as_file
-
-
-_MISSING = object()
-
-
-def open_binary(anchor, *path_names):
-    """Open for binary reading the *resource* within *package*."""
-    return _get_resource(anchor, path_names).open('rb')
-
-
-def open_text(anchor, *path_names, encoding=_MISSING, errors='strict'):
-    """Open for text reading the *resource* within *package*."""
-    encoding = _get_encoding_arg(path_names, encoding)
-    resource = _get_resource(anchor, path_names)
-    return resource.open('r', encoding=encoding, errors=errors)
-
-
-def read_binary(anchor, *path_names):
-    """Read and return contents of *resource* within *package* as bytes."""
-    return _get_resource(anchor, path_names).read_bytes()
-
-
-def read_text(anchor, *path_names, encoding=_MISSING, errors='strict'):
-    """Read and return contents of *resource* within *package* as str."""
-    encoding = _get_encoding_arg(path_names, encoding)
-    resource = _get_resource(anchor, path_names)
-    return resource.read_text(encoding=encoding, errors=errors)
-
-
-def path(anchor, *path_names):
-    """Return the path to the *resource* as an actual file system path."""
-    return as_file(_get_resource(anchor, path_names))
-
-
-def is_resource(anchor, *path_names):
-    """Return ``True`` if there is a resource named *name* in the package,
-
-    Otherwise returns ``False``.
-    """
-    return _get_resource(anchor, path_names).is_file()
-
-
-def contents(anchor, *path_names):
-    """Return an iterable over the named resources within the package.
-
-    The iterable returns :class:`str` resources (e.g. files).
-    The iterable does not recurse into subdirectories.
-    """
-    warnings.warn(
-        "importlib.resources.contents is deprecated. "
-        "Use files(anchor).iterdir() instead.",
-        DeprecationWarning,
-        stacklevel=1,
-    )
-    return (resource.name for resource in _get_resource(anchor, path_names).iterdir())
-
-
-def _get_encoding_arg(path_names, encoding):
-    # For compatibility with versions where *encoding* was a positional
-    # argument, it needs to be given explicitly when there are multiple
-    # *path_names*.
-    # This limitation can be removed in Python 3.15.
-    if encoding is _MISSING:
-        if len(path_names) > 1:
-            raise TypeError(
-                "'encoding' argument required with multiple path names",
-            )
-        else:
-            return 'utf-8'
-    return encoding
-
-
-def _get_resource(anchor, path_names):
-    if anchor is None:
-        raise TypeError("anchor must be module or string, got None")
-    return files(anchor).joinpath(*path_names)

py2docfx/venv/basevenv/Lib/site-packages/setuptools/_vendor/importlib_resources/future/adapters.py

@@ -1,95 +0,0 @@
-import functools
-import pathlib
-from contextlib import suppress
-from types import SimpleNamespace
-
-from .. import readers, _adapters
-
-
-def _block_standard(reader_getter):
-    """
-    Wrap _adapters.TraversableResourcesLoader.get_resource_reader
-    and intercept any standard library readers.
-    """
-
-    @functools.wraps(reader_getter)
-    def wrapper(*args, **kwargs):
-        """
-        If the reader is from the standard library, return None to allow
-        allow likely newer implementations in this library to take precedence.
-        """
-        try:
-            reader = reader_getter(*args, **kwargs)
-        except NotADirectoryError:
-            # MultiplexedPath may fail on zip subdirectory
-            return
-        # Python 3.10+
-        mod_name = reader.__class__.__module__
-        if mod_name.startswith('importlib.') and mod_name.endswith('readers'):
-            return
-        # Python 3.8, 3.9
-        if isinstance(reader, _adapters.CompatibilityFiles) and (
-            reader.spec.loader.__class__.__module__.startswith('zipimport')
-            or reader.spec.loader.__class__.__module__.startswith(
-                '_frozen_importlib_external'
-            )
-        ):
-            return
-        return reader
-
-    return wrapper
-
-
-def _skip_degenerate(reader):
-    """
-    Mask any degenerate reader. Ref #298.
-    """
-    is_degenerate = (
-        isinstance(reader, _adapters.CompatibilityFiles) and not reader._reader
-    )
-    return reader if not is_degenerate else None
-
-
-class TraversableResourcesLoader(_adapters.TraversableResourcesLoader):
-    """
-    Adapt loaders to provide TraversableResources and other
-    compatibility.
-
-    Ensures the readers from importlib_resources are preferred
-    over stdlib readers.
-    """
-
-    def get_resource_reader(self, name):
-        return (
-            _skip_degenerate(_block_standard(super().get_resource_reader)(name))
-            or self._standard_reader()
-            or super().get_resource_reader(name)
-        )
-
-    def _standard_reader(self):
-        return self._zip_reader() or self._namespace_reader() or self._file_reader()
-
-    def _zip_reader(self):
-        with suppress(AttributeError):
-            return readers.ZipReader(self.spec.loader, self.spec.name)
-
-    def _namespace_reader(self):
-        with suppress(AttributeError, ValueError):
-            return readers.NamespaceReader(self.spec.submodule_search_locations)
-
-    def _file_reader(self):
-        try:
-            path = pathlib.Path(self.spec.origin)
-        except TypeError:
-            return None
-        if path.exists():
-            return readers.FileReader(SimpleNamespace(path=path))
-
-
-def wrap_spec(package):
-    """
-    Override _adapters.wrap_spec to use TraversableResourcesLoader
-    from above. Ensures that future behavior is always available on older
-    Pythons.
-    """
-    return _adapters.SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader)

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

@@ -1,194 +0,0 @@
-import collections
-import contextlib
-import itertools
-import pathlib
-import operator
-import re
-import warnings
-
-from . import abc
-
-from ._itertools import only
-from .compat.py39 import ZipPath
-
-
-def remove_duplicates(items):
-    return iter(collections.OrderedDict.fromkeys(items))
-
-
-class FileReader(abc.TraversableResources):
-    def __init__(self, loader):
-        self.path = pathlib.Path(loader.path).parent
-
-    def resource_path(self, resource):
-        """
-        Return the file system path to prevent
-        `resources.path()` from creating a temporary
-        copy.
-        """
-        return str(self.path.joinpath(resource))
-
-    def files(self):
-        return self.path
-
-
-class ZipReader(abc.TraversableResources):
-    def __init__(self, loader, module):
-        _, _, name = module.rpartition('.')
-        self.prefix = loader.prefix.replace('\\', '/') + name + '/'
-        self.archive = loader.archive
-
-    def open_resource(self, resource):
-        try:
-            return super().open_resource(resource)
-        except KeyError as exc:
-            raise FileNotFoundError(exc.args[0])
-
-    def is_resource(self, path):
-        """
-        Workaround for `zipfile.Path.is_file` returning true
-        for non-existent paths.
-        """
-        target = self.files().joinpath(path)
-        return target.is_file() and target.exists()
-
-    def files(self):
-        return ZipPath(self.archive, self.prefix)
-
-
-class MultiplexedPath(abc.Traversable):
-    """
-    Given a series of Traversable objects, implement a merged
-    version of the interface across all objects. Useful for
-    namespace packages which may be multihomed at a single
-    name.
-    """
-
-    def __init__(self, *paths):
-        self._paths = list(map(_ensure_traversable, remove_duplicates(paths)))
-        if not self._paths:
-            message = 'MultiplexedPath must contain at least one path'
-            raise FileNotFoundError(message)
-        if not all(path.is_dir() for path in self._paths):
-            raise NotADirectoryError('MultiplexedPath only supports directories')
-
-    def iterdir(self):
-        children = (child for path in self._paths for child in path.iterdir())
-        by_name = operator.attrgetter('name')
-        groups = itertools.groupby(sorted(children, key=by_name), key=by_name)
-        return map(self._follow, (locs for name, locs in groups))
-
-    def read_bytes(self):
-        raise FileNotFoundError(f'{self} is not a file')
-
-    def read_text(self, *args, **kwargs):
-        raise FileNotFoundError(f'{self} is not a file')
-
-    def is_dir(self):
-        return True
-
-    def is_file(self):
-        return False
-
-    def joinpath(self, *descendants):
-        try:
-            return super().joinpath(*descendants)
-        except abc.TraversalError:
-            # One of the paths did not resolve (a directory does not exist).
-            # Just return something that will not exist.
-            return self._paths[0].joinpath(*descendants)
-
-    @classmethod
-    def _follow(cls, children):
-        """
-        Construct a MultiplexedPath if needed.
-
-        If children contains a sole element, return it.
-        Otherwise, return a MultiplexedPath of the items.
-        Unless one of the items is not a Directory, then return the first.
-        """
-        subdirs, one_dir, one_file = itertools.tee(children, 3)
-
-        try:
-            return only(one_dir)
-        except ValueError:
-            try:
-                return cls(*subdirs)
-            except NotADirectoryError:
-                return next(one_file)
-
-    def open(self, *args, **kwargs):
-        raise FileNotFoundError(f'{self} is not a file')
-
-    @property
-    def name(self):
-        return self._paths[0].name
-
-    def __repr__(self):
-        paths = ', '.join(f"'{path}'" for path in self._paths)
-        return f'MultiplexedPath({paths})'
-
-
-class NamespaceReader(abc.TraversableResources):
-    def __init__(self, namespace_path):
-        if 'NamespacePath' not in str(namespace_path):
-            raise ValueError('Invalid path')
-        self.path = MultiplexedPath(*map(self._resolve, namespace_path))
-
-    @classmethod
-    def _resolve(cls, path_str) -> abc.Traversable:
-        r"""
-        Given an item from a namespace path, resolve it to a Traversable.
-
-        path_str might be a directory on the filesystem or a path to a
-        zipfile plus the path within the zipfile, e.g. ``/foo/bar`` or
-        ``/foo/baz.zip/inner_dir`` or ``foo\baz.zip\inner_dir\sub``.
-        """
-        (dir,) = (cand for cand in cls._candidate_paths(path_str) if cand.is_dir())
-        return dir
-
-    @classmethod
-    def _candidate_paths(cls, path_str):
-        yield pathlib.Path(path_str)
-        yield from cls._resolve_zip_path(path_str)
-
-    @staticmethod
-    def _resolve_zip_path(path_str):
-        for match in reversed(list(re.finditer(r'[\\/]', path_str))):
-            with contextlib.suppress(
-                FileNotFoundError,
-                IsADirectoryError,
-                NotADirectoryError,
-                PermissionError,
-            ):
-                inner = path_str[match.end() :].replace('\\', '/') + '/'
-                yield ZipPath(path_str[: match.start()], inner.lstrip('/'))
-
-    def resource_path(self, resource):
-        """
-        Return the file system path to prevent
-        `resources.path()` from creating a temporary
-        copy.
-        """
-        return str(self.path.joinpath(resource))
-
-    def files(self):
-        return self.path
-
-
-def _ensure_traversable(path):
-    """
-    Convert deprecated string arguments to traversables (pathlib.Path).
-
-    Remove with Python 3.15.
-    """
-    if not isinstance(path, str):
-        return path
-
-    warnings.warn(
-        "String arguments are deprecated. Pass a Traversable instead.",
-        DeprecationWarning,
-        stacklevel=3,
-    )
-
-    return pathlib.Path(path)

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

@@ -1,106 +0,0 @@
-"""
-Interface adapters for low-level readers.
-"""
-
-import abc
-import io
-import itertools
-from typing import BinaryIO, List
-
-from .abc import Traversable, TraversableResources
-
-
-class SimpleReader(abc.ABC):
-    """
-    The minimum, low-level interface required from a resource
-    provider.
-    """
-
-    @property
-    @abc.abstractmethod
-    def package(self) -> str:
-        """
-        The name of the package for which this reader loads resources.
-        """
-
-    @abc.abstractmethod
-    def children(self) -> List['SimpleReader']:
-        """
-        Obtain an iterable of SimpleReader for available
-        child containers (e.g. directories).
-        """
-
-    @abc.abstractmethod
-    def resources(self) -> List[str]:
-        """
-        Obtain available named resources for this virtual package.
-        """
-
-    @abc.abstractmethod
-    def open_binary(self, resource: str) -> BinaryIO:
-        """
-        Obtain a File-like for a named resource.
-        """
-
-    @property
-    def name(self):
-        return self.package.split('.')[-1]
-
-
-class ResourceContainer(Traversable):
-    """
-    Traversable container for a package's resources via its reader.
-    """
-
-    def __init__(self, reader: SimpleReader):
-        self.reader = reader
-
-    def is_dir(self):
-        return True
-
-    def is_file(self):
-        return False
-
-    def iterdir(self):
-        files = (ResourceHandle(self, name) for name in self.reader.resources)
-        dirs = map(ResourceContainer, self.reader.children())
-        return itertools.chain(files, dirs)
-
-    def open(self, *args, **kwargs):
-        raise IsADirectoryError()
-
-
-class ResourceHandle(Traversable):
-    """
-    Handle to a named resource in a ResourceReader.
-    """
-
-    def __init__(self, parent: ResourceContainer, name: str):
-        self.parent = parent
-        self.name = name  # type: ignore
-
-    def is_file(self):
-        return True
-
-    def is_dir(self):
-        return False
-
-    def open(self, mode='r', *args, **kwargs):
-        stream = self.parent.reader.open_binary(self.name)
-        if 'b' not in mode:
-            stream = io.TextIOWrapper(stream, *args, **kwargs)
-        return stream
-
-    def joinpath(self, name):
-        raise RuntimeError("Cannot traverse into a resource")
-
-
-class TraversableReader(TraversableResources, SimpleReader):
-    """
-    A TraversableResources based on SimpleReader. Resource providers
-    may derive from this class to provide the TraversableResources
-    interface by supplying the SimpleReader interface.
-    """
-
-    def files(self):
-        return ResourceContainer(self)

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

@@ -1,56 +0,0 @@
-import pathlib
-import functools
-
-from typing import Dict, Union
-
-
-####
-# from jaraco.path 3.4.1
-
-FilesSpec = Dict[str, Union[str, bytes, 'FilesSpec']]  # type: ignore
-
-
-def build(spec: FilesSpec, prefix=pathlib.Path()):
-    """
-    Build a set of files/directories, as described by the spec.
-
-    Each key represents a pathname, and the value represents
-    the content. Content may be a nested directory.
-
-    >>> spec = {
-    ...     'README.txt': "A README file",
-    ...     "foo": {
-    ...         "__init__.py": "",
-    ...         "bar": {
-    ...             "__init__.py": "",
-    ...         },
-    ...         "baz.py": "# Some code",
-    ...     }
-    ... }
-    >>> target = getfixture('tmp_path')
-    >>> build(spec, target)
-    >>> target.joinpath('foo/baz.py').read_text(encoding='utf-8')
-    '# Some code'
-    """
-    for name, contents in spec.items():
-        create(contents, pathlib.Path(prefix) / name)
-
-
-@functools.singledispatch
-def create(content: Union[str, bytes, FilesSpec], path):
-    path.mkdir(exist_ok=True)
-    build(content, prefix=path)  # type: ignore
-
-
-@create.register
-def _(content: bytes, path):
-    path.write_bytes(content)
-
-
-@create.register
-def _(content: str, path):
-    path.write_text(content, encoding='utf-8')
-
-
-# end from jaraco.path
-####

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

@@ -1,18 +0,0 @@
-import contextlib
-
-from .py39 import import_helper
-
-
-@contextlib.contextmanager
-def isolated_modules():
-    """
-    Save modules on entry and cleanup on exit.
-    """
-    (saved,) = import_helper.modules_setup()
-    try:
-        yield
-    finally:
-        import_helper.modules_cleanup(saved)
-
-
-vars(import_helper).setdefault('isolated_modules', isolated_modules)

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

@@ -1,10 +0,0 @@
-"""
-Backward-compatability shims to support Python 3.9 and earlier.
-"""
-
-from jaraco.test.cpython import from_test_support, try_import
-
-import_helper = try_import('import_helper') or from_test_support(
-    'modules_setup', 'modules_cleanup', 'DirsOnSysPath'
-)
-os_helper = try_import('os_helper') or from_test_support('temp_dir')

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

@@ -1,104 +0,0 @@
-import io
-import unittest
-
-import importlib_resources as resources
-
-from importlib_resources._adapters import (
-    CompatibilityFiles,
-    wrap_spec,
-)
-
-from . import util
-
-
-class CompatibilityFilesTests(unittest.TestCase):
-    @property
-    def package(self):
-        bytes_data = io.BytesIO(b'Hello, world!')
-        return util.create_package(
-            file=bytes_data,
-            path='some_path',
-            contents=('a', 'b', 'c'),
-        )
-
-    @property
-    def files(self):
-        return resources.files(self.package)
-
-    def test_spec_path_iter(self):
-        self.assertEqual(
-            sorted(path.name for path in self.files.iterdir()),
-            ['a', 'b', 'c'],
-        )
-
-    def test_child_path_iter(self):
-        self.assertEqual(list((self.files / 'a').iterdir()), [])
-
-    def test_orphan_path_iter(self):
-        self.assertEqual(list((self.files / 'a' / 'a').iterdir()), [])
-        self.assertEqual(list((self.files / 'a' / 'a' / 'a').iterdir()), [])
-
-    def test_spec_path_is(self):
-        self.assertFalse(self.files.is_file())
-        self.assertFalse(self.files.is_dir())
-
-    def test_child_path_is(self):
-        self.assertTrue((self.files / 'a').is_file())
-        self.assertFalse((self.files / 'a').is_dir())
-
-    def test_orphan_path_is(self):
-        self.assertFalse((self.files / 'a' / 'a').is_file())
-        self.assertFalse((self.files / 'a' / 'a').is_dir())
-        self.assertFalse((self.files / 'a' / 'a' / 'a').is_file())
-        self.assertFalse((self.files / 'a' / 'a' / 'a').is_dir())
-
-    def test_spec_path_name(self):
-        self.assertEqual(self.files.name, 'testingpackage')
-
-    def test_child_path_name(self):
-        self.assertEqual((self.files / 'a').name, 'a')
-
-    def test_orphan_path_name(self):
-        self.assertEqual((self.files / 'a' / 'b').name, 'b')
-        self.assertEqual((self.files / 'a' / 'b' / 'c').name, 'c')
-
-    def test_spec_path_open(self):
-        self.assertEqual(self.files.read_bytes(), b'Hello, world!')
-        self.assertEqual(self.files.read_text(encoding='utf-8'), 'Hello, world!')
-
-    def test_child_path_open(self):
-        self.assertEqual((self.files / 'a').read_bytes(), b'Hello, world!')
-        self.assertEqual(
-            (self.files / 'a').read_text(encoding='utf-8'), 'Hello, world!'
-        )
-
-    def test_orphan_path_open(self):
-        with self.assertRaises(FileNotFoundError):
-            (self.files / 'a' / 'b').read_bytes()
-        with self.assertRaises(FileNotFoundError):
-            (self.files / 'a' / 'b' / 'c').read_bytes()
-
-    def test_open_invalid_mode(self):
-        with self.assertRaises(ValueError):
-            self.files.open('0')
-
-    def test_orphan_path_invalid(self):
-        with self.assertRaises(ValueError):
-            CompatibilityFiles.OrphanPath()
-
-    def test_wrap_spec(self):
-        spec = wrap_spec(self.package)
-        self.assertIsInstance(spec.loader.get_resource_reader(None), CompatibilityFiles)
-
-
-class CompatibilityFilesNoReaderTests(unittest.TestCase):
-    @property
-    def package(self):
-        return util.create_package_from_loader(None)
-
-    @property
-    def files(self):
-        return resources.files(self.package)
-
-    def test_spec_path_joinpath(self):
-        self.assertIsInstance(self.files / 'a', CompatibilityFiles.OrphanPath)