@scrypted/arlo 0.11.26 → 0.11.27

package/venv/lib/python3.10/site-packages/setuptools/archive_util.py

@@ -1,205 +0,0 @@
-"""Utilities for extracting common archive formats"""
-
-import zipfile
-import tarfile
-import os
-import shutil
-import posixpath
-import contextlib
-from distutils.errors import DistutilsError
-
-from pkg_resources import ensure_directory
-
-__all__ = [
-    "unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter",
-    "UnrecognizedFormat", "extraction_drivers", "unpack_directory",
-]
-
-
-class UnrecognizedFormat(DistutilsError):
-    """Couldn't recognize the archive type"""
-
-
-def default_filter(src, dst):
-    """The default progress/filter callback; returns True for all files"""
-    return dst
-
-
-def unpack_archive(
-        filename, extract_dir, progress_filter=default_filter,
-        drivers=None):
-    """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``
-
-    `progress_filter` is a function taking two arguments: a source path
-    internal to the archive ('/'-separated), and a filesystem path where it
-    will be extracted.  The callback must return the desired extract path
-    (which may be the same as the one passed in), or else ``None`` to skip
-    that file or directory.  The callback can thus be used to report on the
-    progress of the extraction, as well as to filter the items extracted or
-    alter their extraction paths.
-
-    `drivers`, if supplied, must be a non-empty sequence of functions with the
-    same signature as this function (minus the `drivers` argument), that raise
-    ``UnrecognizedFormat`` if they do not support extracting the designated
-    archive type.  The `drivers` are tried in sequence until one is found that
-    does not raise an error, or until all are exhausted (in which case
-    ``UnrecognizedFormat`` is raised).  If you do not supply a sequence of
-    drivers, the module's ``extraction_drivers`` constant will be used, which
-    means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
-    order.
-    """
-    for driver in drivers or extraction_drivers:
-        try:
-            driver(filename, extract_dir, progress_filter)
-        except UnrecognizedFormat:
-            continue
-        else:
-            return
-    else:
-        raise UnrecognizedFormat(
-            "Not a recognized archive type: %s" % filename
-        )
-
-
-def unpack_directory(filename, extract_dir, progress_filter=default_filter):
-    """"Unpack" a directory, using the same interface as for archives
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a directory
-    """
-    if not os.path.isdir(filename):
-        raise UnrecognizedFormat("%s is not a directory" % filename)
-
-    paths = {
-        filename: ('', extract_dir),
-    }
-    for base, dirs, files in os.walk(filename):
-        src, dst = paths[base]
-        for d in dirs:
-            paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
-        for f in files:
-            target = os.path.join(dst, f)
-            target = progress_filter(src + f, target)
-            if not target:
-                # skip non-files
-                continue
-            ensure_directory(target)
-            f = os.path.join(base, f)
-            shutil.copyfile(f, target)
-            shutil.copystat(f, target)
-
-
-def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
-    """Unpack zip `filename` to `extract_dir`
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
-    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation
-    of the `progress_filter` argument.
-    """
-
-    if not zipfile.is_zipfile(filename):
-        raise UnrecognizedFormat("%s is not a zip file" % (filename,))
-
-    with zipfile.ZipFile(filename) as z:
-        for info in z.infolist():
-            name = info.filename
-
-            # don't extract absolute paths or ones with .. in them
-            if name.startswith('/') or '..' in name.split('/'):
-                continue
-
-            target = os.path.join(extract_dir, *name.split('/'))
-            target = progress_filter(name, target)
-            if not target:
-                continue
-            if name.endswith('/'):
-                # directory
-                ensure_directory(target)
-            else:
-                # file
-                ensure_directory(target)
-                data = z.read(info.filename)
-                with open(target, 'wb') as f:
-                    f.write(data)
-            unix_attributes = info.external_attr >> 16
-            if unix_attributes:
-                os.chmod(target, unix_attributes)
-
-
-def _resolve_tar_file_or_dir(tar_obj, tar_member_obj):
-    """Resolve any links and extract link targets as normal files."""
-    while tar_member_obj is not None and (
-            tar_member_obj.islnk() or tar_member_obj.issym()):
-        linkpath = tar_member_obj.linkname
-        if tar_member_obj.issym():
-            base = posixpath.dirname(tar_member_obj.name)
-            linkpath = posixpath.join(base, linkpath)
-            linkpath = posixpath.normpath(linkpath)
-        tar_member_obj = tar_obj._getmember(linkpath)
-
-    is_file_or_dir = (
-        tar_member_obj is not None and
-        (tar_member_obj.isfile() or tar_member_obj.isdir())
-    )
-    if is_file_or_dir:
-        return tar_member_obj
-
-    raise LookupError('Got unknown file type')
-
-
-def _iter_open_tar(tar_obj, extract_dir, progress_filter):
-    """Emit member-destination pairs from a tar archive."""
-    # don't do any chowning!
-    tar_obj.chown = lambda *args: None
-
-    with contextlib.closing(tar_obj):
-        for member in tar_obj:
-            name = member.name
-            # don't extract absolute paths or ones with .. in them
-            if name.startswith('/') or '..' in name.split('/'):
-                continue
-
-            prelim_dst = os.path.join(extract_dir, *name.split('/'))
-
-            try:
-                member = _resolve_tar_file_or_dir(tar_obj, member)
-            except LookupError:
-                continue
-
-            final_dst = progress_filter(name, prelim_dst)
-            if not final_dst:
-                continue
-
-            if final_dst.endswith(os.sep):
-                final_dst = final_dst[:-1]
-
-            yield member, final_dst
-
-
-def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
-    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
-    by ``tarfile.open()``).  See ``unpack_archive()`` for an explanation
-    of the `progress_filter` argument.
-    """
-    try:
-        tarobj = tarfile.open(filename)
-    except tarfile.TarError as e:
-        raise UnrecognizedFormat(
-            "%s is not a compressed or uncompressed tar file" % (filename,)
-        ) from e
-
-    for member, final_dst in _iter_open_tar(
-            tarobj, extract_dir, progress_filter,
-    ):
-        try:
-            # XXX Ugh
-            tarobj._extract_member(member, final_dst)
-        except tarfile.ExtractError:
-            # chown/chmod/mkfifo/mknode/makedev failed
-            pass
-
-    return True
-
-
-extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile

package/venv/lib/python3.10/site-packages/setuptools/build_meta.py

@@ -1,290 +0,0 @@
-"""A PEP 517 interface to setuptools
-
-Previously, when a user or a command line tool (let's call it a "frontend")
-needed to make a request of setuptools to take a certain action, for
-example, generating a list of installation requirements, the frontend would
-would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line.
-
-PEP 517 defines a different method of interfacing with setuptools. Rather
-than calling "setup.py" directly, the frontend should:
-
-  1. Set the current directory to the directory with a setup.py file
-  2. Import this module into a safe python interpreter (one in which
-     setuptools can potentially set global variables or crash hard).
-  3. Call one of the functions defined in PEP 517.
-
-What each function does is defined in PEP 517. However, here is a "casual"
-definition of the functions (this definition should not be relied on for
-bug reports or API stability):
-
-  - `build_wheel`: build a wheel in the folder and return the basename
-  - `get_requires_for_build_wheel`: get the `setup_requires` to build
-  - `prepare_metadata_for_build_wheel`: get the `install_requires`
-  - `build_sdist`: build an sdist in the folder and return the basename
-  - `get_requires_for_build_sdist`: get the `setup_requires` to build
-
-Again, this is not a formal definition! Just a "taste" of the module.
-"""
-
-import io
-import os
-import sys
-import tokenize
-import shutil
-import contextlib
-import tempfile
-import warnings
-
-import setuptools
-import distutils
-
-from pkg_resources import parse_requirements
-
-__all__ = ['get_requires_for_build_sdist',
-           'get_requires_for_build_wheel',
-           'prepare_metadata_for_build_wheel',
-           'build_wheel',
-           'build_sdist',
-           '__legacy__',
-           'SetupRequirementsError']
-
-
-class SetupRequirementsError(BaseException):
-    def __init__(self, specifiers):
-        self.specifiers = specifiers
-
-
-class Distribution(setuptools.dist.Distribution):
-    def fetch_build_eggs(self, specifiers):
-        specifier_list = list(map(str, parse_requirements(specifiers)))
-
-        raise SetupRequirementsError(specifier_list)
-
-    @classmethod
-    @contextlib.contextmanager
-    def patch(cls):
-        """
-        Replace
-        distutils.dist.Distribution with this class
-        for the duration of this context.
-        """
-        orig = distutils.core.Distribution
-        distutils.core.Distribution = cls
-        try:
-            yield
-        finally:
-            distutils.core.Distribution = orig
-
-
-@contextlib.contextmanager
-def no_install_setup_requires():
-    """Temporarily disable installing setup_requires
-
-    Under PEP 517, the backend reports build dependencies to the frontend,
-    and the frontend is responsible for ensuring they're installed.
-    So setuptools (acting as a backend) should not try to install them.
-    """
-    orig = setuptools._install_setup_requires
-    setuptools._install_setup_requires = lambda attrs: None
-    try:
-        yield
-    finally:
-        setuptools._install_setup_requires = orig
-
-
-def _get_immediate_subdirectories(a_dir):
-    return [name for name in os.listdir(a_dir)
-            if os.path.isdir(os.path.join(a_dir, name))]
-
-
-def _file_with_extension(directory, extension):
-    matching = (
-        f for f in os.listdir(directory)
-        if f.endswith(extension)
-    )
-    try:
-        file, = matching
-    except ValueError:
-        raise ValueError(
-            'No distribution was found. Ensure that `setup.py` '
-            'is not empty and that it calls `setup()`.')
-    return file
-
-
-def _open_setup_script(setup_script):
-    if not os.path.exists(setup_script):
-        # Supply a default setup.py
-        return io.StringIO(u"from setuptools import setup; setup()")
-
-    return getattr(tokenize, 'open', open)(setup_script)
-
-
-@contextlib.contextmanager
-def suppress_known_deprecation():
-    with warnings.catch_warnings():
-        warnings.filterwarnings('ignore', 'setup.py install is deprecated')
-        yield
-
-
-class _BuildMetaBackend(object):
-
-    def _fix_config(self, config_settings):
-        config_settings = config_settings or {}
-        config_settings.setdefault('--global-option', [])
-        return config_settings
-
-    def _get_build_requires(self, config_settings, requirements):
-        config_settings = self._fix_config(config_settings)
-
-        sys.argv = sys.argv[:1] + ['egg_info'] + \
-            config_settings["--global-option"]
-        try:
-            with Distribution.patch():
-                self.run_setup()
-        except SetupRequirementsError as e:
-            requirements += e.specifiers
-
-        return requirements
-
-    def run_setup(self, setup_script='setup.py'):
-        # Note that we can reuse our build directory between calls
-        # Correctness comes first, then optimization later
-        __file__ = setup_script
-        __name__ = '__main__'
-
-        with _open_setup_script(__file__) as f:
-            code = f.read().replace(r'\r\n', r'\n')
-
-        exec(compile(code, __file__, 'exec'), locals())
-
-    def get_requires_for_build_wheel(self, config_settings=None):
-        config_settings = self._fix_config(config_settings)
-        return self._get_build_requires(
-            config_settings, requirements=['wheel'])
-
-    def get_requires_for_build_sdist(self, config_settings=None):
-        config_settings = self._fix_config(config_settings)
-        return self._get_build_requires(config_settings, requirements=[])
-
-    def prepare_metadata_for_build_wheel(self, metadata_directory,
-                                         config_settings=None):
-        sys.argv = sys.argv[:1] + [
-            'dist_info', '--egg-base', metadata_directory]
-        with no_install_setup_requires():
-            self.run_setup()
-
-        dist_info_directory = metadata_directory
-        while True:
-            dist_infos = [f for f in os.listdir(dist_info_directory)
-                          if f.endswith('.dist-info')]
-
-            if (
-                len(dist_infos) == 0 and
-                len(_get_immediate_subdirectories(dist_info_directory)) == 1
-            ):
-
-                dist_info_directory = os.path.join(
-                    dist_info_directory, os.listdir(dist_info_directory)[0])
-                continue
-
-            assert len(dist_infos) == 1
-            break
-
-        # PEP 517 requires that the .dist-info directory be placed in the
-        # metadata_directory. To comply, we MUST copy the directory to the root
-        if dist_info_directory != metadata_directory:
-            shutil.move(
-                os.path.join(dist_info_directory, dist_infos[0]),
-                metadata_directory)
-            shutil.rmtree(dist_info_directory, ignore_errors=True)
-
-        return dist_infos[0]
-
-    def _build_with_temp_dir(self, setup_command, result_extension,
-                             result_directory, config_settings):
-        config_settings = self._fix_config(config_settings)
-        result_directory = os.path.abspath(result_directory)
-
-        # Build in a temporary directory, then copy to the target.
-        os.makedirs(result_directory, exist_ok=True)
-        with tempfile.TemporaryDirectory(dir=result_directory) as tmp_dist_dir:
-            sys.argv = (sys.argv[:1] + setup_command +
-                        ['--dist-dir', tmp_dist_dir] +
-                        config_settings["--global-option"])
-            with no_install_setup_requires():
-                self.run_setup()
-
-            result_basename = _file_with_extension(
-                tmp_dist_dir, result_extension)
-            result_path = os.path.join(result_directory, result_basename)
-            if os.path.exists(result_path):
-                # os.rename will fail overwriting on non-Unix.
-                os.remove(result_path)
-            os.rename(os.path.join(tmp_dist_dir, result_basename), result_path)
-
-        return result_basename
-
-    def build_wheel(self, wheel_directory, config_settings=None,
-                    metadata_directory=None):
-        with suppress_known_deprecation():
-            return self._build_with_temp_dir(['bdist_wheel'], '.whl',
-                                             wheel_directory, config_settings)
-
-    def build_sdist(self, sdist_directory, config_settings=None):
-        return self._build_with_temp_dir(['sdist', '--formats', 'gztar'],
-                                         '.tar.gz', sdist_directory,
-                                         config_settings)
-
-
-class _BuildMetaLegacyBackend(_BuildMetaBackend):
-    """Compatibility backend for setuptools
-
-    This is a version of setuptools.build_meta that endeavors
-    to maintain backwards
-    compatibility with pre-PEP 517 modes of invocation. It
-    exists as a temporary
-    bridge between the old packaging mechanism and the new
-    packaging mechanism,
-    and will eventually be removed.
-    """
-    def run_setup(self, setup_script='setup.py'):
-        # In order to maintain compatibility with scripts assuming that
-        # the setup.py script is in a directory on the PYTHONPATH, inject
-        # '' into sys.path. (pypa/setuptools#1642)
-        sys_path = list(sys.path)           # Save the original path
-
-        script_dir = os.path.dirname(os.path.abspath(setup_script))
-        if script_dir not in sys.path:
-            sys.path.insert(0, script_dir)
-
-        # Some setup.py scripts (e.g. in pygame and numpy) use sys.argv[0] to
-        # get the directory of the source code. They expect it to refer to the
-        # setup.py script.
-        sys_argv_0 = sys.argv[0]
-        sys.argv[0] = setup_script
-
-        try:
-            super(_BuildMetaLegacyBackend,
-                  self).run_setup(setup_script=setup_script)
-        finally:
-            # While PEP 517 frontends should be calling each hook in a fresh
-            # subprocess according to the standard (and thus it should not be
-            # strictly necessary to restore the old sys.path), we'll restore
-            # the original path so that the path manipulation does not persist
-            # within the hook after run_setup is called.
-            sys.path[:] = sys_path
-            sys.argv[0] = sys_argv_0
-
-
-# The primary backend
-_BACKEND = _BuildMetaBackend()
-
-get_requires_for_build_wheel = _BACKEND.get_requires_for_build_wheel
-get_requires_for_build_sdist = _BACKEND.get_requires_for_build_sdist
-prepare_metadata_for_build_wheel = _BACKEND.prepare_metadata_for_build_wheel
-build_wheel = _BACKEND.build_wheel
-build_sdist = _BACKEND.build_sdist
-
-
-# The legacy backend
-__legacy__ = _BuildMetaLegacyBackend()

package/venv/lib/python3.10/site-packages/setuptools/command/__init__.py

@@ -1,8 +0,0 @@
-from distutils.command.bdist import bdist
-import sys
-
-if 'egg' not in bdist.format_commands:
-    bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
-    bdist.format_commands.append('egg')
-
-del bdist, sys

package/venv/lib/python3.10/site-packages/setuptools/command/alias.py

@@ -1,78 +0,0 @@
-from distutils.errors import DistutilsOptionError
-
-from setuptools.command.setopt import edit_config, option_base, config_file
-
-
-def shquote(arg):
-    """Quote an argument for later parsing by shlex.split()"""
-    for c in '"', "'", "\\", "#":
-        if c in arg:
-            return repr(arg)
-    if arg.split() != [arg]:
-        return repr(arg)
-    return arg
-
-
-class alias(option_base):
-    """Define a shortcut that invokes one or more commands"""
-
-    description = "define a shortcut to invoke one or more commands"
-    command_consumes_arguments = True
-
-    user_options = [
-        ('remove', 'r', 'remove (unset) the alias'),
-    ] + option_base.user_options
-
-    boolean_options = option_base.boolean_options + ['remove']
-
-    def initialize_options(self):
-        option_base.initialize_options(self)
-        self.args = None
-        self.remove = None
-
-    def finalize_options(self):
-        option_base.finalize_options(self)
-        if self.remove and len(self.args) != 1:
-            raise DistutilsOptionError(
-                "Must specify exactly one argument (the alias name) when "
-                "using --remove"
-            )
-
-    def run(self):
-        aliases = self.distribution.get_option_dict('aliases')
-
-        if not self.args:
-            print("Command Aliases")
-            print("---------------")
-            for alias in aliases:
-                print("setup.py alias", format_alias(alias, aliases))
-            return
-
-        elif len(self.args) == 1:
-            alias, = self.args
-            if self.remove:
-                command = None
-            elif alias in aliases:
-                print("setup.py alias", format_alias(alias, aliases))
-                return
-            else:
-                print("No alias definition found for %r" % alias)
-                return
-        else:
-            alias = self.args[0]
-            command = ' '.join(map(shquote, self.args[1:]))
-
-        edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run)
-
-
-def format_alias(name, aliases):
-    source, command = aliases[name]
-    if source == config_file('global'):
-        source = '--global-config '
-    elif source == config_file('user'):
-        source = '--user-config '
-    elif source == config_file('local'):
-        source = ''
-    else:
-        source = '--filename=%r' % source
-    return source + name + ' ' + command