Add base vars and sudo check

venv/lib/python3.8/site-packages/pip/_vendor/distlib/LICENSE.txt

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/80/8e/10/c8a6ab8deb149ff9b3fb19f447a808094606d712a9ca57fead3552599d

venv/lib/python3.8/site-packages/pip/_vendor/distlib/__init__.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/de/f7/80/936acfce7381da0b0aead8db6e1d1340c9861393fcd9e13dc17aba3489

venv/lib/python3.8/site-packages/pip/_vendor/distlib/_backport/__init__.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/6e/a4/bf/753387eae5bd88681dd2ecdfa4f8e8eaf678c693d9ee4c9f649daf35ac

venv/lib/python3.8/site-packages/pip/_vendor/distlib/_backport/misc.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/29/67/9c/20d75b14d3b148e3f57c617af340899da0ba4b87c146012d6984f0d228

venv/lib/python3.8/site-packages/pip/_vendor/distlib/_backport/shutil.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/21/7f/c6/d8d3eac1e70989b9080e37b4e1baaed31a4791f490d8668674456a3396

venv/lib/python3.8/site-packages/pip/_vendor/distlib/_backport/sysconfig.cfg

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/b3/06/4a/c6af516397bdaf73d70ab96f40f32cbce7625990531cb11ba92f0b24b5

venv/lib/python3.8/site-packages/pip/_vendor/distlib/_backport/sysconfig.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/05/01/c5/95bea9b9b0a5fddbd3d4d8edcc8b61ca5a1f8ca8aca31db7f6cb438345

venv/lib/python3.8/site-packages/pip/_vendor/distlib/_backport/tarfile.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/22/1a/7b/ad745c8db20ac3c08e9bdc1278f57d0111976d217d8065c0327d90f8a5

venv/lib/python3.8/site-packages/pip/_vendor/distlib/compat.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/00/30/39/eb1880c5aaf7994eaa7a694184d6ecac53e8b174613b8e11cec6c93ea9

venv/lib/python3.8/site-packages/pip/_vendor/distlib/database.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/2a/5d/18/bcf40a73839ca558bb939705ce2c9d335c4e2bc8aa7712c65e06d91d5e

venv/lib/python3.8/site-packages/pip/_vendor/distlib/index.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/49/72/b3/a5008445cb71603329fce2de7b67f42747b5f5984674222832551f5103

venv/lib/python3.8/site-packages/pip/_vendor/distlib/locators.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/73/d1/38/70311a709fee29bb84e41a805687285a9eabb2e0464e488d0d0ab7cd5e

venv/lib/python3.8/site-packages/pip/_vendor/distlib/manifest.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/9d/01/21/626828ade681673c85cf062c5f124046eddfa38124ba7535eb7535ea21

venv/lib/python3.8/site-packages/pip/_vendor/distlib/markers.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/e8/07/37/7027c504445ec621125883979a0f9aa483fc9767ac69f3525f728ccbef

venv/lib/python3.8/site-packages/pip/_vendor/distlib/metadata.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/cf/62/8f/cb7877b5c0e76fd5ecee702a4393b3d1baa358050598a59c14a468a1d8

venv/lib/python3.8/site-packages/pip/_vendor/distlib/resources.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/d8/51/af/d191c5d782978cb2252f447df7597241019c7b0392e2627ee67f895677

venv/lib/python3.8/site-packages/pip/_vendor/distlib/scripts.py

@@ -0,0 +1,419 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2015 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from io import BytesIO
+import logging
+import os
+import re
+import struct
+import sys
+
+from .compat import sysconfig, detect_encoding, ZipFile
+from .resources import finder
+from .util import (FileOperator, get_export_entry, convert_path,
+                   get_executable, in_venv)
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_MANIFEST = '''
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+ <assemblyIdentity version="1.0.0.0"
+ processorArchitecture="X86"
+ name="%s"
+ type="win32"/>
+
+ <!-- Identify the application security requirements. -->
+ <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+ <security>
+ <requestedPrivileges>
+ <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+ </requestedPrivileges>
+ </security>
+ </trustInfo>
+</assembly>'''.strip()
+
+# check if Python is called on the first line with this expression
+FIRST_LINE_RE = re.compile(b'^#!.*pythonw?[0-9.]*([ \t].*)?$')
+SCRIPT_TEMPLATE = r'''# -*- coding: utf-8 -*-
+import re
+import sys
+from %(module)s import %(import_name)s
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(%(func)s())
+'''
+
+
+def enquote_executable(executable):
+    if ' ' in executable:
+        # make sure we quote only the executable in case of env
+        # for example /usr/bin/env "/dir with spaces/bin/jython"
+        # instead of "/usr/bin/env /dir with spaces/bin/jython"
+        # otherwise whole
+        if executable.startswith('/usr/bin/env '):
+            env, _executable = executable.split(' ', 1)
+            if ' ' in _executable and not _executable.startswith('"'):
+                executable = '%s "%s"' % (env, _executable)
+        else:
+            if not executable.startswith('"'):
+                executable = '"%s"' % executable
+    return executable
+
+# Keep the old name around (for now), as there is at least one project using it!
+_enquote_executable = enquote_executable
+
+class ScriptMaker(object):
+    """
+    A class to copy or create scripts from source scripts or callable
+    specifications.
+    """
+    script_template = SCRIPT_TEMPLATE
+
+    executable = None  # for shebangs
+
+    def __init__(self, source_dir, target_dir, add_launchers=True,
+                 dry_run=False, fileop=None):
+        self.source_dir = source_dir
+        self.target_dir = target_dir
+        self.add_launchers = add_launchers
+        self.force = False
+        self.clobber = False
+        # It only makes sense to set mode bits on POSIX.
+        self.set_mode = (os.name == 'posix') or (os.name == 'java' and
+                                                 os._name == 'posix')
+        self.variants = set(('', 'X.Y'))
+        self._fileop = fileop or FileOperator(dry_run)
+
+        self._is_nt = os.name == 'nt' or (
+            os.name == 'java' and os._name == 'nt')
+        self.version_info = sys.version_info
+
+    def _get_alternate_executable(self, executable, options):
+        if options.get('gui', False) and self._is_nt:  # pragma: no cover
+            dn, fn = os.path.split(executable)
+            fn = fn.replace('python', 'pythonw')
+            executable = os.path.join(dn, fn)
+        return executable
+
+    if sys.platform.startswith('java'):  # pragma: no cover
+        def _is_shell(self, executable):
+            """
+            Determine if the specified executable is a script
+            (contains a #! line)
+            """
+            try:
+                with open(executable) as fp:
+                    return fp.read(2) == '#!'
+            except (OSError, IOError):
+                logger.warning('Failed to open %s', executable)
+                return False
+
+        def _fix_jython_executable(self, executable):
+            if self._is_shell(executable):
+                # Workaround for Jython is not needed on Linux systems.
+                import java
+
+                if java.lang.System.getProperty('os.name') == 'Linux':
+                    return executable
+            elif executable.lower().endswith('jython.exe'):
+                # Use wrapper exe for Jython on Windows
+                return executable
+            return '/usr/bin/env %s' % executable
+
+    def _build_shebang(self, executable, post_interp):
+        """
+        Build a shebang line. In the simple case (on Windows, or a shebang line
+        which is not too long or contains spaces) use a simple formulation for
+        the shebang. Otherwise, use /bin/sh as the executable, with a contrived
+        shebang which allows the script to run either under Python or sh, using
+        suitable quoting. Thanks to Harald Nordgren for his input.
+
+        See also: http://www.in-ulm.de/~mascheck/various/shebang/#length
+                  https://hg.mozilla.org/mozilla-central/file/tip/mach
+        """
+        if os.name != 'posix':
+            simple_shebang = True
+        else:
+            # Add 3 for '#!' prefix and newline suffix.
+            shebang_length = len(executable) + len(post_interp) + 3
+            if sys.platform == 'darwin':
+                max_shebang_length = 512
+            else:
+                max_shebang_length = 127
+            simple_shebang = ((b' ' not in executable) and
+                              (shebang_length <= max_shebang_length))
+
+        if simple_shebang:
+            result = b'#!/usr/bin/env python3' + post_interp + b'\n'
+        else:
+            result = b'#!/bin/sh\n'
+            result += b"'''exec' python3" + post_interp + b' "$0" "$@"\n'
+            result += b"' '''"
+        return result
+
+    def _get_shebang(self, encoding, post_interp=b'', options=None):
+        enquote = True
+        if self.executable:
+            executable = self.executable
+            enquote = False     # assume this will be taken care of
+        elif not sysconfig.is_python_build():
+            executable = get_executable()
+        elif in_venv():  # pragma: no cover
+            executable = os.path.join(sysconfig.get_path('scripts'),
+                            'python%s' % sysconfig.get_config_var('EXE'))
+        else:  # pragma: no cover
+            executable = os.path.join(
+                sysconfig.get_config_var('BINDIR'),
+               'python%s%s' % (sysconfig.get_config_var('VERSION'),
+                               sysconfig.get_config_var('EXE')))
+        if options:
+            executable = self._get_alternate_executable(executable, options)
+
+        if sys.platform.startswith('java'):  # pragma: no cover
+            executable = self._fix_jython_executable(executable)
+
+        # Normalise case for Windows - COMMENTED OUT
+        # executable = os.path.normcase(executable)
+        # N.B. The normalising operation above has been commented out: See
+        # issue #124. Although paths in Windows are generally case-insensitive,
+        # they aren't always. For example, a path containing a ẞ (which is a
+        # LATIN CAPITAL LETTER SHARP S - U+1E9E) is normcased to ß (which is a
+        # LATIN SMALL LETTER SHARP S' - U+00DF). The two are not considered by
+        # Windows as equivalent in path names.
+
+        # If the user didn't specify an executable, it may be necessary to
+        # cater for executable paths with spaces (not uncommon on Windows)
+        if enquote:
+            executable = enquote_executable(executable)
+        # Issue #51: don't use fsencode, since we later try to
+        # check that the shebang is decodable using utf-8.
+        executable = executable.encode('utf-8')
+        # in case of IronPython, play safe and enable frames support
+        if (sys.platform == 'cli' and '-X:Frames' not in post_interp
+            and '-X:FullFrames' not in post_interp):  # pragma: no cover
+            post_interp += b' -X:Frames'
+        shebang = self._build_shebang(executable, post_interp)
+        # Python parser starts to read a script using UTF-8 until
+        # it gets a #coding:xxx cookie. The shebang has to be the
+        # first line of a file, the #coding:xxx cookie cannot be
+        # written before. So the shebang has to be decodable from
+        # UTF-8.
+        try:
+            shebang.decode('utf-8')
+        except UnicodeDecodeError:  # pragma: no cover
+            raise ValueError(
+                'The shebang (%r) is not decodable from utf-8' % shebang)
+        # If the script is encoded to a custom encoding (use a
+        # #coding:xxx cookie), the shebang has to be decodable from
+        # the script encoding too.
+        if encoding != 'utf-8':
+            try:
+                shebang.decode(encoding)
+            except UnicodeDecodeError:  # pragma: no cover
+                raise ValueError(
+                    'The shebang (%r) is not decodable '
+                    'from the script encoding (%r)' % (shebang, encoding))
+        return shebang
+
+    def _get_script_text(self, entry):
+        return self.script_template % dict(module=entry.prefix,
+                                           import_name=entry.suffix.split('.')[0],
+                                           func=entry.suffix)
+
+    manifest = _DEFAULT_MANIFEST
+
+    def get_manifest(self, exename):
+        base = os.path.basename(exename)
+        return self.manifest % base
+
+    def _write_script(self, names, shebang, script_bytes, filenames, ext):
+        use_launcher = self.add_launchers and self._is_nt
+        linesep = os.linesep.encode('utf-8')
+        if not shebang.endswith(linesep):
+            shebang += linesep
+        if not use_launcher:
+            script_bytes = shebang + script_bytes
+        else:  # pragma: no cover
+            if ext == 'py':
+                launcher = self._get_launcher('t')
+            else:
+                launcher = self._get_launcher('w')
+            stream = BytesIO()
+            with ZipFile(stream, 'w') as zf:
+                zf.writestr('__main__.py', script_bytes)
+            zip_data = stream.getvalue()
+            script_bytes = launcher + shebang + zip_data
+        for name in names:
+            outname = os.path.join(self.target_dir, name)
+            if use_launcher:  # pragma: no cover
+                n, e = os.path.splitext(outname)
+                if e.startswith('.py'):
+                    outname = n
+                outname = '%s.exe' % outname
+                try:
+                    self._fileop.write_binary_file(outname, script_bytes)
+                except Exception:
+                    # Failed writing an executable - it might be in use.
+                    logger.warning('Failed to write executable - trying to '
+                                   'use .deleteme logic')
+                    dfname = '%s.deleteme' % outname
+                    if os.path.exists(dfname):
+                        os.remove(dfname)       # Not allowed to fail here
+                    os.rename(outname, dfname)  # nor here
+                    self._fileop.write_binary_file(outname, script_bytes)
+                    logger.debug('Able to replace executable using '
+                                 '.deleteme logic')
+                    try:
+                        os.remove(dfname)
+                    except Exception:
+                        pass    # still in use - ignore error
+            else:
+                if self._is_nt and not outname.endswith('.' + ext):  # pragma: no cover
+                    outname = '%s.%s' % (outname, ext)
+                if os.path.exists(outname) and not self.clobber:
+                    logger.warning('Skipping existing file %s', outname)
+                    continue
+                self._fileop.write_binary_file(outname, script_bytes)
+                if self.set_mode:
+                    self._fileop.set_executable_mode([outname])
+            filenames.append(outname)
+
+    def _make_script(self, entry, filenames, options=None):
+        post_interp = b''
+        if options:
+            args = options.get('interpreter_args', [])
+            if args:
+                args = ' %s' % ' '.join(args)
+                post_interp = args.encode('utf-8')
+        shebang = self._get_shebang('utf-8', post_interp, options=options)
+        script = self._get_script_text(entry).encode('utf-8')
+        name = entry.name
+        scriptnames = set()
+        if '' in self.variants:
+            scriptnames.add(name)
+        if 'X' in self.variants:
+            scriptnames.add('%s%s' % (name, self.version_info[0]))
+        if 'X.Y' in self.variants:
+            scriptnames.add('%s-%s.%s' % (name, self.version_info[0],
+                                          self.version_info[1]))
+        if options and options.get('gui', False):
+            ext = 'pyw'
+        else:
+            ext = 'py'
+        self._write_script(scriptnames, shebang, script, filenames, ext)
+
+    def _copy_script(self, script, filenames):
+        adjust = False
+        script = os.path.join(self.source_dir, convert_path(script))
+        outname = os.path.join(self.target_dir, os.path.basename(script))
+        if not self.force and not self._fileop.newer(script, outname):
+            logger.debug('not copying %s (up-to-date)', script)
+            return
+
+        # Always open the file, but ignore failures in dry-run mode --
+        # that way, we'll get accurate feedback if we can read the
+        # script.
+        try:
+            f = open(script, 'rb')
+        except IOError:  # pragma: no cover
+            if not self.dry_run:
+                raise
+            f = None
+        else:
+            first_line = f.readline()
+            if not first_line:  # pragma: no cover
+                logger.warning('%s: %s is an empty file (skipping)',
+                               self.get_command_name(),  script)
+                return
+
+            match = FIRST_LINE_RE.match(first_line.replace(b'\r\n', b'\n'))
+            if match:
+                adjust = True
+                post_interp = match.group(1) or b''
+
+        if not adjust:
+            if f:
+                f.close()
+            self._fileop.copy_file(script, outname)
+            if self.set_mode:
+                self._fileop.set_executable_mode([outname])
+            filenames.append(outname)
+        else:
+            logger.info('copying and adjusting %s -> %s', script,
+                        self.target_dir)
+            if not self._fileop.dry_run:
+                encoding, lines = detect_encoding(f.readline)
+                f.seek(0)
+                shebang = self._get_shebang(encoding, post_interp)
+                if b'pythonw' in first_line:  # pragma: no cover
+                    ext = 'pyw'
+                else:
+                    ext = 'py'
+                n = os.path.basename(outname)
+                self._write_script([n], shebang, f.read(), filenames, ext)
+            if f:
+                f.close()
+
+    @property
+    def dry_run(self):
+        return self._fileop.dry_run
+
+    @dry_run.setter
+    def dry_run(self, value):
+        self._fileop.dry_run = value
+
+    if os.name == 'nt' or (os.name == 'java' and os._name == 'nt'):  # pragma: no cover
+        # Executable launcher support.
+        # Launchers are from https://bitbucket.org/vinay.sajip/simple_launcher/
+
+        def _get_launcher(self, kind):
+            if struct.calcsize('P') == 8:   # 64-bit
+                bits = '64'
+            else:
+                bits = '32'
+            name = '%s%s.exe' % (kind, bits)
+            # Issue 31: don't hardcode an absolute package name, but
+            # determine it relative to the current package
+            distlib_package = __name__.rsplit('.', 1)[0]
+            resource = finder(distlib_package).find(name)
+            if not resource:
+                msg = ('Unable to find resource %s in package %s' % (name,
+                       distlib_package))
+                raise ValueError(msg)
+            return resource.bytes
+
+    # Public API follows
+
+    def make(self, specification, options=None):
+        """
+        Make a script.
+
+        :param specification: The specification, which is either a valid export
+                              entry specification (to make a script from a
+                              callable) or a filename (to make a script by
+                              copying from a source location).
+        :param options: A dictionary of options controlling script generation.
+        :return: A list of all absolute pathnames written to.
+        """
+        filenames = []
+        entry = get_export_entry(specification)
+        if entry is None:
+            self._copy_script(specification, filenames)
+        else:
+            self._make_script(entry, filenames, options=options)
+        return filenames
+
+    def make_multiple(self, specifications, options=None):
+        """
+        Take a list of specifications and make scripts from them,
+        :param specifications: A list of specifications.
+        :return: A list of all absolute pathnames written to,
+        """
+        filenames = []
+        for specification in specifications:
+            filenames.extend(self.make(specification, options))
+        return filenames

venv/lib/python3.8/site-packages/pip/_vendor/distlib/t32.exe

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/35/2d/f1/04254095ddf925514d99bfb5411c95b5386e90caf06557979f82e16844

venv/lib/python3.8/site-packages/pip/_vendor/distlib/t64.exe

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/a0/0a/87/7acefcad45953343ad56a22152f7aaba5fcf2a10215d84169d47fbcd1d

venv/lib/python3.8/site-packages/pip/_vendor/distlib/util.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/7f/68/d9/08fadc2c2b7a2dc9c2d20532f85babeb4b570fcade03b938ac3a47303c

venv/lib/python3.8/site-packages/pip/_vendor/distlib/version.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/fe/7e/c5/ea3baf40601c9fbebd13f4876bb7ce71fe44465115ca627f1233d1c06c

venv/lib/python3.8/site-packages/pip/_vendor/distlib/w32.exe

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/94/9b/67/65d794c53656c9afc45b90d9a2cfcae6bb30444086b29225f19242217b

venv/lib/python3.8/site-packages/pip/_vendor/distlib/w64.exe

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/d1/a4/73/a0dd813bd3565b810dcb8ff8bc7907478a994c564d55200925894e0d32

venv/lib/python3.8/site-packages/pip/_vendor/distlib/wheel.py

@@ -0,0 +1 @@
+/home/runner/.cache/pip/pool/bf/a0/e7/c13aa1347c2b11516bf3f61e8935ba1b87ed3ff7afb32c0d82b99d6f6a