@scrypted/server 0.0.141 → 0.0.142

package/.venv/lib/python3.9/site-packages/pip/_vendor/pep517/check.py

@@ -1,207 +0,0 @@
-"""Check a project and backend by attempting to build using PEP 517 hooks.
-"""
-import argparse
-import io
-import logging
-import os
-from os.path import isfile, join as pjoin
-import shutil
-from subprocess import CalledProcessError
-import sys
-import tarfile
-from tempfile import mkdtemp
-import zipfile
-
-from .colorlog import enable_colourful_output
-from .compat import TOMLDecodeError, toml_load
-from .envbuild import BuildEnvironment
-from .wrappers import Pep517HookCaller
-
-log = logging.getLogger(__name__)
-
-
-def check_build_sdist(hooks, build_sys_requires):
-    with BuildEnvironment() as env:
-        try:
-            env.pip_install(build_sys_requires)
-            log.info('Installed static build dependencies')
-        except CalledProcessError:
-            log.error('Failed to install static build dependencies')
-            return False
-
-        try:
-            reqs = hooks.get_requires_for_build_sdist({})
-            log.info('Got build requires: %s', reqs)
-        except Exception:
-            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
-            return False
-
-        try:
-            env.pip_install(reqs)
-            log.info('Installed dynamic build dependencies')
-        except CalledProcessError:
-            log.error('Failed to install dynamic build dependencies')
-            return False
-
-        td = mkdtemp()
-        log.info('Trying to build sdist in %s', td)
-        try:
-            try:
-                filename = hooks.build_sdist(td, {})
-                log.info('build_sdist returned %r', filename)
-            except Exception:
-                log.info('Failure in build_sdist', exc_info=True)
-                return False
-
-            if not filename.endswith('.tar.gz'):
-                log.error(
-                    "Filename %s doesn't have .tar.gz extension", filename)
-                return False
-
-            path = pjoin(td, filename)
-            if isfile(path):
-                log.info("Output file %s exists", path)
-            else:
-                log.error("Output file %s does not exist", path)
-                return False
-
-            if tarfile.is_tarfile(path):
-                log.info("Output file is a tar file")
-            else:
-                log.error("Output file is not a tar file")
-                return False
-
-        finally:
-            shutil.rmtree(td)
-
-        return True
-
-
-def check_build_wheel(hooks, build_sys_requires):
-    with BuildEnvironment() as env:
-        try:
-            env.pip_install(build_sys_requires)
-            log.info('Installed static build dependencies')
-        except CalledProcessError:
-            log.error('Failed to install static build dependencies')
-            return False
-
-        try:
-            reqs = hooks.get_requires_for_build_wheel({})
-            log.info('Got build requires: %s', reqs)
-        except Exception:
-            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
-            return False
-
-        try:
-            env.pip_install(reqs)
-            log.info('Installed dynamic build dependencies')
-        except CalledProcessError:
-            log.error('Failed to install dynamic build dependencies')
-            return False
-
-        td = mkdtemp()
-        log.info('Trying to build wheel in %s', td)
-        try:
-            try:
-                filename = hooks.build_wheel(td, {})
-                log.info('build_wheel returned %r', filename)
-            except Exception:
-                log.info('Failure in build_wheel', exc_info=True)
-                return False
-
-            if not filename.endswith('.whl'):
-                log.error("Filename %s doesn't have .whl extension", filename)
-                return False
-
-            path = pjoin(td, filename)
-            if isfile(path):
-                log.info("Output file %s exists", path)
-            else:
-                log.error("Output file %s does not exist", path)
-                return False
-
-            if zipfile.is_zipfile(path):
-                log.info("Output file is a zip file")
-            else:
-                log.error("Output file is not a zip file")
-                return False
-
-        finally:
-            shutil.rmtree(td)
-
-        return True
-
-
-def check(source_dir):
-    pyproject = pjoin(source_dir, 'pyproject.toml')
-    if isfile(pyproject):
-        log.info('Found pyproject.toml')
-    else:
-        log.error('Missing pyproject.toml')
-        return False
-
-    try:
-        with io.open(pyproject, 'rb') as f:
-            pyproject_data = toml_load(f)
-        # Ensure the mandatory data can be loaded
-        buildsys = pyproject_data['build-system']
-        requires = buildsys['requires']
-        backend = buildsys['build-backend']
-        backend_path = buildsys.get('backend-path')
-        log.info('Loaded pyproject.toml')
-    except (TOMLDecodeError, KeyError):
-        log.error("Invalid pyproject.toml", exc_info=True)
-        return False
-
-    hooks = Pep517HookCaller(source_dir, backend, backend_path)
-
-    sdist_ok = check_build_sdist(hooks, requires)
-    wheel_ok = check_build_wheel(hooks, requires)
-
-    if not sdist_ok:
-        log.warning('Sdist checks failed; scroll up to see')
-    if not wheel_ok:
-        log.warning('Wheel checks failed')
-
-    return sdist_ok
-
-
-def main(argv=None):
-    log.warning('pep517.check is deprecated. '
-                'Consider switching to https://pypi.org/project/build/')
-
-    ap = argparse.ArgumentParser()
-    ap.add_argument(
-        'source_dir',
-        help="A directory containing pyproject.toml")
-    args = ap.parse_args(argv)
-
-    enable_colourful_output()
-
-    ok = check(args.source_dir)
-
-    if ok:
-        print(ansi('Checks passed', 'green'))
-    else:
-        print(ansi('Checks failed', 'red'))
-        sys.exit(1)
-
-
-ansi_codes = {
-    'reset': '\x1b[0m',
-    'bold': '\x1b[1m',
-    'red': '\x1b[31m',
-    'green': '\x1b[32m',
-}
-
-
-def ansi(s, attr):
-    if os.name != 'nt' and sys.stdout.isatty():
-        return ansi_codes[attr] + str(s) + ansi_codes['reset']
-    else:
-        return str(s)
-
-
-if __name__ == '__main__':
-    main()

package/.venv/lib/python3.9/site-packages/pip/_vendor/pep517/colorlog.py

@@ -1,115 +0,0 @@
-"""Nicer log formatting with colours.
-
-Code copied from Tornado, Apache licensed.
-"""
-# Copyright 2012 Facebook
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-
-import logging
-import sys
-
-try:
-    import curses
-except ImportError:
-    curses = None
-
-
-def _stderr_supports_color():
-    color = False
-    if curses and hasattr(sys.stderr, 'isatty') and sys.stderr.isatty():
-        try:
-            curses.setupterm()
-            if curses.tigetnum("colors") > 0:
-                color = True
-        except Exception:
-            pass
-    return color
-
-
-class LogFormatter(logging.Formatter):
-    """Log formatter with colour support
-    """
-    DEFAULT_COLORS = {
-        logging.INFO: 2,  # Green
-        logging.WARNING: 3,  # Yellow
-        logging.ERROR: 1,  # Red
-        logging.CRITICAL: 1,
-    }
-
-    def __init__(self, color=True, datefmt=None):
-        r"""
-        :arg bool color: Enables color support.
-        :arg string fmt: Log message format.
-        It will be applied to the attributes dict of log records. The
-        text between ``%(color)s`` and ``%(end_color)s`` will be colored
-        depending on the level if color support is on.
-        :arg dict colors: color mappings from logging level to terminal color
-        code
-        :arg string datefmt: Datetime format.
-        Used for formatting ``(asctime)`` placeholder in ``prefix_fmt``.
-        .. versionchanged:: 3.2
-        Added ``fmt`` and ``datefmt`` arguments.
-        """
-        logging.Formatter.__init__(self, datefmt=datefmt)
-        self._colors = {}
-        if color and _stderr_supports_color():
-            # The curses module has some str/bytes confusion in
-            # python3. Until version 3.2.3, most methods return
-            # bytes, but only accept strings. In addition, we want to
-            # output these strings with the logging module, which
-            # works with unicode strings. The explicit calls to
-            # unicode() below are harmless in python2 but will do the
-            # right conversion in python 3.
-            fg_color = (curses.tigetstr("setaf") or
-                        curses.tigetstr("setf") or "")
-            if (3, 0) < sys.version_info < (3, 2, 3):
-                fg_color = str(fg_color, "ascii")
-
-            for levelno, code in self.DEFAULT_COLORS.items():
-                self._colors[levelno] = str(
-                    curses.tparm(fg_color, code), "ascii")
-            self._normal = str(curses.tigetstr("sgr0"), "ascii")
-
-            scr = curses.initscr()
-            self.termwidth = scr.getmaxyx()[1]
-            curses.endwin()
-        else:
-            self._normal = ''
-            # Default width is usually 80, but too wide is
-            # worse than too narrow
-            self.termwidth = 70
-
-    def formatMessage(self, record):
-        mlen = len(record.message)
-        right_text = '{initial}-{name}'.format(initial=record.levelname[0],
-                                               name=record.name)
-        if mlen + len(right_text) < self.termwidth:
-            space = ' ' * (self.termwidth - (mlen + len(right_text)))
-        else:
-            space = '  '
-
-        if record.levelno in self._colors:
-            start_color = self._colors[record.levelno]
-            end_color = self._normal
-        else:
-            start_color = end_color = ''
-
-        return record.message + space + start_color + right_text + end_color
-
-
-def enable_colourful_output(level=logging.INFO):
-    handler = logging.StreamHandler()
-    handler.setFormatter(LogFormatter())
-    logging.root.addHandler(handler)
-    logging.root.setLevel(level)

package/.venv/lib/python3.9/site-packages/pip/_vendor/pep517/compat.py

@@ -1,51 +0,0 @@
-"""Python 2/3 compatibility"""
-import io
-import json
-import sys
-
-
-# Handle reading and writing JSON in UTF-8, on Python 3 and 2.
-
-if sys.version_info[0] >= 3:
-    # Python 3
-    def write_json(obj, path, **kwargs):
-        with open(path, 'w', encoding='utf-8') as f:
-            json.dump(obj, f, **kwargs)
-
-    def read_json(path):
-        with open(path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-
-else:
-    # Python 2
-    def write_json(obj, path, **kwargs):
-        with open(path, 'wb') as f:
-            json.dump(obj, f, encoding='utf-8', **kwargs)
-
-    def read_json(path):
-        with open(path, 'rb') as f:
-            return json.load(f)
-
-
-# FileNotFoundError
-
-try:
-    FileNotFoundError = FileNotFoundError
-except NameError:
-    FileNotFoundError = IOError
-
-
-if sys.version_info < (3, 6):
-    from toml import load as _toml_load  # noqa: F401
-
-    def toml_load(f):
-        w = io.TextIOWrapper(f, encoding="utf8", newline="")
-        try:
-            return _toml_load(w)
-        finally:
-            w.detach()
-
-    from toml import TomlDecodeError as TOMLDecodeError  # noqa: F401
-else:
-    from pip._vendor.tomli import load as toml_load  # noqa: F401
-    from pip._vendor.tomli import TOMLDecodeError  # noqa: F401

package/.venv/lib/python3.9/site-packages/pip/_vendor/pep517/dirtools.py

@@ -1,44 +0,0 @@
-import os
-import io
-import contextlib
-import tempfile
-import shutil
-import errno
-import zipfile
-
-
-@contextlib.contextmanager
-def tempdir():
-    """Create a temporary directory in a context manager."""
-    td = tempfile.mkdtemp()
-    try:
-        yield td
-    finally:
-        shutil.rmtree(td)
-
-
-def mkdir_p(*args, **kwargs):
-    """Like `mkdir`, but does not raise an exception if the
-    directory already exists.
-    """
-    try:
-        return os.mkdir(*args, **kwargs)
-    except OSError as exc:
-        if exc.errno != errno.EEXIST:
-            raise
-
-
-def dir_to_zipfile(root):
-    """Construct an in-memory zip file for a directory."""
-    buffer = io.BytesIO()
-    zip_file = zipfile.ZipFile(buffer, 'w')
-    for root, dirs, files in os.walk(root):
-        for path in dirs:
-            fs_path = os.path.join(root, path)
-            rel_path = os.path.relpath(fs_path, root)
-            zip_file.writestr(rel_path + '/', '')
-        for path in files:
-            fs_path = os.path.join(root, path)
-            rel_path = os.path.relpath(fs_path, root)
-            zip_file.write(fs_path, rel_path)
-    return zip_file

package/.venv/lib/python3.9/site-packages/pip/_vendor/pep517/envbuild.py

@@ -1,171 +0,0 @@
-"""Build wheels/sdists by installing build deps to a temporary environment.
-"""
-
-import io
-import os
-import logging
-import shutil
-from subprocess import check_call
-import sys
-from sysconfig import get_paths
-from tempfile import mkdtemp
-
-from .compat import toml_load
-from .wrappers import Pep517HookCaller, LoggerWrapper
-
-log = logging.getLogger(__name__)
-
-
-def _load_pyproject(source_dir):
-    with io.open(
-            os.path.join(source_dir, 'pyproject.toml'),
-            'rb',
-            ) as f:
-        pyproject_data = toml_load(f)
-    buildsys = pyproject_data['build-system']
-    return (
-        buildsys['requires'],
-        buildsys['build-backend'],
-        buildsys.get('backend-path'),
-    )
-
-
-class BuildEnvironment(object):
-    """Context manager to install build deps in a simple temporary environment
-
-    Based on code I wrote for pip, which is MIT licensed.
-    """
-    # Copyright (c) 2008-2016 The pip developers (see AUTHORS.txt file)
-    #
-    # Permission is hereby granted, free of charge, to any person obtaining
-    # a copy of this software and associated documentation files (the
-    # "Software"), to deal in the Software without restriction, including
-    # without limitation the rights to use, copy, modify, merge, publish,
-    # distribute, sublicense, and/or sell copies of the Software, and to
-    # permit persons to whom the Software is furnished to do so, subject to
-    # the following conditions:
-    #
-    # The above copyright notice and this permission notice shall be
-    # included in all copies or substantial portions of the Software.
-    #
-    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-    # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-    # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-    # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-    # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-    # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-    # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-    path = None
-
-    def __init__(self, cleanup=True):
-        self._cleanup = cleanup
-
-    def __enter__(self):
-        self.path = mkdtemp(prefix='pep517-build-env-')
-        log.info('Temporary build environment: %s', self.path)
-
-        self.save_path = os.environ.get('PATH', None)
-        self.save_pythonpath = os.environ.get('PYTHONPATH', None)
-
-        install_scheme = 'nt' if (os.name == 'nt') else 'posix_prefix'
-        install_dirs = get_paths(install_scheme, vars={
-            'base': self.path,
-            'platbase': self.path,
-        })
-
-        scripts = install_dirs['scripts']
-        if self.save_path:
-            os.environ['PATH'] = scripts + os.pathsep + self.save_path
-        else:
-            os.environ['PATH'] = scripts + os.pathsep + os.defpath
-
-        if install_dirs['purelib'] == install_dirs['platlib']:
-            lib_dirs = install_dirs['purelib']
-        else:
-            lib_dirs = install_dirs['purelib'] + os.pathsep + \
-                install_dirs['platlib']
-        if self.save_pythonpath:
-            os.environ['PYTHONPATH'] = lib_dirs + os.pathsep + \
-                self.save_pythonpath
-        else:
-            os.environ['PYTHONPATH'] = lib_dirs
-
-        return self
-
-    def pip_install(self, reqs):
-        """Install dependencies into this env by calling pip in a subprocess"""
-        if not reqs:
-            return
-        log.info('Calling pip to install %s', reqs)
-        cmd = [
-            sys.executable, '-m', 'pip', 'install', '--ignore-installed',
-            '--prefix', self.path] + list(reqs)
-        check_call(
-            cmd,
-            stdout=LoggerWrapper(log, logging.INFO),
-            stderr=LoggerWrapper(log, logging.ERROR),
-        )
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        needs_cleanup = (
-            self._cleanup and
-            self.path is not None and
-            os.path.isdir(self.path)
-        )
-        if needs_cleanup:
-            shutil.rmtree(self.path)
-
-        if self.save_path is None:
-            os.environ.pop('PATH', None)
-        else:
-            os.environ['PATH'] = self.save_path
-
-        if self.save_pythonpath is None:
-            os.environ.pop('PYTHONPATH', None)
-        else:
-            os.environ['PYTHONPATH'] = self.save_pythonpath
-
-
-def build_wheel(source_dir, wheel_dir, config_settings=None):
-    """Build a wheel from a source directory using PEP 517 hooks.
-
-    :param str source_dir: Source directory containing pyproject.toml
-    :param str wheel_dir: Target directory to create wheel in
-    :param dict config_settings: Options to pass to build backend
-
-    This is a blocking function which will run pip in a subprocess to install
-    build requirements.
-    """
-    if config_settings is None:
-        config_settings = {}
-    requires, backend, backend_path = _load_pyproject(source_dir)
-    hooks = Pep517HookCaller(source_dir, backend, backend_path)
-
-    with BuildEnvironment() as env:
-        env.pip_install(requires)
-        reqs = hooks.get_requires_for_build_wheel(config_settings)
-        env.pip_install(reqs)
-        return hooks.build_wheel(wheel_dir, config_settings)
-
-
-def build_sdist(source_dir, sdist_dir, config_settings=None):
-    """Build an sdist from a source directory using PEP 517 hooks.
-
-    :param str source_dir: Source directory containing pyproject.toml
-    :param str sdist_dir: Target directory to place sdist in
-    :param dict config_settings: Options to pass to build backend
-
-    This is a blocking function which will run pip in a subprocess to install
-    build requirements.
-    """
-    if config_settings is None:
-        config_settings = {}
-    requires, backend, backend_path = _load_pyproject(source_dir)
-    hooks = Pep517HookCaller(source_dir, backend, backend_path)
-
-    with BuildEnvironment() as env:
-        env.pip_install(requires)
-        reqs = hooks.get_requires_for_build_sdist(config_settings)
-        env.pip_install(reqs)
-        return hooks.build_sdist(sdist_dir, config_settings)

package/.venv/lib/python3.9/site-packages/pip/_vendor/pep517/in_process/__init__.py

@@ -1,17 +0,0 @@
-"""This is a subpackage because the directory is on sys.path for _in_process.py
-
-The subpackage should stay as empty as possible to avoid shadowing modules that
-the backend might import.
-"""
-from os.path import dirname, abspath, join as pjoin
-from contextlib import contextmanager
-
-try:
-    import importlib.resources as resources
-
-    def _in_proc_script_path():
-        return resources.path(__package__, '_in_process.py')
-except ImportError:
-    @contextmanager
-    def _in_proc_script_path():
-        yield pjoin(dirname(abspath(__file__)), '_in_process.py')