You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@senssoft.apache.org by ar...@apache.org on 2016/12/16 17:10:47 UTC
[29/58] [abbrv] [partial] incubator-senssoft-tap git commit: Fixed
.gitignore file
http://git-wip-us.apache.org/repos/asf/incubator-senssoft-tap/blob/6a81d1e7/env2/lib/python2.7/site-packages/pip/_vendor/distlib/wheel.py
----------------------------------------------------------------------
diff --git a/env2/lib/python2.7/site-packages/pip/_vendor/distlib/wheel.py b/env2/lib/python2.7/site-packages/pip/_vendor/distlib/wheel.py
deleted file mode 100644
index 2952b8e..0000000
--- a/env2/lib/python2.7/site-packages/pip/_vendor/distlib/wheel.py
+++ /dev/null
@@ -1,978 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013-2016 Vinay Sajip.
-# Licensed to the Python Software Foundation under a contributor agreement.
-# See LICENSE.txt and CONTRIBUTORS.txt.
-#
-from __future__ import unicode_literals
-
-import base64
-import codecs
-import datetime
-import distutils.util
-from email import message_from_file
-import hashlib
-import imp
-import json
-import logging
-import os
-import posixpath
-import re
-import shutil
-import sys
-import tempfile
-import zipfile
-
-from . import __version__, DistlibException
-from .compat import sysconfig, ZipFile, fsdecode, text_type, filter
-from .database import InstalledDistribution
-from .metadata import Metadata, METADATA_FILENAME
-from .util import (FileOperator, convert_path, CSVReader, CSVWriter, Cache,
- cached_property, get_cache_base, read_exports, tempdir)
-from .version import NormalizedVersion, UnsupportedVersionError
-
-logger = logging.getLogger(__name__)
-
-cache = None # created when needed
-
-if hasattr(sys, 'pypy_version_info'):
- IMP_PREFIX = 'pp'
-elif sys.platform.startswith('java'):
- IMP_PREFIX = 'jy'
-elif sys.platform == 'cli':
- IMP_PREFIX = 'ip'
-else:
- IMP_PREFIX = 'cp'
-
-VER_SUFFIX = sysconfig.get_config_var('py_version_nodot')
-if not VER_SUFFIX: # pragma: no cover
- VER_SUFFIX = '%s%s' % sys.version_info[:2]
-PYVER = 'py' + VER_SUFFIX
-IMPVER = IMP_PREFIX + VER_SUFFIX
-
-ARCH = distutils.util.get_platform().replace('-', '_').replace('.', '_')
-
-ABI = sysconfig.get_config_var('SOABI')
-if ABI and ABI.startswith('cpython-'):
- ABI = ABI.replace('cpython-', 'cp')
-else:
- def _derive_abi():
- parts = ['cp', VER_SUFFIX]
- if sysconfig.get_config_var('Py_DEBUG'):
- parts.append('d')
- if sysconfig.get_config_var('WITH_PYMALLOC'):
- parts.append('m')
- if sysconfig.get_config_var('Py_UNICODE_SIZE') == 4:
- parts.append('u')
- return ''.join(parts)
- ABI = _derive_abi()
- del _derive_abi
-
-FILENAME_RE = re.compile(r'''
-(?P<nm>[^-]+)
--(?P<vn>\d+[^-]*)
-(-(?P<bn>\d+[^-]*))?
--(?P<py>\w+\d+(\.\w+\d+)*)
--(?P<bi>\w+)
--(?P<ar>\w+(\.\w+)*)
-\.whl$
-''', re.IGNORECASE | re.VERBOSE)
-
-NAME_VERSION_RE = re.compile(r'''
-(?P<nm>[^-]+)
--(?P<vn>\d+[^-]*)
-(-(?P<bn>\d+[^-]*))?$
-''', re.IGNORECASE | re.VERBOSE)
-
-SHEBANG_RE = re.compile(br'\s*#![^\r\n]*')
-SHEBANG_DETAIL_RE = re.compile(br'^(\s*#!("[^"]+"|\S+))\s+(.*)$')
-SHEBANG_PYTHON = b'#!python'
-SHEBANG_PYTHONW = b'#!pythonw'
-
-if os.sep == '/':
- to_posix = lambda o: o
-else:
- to_posix = lambda o: o.replace(os.sep, '/')
-
-
-class Mounter(object):
- def __init__(self):
- self.impure_wheels = {}
- self.libs = {}
-
- def add(self, pathname, extensions):
- self.impure_wheels[pathname] = extensions
- self.libs.update(extensions)
-
- def remove(self, pathname):
- extensions = self.impure_wheels.pop(pathname)
- for k, v in extensions:
- if k in self.libs:
- del self.libs[k]
-
- def find_module(self, fullname, path=None):
- if fullname in self.libs:
- result = self
- else:
- result = None
- return result
-
- def load_module(self, fullname):
- if fullname in sys.modules:
- result = sys.modules[fullname]
- else:
- if fullname not in self.libs:
- raise ImportError('unable to find extension for %s' % fullname)
- result = imp.load_dynamic(fullname, self.libs[fullname])
- result.__loader__ = self
- parts = fullname.rsplit('.', 1)
- if len(parts) > 1:
- result.__package__ = parts[0]
- return result
-
-_hook = Mounter()
-
-
-class Wheel(object):
- """
- Class to build and install from Wheel files (PEP 427).
- """
-
- wheel_version = (1, 1)
- hash_kind = 'sha256'
-
- def __init__(self, filename=None, sign=False, verify=False):
- """
- Initialise an instance using a (valid) filename.
- """
- self.sign = sign
- self.should_verify = verify
- self.buildver = ''
- self.pyver = [PYVER]
- self.abi = ['none']
- self.arch = ['any']
- self.dirname = os.getcwd()
- if filename is None:
- self.name = 'dummy'
- self.version = '0.1'
- self._filename = self.filename
- else:
- m = NAME_VERSION_RE.match(filename)
- if m:
- info = m.groupdict('')
- self.name = info['nm']
- # Reinstate the local version separator
- self.version = info['vn'].replace('_', '-')
- self.buildver = info['bn']
- self._filename = self.filename
- else:
- dirname, filename = os.path.split(filename)
- m = FILENAME_RE.match(filename)
- if not m:
- raise DistlibException('Invalid name or '
- 'filename: %r' % filename)
- if dirname:
- self.dirname = os.path.abspath(dirname)
- self._filename = filename
- info = m.groupdict('')
- self.name = info['nm']
- self.version = info['vn']
- self.buildver = info['bn']
- self.pyver = info['py'].split('.')
- self.abi = info['bi'].split('.')
- self.arch = info['ar'].split('.')
-
- @property
- def filename(self):
- """
- Build and return a filename from the various components.
- """
- if self.buildver:
- buildver = '-' + self.buildver
- else:
- buildver = ''
- pyver = '.'.join(self.pyver)
- abi = '.'.join(self.abi)
- arch = '.'.join(self.arch)
- # replace - with _ as a local version separator
- version = self.version.replace('-', '_')
- return '%s-%s%s-%s-%s-%s.whl' % (self.name, version, buildver,
- pyver, abi, arch)
-
- @property
- def exists(self):
- path = os.path.join(self.dirname, self.filename)
- return os.path.isfile(path)
-
- @property
- def tags(self):
- for pyver in self.pyver:
- for abi in self.abi:
- for arch in self.arch:
- yield pyver, abi, arch
-
- @cached_property
- def metadata(self):
- pathname = os.path.join(self.dirname, self.filename)
- name_ver = '%s-%s' % (self.name, self.version)
- info_dir = '%s.dist-info' % name_ver
- wrapper = codecs.getreader('utf-8')
- with ZipFile(pathname, 'r') as zf:
- wheel_metadata = self.get_wheel_metadata(zf)
- wv = wheel_metadata['Wheel-Version'].split('.', 1)
- file_version = tuple([int(i) for i in wv])
- if file_version < (1, 1):
- fn = 'METADATA'
- else:
- fn = METADATA_FILENAME
- try:
- metadata_filename = posixpath.join(info_dir, fn)
- with zf.open(metadata_filename) as bf:
- wf = wrapper(bf)
- result = Metadata(fileobj=wf)
- except KeyError:
- raise ValueError('Invalid wheel, because %s is '
- 'missing' % fn)
- return result
-
- def get_wheel_metadata(self, zf):
- name_ver = '%s-%s' % (self.name, self.version)
- info_dir = '%s.dist-info' % name_ver
- metadata_filename = posixpath.join(info_dir, 'WHEEL')
- with zf.open(metadata_filename) as bf:
- wf = codecs.getreader('utf-8')(bf)
- message = message_from_file(wf)
- return dict(message)
-
- @cached_property
- def info(self):
- pathname = os.path.join(self.dirname, self.filename)
- with ZipFile(pathname, 'r') as zf:
- result = self.get_wheel_metadata(zf)
- return result
-
- def process_shebang(self, data):
- m = SHEBANG_RE.match(data)
- if m:
- end = m.end()
- shebang, data_after_shebang = data[:end], data[end:]
- # Preserve any arguments after the interpreter
- if b'pythonw' in shebang.lower():
- shebang_python = SHEBANG_PYTHONW
- else:
- shebang_python = SHEBANG_PYTHON
- m = SHEBANG_DETAIL_RE.match(shebang)
- if m:
- args = b' ' + m.groups()[-1]
- else:
- args = b''
- shebang = shebang_python + args
- data = shebang + data_after_shebang
- else:
- cr = data.find(b'\r')
- lf = data.find(b'\n')
- if cr < 0 or cr > lf:
- term = b'\n'
- else:
- if data[cr:cr + 2] == b'\r\n':
- term = b'\r\n'
- else:
- term = b'\r'
- data = SHEBANG_PYTHON + term + data
- return data
-
- def get_hash(self, data, hash_kind=None):
- if hash_kind is None:
- hash_kind = self.hash_kind
- try:
- hasher = getattr(hashlib, hash_kind)
- except AttributeError:
- raise DistlibException('Unsupported hash algorithm: %r' % hash_kind)
- result = hasher(data).digest()
- result = base64.urlsafe_b64encode(result).rstrip(b'=').decode('ascii')
- return hash_kind, result
-
- def write_record(self, records, record_path, base):
- records = list(records) # make a copy for sorting
- p = to_posix(os.path.relpath(record_path, base))
- records.append((p, '', ''))
- records.sort()
- with CSVWriter(record_path) as writer:
- for row in records:
- writer.writerow(row)
-
- def write_records(self, info, libdir, archive_paths):
- records = []
- distinfo, info_dir = info
- hasher = getattr(hashlib, self.hash_kind)
- for ap, p in archive_paths:
- with open(p, 'rb') as f:
- data = f.read()
- digest = '%s=%s' % self.get_hash(data)
- size = os.path.getsize(p)
- records.append((ap, digest, size))
-
- p = os.path.join(distinfo, 'RECORD')
- self.write_record(records, p, libdir)
- ap = to_posix(os.path.join(info_dir, 'RECORD'))
- archive_paths.append((ap, p))
-
- def build_zip(self, pathname, archive_paths):
- with ZipFile(pathname, 'w', zipfile.ZIP_DEFLATED) as zf:
- for ap, p in archive_paths:
- logger.debug('Wrote %s to %s in wheel', p, ap)
- zf.write(p, ap)
-
- def build(self, paths, tags=None, wheel_version=None):
- """
- Build a wheel from files in specified paths, and use any specified tags
- when determining the name of the wheel.
- """
- if tags is None:
- tags = {}
-
- libkey = list(filter(lambda o: o in paths, ('purelib', 'platlib')))[0]
- if libkey == 'platlib':
- is_pure = 'false'
- default_pyver = [IMPVER]
- default_abi = [ABI]
- default_arch = [ARCH]
- else:
- is_pure = 'true'
- default_pyver = [PYVER]
- default_abi = ['none']
- default_arch = ['any']
-
- self.pyver = tags.get('pyver', default_pyver)
- self.abi = tags.get('abi', default_abi)
- self.arch = tags.get('arch', default_arch)
-
- libdir = paths[libkey]
-
- name_ver = '%s-%s' % (self.name, self.version)
- data_dir = '%s.data' % name_ver
- info_dir = '%s.dist-info' % name_ver
-
- archive_paths = []
-
- # First, stuff which is not in site-packages
- for key in ('data', 'headers', 'scripts'):
- if key not in paths:
- continue
- path = paths[key]
- if os.path.isdir(path):
- for root, dirs, files in os.walk(path):
- for fn in files:
- p = fsdecode(os.path.join(root, fn))
- rp = os.path.relpath(p, path)
- ap = to_posix(os.path.join(data_dir, key, rp))
- archive_paths.append((ap, p))
- if key == 'scripts' and not p.endswith('.exe'):
- with open(p, 'rb') as f:
- data = f.read()
- data = self.process_shebang(data)
- with open(p, 'wb') as f:
- f.write(data)
-
- # Now, stuff which is in site-packages, other than the
- # distinfo stuff.
- path = libdir
- distinfo = None
- for root, dirs, files in os.walk(path):
- if root == path:
- # At the top level only, save distinfo for later
- # and skip it for now
- for i, dn in enumerate(dirs):
- dn = fsdecode(dn)
- if dn.endswith('.dist-info'):
- distinfo = os.path.join(root, dn)
- del dirs[i]
- break
- assert distinfo, '.dist-info directory expected, not found'
-
- for fn in files:
- # comment out next suite to leave .pyc files in
- if fsdecode(fn).endswith(('.pyc', '.pyo')):
- continue
- p = os.path.join(root, fn)
- rp = to_posix(os.path.relpath(p, path))
- archive_paths.append((rp, p))
-
- # Now distinfo. Assumed to be flat, i.e. os.listdir is enough.
- files = os.listdir(distinfo)
- for fn in files:
- if fn not in ('RECORD', 'INSTALLER', 'SHARED', 'WHEEL'):
- p = fsdecode(os.path.join(distinfo, fn))
- ap = to_posix(os.path.join(info_dir, fn))
- archive_paths.append((ap, p))
-
- wheel_metadata = [
- 'Wheel-Version: %d.%d' % (wheel_version or self.wheel_version),
- 'Generator: distlib %s' % __version__,
- 'Root-Is-Purelib: %s' % is_pure,
- ]
- for pyver, abi, arch in self.tags:
- wheel_metadata.append('Tag: %s-%s-%s' % (pyver, abi, arch))
- p = os.path.join(distinfo, 'WHEEL')
- with open(p, 'w') as f:
- f.write('\n'.join(wheel_metadata))
- ap = to_posix(os.path.join(info_dir, 'WHEEL'))
- archive_paths.append((ap, p))
-
- # Now, at last, RECORD.
- # Paths in here are archive paths - nothing else makes sense.
- self.write_records((distinfo, info_dir), libdir, archive_paths)
- # Now, ready to build the zip file
- pathname = os.path.join(self.dirname, self.filename)
- self.build_zip(pathname, archive_paths)
- return pathname
-
- def install(self, paths, maker, **kwargs):
- """
- Install a wheel to the specified paths. If kwarg ``warner`` is
- specified, it should be a callable, which will be called with two
- tuples indicating the wheel version of this software and the wheel
- version in the file, if there is a discrepancy in the versions.
- This can be used to issue any warnings to raise any exceptions.
- If kwarg ``lib_only`` is True, only the purelib/platlib files are
- installed, and the headers, scripts, data and dist-info metadata are
- not written.
-
- The return value is a :class:`InstalledDistribution` instance unless
- ``options.lib_only`` is True, in which case the return value is ``None``.
- """
-
- dry_run = maker.dry_run
- warner = kwargs.get('warner')
- lib_only = kwargs.get('lib_only', False)
-
- pathname = os.path.join(self.dirname, self.filename)
- name_ver = '%s-%s' % (self.name, self.version)
- data_dir = '%s.data' % name_ver
- info_dir = '%s.dist-info' % name_ver
-
- metadata_name = posixpath.join(info_dir, METADATA_FILENAME)
- wheel_metadata_name = posixpath.join(info_dir, 'WHEEL')
- record_name = posixpath.join(info_dir, 'RECORD')
-
- wrapper = codecs.getreader('utf-8')
-
- with ZipFile(pathname, 'r') as zf:
- with zf.open(wheel_metadata_name) as bwf:
- wf = wrapper(bwf)
- message = message_from_file(wf)
- wv = message['Wheel-Version'].split('.', 1)
- file_version = tuple([int(i) for i in wv])
- if (file_version != self.wheel_version) and warner:
- warner(self.wheel_version, file_version)
-
- if message['Root-Is-Purelib'] == 'true':
- libdir = paths['purelib']
- else:
- libdir = paths['platlib']
-
- records = {}
- with zf.open(record_name) as bf:
- with CSVReader(stream=bf) as reader:
- for row in reader:
- p = row[0]
- records[p] = row
-
- data_pfx = posixpath.join(data_dir, '')
- info_pfx = posixpath.join(info_dir, '')
- script_pfx = posixpath.join(data_dir, 'scripts', '')
-
- # make a new instance rather than a copy of maker's,
- # as we mutate it
- fileop = FileOperator(dry_run=dry_run)
- fileop.record = True # so we can rollback if needed
-
- bc = not sys.dont_write_bytecode # Double negatives. Lovely!
-
- outfiles = [] # for RECORD writing
-
- # for script copying/shebang processing
- workdir = tempfile.mkdtemp()
- # set target dir later
- # we default add_launchers to False, as the
- # Python Launcher should be used instead
- maker.source_dir = workdir
- maker.target_dir = None
- try:
- for zinfo in zf.infolist():
- arcname = zinfo.filename
- if isinstance(arcname, text_type):
- u_arcname = arcname
- else:
- u_arcname = arcname.decode('utf-8')
- # The signature file won't be in RECORD,
- # and we don't currently don't do anything with it
- if u_arcname.endswith('/RECORD.jws'):
- continue
- row = records[u_arcname]
- if row[2] and str(zinfo.file_size) != row[2]:
- raise DistlibException('size mismatch for '
- '%s' % u_arcname)
- if row[1]:
- kind, value = row[1].split('=', 1)
- with zf.open(arcname) as bf:
- data = bf.read()
- _, digest = self.get_hash(data, kind)
- if digest != value:
- raise DistlibException('digest mismatch for '
- '%s' % arcname)
-
- if lib_only and u_arcname.startswith((info_pfx, data_pfx)):
- logger.debug('lib_only: skipping %s', u_arcname)
- continue
- is_script = (u_arcname.startswith(script_pfx)
- and not u_arcname.endswith('.exe'))
-
- if u_arcname.startswith(data_pfx):
- _, where, rp = u_arcname.split('/', 2)
- outfile = os.path.join(paths[where], convert_path(rp))
- else:
- # meant for site-packages.
- if u_arcname in (wheel_metadata_name, record_name):
- continue
- outfile = os.path.join(libdir, convert_path(u_arcname))
- if not is_script:
- with zf.open(arcname) as bf:
- fileop.copy_stream(bf, outfile)
- outfiles.append(outfile)
- # Double check the digest of the written file
- if not dry_run and row[1]:
- with open(outfile, 'rb') as bf:
- data = bf.read()
- _, newdigest = self.get_hash(data, kind)
- if newdigest != digest:
- raise DistlibException('digest mismatch '
- 'on write for '
- '%s' % outfile)
- if bc and outfile.endswith('.py'):
- try:
- pyc = fileop.byte_compile(outfile)
- outfiles.append(pyc)
- except Exception:
- # Don't give up if byte-compilation fails,
- # but log it and perhaps warn the user
- logger.warning('Byte-compilation failed',
- exc_info=True)
- else:
- fn = os.path.basename(convert_path(arcname))
- workname = os.path.join(workdir, fn)
- with zf.open(arcname) as bf:
- fileop.copy_stream(bf, workname)
-
- dn, fn = os.path.split(outfile)
- maker.target_dir = dn
- filenames = maker.make(fn)
- fileop.set_executable_mode(filenames)
- outfiles.extend(filenames)
-
- if lib_only:
- logger.debug('lib_only: returning None')
- dist = None
- else:
- # Generate scripts
-
- # Try to get pydist.json so we can see if there are
- # any commands to generate. If this fails (e.g. because
- # of a legacy wheel), log a warning but don't give up.
- commands = None
- file_version = self.info['Wheel-Version']
- if file_version == '1.0':
- # Use legacy info
- ep = posixpath.join(info_dir, 'entry_points.txt')
- try:
- with zf.open(ep) as bwf:
- epdata = read_exports(bwf)
- commands = {}
- for key in ('console', 'gui'):
- k = '%s_scripts' % key
- if k in epdata:
- commands['wrap_%s' % key] = d = {}
- for v in epdata[k].values():
- s = '%s:%s' % (v.prefix, v.suffix)
- if v.flags:
- s += ' %s' % v.flags
- d[v.name] = s
- except Exception:
- logger.warning('Unable to read legacy script '
- 'metadata, so cannot generate '
- 'scripts')
- else:
- try:
- with zf.open(metadata_name) as bwf:
- wf = wrapper(bwf)
- commands = json.load(wf).get('extensions')
- if commands:
- commands = commands.get('python.commands')
- except Exception:
- logger.warning('Unable to read JSON metadata, so '
- 'cannot generate scripts')
- if commands:
- console_scripts = commands.get('wrap_console', {})
- gui_scripts = commands.get('wrap_gui', {})
- if console_scripts or gui_scripts:
- script_dir = paths.get('scripts', '')
- if not os.path.isdir(script_dir):
- raise ValueError('Valid script path not '
- 'specified')
- maker.target_dir = script_dir
- for k, v in console_scripts.items():
- script = '%s = %s' % (k, v)
- filenames = maker.make(script)
- fileop.set_executable_mode(filenames)
-
- if gui_scripts:
- options = {'gui': True }
- for k, v in gui_scripts.items():
- script = '%s = %s' % (k, v)
- filenames = maker.make(script, options)
- fileop.set_executable_mode(filenames)
-
- p = os.path.join(libdir, info_dir)
- dist = InstalledDistribution(p)
-
- # Write SHARED
- paths = dict(paths) # don't change passed in dict
- del paths['purelib']
- del paths['platlib']
- paths['lib'] = libdir
- p = dist.write_shared_locations(paths, dry_run)
- if p:
- outfiles.append(p)
-
- # Write RECORD
- dist.write_installed_files(outfiles, paths['prefix'],
- dry_run)
- return dist
- except Exception: # pragma: no cover
- logger.exception('installation failed.')
- fileop.rollback()
- raise
- finally:
- shutil.rmtree(workdir)
-
- def _get_dylib_cache(self):
- global cache
- if cache is None:
- # Use native string to avoid issues on 2.x: see Python #20140.
- base = os.path.join(get_cache_base(), str('dylib-cache'),
- sys.version[:3])
- cache = Cache(base)
- return cache
-
- def _get_extensions(self):
- pathname = os.path.join(self.dirname, self.filename)
- name_ver = '%s-%s' % (self.name, self.version)
- info_dir = '%s.dist-info' % name_ver
- arcname = posixpath.join(info_dir, 'EXTENSIONS')
- wrapper = codecs.getreader('utf-8')
- result = []
- with ZipFile(pathname, 'r') as zf:
- try:
- with zf.open(arcname) as bf:
- wf = wrapper(bf)
- extensions = json.load(wf)
- cache = self._get_dylib_cache()
- prefix = cache.prefix_to_dir(pathname)
- cache_base = os.path.join(cache.base, prefix)
- if not os.path.isdir(cache_base):
- os.makedirs(cache_base)
- for name, relpath in extensions.items():
- dest = os.path.join(cache_base, convert_path(relpath))
- if not os.path.exists(dest):
- extract = True
- else:
- file_time = os.stat(dest).st_mtime
- file_time = datetime.datetime.fromtimestamp(file_time)
- info = zf.getinfo(relpath)
- wheel_time = datetime.datetime(*info.date_time)
- extract = wheel_time > file_time
- if extract:
- zf.extract(relpath, cache_base)
- result.append((name, dest))
- except KeyError:
- pass
- return result
-
- def is_compatible(self):
- """
- Determine if a wheel is compatible with the running system.
- """
- return is_compatible(self)
-
- def is_mountable(self):
- """
- Determine if a wheel is asserted as mountable by its metadata.
- """
- return True # for now - metadata details TBD
-
- def mount(self, append=False):
- pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
- if not self.is_compatible():
- msg = 'Wheel %s not compatible with this Python.' % pathname
- raise DistlibException(msg)
- if not self.is_mountable():
- msg = 'Wheel %s is marked as not mountable.' % pathname
- raise DistlibException(msg)
- if pathname in sys.path:
- logger.debug('%s already in path', pathname)
- else:
- if append:
- sys.path.append(pathname)
- else:
- sys.path.insert(0, pathname)
- extensions = self._get_extensions()
- if extensions:
- if _hook not in sys.meta_path:
- sys.meta_path.append(_hook)
- _hook.add(pathname, extensions)
-
- def unmount(self):
- pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
- if pathname not in sys.path:
- logger.debug('%s not in path', pathname)
- else:
- sys.path.remove(pathname)
- if pathname in _hook.impure_wheels:
- _hook.remove(pathname)
- if not _hook.impure_wheels:
- if _hook in sys.meta_path:
- sys.meta_path.remove(_hook)
-
- def verify(self):
- pathname = os.path.join(self.dirname, self.filename)
- name_ver = '%s-%s' % (self.name, self.version)
- data_dir = '%s.data' % name_ver
- info_dir = '%s.dist-info' % name_ver
-
- metadata_name = posixpath.join(info_dir, METADATA_FILENAME)
- wheel_metadata_name = posixpath.join(info_dir, 'WHEEL')
- record_name = posixpath.join(info_dir, 'RECORD')
-
- wrapper = codecs.getreader('utf-8')
-
- with ZipFile(pathname, 'r') as zf:
- with zf.open(wheel_metadata_name) as bwf:
- wf = wrapper(bwf)
- message = message_from_file(wf)
- wv = message['Wheel-Version'].split('.', 1)
- file_version = tuple([int(i) for i in wv])
- # TODO version verification
-
- records = {}
- with zf.open(record_name) as bf:
- with CSVReader(stream=bf) as reader:
- for row in reader:
- p = row[0]
- records[p] = row
-
- for zinfo in zf.infolist():
- arcname = zinfo.filename
- if isinstance(arcname, text_type):
- u_arcname = arcname
- else:
- u_arcname = arcname.decode('utf-8')
- if '..' in u_arcname:
- raise DistlibException('invalid entry in '
- 'wheel: %r' % u_arcname)
-
- # The signature file won't be in RECORD,
- # and we don't currently don't do anything with it
- if u_arcname.endswith('/RECORD.jws'):
- continue
- row = records[u_arcname]
- if row[2] and str(zinfo.file_size) != row[2]:
- raise DistlibException('size mismatch for '
- '%s' % u_arcname)
- if row[1]:
- kind, value = row[1].split('=', 1)
- with zf.open(arcname) as bf:
- data = bf.read()
- _, digest = self.get_hash(data, kind)
- if digest != value:
- raise DistlibException('digest mismatch for '
- '%s' % arcname)
-
- def update(self, modifier, dest_dir=None, **kwargs):
- """
- Update the contents of a wheel in a generic way. The modifier should
- be a callable which expects a dictionary argument: its keys are
- archive-entry paths, and its values are absolute filesystem paths
- where the contents the corresponding archive entries can be found. The
- modifier is free to change the contents of the files pointed to, add
- new entries and remove entries, before returning. This method will
- extract the entire contents of the wheel to a temporary location, call
- the modifier, and then use the passed (and possibly updated)
- dictionary to write a new wheel. If ``dest_dir`` is specified, the new
- wheel is written there -- otherwise, the original wheel is overwritten.
-
- The modifier should return True if it updated the wheel, else False.
- This method returns the same value the modifier returns.
- """
-
- def get_version(path_map, info_dir):
- version = path = None
- key = '%s/%s' % (info_dir, METADATA_FILENAME)
- if key not in path_map:
- key = '%s/PKG-INFO' % info_dir
- if key in path_map:
- path = path_map[key]
- version = Metadata(path=path).version
- return version, path
-
- def update_version(version, path):
- updated = None
- try:
- v = NormalizedVersion(version)
- i = version.find('-')
- if i < 0:
- updated = '%s+1' % version
- else:
- parts = [int(s) for s in version[i + 1:].split('.')]
- parts[-1] += 1
- updated = '%s+%s' % (version[:i],
- '.'.join(str(i) for i in parts))
- except UnsupportedVersionError:
- logger.debug('Cannot update non-compliant (PEP-440) '
- 'version %r', version)
- if updated:
- md = Metadata(path=path)
- md.version = updated
- legacy = not path.endswith(METADATA_FILENAME)
- md.write(path=path, legacy=legacy)
- logger.debug('Version updated from %r to %r', version,
- updated)
-
- pathname = os.path.join(self.dirname, self.filename)
- name_ver = '%s-%s' % (self.name, self.version)
- info_dir = '%s.dist-info' % name_ver
- record_name = posixpath.join(info_dir, 'RECORD')
- with tempdir() as workdir:
- with ZipFile(pathname, 'r') as zf:
- path_map = {}
- for zinfo in zf.infolist():
- arcname = zinfo.filename
- if isinstance(arcname, text_type):
- u_arcname = arcname
- else:
- u_arcname = arcname.decode('utf-8')
- if u_arcname == record_name:
- continue
- if '..' in u_arcname:
- raise DistlibException('invalid entry in '
- 'wheel: %r' % u_arcname)
- zf.extract(zinfo, workdir)
- path = os.path.join(workdir, convert_path(u_arcname))
- path_map[u_arcname] = path
-
- # Remember the version.
- original_version, _ = get_version(path_map, info_dir)
- # Files extracted. Call the modifier.
- modified = modifier(path_map, **kwargs)
- if modified:
- # Something changed - need to build a new wheel.
- current_version, path = get_version(path_map, info_dir)
- if current_version and (current_version == original_version):
- # Add or update local version to signify changes.
- update_version(current_version, path)
- # Decide where the new wheel goes.
- if dest_dir is None:
- fd, newpath = tempfile.mkstemp(suffix='.whl',
- prefix='wheel-update-',
- dir=workdir)
- os.close(fd)
- else:
- if not os.path.isdir(dest_dir):
- raise DistlibException('Not a directory: %r' % dest_dir)
- newpath = os.path.join(dest_dir, self.filename)
- archive_paths = list(path_map.items())
- distinfo = os.path.join(workdir, info_dir)
- info = distinfo, info_dir
- self.write_records(info, workdir, archive_paths)
- self.build_zip(newpath, archive_paths)
- if dest_dir is None:
- shutil.copyfile(newpath, pathname)
- return modified
-
-def compatible_tags():
- """
- Return (pyver, abi, arch) tuples compatible with this Python.
- """
- versions = [VER_SUFFIX]
- major = VER_SUFFIX[0]
- for minor in range(sys.version_info[1] - 1, - 1, -1):
- versions.append(''.join([major, str(minor)]))
-
- abis = []
- for suffix, _, _ in imp.get_suffixes():
- if suffix.startswith('.abi'):
- abis.append(suffix.split('.', 2)[1])
- abis.sort()
- if ABI != 'none':
- abis.insert(0, ABI)
- abis.append('none')
- result = []
-
- arches = [ARCH]
- if sys.platform == 'darwin':
- m = re.match('(\w+)_(\d+)_(\d+)_(\w+)$', ARCH)
- if m:
- name, major, minor, arch = m.groups()
- minor = int(minor)
- matches = [arch]
- if arch in ('i386', 'ppc'):
- matches.append('fat')
- if arch in ('i386', 'ppc', 'x86_64'):
- matches.append('fat3')
- if arch in ('ppc64', 'x86_64'):
- matches.append('fat64')
- if arch in ('i386', 'x86_64'):
- matches.append('intel')
- if arch in ('i386', 'x86_64', 'intel', 'ppc', 'ppc64'):
- matches.append('universal')
- while minor >= 0:
- for match in matches:
- s = '%s_%s_%s_%s' % (name, major, minor, match)
- if s != ARCH: # already there
- arches.append(s)
- minor -= 1
-
- # Most specific - our Python version, ABI and arch
- for abi in abis:
- for arch in arches:
- result.append((''.join((IMP_PREFIX, versions[0])), abi, arch))
-
- # where no ABI / arch dependency, but IMP_PREFIX dependency
- for i, version in enumerate(versions):
- result.append((''.join((IMP_PREFIX, version)), 'none', 'any'))
- if i == 0:
- result.append((''.join((IMP_PREFIX, version[0])), 'none', 'any'))
-
- # no IMP_PREFIX, ABI or arch dependency
- for i, version in enumerate(versions):
- result.append((''.join(('py', version)), 'none', 'any'))
- if i == 0:
- result.append((''.join(('py', version[0])), 'none', 'any'))
- return set(result)
-
-
-COMPATIBLE_TAGS = compatible_tags()
-
-del compatible_tags
-
-
-def is_compatible(wheel, tags=None):
- if not isinstance(wheel, Wheel):
- wheel = Wheel(wheel) # assume it's a filename
- result = False
- if tags is None:
- tags = COMPATIBLE_TAGS
- for ver, abi, arch in tags:
- if ver in wheel.pyver and abi in wheel.abi and arch in wheel.arch:
- result = True
- break
- return result
http://git-wip-us.apache.org/repos/asf/incubator-senssoft-tap/blob/6a81d1e7/env2/lib/python2.7/site-packages/pip/_vendor/distro.py
----------------------------------------------------------------------
diff --git a/env2/lib/python2.7/site-packages/pip/_vendor/distro.py b/env2/lib/python2.7/site-packages/pip/_vendor/distro.py
deleted file mode 100644
index 9e7daad..0000000
--- a/env2/lib/python2.7/site-packages/pip/_vendor/distro.py
+++ /dev/null
@@ -1,1081 +0,0 @@
-# Copyright 2015,2016 Nir Cohen
-#
-# 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.
-
-"""
-The ``distro`` package (``distro`` stands for Linux Distribution) provides
-information about the Linux distribution it runs on, such as a reliable
-machine-readable distro ID, or version information.
-
-It is a renewed alternative implementation for Python's original
-:py:func:`platform.linux_distribution` function, but it provides much more
-functionality. An alternative implementation became necessary because Python
-3.5 deprecated this function, and Python 3.7 is expected to remove it
-altogether. Its predecessor function :py:func:`platform.dist` was already
-deprecated since Python 2.6 and is also expected to be removed in Python 3.7.
-Still, there are many cases in which access to Linux distribution information
-is needed. See `Python issue 1322 <https://bugs.python.org/issue1322>`_ for
-more information.
-"""
-
-import os
-import re
-import sys
-import json
-import shlex
-import logging
-import subprocess
-
-
-if not sys.platform.startswith('linux'):
- raise ImportError('Unsupported platform: {0}'.format(sys.platform))
-
-_UNIXCONFDIR = '/etc'
-_OS_RELEASE_BASENAME = 'os-release'
-
-#: Translation table for normalizing the "ID" attribute defined in os-release
-#: files, for use by the :func:`distro.id` method.
-#:
-#: * Key: Value as defined in the os-release file, translated to lower case,
-#: with blanks translated to underscores.
-#:
-#: * Value: Normalized value.
-NORMALIZED_OS_ID = {}
-
-#: Translation table for normalizing the "Distributor ID" attribute returned by
-#: the lsb_release command, for use by the :func:`distro.id` method.
-#:
-#: * Key: Value as returned by the lsb_release command, translated to lower
-#: case, with blanks translated to underscores.
-#:
-#: * Value: Normalized value.
-NORMALIZED_LSB_ID = {
- 'enterpriseenterprise': 'oracle', # Oracle Enterprise Linux
- 'redhatenterpriseworkstation': 'rhel', # RHEL 6.7
-}
-
-#: Translation table for normalizing the distro ID derived from the file name
-#: of distro release files, for use by the :func:`distro.id` method.
-#:
-#: * Key: Value as derived from the file name of a distro release file,
-#: translated to lower case, with blanks translated to underscores.
-#:
-#: * Value: Normalized value.
-NORMALIZED_DISTRO_ID = {
- 'redhat': 'rhel', # RHEL 6.x, 7.x
-}
-
-# Pattern for content of distro release file (reversed)
-_DISTRO_RELEASE_CONTENT_REVERSED_PATTERN = re.compile(
- r'(?:[^)]*\)(.*)\()? *(?:STL )?([\d.+\-a-z]*\d) *(?:esaeler *)?(.+)')
-
-# Pattern for base file name of distro release file
-_DISTRO_RELEASE_BASENAME_PATTERN = re.compile(
- r'(\w+)[-_](release|version)$')
-
-# Base file names to be ignored when searching for distro release file
-_DISTRO_RELEASE_IGNORE_BASENAMES = (
- 'debian_version',
- 'lsb-release',
- 'oem-release',
- _OS_RELEASE_BASENAME,
- 'system-release'
-)
-
-
-def linux_distribution(full_distribution_name=True):
- """
- Return information about the current Linux distribution as a tuple
- ``(id_name, version, codename)`` with items as follows:
-
- * ``id_name``: If *full_distribution_name* is false, the result of
- :func:`distro.id`. Otherwise, the result of :func:`distro.name`.
-
- * ``version``: The result of :func:`distro.version`.
-
- * ``codename``: The result of :func:`distro.codename`.
-
- The interface of this function is compatible with the original
- :py:func:`platform.linux_distribution` function, supporting a subset of
- its parameters.
-
- The data it returns may not exactly be the same, because it uses more data
- sources than the original function, and that may lead to different data if
- the Linux distribution is not consistent across multiple data sources it
- provides (there are indeed such distributions ...).
-
- Another reason for differences is the fact that the :func:`distro.id`
- method normalizes the distro ID string to a reliable machine-readable value
- for a number of popular Linux distributions.
- """
- return _distro.linux_distribution(full_distribution_name)
-
-
-def id():
- """
- Return the distro ID of the current Linux distribution, as a
- machine-readable string.
-
- For a number of Linux distributions, the returned distro ID value is
- *reliable*, in the sense that it is documented and that it does not change
- across releases of the distribution.
-
- This package maintains the following reliable distro ID values:
-
- ============== =========================================
- Distro ID Distribution
- ============== =========================================
- "ubuntu" Ubuntu
- "debian" Debian
- "rhel" RedHat Enterprise Linux
- "centos" CentOS
- "fedora" Fedora
- "sles" SUSE Linux Enterprise Server
- "opensuse" openSUSE
- "amazon" Amazon Linux
- "arch" Arch Linux
- "cloudlinux" CloudLinux OS
- "exherbo" Exherbo Linux
- "gentoo" GenToo Linux
- "ibm_powerkvm" IBM PowerKVM
- "kvmibm" KVM for IBM z Systems
- "linuxmint" Linux Mint
- "mageia" Mageia
- "mandriva" Mandriva Linux
- "parallels" Parallels
- "pidora" Pidora
- "raspbian" Raspbian
- "oracle" Oracle Linux (and Oracle Enterprise Linux)
- "scientific" Scientific Linux
- "slackware" Slackware
- "xenserver" XenServer
- ============== =========================================
-
- If you have a need to get distros for reliable IDs added into this set,
- or if you find that the :func:`distro.id` function returns a different
- distro ID for one of the listed distros, please create an issue in the
- `distro issue tracker`_.
-
- **Lookup hierarchy and transformations:**
-
- First, the ID is obtained from the following sources, in the specified
- order. The first available and non-empty value is used:
-
- * the value of the "ID" attribute of the os-release file,
-
- * the value of the "Distributor ID" attribute returned by the lsb_release
- command,
-
- * the first part of the file name of the distro release file,
-
- The so determined ID value then passes the following transformations,
- before it is returned by this method:
-
- * it is translated to lower case,
-
- * blanks (which should not be there anyway) are translated to underscores,
-
- * a normalization of the ID is performed, based upon
- `normalization tables`_. The purpose of this normalization is to ensure
- that the ID is as reliable as possible, even across incompatible changes
- in the Linux distributions. A common reason for an incompatible change is
- the addition of an os-release file, or the addition of the lsb_release
- command, with ID values that differ from what was previously determined
- from the distro release file name.
- """
- return _distro.id()
-
-
-def name(pretty=False):
- """
- Return the name of the current Linux distribution, as a human-readable
- string.
-
- If *pretty* is false, the name is returned without version or codename.
- (e.g. "CentOS Linux")
-
- If *pretty* is true, the version and codename are appended.
- (e.g. "CentOS Linux 7.1.1503 (Core)")
-
- **Lookup hierarchy:**
-
- The name is obtained from the following sources, in the specified order.
- The first available and non-empty value is used:
-
- * If *pretty* is false:
-
- - the value of the "NAME" attribute of the os-release file,
-
- - the value of the "Distributor ID" attribute returned by the lsb_release
- command,
-
- - the value of the "<name>" field of the distro release file.
-
- * If *pretty* is true:
-
- - the value of the "PRETTY_NAME" attribute of the os-release file,
-
- - the value of the "Description" attribute returned by the lsb_release
- command,
-
- - the value of the "<name>" field of the distro release file, appended
- with the value of the pretty version ("<version_id>" and "<codename>"
- fields) of the distro release file, if available.
- """
- return _distro.name(pretty)
-
-
-def version(pretty=False, best=False):
- """
- Return the version of the current Linux distribution, as a human-readable
- string.
-
- If *pretty* is false, the version is returned without codename (e.g.
- "7.0").
-
- If *pretty* is true, the codename in parenthesis is appended, if the
- codename is non-empty (e.g. "7.0 (Maipo)").
-
- Some distributions provide version numbers with different precisions in
- the different sources of distribution information. Examining the different
- sources in a fixed priority order does not always yield the most precise
- version (e.g. for Debian 8.2, or CentOS 7.1).
-
- The *best* parameter can be used to control the approach for the returned
- version:
-
- If *best* is false, the first non-empty version number in priority order of
- the examined sources is returned.
-
- If *best* is true, the most precise version number out of all examined
- sources is returned.
-
- **Lookup hierarchy:**
-
- In all cases, the version number is obtained from the following sources.
- If *best* is false, this order represents the priority order:
-
- * the value of the "VERSION_ID" attribute of the os-release file,
- * the value of the "Release" attribute returned by the lsb_release
- command,
- * the version number parsed from the "<version_id>" field of the first line
- of the distro release file,
- * the version number parsed from the "PRETTY_NAME" attribute of the
- os-release file, if it follows the format of the distro release files.
- * the version number parsed from the "Description" attribute returned by
- the lsb_release command, if it follows the format of the distro release
- files.
- """
- return _distro.version(pretty, best)
-
-
-def version_parts(best=False):
- """
- Return the version of the current Linux distribution as a tuple
- ``(major, minor, build_number)`` with items as follows:
-
- * ``major``: The result of :func:`distro.major_version`.
-
- * ``minor``: The result of :func:`distro.minor_version`.
-
- * ``build_number``: The result of :func:`distro.build_number`.
-
- For a description of the *best* parameter, see the :func:`distro.version`
- method.
- """
- return _distro.version_parts(best)
-
-
-def major_version(best=False):
- """
- Return the major version of the current Linux distribution, as a string,
- if provided.
- Otherwise, the empty string is returned. The major version is the first
- part of the dot-separated version string.
-
- For a description of the *best* parameter, see the :func:`distro.version`
- method.
- """
- return _distro.major_version(best)
-
-
-def minor_version(best=False):
- """
- Return the minor version of the current Linux distribution, as a string,
- if provided.
- Otherwise, the empty string is returned. The minor version is the second
- part of the dot-separated version string.
-
- For a description of the *best* parameter, see the :func:`distro.version`
- method.
- """
- return _distro.minor_version(best)
-
-
-def build_number(best=False):
- """
- Return the build number of the current Linux distribution, as a string,
- if provided.
- Otherwise, the empty string is returned. The build number is the third part
- of the dot-separated version string.
-
- For a description of the *best* parameter, see the :func:`distro.version`
- method.
- """
- return _distro.build_number(best)
-
-
-def like():
- """
- Return a space-separated list of distro IDs of distributions that are
- closely related to the current Linux distribution in regards to packaging
- and programming interfaces, for example distributions the current
- distribution is a derivative from.
-
- **Lookup hierarchy:**
-
- This information item is only provided by the os-release file.
- For details, see the description of the "ID_LIKE" attribute in the
- `os-release man page
- <http://www.freedesktop.org/software/systemd/man/os-release.html>`_.
- """
- return _distro.like()
-
-
-def codename():
- """
- Return the codename for the release of the current Linux distribution,
- as a string.
-
- If the distribution does not have a codename, an empty string is returned.
-
- Note that the returned codename is not always really a codename. For
- example, openSUSE returns "x86_64". This function does not handle such
- cases in any special way and just returns the string it finds, if any.
-
- **Lookup hierarchy:**
-
- * the codename within the "VERSION" attribute of the os-release file, if
- provided,
-
- * the value of the "Codename" attribute returned by the lsb_release
- command,
-
- * the value of the "<codename>" field of the distro release file.
- """
- return _distro.codename()
-
-
-def info(pretty=False, best=False):
- """
- Return certain machine-readable information items about the current Linux
- distribution in a dictionary, as shown in the following example:
-
- .. sourcecode:: python
-
- {
- 'id': 'rhel',
- 'version': '7.0',
- 'version_parts': {
- 'major': '7',
- 'minor': '0',
- 'build_number': ''
- },
- 'like': 'fedora',
- 'codename': 'Maipo'
- }
-
- The dictionary structure and keys are always the same, regardless of which
- information items are available in the underlying data sources. The values
- for the various keys are as follows:
-
- * ``id``: The result of :func:`distro.id`.
-
- * ``version``: The result of :func:`distro.version`.
-
- * ``version_parts -> major``: The result of :func:`distro.major_version`.
-
- * ``version_parts -> minor``: The result of :func:`distro.minor_version`.
-
- * ``version_parts -> build_number``: The result of
- :func:`distro.build_number`.
-
- * ``like``: The result of :func:`distro.like`.
-
- * ``codename``: The result of :func:`distro.codename`.
-
- For a description of the *pretty* and *best* parameters, see the
- :func:`distro.version` method.
- """
- return _distro.info(pretty, best)
-
-
-def os_release_info():
- """
- Return a dictionary containing key-value pairs for the information items
- from the os-release file data source of the current Linux distribution.
-
- See `os-release file`_ for details about these information items.
- """
- return _distro.os_release_info()
-
-
-def lsb_release_info():
- """
- Return a dictionary containing key-value pairs for the information items
- from the lsb_release command data source of the current Linux distribution.
-
- See `lsb_release command output`_ for details about these information
- items.
- """
- return _distro.lsb_release_info()
-
-
-def distro_release_info():
- """
- Return a dictionary containing key-value pairs for the information items
- from the distro release file data source of the current Linux distribution.
-
- See `distro release file`_ for details about these information items.
- """
- return _distro.distro_release_info()
-
-
-def os_release_attr(attribute):
- """
- Return a single named information item from the os-release file data source
- of the current Linux distribution.
-
- Parameters:
-
- * ``attribute`` (string): Key of the information item.
-
- Returns:
-
- * (string): Value of the information item, if the item exists.
- The empty string, if the item does not exist.
-
- See `os-release file`_ for details about these information items.
- """
- return _distro.os_release_attr(attribute)
-
-
-def lsb_release_attr(attribute):
- """
- Return a single named information item from the lsb_release command output
- data source of the current Linux distribution.
-
- Parameters:
-
- * ``attribute`` (string): Key of the information item.
-
- Returns:
-
- * (string): Value of the information item, if the item exists.
- The empty string, if the item does not exist.
-
- See `lsb_release command output`_ for details about these information
- items.
- """
- return _distro.lsb_release_attr(attribute)
-
-
-def distro_release_attr(attribute):
- """
- Return a single named information item from the distro release file
- data source of the current Linux distribution.
-
- Parameters:
-
- * ``attribute`` (string): Key of the information item.
-
- Returns:
-
- * (string): Value of the information item, if the item exists.
- The empty string, if the item does not exist.
-
- See `distro release file`_ for details about these information items.
- """
- return _distro.distro_release_attr(attribute)
-
-
-class LinuxDistribution(object):
- """
- Provides information about a Linux distribution.
-
- This package creates a private module-global instance of this class with
- default initialization arguments, that is used by the
- `consolidated accessor functions`_ and `single source accessor functions`_.
- By using default initialization arguments, that module-global instance
- returns data about the current Linux distribution (i.e. the distro this
- package runs on).
-
- Normally, it is not necessary to create additional instances of this class.
- However, in situations where control is needed over the exact data sources
- that are used, instances of this class can be created with a specific
- distro release file, or a specific os-release file, or without invoking the
- lsb_release command.
- """
-
- def __init__(self,
- include_lsb=True,
- os_release_file='',
- distro_release_file=''):
- """
- The initialization method of this class gathers information from the
- available data sources, and stores that in private instance attributes.
- Subsequent access to the information items uses these private instance
- attributes, so that the data sources are read only once.
-
- Parameters:
-
- * ``include_lsb`` (bool): Controls whether the
- `lsb_release command output`_ is included as a data source.
-
- If the lsb_release command is not available in the program execution
- path, the data source for the lsb_release command will be empty.
-
- * ``os_release_file`` (string): The path name of the
- `os-release file`_ that is to be used as a data source.
-
- An empty string (the default) will cause the default path name to
- be used (see `os-release file`_ for details).
-
- If the specified or defaulted os-release file does not exist, the
- data source for the os-release file will be empty.
-
- * ``distro_release_file`` (string): The path name of the
- `distro release file`_ that is to be used as a data source.
-
- An empty string (the default) will cause a default search algorithm
- to be used (see `distro release file`_ for details).
-
- If the specified distro release file does not exist, or if no default
- distro release file can be found, the data source for the distro
- release file will be empty.
-
- Public instance attributes:
-
- * ``os_release_file`` (string): The path name of the
- `os-release file`_ that is actually used as a data source. The
- empty string if no distro release file is used as a data source.
-
- * ``distro_release_file`` (string): The path name of the
- `distro release file`_ that is actually used as a data source. The
- empty string if no distro release file is used as a data source.
-
- Raises:
-
- * :py:exc:`IOError`: Some I/O issue with an os-release file or distro
- release file.
-
- * :py:exc:`subprocess.CalledProcessError`: The lsb_release command had
- some issue (other than not being available in the program execution
- path).
-
- * :py:exc:`UnicodeError`: A data source has unexpected characters or
- uses an unexpected encoding.
- """
- self.os_release_file = os_release_file or \
- os.path.join(_UNIXCONFDIR, _OS_RELEASE_BASENAME)
- self.distro_release_file = distro_release_file or '' # updated later
- self._os_release_info = self._get_os_release_info()
- self._lsb_release_info = self._get_lsb_release_info() \
- if include_lsb else {}
- self._distro_release_info = self._get_distro_release_info()
-
- def __repr__(self):
- """Return repr of all info
- """
- return \
- "LinuxDistribution(" \
- "os_release_file={0!r}, " \
- "distro_release_file={1!r}, " \
- "_os_release_info={2!r}, " \
- "_lsb_release_info={3!r}, " \
- "_distro_release_info={4!r})".format(
- self.os_release_file,
- self.distro_release_file,
- self._os_release_info,
- self._lsb_release_info,
- self._distro_release_info)
-
- def linux_distribution(self, full_distribution_name=True):
- """
- Return information about the Linux distribution that is compatible
- with Python's :func:`platform.linux_distribution`, supporting a subset
- of its parameters.
-
- For details, see :func:`distro.linux_distribution`.
- """
- return (
- self.name() if full_distribution_name else self.id(),
- self.version(),
- self.codename()
- )
-
- def id(self):
- """Return the distro ID of the Linux distribution, as a string.
-
- For details, see :func:`distro.id`.
- """
- def normalize(distro_id, table):
- distro_id = distro_id.lower().replace(' ', '_')
- return table.get(distro_id, distro_id)
-
- distro_id = self.os_release_attr('id')
- if distro_id:
- return normalize(distro_id, NORMALIZED_OS_ID)
-
- distro_id = self.lsb_release_attr('distributor_id')
- if distro_id:
- return normalize(distro_id, NORMALIZED_LSB_ID)
-
- distro_id = self.distro_release_attr('id')
- if distro_id:
- return normalize(distro_id, NORMALIZED_DISTRO_ID)
-
- return ''
-
- def name(self, pretty=False):
- """
- Return the name of the Linux distribution, as a string.
-
- For details, see :func:`distro.name`.
- """
- name = self.os_release_attr('name') \
- or self.lsb_release_attr('distributor_id') \
- or self.distro_release_attr('name')
- if pretty:
- name = self.os_release_attr('pretty_name') \
- or self.lsb_release_attr('description')
- if not name:
- name = self.distro_release_attr('name')
- version = self.version(pretty=True)
- if version:
- name = name + ' ' + version
- return name or ''
-
- def version(self, pretty=False, best=False):
- """
- Return the version of the Linux distribution, as a string.
-
- For details, see :func:`distro.version`.
- """
- versions = [
- self.os_release_attr('version_id'),
- self.lsb_release_attr('release'),
- self.distro_release_attr('version_id'),
- self._parse_distro_release_content(
- self.os_release_attr('pretty_name')).get('version_id', ''),
- self._parse_distro_release_content(
- self.lsb_release_attr('description')).get('version_id', '')
- ]
- version = ''
- if best:
- # This algorithm uses the last version in priority order that has
- # the best precision. If the versions are not in conflict, that
- # does not matter; otherwise, using the last one instead of the
- # first one might be considered a surprise.
- for v in versions:
- if v.count(".") > version.count(".") or version == '':
- version = v
- else:
- for v in versions:
- if v != '':
- version = v
- break
- if pretty and version and self.codename():
- version = u'{0} ({1})'.format(version, self.codename())
- return version
-
- def version_parts(self, best=False):
- """
- Return the version of the Linux distribution, as a tuple of version
- numbers.
-
- For details, see :func:`distro.version_parts`.
- """
- version_str = self.version(best=best)
- if version_str:
- version_regex = re.compile(r'(\d+)\.?(\d+)?\.?(\d+)?')
- matches = version_regex.match(version_str)
- if matches:
- major, minor, build_number = matches.groups()
- return major, minor or '', build_number or ''
- return '', '', ''
-
- def major_version(self, best=False):
- """
- Return the major version number of the current distribution.
-
- For details, see :func:`distro.major_version`.
- """
- return self.version_parts(best)[0]
-
- def minor_version(self, best=False):
- """
- Return the minor version number of the Linux distribution.
-
- For details, see :func:`distro.minor_version`.
- """
- return self.version_parts(best)[1]
-
- def build_number(self, best=False):
- """
- Return the build number of the Linux distribution.
-
- For details, see :func:`distro.build_number`.
- """
- return self.version_parts(best)[2]
-
- def like(self):
- """
- Return the IDs of distributions that are like the Linux distribution.
-
- For details, see :func:`distro.like`.
- """
- return self.os_release_attr('id_like') or ''
-
- def codename(self):
- """
- Return the codename of the Linux distribution.
-
- For details, see :func:`distro.codename`.
- """
- return self.os_release_attr('codename') \
- or self.lsb_release_attr('codename') \
- or self.distro_release_attr('codename') \
- or ''
-
- def info(self, pretty=False, best=False):
- """
- Return certain machine-readable information about the Linux
- distribution.
-
- For details, see :func:`distro.info`.
- """
- return dict(
- id=self.id(),
- version=self.version(pretty, best),
- version_parts=dict(
- major=self.major_version(best),
- minor=self.minor_version(best),
- build_number=self.build_number(best)
- ),
- like=self.like(),
- codename=self.codename(),
- )
-
- def os_release_info(self):
- """
- Return a dictionary containing key-value pairs for the information
- items from the os-release file data source of the Linux distribution.
-
- For details, see :func:`distro.os_release_info`.
- """
- return self._os_release_info
-
- def lsb_release_info(self):
- """
- Return a dictionary containing key-value pairs for the information
- items from the lsb_release command data source of the Linux
- distribution.
-
- For details, see :func:`distro.lsb_release_info`.
- """
- return self._lsb_release_info
-
- def distro_release_info(self):
- """
- Return a dictionary containing key-value pairs for the information
- items from the distro release file data source of the Linux
- distribution.
-
- For details, see :func:`distro.distro_release_info`.
- """
- return self._distro_release_info
-
- def os_release_attr(self, attribute):
- """
- Return a single named information item from the os-release file data
- source of the Linux distribution.
-
- For details, see :func:`distro.os_release_attr`.
- """
- return self._os_release_info.get(attribute, '')
-
- def lsb_release_attr(self, attribute):
- """
- Return a single named information item from the lsb_release command
- output data source of the Linux distribution.
-
- For details, see :func:`distro.lsb_release_attr`.
- """
- return self._lsb_release_info.get(attribute, '')
-
- def distro_release_attr(self, attribute):
- """
- Return a single named information item from the distro release file
- data source of the Linux distribution.
-
- For details, see :func:`distro.distro_release_attr`.
- """
- return self._distro_release_info.get(attribute, '')
-
- def _get_os_release_info(self):
- """
- Get the information items from the specified os-release file.
-
- Returns:
- A dictionary containing all information items.
- """
- if os.path.isfile(self.os_release_file):
- with open(self.os_release_file) as release_file:
- return self._parse_os_release_content(release_file)
- return {}
-
- @staticmethod
- def _parse_os_release_content(lines):
- """
- Parse the lines of an os-release file.
-
- Parameters:
-
- * lines: Iterable through the lines in the os-release file.
- Each line must be a unicode string or a UTF-8 encoded byte
- string.
-
- Returns:
- A dictionary containing all information items.
- """
- props = {}
- lexer = shlex.shlex(lines, posix=True)
- lexer.whitespace_split = True
-
- # The shlex module defines its `wordchars` variable using literals,
- # making it dependent on the encoding of the Python source file.
- # In Python 2.6 and 2.7, the shlex source file is encoded in
- # 'iso-8859-1', and the `wordchars` variable is defined as a byte
- # string. This causes a UnicodeDecodeError to be raised when the
- # parsed content is a unicode object. The following fix resolves that
- # (... but it should be fixed in shlex...):
- if sys.version_info[0] == 2 and isinstance(lexer.wordchars, bytes):
- lexer.wordchars = lexer.wordchars.decode('iso-8859-1')
-
- tokens = list(lexer)
- for token in tokens:
- # At this point, all shell-like parsing has been done (i.e.
- # comments processed, quotes and backslash escape sequences
- # processed, multi-line values assembled, trailing newlines
- # stripped, etc.), so the tokens are now either:
- # * variable assignments: var=value
- # * commands or their arguments (not allowed in os-release)
- if '=' in token:
- k, v = token.split('=', 1)
- if isinstance(v, bytes):
- v = v.decode('utf-8')
- props[k.lower()] = v
- if k == 'VERSION':
- # this handles cases in which the codename is in
- # the `(CODENAME)` (rhel, centos, fedora) format
- # or in the `, CODENAME` format (Ubuntu).
- codename = re.search(r'(\(\D+\))|,(\s+)?\D+', v)
- if codename:
- codename = codename.group()
- codename = codename.strip('()')
- codename = codename.strip(',')
- codename = codename.strip()
- # codename appears within paranthese.
- props['codename'] = codename
- else:
- props['codename'] = ''
- else:
- # Ignore any tokens that are not variable assignments
- pass
- return props
-
- def _get_lsb_release_info(self):
- """
- Get the information items from the lsb_release command output.
-
- Returns:
- A dictionary containing all information items.
- """
- cmd = 'lsb_release -a'
- process = subprocess.Popen(
- cmd,
- shell=True,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
- stdout, stderr = process.communicate()
- stdout, stderr = stdout.decode('utf-8'), stderr.decode('utf-8')
- code = process.returncode
- if code == 0:
- content = stdout.splitlines()
- return self._parse_lsb_release_content(content)
- elif code == 127: # Command not found
- return {}
- else:
- if sys.version_info[:2] >= (3, 5):
- raise subprocess.CalledProcessError(code, cmd, stdout, stderr)
- elif sys.version_info[:2] >= (2, 7):
- raise subprocess.CalledProcessError(code, cmd, stdout)
- elif sys.version_info[:2] == (2, 6):
- raise subprocess.CalledProcessError(code, cmd)
-
- @staticmethod
- def _parse_lsb_release_content(lines):
- """
- Parse the output of the lsb_release command.
-
- Parameters:
-
- * lines: Iterable through the lines of the lsb_release output.
- Each line must be a unicode string or a UTF-8 encoded byte
- string.
-
- Returns:
- A dictionary containing all information items.
- """
- props = {}
- for line in lines:
- line = line.decode('utf-8') if isinstance(line, bytes) else line
- kv = line.strip('\n').split(':', 1)
- if len(kv) != 2:
- # Ignore lines without colon.
- continue
- k, v = kv
- props.update({k.replace(' ', '_').lower(): v.strip()})
- return props
-
- def _get_distro_release_info(self):
- """
- Get the information items from the specified distro release file.
-
- Returns:
- A dictionary containing all information items.
- """
- if self.distro_release_file:
- # If it was specified, we use it and parse what we can, even if
- # its file name or content does not match the expected pattern.
- distro_info = self._parse_distro_release_file(
- self.distro_release_file)
- basename = os.path.basename(self.distro_release_file)
- # The file name pattern for user-specified distro release files
- # is somewhat more tolerant (compared to when searching for the
- # file), because we want to use what was specified as best as
- # possible.
- match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
- if match:
- distro_info['id'] = match.group(1)
- return distro_info
- else:
- basenames = os.listdir(_UNIXCONFDIR)
- # We sort for repeatability in cases where there are multiple
- # distro specific files; e.g. CentOS, Oracle, Enterprise all
- # containing `redhat-release` on top of their own.
- basenames.sort()
- for basename in basenames:
- if basename in _DISTRO_RELEASE_IGNORE_BASENAMES:
- continue
- match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
- if match:
- filepath = os.path.join(_UNIXCONFDIR, basename)
- distro_info = self._parse_distro_release_file(filepath)
- if 'name' in distro_info:
- # The name is always present if the pattern matches
- self.distro_release_file = filepath
- distro_info['id'] = match.group(1)
- return distro_info
- return {}
-
- def _parse_distro_release_file(self, filepath):
- """
- Parse a distro release file.
-
- Parameters:
-
- * filepath: Path name of the distro release file.
-
- Returns:
- A dictionary containing all information items.
- """
- if os.path.isfile(filepath):
- with open(filepath) as fp:
- # Only parse the first line. For instance, on SLES there
- # are multiple lines. We don't want them...
- return self._parse_distro_release_content(fp.readline())
- return {}
-
- @staticmethod
- def _parse_distro_release_content(line):
- """
- Parse a line from a distro release file.
-
- Parameters:
- * line: Line from the distro release file. Must be a unicode string
- or a UTF-8 encoded byte string.
-
- Returns:
- A dictionary containing all information items.
- """
- if isinstance(line, bytes):
- line = line.decode('utf-8')
- matches = _DISTRO_RELEASE_CONTENT_REVERSED_PATTERN.match(
- line.strip()[::-1])
- distro_info = {}
- if matches:
- # regexp ensures non-None
- distro_info['name'] = matches.group(3)[::-1]
- if matches.group(2):
- distro_info['version_id'] = matches.group(2)[::-1]
- if matches.group(1):
- distro_info['codename'] = matches.group(1)[::-1]
- elif line:
- distro_info['name'] = line.strip()
- return distro_info
-
-
-_distro = LinuxDistribution()
-
-
-def main():
- import argparse
-
- logger = logging.getLogger(__name__)
- logger.setLevel(logging.DEBUG)
- logger.addHandler(logging.StreamHandler(sys.stdout))
-
- parser = argparse.ArgumentParser(description="Linux distro info tool")
- parser.add_argument(
- '--json',
- '-j',
- help="Output in machine readable format",
- action="store_true")
- args = parser.parse_args()
-
- if args.json:
- logger.info(json.dumps(info(), indent=4, sort_keys=True))
- else:
- logger.info('Name: %s', name(pretty=True))
- distribution_version = version(pretty=True)
- if distribution_version:
- logger.info('Version: %s', distribution_version)
- distribution_codename = codename()
- if distribution_codename:
- logger.info('Codename: %s', distribution_codename)
-
-
-if __name__ == '__main__':
- main()
http://git-wip-us.apache.org/repos/asf/incubator-senssoft-tap/blob/6a81d1e7/env2/lib/python2.7/site-packages/pip/_vendor/html5lib/__init__.py
----------------------------------------------------------------------
diff --git a/env2/lib/python2.7/site-packages/pip/_vendor/html5lib/__init__.py b/env2/lib/python2.7/site-packages/pip/_vendor/html5lib/__init__.py
deleted file mode 100644
index 7427eb1..0000000
--- a/env2/lib/python2.7/site-packages/pip/_vendor/html5lib/__init__.py
+++ /dev/null
@@ -1,25 +0,0 @@
-"""
-HTML parsing library based on the WHATWG "HTML5"
-specification. The parser is designed to be compatible with existing
-HTML found in the wild and implements well-defined error recovery that
-is largely compatible with modern desktop web browsers.
-
-Example usage:
-
-import html5lib
-f = open("my_document.html")
-tree = html5lib.parse(f)
-"""
-
-from __future__ import absolute_import, division, unicode_literals
-
-from .html5parser import HTMLParser, parse, parseFragment
-from .treebuilders import getTreeBuilder
-from .treewalkers import getTreeWalker
-from .serializer import serialize
-
-__all__ = ["HTMLParser", "parse", "parseFragment", "getTreeBuilder",
- "getTreeWalker", "serialize"]
-
-# this has to be at the top level, see how setup.py parses this
-__version__ = "1.0b10"