run update.sh, install netifaces
This commit is contained in:
parent
feb4ce7352
commit
717a291e19
258 changed files with 71187 additions and 1047 deletions
|
|
@ -75,6 +75,8 @@ except ImportError:
|
|||
from pkg_resources.extern import packaging
|
||||
__import__('pkg_resources.extern.packaging.version')
|
||||
__import__('pkg_resources.extern.packaging.specifiers')
|
||||
__import__('pkg_resources.extern.packaging.requirements')
|
||||
__import__('pkg_resources.extern.packaging.markers')
|
||||
|
||||
|
||||
if (3, 0) < sys.version_info < (3, 3):
|
||||
|
|
@ -1385,202 +1387,34 @@ def to_filename(name):
|
|||
return name.replace('-','_')
|
||||
|
||||
|
||||
class MarkerEvaluation(object):
|
||||
values = {
|
||||
'os_name': lambda: os.name,
|
||||
'sys_platform': lambda: sys.platform,
|
||||
'python_full_version': platform.python_version,
|
||||
'python_version': lambda: platform.python_version()[:3],
|
||||
'platform_version': platform.version,
|
||||
'platform_machine': platform.machine,
|
||||
'platform_python_implementation': platform.python_implementation,
|
||||
'python_implementation': platform.python_implementation,
|
||||
}
|
||||
def invalid_marker(text):
|
||||
"""
|
||||
Validate text as a PEP 508 environment marker; return an exception
|
||||
if invalid or False otherwise.
|
||||
"""
|
||||
try:
|
||||
evaluate_marker(text)
|
||||
except SyntaxError as e:
|
||||
e.filename = None
|
||||
e.lineno = None
|
||||
return e
|
||||
return False
|
||||
|
||||
@classmethod
|
||||
def is_invalid_marker(cls, text):
|
||||
"""
|
||||
Validate text as a PEP 426 environment marker; return an exception
|
||||
if invalid or False otherwise.
|
||||
"""
|
||||
try:
|
||||
cls.evaluate_marker(text)
|
||||
except SyntaxError as e:
|
||||
return cls.normalize_exception(e)
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def normalize_exception(exc):
|
||||
"""
|
||||
Given a SyntaxError from a marker evaluation, normalize the error
|
||||
message:
|
||||
- Remove indications of filename and line number.
|
||||
- Replace platform-specific error messages with standard error
|
||||
messages.
|
||||
"""
|
||||
subs = {
|
||||
'unexpected EOF while parsing': 'invalid syntax',
|
||||
'parenthesis is never closed': 'invalid syntax',
|
||||
}
|
||||
exc.filename = None
|
||||
exc.lineno = None
|
||||
exc.msg = subs.get(exc.msg, exc.msg)
|
||||
return exc
|
||||
def evaluate_marker(text, extra=None):
|
||||
"""
|
||||
Evaluate a PEP 508 environment marker.
|
||||
Return a boolean indicating the marker result in this environment.
|
||||
Raise SyntaxError if marker is invalid.
|
||||
|
||||
@classmethod
|
||||
def and_test(cls, nodelist):
|
||||
# MUST NOT short-circuit evaluation, or invalid syntax can be skipped!
|
||||
items = [
|
||||
cls.interpret(nodelist[i])
|
||||
for i in range(1, len(nodelist), 2)
|
||||
]
|
||||
return functools.reduce(operator.and_, items)
|
||||
This implementation uses the 'pyparsing' module.
|
||||
"""
|
||||
try:
|
||||
marker = packaging.markers.Marker(text)
|
||||
return marker.evaluate()
|
||||
except packaging.markers.InvalidMarker as e:
|
||||
raise SyntaxError(e)
|
||||
|
||||
@classmethod
|
||||
def test(cls, nodelist):
|
||||
# MUST NOT short-circuit evaluation, or invalid syntax can be skipped!
|
||||
items = [
|
||||
cls.interpret(nodelist[i])
|
||||
for i in range(1, len(nodelist), 2)
|
||||
]
|
||||
return functools.reduce(operator.or_, items)
|
||||
|
||||
@classmethod
|
||||
def atom(cls, nodelist):
|
||||
t = nodelist[1][0]
|
||||
if t == token.LPAR:
|
||||
if nodelist[2][0] == token.RPAR:
|
||||
raise SyntaxError("Empty parentheses")
|
||||
return cls.interpret(nodelist[2])
|
||||
msg = "Language feature not supported in environment markers"
|
||||
raise SyntaxError(msg)
|
||||
|
||||
@classmethod
|
||||
def comparison(cls, nodelist):
|
||||
if len(nodelist) > 4:
|
||||
msg = "Chained comparison not allowed in environment markers"
|
||||
raise SyntaxError(msg)
|
||||
comp = nodelist[2][1]
|
||||
cop = comp[1]
|
||||
if comp[0] == token.NAME:
|
||||
if len(nodelist[2]) == 3:
|
||||
if cop == 'not':
|
||||
cop = 'not in'
|
||||
else:
|
||||
cop = 'is not'
|
||||
try:
|
||||
cop = cls.get_op(cop)
|
||||
except KeyError:
|
||||
msg = repr(cop) + " operator not allowed in environment markers"
|
||||
raise SyntaxError(msg)
|
||||
return cop(cls.evaluate(nodelist[1]), cls.evaluate(nodelist[3]))
|
||||
|
||||
@classmethod
|
||||
def get_op(cls, op):
|
||||
ops = {
|
||||
symbol.test: cls.test,
|
||||
symbol.and_test: cls.and_test,
|
||||
symbol.atom: cls.atom,
|
||||
symbol.comparison: cls.comparison,
|
||||
'not in': lambda x, y: x not in y,
|
||||
'in': lambda x, y: x in y,
|
||||
'==': operator.eq,
|
||||
'!=': operator.ne,
|
||||
'<': operator.lt,
|
||||
'>': operator.gt,
|
||||
'<=': operator.le,
|
||||
'>=': operator.ge,
|
||||
}
|
||||
if hasattr(symbol, 'or_test'):
|
||||
ops[symbol.or_test] = cls.test
|
||||
return ops[op]
|
||||
|
||||
@classmethod
|
||||
def evaluate_marker(cls, text, extra=None):
|
||||
"""
|
||||
Evaluate a PEP 426 environment marker on CPython 2.4+.
|
||||
Return a boolean indicating the marker result in this environment.
|
||||
Raise SyntaxError if marker is invalid.
|
||||
|
||||
This implementation uses the 'parser' module, which is not implemented
|
||||
on
|
||||
Jython and has been superseded by the 'ast' module in Python 2.6 and
|
||||
later.
|
||||
"""
|
||||
return cls.interpret(parser.expr(text).totuple(1)[1])
|
||||
|
||||
@staticmethod
|
||||
def _translate_metadata2(env):
|
||||
"""
|
||||
Markerlib implements Metadata 1.2 (PEP 345) environment markers.
|
||||
Translate the variables to Metadata 2.0 (PEP 426).
|
||||
"""
|
||||
return dict(
|
||||
(key.replace('.', '_'), value)
|
||||
for key, value in env.items()
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def _markerlib_evaluate(cls, text):
|
||||
"""
|
||||
Evaluate a PEP 426 environment marker using markerlib.
|
||||
Return a boolean indicating the marker result in this environment.
|
||||
Raise SyntaxError if marker is invalid.
|
||||
"""
|
||||
import _markerlib
|
||||
|
||||
env = cls._translate_metadata2(_markerlib.default_environment())
|
||||
try:
|
||||
result = _markerlib.interpret(text, env)
|
||||
except NameError as e:
|
||||
raise SyntaxError(e.args[0])
|
||||
return result
|
||||
|
||||
if 'parser' not in globals():
|
||||
# Fall back to less-complete _markerlib implementation if 'parser' module
|
||||
# is not available.
|
||||
evaluate_marker = _markerlib_evaluate
|
||||
|
||||
@classmethod
|
||||
def interpret(cls, nodelist):
|
||||
while len(nodelist)==2: nodelist = nodelist[1]
|
||||
try:
|
||||
op = cls.get_op(nodelist[0])
|
||||
except KeyError:
|
||||
raise SyntaxError("Comparison or logical expression expected")
|
||||
return op(nodelist)
|
||||
|
||||
@classmethod
|
||||
def evaluate(cls, nodelist):
|
||||
while len(nodelist)==2: nodelist = nodelist[1]
|
||||
kind = nodelist[0]
|
||||
name = nodelist[1]
|
||||
if kind==token.NAME:
|
||||
try:
|
||||
op = cls.values[name]
|
||||
except KeyError:
|
||||
raise SyntaxError("Unknown name %r" % name)
|
||||
return op()
|
||||
if kind==token.STRING:
|
||||
s = nodelist[1]
|
||||
if not cls._safe_string(s):
|
||||
raise SyntaxError(
|
||||
"Only plain strings allowed in environment markers")
|
||||
return s[1:-1]
|
||||
msg = "Language feature not supported in environment markers"
|
||||
raise SyntaxError(msg)
|
||||
|
||||
@staticmethod
|
||||
def _safe_string(cand):
|
||||
return (
|
||||
cand[:1] in "'\"" and
|
||||
not cand.startswith('"""') and
|
||||
not cand.startswith("'''") and
|
||||
'\\' not in cand
|
||||
)
|
||||
|
||||
invalid_marker = MarkerEvaluation.is_invalid_marker
|
||||
evaluate_marker = MarkerEvaluation.evaluate_marker
|
||||
|
||||
class NullProvider:
|
||||
"""Try to implement resources and metadata for arbitrary PEP 302 loaders"""
|
||||
|
|
@ -2314,18 +2148,6 @@ def yield_lines(strs):
|
|||
for s in yield_lines(ss):
|
||||
yield s
|
||||
|
||||
# whitespace and comment
|
||||
LINE_END = re.compile(r"\s*(#.*)?$").match
|
||||
# line continuation
|
||||
CONTINUE = re.compile(r"\s*\\\s*(#.*)?$").match
|
||||
# Distribution or extra
|
||||
DISTRO = re.compile(r"\s*((\w|[-.])+)").match
|
||||
# ver. info
|
||||
VERSION = re.compile(r"\s*(<=?|>=?|===?|!=|~=)\s*((\w|[-.*_!+])+)").match
|
||||
# comma between items
|
||||
COMMA = re.compile(r"\s*,").match
|
||||
OBRACKET = re.compile(r"\s*\[").match
|
||||
CBRACKET = re.compile(r"\s*\]").match
|
||||
MODULE = re.compile(r"\w+(\.\w+)*$").match
|
||||
EGG_NAME = re.compile(
|
||||
r"""
|
||||
|
|
@ -2864,34 +2686,18 @@ class DistInfoDistribution(Distribution):
|
|||
self.__dep_map = self._compute_dependencies()
|
||||
return self.__dep_map
|
||||
|
||||
def _preparse_requirement(self, requires_dist):
|
||||
"""Convert 'Foobar (1); baz' to ('Foobar ==1', 'baz')
|
||||
Split environment marker, add == prefix to version specifiers as
|
||||
necessary, and remove parenthesis.
|
||||
"""
|
||||
parts = requires_dist.split(';', 1) + ['']
|
||||
distvers = parts[0].strip()
|
||||
mark = parts[1].strip()
|
||||
distvers = re.sub(self.EQEQ, r"\1==\2\3", distvers)
|
||||
distvers = distvers.replace('(', '').replace(')', '')
|
||||
return (distvers, mark)
|
||||
|
||||
def _compute_dependencies(self):
|
||||
"""Recompute this distribution's dependencies."""
|
||||
from _markerlib import compile as compile_marker
|
||||
dm = self.__dep_map = {None: []}
|
||||
|
||||
reqs = []
|
||||
# Including any condition expressions
|
||||
for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
|
||||
distvers, mark = self._preparse_requirement(req)
|
||||
parsed = next(parse_requirements(distvers))
|
||||
parsed.marker_fn = compile_marker(mark)
|
||||
reqs.append(parsed)
|
||||
reqs.extend(parse_requirements(req))
|
||||
|
||||
def reqs_for_extra(extra):
|
||||
for req in reqs:
|
||||
if req.marker_fn(override={'extra':extra}):
|
||||
if not req.marker or req.marker.evaluate({'extra': extra}):
|
||||
yield req
|
||||
|
||||
common = frozenset(reqs_for_extra(None))
|
||||
|
|
@ -2937,85 +2743,38 @@ def parse_requirements(strs):
|
|||
# create a steppable iterator, so we can handle \-continuations
|
||||
lines = iter(yield_lines(strs))
|
||||
|
||||
def scan_list(ITEM, TERMINATOR, line, p, groups, item_name):
|
||||
|
||||
items = []
|
||||
|
||||
while not TERMINATOR(line, p):
|
||||
if CONTINUE(line, p):
|
||||
try:
|
||||
line = next(lines)
|
||||
p = 0
|
||||
except StopIteration:
|
||||
msg = "\\ must not appear on the last nonblank line"
|
||||
raise RequirementParseError(msg)
|
||||
|
||||
match = ITEM(line, p)
|
||||
if not match:
|
||||
msg = "Expected " + item_name + " in"
|
||||
raise RequirementParseError(msg, line, "at", line[p:])
|
||||
|
||||
items.append(match.group(*groups))
|
||||
p = match.end()
|
||||
|
||||
match = COMMA(line, p)
|
||||
if match:
|
||||
# skip the comma
|
||||
p = match.end()
|
||||
elif not TERMINATOR(line, p):
|
||||
msg = "Expected ',' or end-of-list in"
|
||||
raise RequirementParseError(msg, line, "at", line[p:])
|
||||
|
||||
match = TERMINATOR(line, p)
|
||||
# skip the terminator, if any
|
||||
if match:
|
||||
p = match.end()
|
||||
return line, p, items
|
||||
|
||||
for line in lines:
|
||||
match = DISTRO(line)
|
||||
if not match:
|
||||
raise RequirementParseError("Missing distribution spec", line)
|
||||
project_name = match.group(1)
|
||||
p = match.end()
|
||||
extras = []
|
||||
|
||||
match = OBRACKET(line, p)
|
||||
if match:
|
||||
p = match.end()
|
||||
line, p, extras = scan_list(
|
||||
DISTRO, CBRACKET, line, p, (1,), "'extra' name"
|
||||
)
|
||||
|
||||
line, p, specs = scan_list(VERSION, LINE_END, line, p, (1, 2),
|
||||
"version spec")
|
||||
specs = [(op, val) for op, val in specs]
|
||||
yield Requirement(project_name, specs, extras)
|
||||
# Drop comments -- a hash without a space may be in a URL.
|
||||
if ' #' in line:
|
||||
line = line[:line.find(' #')]
|
||||
# If there is a line continuation, drop it, and append the next line.
|
||||
if line.endswith('\\'):
|
||||
line = line[:-2].strip()
|
||||
line += next(lines)
|
||||
yield Requirement(line)
|
||||
|
||||
|
||||
class Requirement:
|
||||
def __init__(self, project_name, specs, extras):
|
||||
class Requirement(packaging.requirements.Requirement):
|
||||
def __init__(self, requirement_string):
|
||||
"""DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
|
||||
self.unsafe_name, project_name = project_name, safe_name(project_name)
|
||||
try:
|
||||
super(Requirement, self).__init__(requirement_string)
|
||||
except packaging.requirements.InvalidRequirement as e:
|
||||
raise RequirementParseError(str(e))
|
||||
self.unsafe_name = self.name
|
||||
project_name = safe_name(self.name)
|
||||
self.project_name, self.key = project_name, project_name.lower()
|
||||
self.specifier = packaging.specifiers.SpecifierSet(
|
||||
",".join(["".join([x, y]) for x, y in specs])
|
||||
)
|
||||
self.specs = specs
|
||||
self.extras = tuple(map(safe_extra, extras))
|
||||
self.specs = [
|
||||
(spec.operator, spec.version) for spec in self.specifier]
|
||||
self.extras = tuple(map(safe_extra, self.extras))
|
||||
self.hashCmp = (
|
||||
self.key,
|
||||
self.specifier,
|
||||
frozenset(self.extras),
|
||||
str(self.marker) if self.marker else None,
|
||||
)
|
||||
self.__hash = hash(self.hashCmp)
|
||||
|
||||
def __str__(self):
|
||||
extras = ','.join(self.extras)
|
||||
if extras:
|
||||
extras = '[%s]' % extras
|
||||
return '%s%s%s' % (self.project_name, extras, self.specifier)
|
||||
|
||||
def __eq__(self, other):
|
||||
return (
|
||||
isinstance(other, Requirement) and
|
||||
|
|
|
|||
|
|
@ -1,16 +1,6 @@
|
|||
# Copyright 2014 Donald Stufft
|
||||
#
|
||||
# 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.
|
||||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
__all__ = [
|
||||
|
|
@ -22,10 +12,10 @@ __title__ = "packaging"
|
|||
__summary__ = "Core utilities for Python packages"
|
||||
__uri__ = "https://github.com/pypa/packaging"
|
||||
|
||||
__version__ = "15.3"
|
||||
__version__ = "16.5"
|
||||
|
||||
__author__ = "Donald Stufft"
|
||||
__author__ = "Donald Stufft and individual contributors"
|
||||
__email__ = "donald@stufft.io"
|
||||
|
||||
__license__ = "Apache License, Version 2.0"
|
||||
__copyright__ = "Copyright 2014 %s" % __author__
|
||||
__license__ = "BSD or Apache License, Version 2.0"
|
||||
__copyright__ = "Copyright 2014-2016 %s" % __author__
|
||||
|
|
|
|||
|
|
@ -1,16 +1,6 @@
|
|||
# Copyright 2014 Donald Stufft
|
||||
#
|
||||
# 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.
|
||||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
from .__about__ import (
|
||||
|
|
|
|||
|
|
@ -1,16 +1,6 @@
|
|||
# Copyright 2014 Donald Stufft
|
||||
#
|
||||
# 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.
|
||||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
import sys
|
||||
|
|
|
|||
|
|
@ -1,16 +1,6 @@
|
|||
# Copyright 2014 Donald Stufft
|
||||
#
|
||||
# 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.
|
||||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,273 @@
|
|||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
import operator
|
||||
import os
|
||||
import platform
|
||||
import sys
|
||||
|
||||
from pkg_resources.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd
|
||||
from pkg_resources.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString
|
||||
from pkg_resources.extern.pyparsing import Literal as L # noqa
|
||||
|
||||
from ._compat import string_types
|
||||
from .specifiers import Specifier, InvalidSpecifier
|
||||
|
||||
|
||||
__all__ = [
|
||||
"InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName",
|
||||
"Marker", "default_environment",
|
||||
]
|
||||
|
||||
|
||||
class InvalidMarker(ValueError):
|
||||
"""
|
||||
An invalid marker was found, users should refer to PEP 508.
|
||||
"""
|
||||
|
||||
|
||||
class UndefinedComparison(ValueError):
|
||||
"""
|
||||
An invalid operation was attempted on a value that doesn't support it.
|
||||
"""
|
||||
|
||||
|
||||
class UndefinedEnvironmentName(ValueError):
|
||||
"""
|
||||
A name was attempted to be used that does not exist inside of the
|
||||
environment.
|
||||
"""
|
||||
|
||||
|
||||
class Node(object):
|
||||
|
||||
def __init__(self, value):
|
||||
self.value = value
|
||||
|
||||
def __str__(self):
|
||||
return str(self.value)
|
||||
|
||||
def __repr__(self):
|
||||
return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
|
||||
|
||||
|
||||
class Variable(Node):
|
||||
pass
|
||||
|
||||
|
||||
class Value(Node):
|
||||
pass
|
||||
|
||||
|
||||
VARIABLE = (
|
||||
L("implementation_version") |
|
||||
L("platform_python_implementation") |
|
||||
L("implementation_name") |
|
||||
L("python_full_version") |
|
||||
L("platform_release") |
|
||||
L("platform_version") |
|
||||
L("platform_machine") |
|
||||
L("platform_system") |
|
||||
L("python_version") |
|
||||
L("sys_platform") |
|
||||
L("os_name") |
|
||||
L("extra")
|
||||
)
|
||||
VARIABLE.setParseAction(lambda s, l, t: Variable(t[0]))
|
||||
|
||||
VERSION_CMP = (
|
||||
L("===") |
|
||||
L("==") |
|
||||
L(">=") |
|
||||
L("<=") |
|
||||
L("!=") |
|
||||
L("~=") |
|
||||
L(">") |
|
||||
L("<")
|
||||
)
|
||||
|
||||
MARKER_OP = VERSION_CMP | L("not in") | L("in")
|
||||
|
||||
MARKER_VALUE = QuotedString("'") | QuotedString('"')
|
||||
MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
|
||||
|
||||
BOOLOP = L("and") | L("or")
|
||||
|
||||
MARKER_VAR = VARIABLE | MARKER_VALUE
|
||||
|
||||
MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
|
||||
MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
|
||||
|
||||
LPAREN = L("(").suppress()
|
||||
RPAREN = L(")").suppress()
|
||||
|
||||
MARKER_EXPR = Forward()
|
||||
MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
|
||||
MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
|
||||
|
||||
MARKER = stringStart + MARKER_EXPR + stringEnd
|
||||
|
||||
|
||||
def _coerce_parse_result(results):
|
||||
if isinstance(results, ParseResults):
|
||||
return [_coerce_parse_result(i) for i in results]
|
||||
else:
|
||||
return results
|
||||
|
||||
|
||||
def _format_marker(marker, first=True):
|
||||
assert isinstance(marker, (list, tuple, string_types))
|
||||
|
||||
# Sometimes we have a structure like [[...]] which is a single item list
|
||||
# where the single item is itself it's own list. In that case we want skip
|
||||
# the rest of this function so that we don't get extraneous () on the
|
||||
# outside.
|
||||
if (isinstance(marker, list) and len(marker) == 1 and
|
||||
isinstance(marker[0], (list, tuple))):
|
||||
return _format_marker(marker[0])
|
||||
|
||||
if isinstance(marker, list):
|
||||
inner = (_format_marker(m, first=False) for m in marker)
|
||||
if first:
|
||||
return " ".join(inner)
|
||||
else:
|
||||
return "(" + " ".join(inner) + ")"
|
||||
elif isinstance(marker, tuple):
|
||||
return '{0} {1} "{2}"'.format(*marker)
|
||||
else:
|
||||
return marker
|
||||
|
||||
|
||||
_operators = {
|
||||
"in": lambda lhs, rhs: lhs in rhs,
|
||||
"not in": lambda lhs, rhs: lhs not in rhs,
|
||||
"<": operator.lt,
|
||||
"<=": operator.le,
|
||||
"==": operator.eq,
|
||||
"!=": operator.ne,
|
||||
">=": operator.ge,
|
||||
">": operator.gt,
|
||||
}
|
||||
|
||||
|
||||
def _eval_op(lhs, op, rhs):
|
||||
try:
|
||||
spec = Specifier("".join([op, rhs]))
|
||||
except InvalidSpecifier:
|
||||
pass
|
||||
else:
|
||||
return spec.contains(lhs)
|
||||
|
||||
oper = _operators.get(op)
|
||||
if oper is None:
|
||||
raise UndefinedComparison(
|
||||
"Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
|
||||
)
|
||||
|
||||
return oper(lhs, rhs)
|
||||
|
||||
|
||||
_undefined = object()
|
||||
|
||||
|
||||
def _get_env(environment, name):
|
||||
value = environment.get(name, _undefined)
|
||||
|
||||
if value is _undefined:
|
||||
raise UndefinedEnvironmentName(
|
||||
"{0!r} does not exist in evaluation environment.".format(name)
|
||||
)
|
||||
|
||||
return value
|
||||
|
||||
|
||||
def _evaluate_markers(markers, environment):
|
||||
groups = [[]]
|
||||
|
||||
for marker in markers:
|
||||
assert isinstance(marker, (list, tuple, string_types))
|
||||
|
||||
if isinstance(marker, list):
|
||||
groups[-1].append(_evaluate_markers(marker, environment))
|
||||
elif isinstance(marker, tuple):
|
||||
lhs, op, rhs = marker
|
||||
|
||||
if isinstance(lhs, Variable):
|
||||
lhs_value = _get_env(environment, lhs.value)
|
||||
rhs_value = rhs.value
|
||||
else:
|
||||
lhs_value = lhs.value
|
||||
rhs_value = _get_env(environment, rhs.value)
|
||||
|
||||
groups[-1].append(_eval_op(lhs_value, op, rhs_value))
|
||||
else:
|
||||
assert marker in ["and", "or"]
|
||||
if marker == "or":
|
||||
groups.append([])
|
||||
|
||||
return any(all(item) for item in groups)
|
||||
|
||||
|
||||
def format_full_version(info):
|
||||
version = '{0.major}.{0.minor}.{0.micro}'.format(info)
|
||||
kind = info.releaselevel
|
||||
if kind != 'final':
|
||||
version += kind[0] + str(info.serial)
|
||||
return version
|
||||
|
||||
|
||||
def default_environment():
|
||||
if hasattr(sys, 'implementation'):
|
||||
iver = format_full_version(sys.implementation.version)
|
||||
implementation_name = sys.implementation.name
|
||||
else:
|
||||
iver = '0'
|
||||
implementation_name = ''
|
||||
|
||||
return {
|
||||
"implementation_name": implementation_name,
|
||||
"implementation_version": iver,
|
||||
"os_name": os.name,
|
||||
"platform_machine": platform.machine(),
|
||||
"platform_release": platform.release(),
|
||||
"platform_system": platform.system(),
|
||||
"platform_version": platform.version(),
|
||||
"python_full_version": platform.python_version(),
|
||||
"platform_python_implementation": platform.python_implementation(),
|
||||
"python_version": platform.python_version()[:3],
|
||||
"sys_platform": sys.platform,
|
||||
}
|
||||
|
||||
|
||||
class Marker(object):
|
||||
|
||||
def __init__(self, marker):
|
||||
try:
|
||||
self._markers = _coerce_parse_result(MARKER.parseString(marker))
|
||||
except ParseException as e:
|
||||
err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
|
||||
marker, marker[e.loc:e.loc + 8])
|
||||
raise InvalidMarker(err_str)
|
||||
|
||||
def __str__(self):
|
||||
return _format_marker(self._markers)
|
||||
|
||||
def __repr__(self):
|
||||
return "<Marker({0!r})>".format(str(self))
|
||||
|
||||
def evaluate(self, environment=None):
|
||||
"""Evaluate a marker.
|
||||
|
||||
Return the boolean from evaluating the given marker against the
|
||||
environment. environment is an optional argument to override all or
|
||||
part of the determined environment.
|
||||
|
||||
The environment is determined from the current Python process.
|
||||
"""
|
||||
current_environment = default_environment()
|
||||
if environment is not None:
|
||||
current_environment.update(environment)
|
||||
|
||||
return _evaluate_markers(self._markers, current_environment)
|
||||
|
|
@ -0,0 +1,127 @@
|
|||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
import string
|
||||
import re
|
||||
|
||||
from pkg_resources.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException
|
||||
from pkg_resources.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
|
||||
from pkg_resources.extern.pyparsing import Literal as L # noqa
|
||||
from pkg_resources.extern.six.moves.urllib import parse as urlparse
|
||||
|
||||
from .markers import MARKER_EXPR, Marker
|
||||
from .specifiers import LegacySpecifier, Specifier, SpecifierSet
|
||||
|
||||
|
||||
class InvalidRequirement(ValueError):
|
||||
"""
|
||||
An invalid requirement was found, users should refer to PEP 508.
|
||||
"""
|
||||
|
||||
|
||||
ALPHANUM = Word(string.ascii_letters + string.digits)
|
||||
|
||||
LBRACKET = L("[").suppress()
|
||||
RBRACKET = L("]").suppress()
|
||||
LPAREN = L("(").suppress()
|
||||
RPAREN = L(")").suppress()
|
||||
COMMA = L(",").suppress()
|
||||
SEMICOLON = L(";").suppress()
|
||||
AT = L("@").suppress()
|
||||
|
||||
PUNCTUATION = Word("-_.")
|
||||
IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
|
||||
IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
|
||||
|
||||
NAME = IDENTIFIER("name")
|
||||
EXTRA = IDENTIFIER
|
||||
|
||||
URI = Regex(r'[^ ]+')("url")
|
||||
URL = (AT + URI)
|
||||
|
||||
EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
|
||||
EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
|
||||
|
||||
VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
|
||||
VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
|
||||
|
||||
VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
|
||||
VERSION_MANY = Combine(VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE),
|
||||
joinString=",", adjacent=False)("_raw_spec")
|
||||
_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
|
||||
_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or '')
|
||||
|
||||
VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
|
||||
VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
|
||||
|
||||
MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
|
||||
MARKER_EXPR.setParseAction(
|
||||
lambda s, l, t: Marker(s[t._original_start:t._original_end])
|
||||
)
|
||||
MARKER_SEPERATOR = SEMICOLON
|
||||
MARKER = MARKER_SEPERATOR + MARKER_EXPR
|
||||
|
||||
VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
|
||||
URL_AND_MARKER = URL + Optional(MARKER)
|
||||
|
||||
NAMED_REQUIREMENT = \
|
||||
NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
|
||||
|
||||
REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
|
||||
|
||||
|
||||
class Requirement(object):
|
||||
"""Parse a requirement.
|
||||
|
||||
Parse a given requirement string into its parts, such as name, specifier,
|
||||
URL, and extras. Raises InvalidRequirement on a badly-formed requirement
|
||||
string.
|
||||
"""
|
||||
|
||||
# TODO: Can we test whether something is contained within a requirement?
|
||||
# If so how do we do that? Do we need to test against the _name_ of
|
||||
# the thing as well as the version? What about the markers?
|
||||
# TODO: Can we normalize the name and extra name?
|
||||
|
||||
def __init__(self, requirement_string):
|
||||
try:
|
||||
req = REQUIREMENT.parseString(requirement_string)
|
||||
except ParseException as e:
|
||||
raise InvalidRequirement(
|
||||
"Invalid requirement, parse error at \"{0!r}\"".format(
|
||||
requirement_string[e.loc:e.loc + 8]))
|
||||
|
||||
self.name = req.name
|
||||
if req.url:
|
||||
parsed_url = urlparse.urlparse(req.url)
|
||||
if not (parsed_url.scheme and parsed_url.netloc) or (
|
||||
not parsed_url.scheme and not parsed_url.netloc):
|
||||
raise InvalidRequirement("Invalid URL given")
|
||||
self.url = req.url
|
||||
else:
|
||||
self.url = None
|
||||
self.extras = set(req.extras.asList() if req.extras else [])
|
||||
self.specifier = SpecifierSet(req.specifier)
|
||||
self.marker = req.marker if req.marker else None
|
||||
|
||||
def __str__(self):
|
||||
parts = [self.name]
|
||||
|
||||
if self.extras:
|
||||
parts.append("[{0}]".format(",".join(sorted(self.extras))))
|
||||
|
||||
if self.specifier:
|
||||
parts.append(str(self.specifier))
|
||||
|
||||
if self.url:
|
||||
parts.append("@ {0}".format(self.url))
|
||||
|
||||
if self.marker:
|
||||
parts.append("; {0}".format(self.marker))
|
||||
|
||||
return "".join(parts)
|
||||
|
||||
def __repr__(self):
|
||||
return "<Requirement({0!r})>".format(str(self))
|
||||
|
|
@ -1,16 +1,6 @@
|
|||
# Copyright 2014 Donald Stufft
|
||||
#
|
||||
# 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.
|
||||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
import abc
|
||||
|
|
@ -204,8 +194,8 @@ class _IndividualSpecifier(BaseSpecifier):
|
|||
# If our version is a prerelease, and we were not set to allow
|
||||
# prereleases, then we'll store it for later incase nothing
|
||||
# else matches this specifier.
|
||||
if (parsed_version.is_prerelease
|
||||
and not (prereleases or self.prereleases)):
|
||||
if (parsed_version.is_prerelease and not
|
||||
(prereleases or self.prereleases)):
|
||||
found_prereleases.append(version)
|
||||
# Either this is not a prerelease, or we should have been
|
||||
# accepting prereleases from the begining.
|
||||
|
|
@ -223,23 +213,23 @@ class _IndividualSpecifier(BaseSpecifier):
|
|||
|
||||
class LegacySpecifier(_IndividualSpecifier):
|
||||
|
||||
_regex = re.compile(
|
||||
_regex_str = (
|
||||
r"""
|
||||
^
|
||||
\s*
|
||||
(?P<operator>(==|!=|<=|>=|<|>))
|
||||
\s*
|
||||
(?P<version>
|
||||
[^\s]* # We just match everything, except for whitespace since this
|
||||
# is a "legacy" specifier and the version string can be just
|
||||
# about anything.
|
||||
[^,;\s)]* # Since this is a "legacy" specifier, and the version
|
||||
# string can be just about anything, we match everything
|
||||
# except for whitespace, a semi-colon for marker support,
|
||||
# a closing paren since versions can be enclosed in
|
||||
# them, and a comma since it's a version separator.
|
||||
)
|
||||
\s*
|
||||
$
|
||||
""",
|
||||
re.VERBOSE | re.IGNORECASE,
|
||||
"""
|
||||
)
|
||||
|
||||
_regex = re.compile(
|
||||
r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
|
||||
|
||||
_operators = {
|
||||
"==": "equal",
|
||||
"!=": "not_equal",
|
||||
|
|
@ -284,10 +274,8 @@ def _require_version_compare(fn):
|
|||
|
||||
class Specifier(_IndividualSpecifier):
|
||||
|
||||
_regex = re.compile(
|
||||
_regex_str = (
|
||||
r"""
|
||||
^
|
||||
\s*
|
||||
(?P<operator>(~=|==|!=|<=|>=|<|>|===))
|
||||
(?P<version>
|
||||
(?:
|
||||
|
|
@ -378,12 +366,12 @@ class Specifier(_IndividualSpecifier):
|
|||
(?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release
|
||||
)
|
||||
)
|
||||
\s*
|
||||
$
|
||||
""",
|
||||
re.VERBOSE | re.IGNORECASE,
|
||||
"""
|
||||
)
|
||||
|
||||
_regex = re.compile(
|
||||
r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
|
||||
|
||||
_operators = {
|
||||
"~=": "compatible",
|
||||
"==": "equal",
|
||||
|
|
@ -409,8 +397,8 @@ class Specifier(_IndividualSpecifier):
|
|||
prefix = ".".join(
|
||||
list(
|
||||
itertools.takewhile(
|
||||
lambda x: (not x.startswith("post")
|
||||
and not x.startswith("dev")),
|
||||
lambda x: (not x.startswith("post") and not
|
||||
x.startswith("dev")),
|
||||
_version_split(spec),
|
||||
)
|
||||
)[:-1]
|
||||
|
|
@ -419,13 +407,15 @@ class Specifier(_IndividualSpecifier):
|
|||
# Add the prefix notation to the end of our string
|
||||
prefix += ".*"
|
||||
|
||||
return (self._get_operator(">=")(prospective, spec)
|
||||
and self._get_operator("==")(prospective, prefix))
|
||||
return (self._get_operator(">=")(prospective, spec) and
|
||||
self._get_operator("==")(prospective, prefix))
|
||||
|
||||
@_require_version_compare
|
||||
def _compare_equal(self, prospective, spec):
|
||||
# We need special logic to handle prefix matching
|
||||
if spec.endswith(".*"):
|
||||
# In the case of prefix matching we want to ignore local segment.
|
||||
prospective = Version(prospective.public)
|
||||
# Split the spec out by dots, and pretend that there is an implicit
|
||||
# dot in between a release segment and a pre-release segment.
|
||||
spec = _version_split(spec[:-2]) # Remove the trailing .*
|
||||
|
|
@ -577,8 +567,8 @@ def _pad_version(left, right):
|
|||
right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
|
||||
|
||||
# Get the rest of our versions
|
||||
left_split.append(left[len(left_split):])
|
||||
right_split.append(left[len(right_split):])
|
||||
left_split.append(left[len(left_split[0]):])
|
||||
right_split.append(right[len(right_split[0]):])
|
||||
|
||||
# Insert our padding
|
||||
left_split.insert(
|
||||
|
|
|
|||
|
|
@ -0,0 +1,14 @@
|
|||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
import re
|
||||
|
||||
|
||||
_canonicalize_regex = re.compile(r"[-_.]+")
|
||||
|
||||
|
||||
def canonicalize_name(name):
|
||||
# This is taken from PEP 503.
|
||||
return _canonicalize_regex.sub("-", name).lower()
|
||||
|
|
@ -1,16 +1,6 @@
|
|||
# Copyright 2014 Donald Stufft
|
||||
#
|
||||
# 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.
|
||||
# This file is dual licensed under the terms of the Apache License, Version
|
||||
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
||||
# for complete details.
|
||||
from __future__ import absolute_import, division, print_function
|
||||
|
||||
import collections
|
||||
|
|
|
|||
3805
lib/python3.4/site-packages/pkg_resources/_vendor/pyparsing.py
Normal file
3805
lib/python3.4/site-packages/pkg_resources/_vendor/pyparsing.py
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -67,5 +67,5 @@ class VendorImporter:
|
|||
if self not in sys.meta_path:
|
||||
sys.meta_path.append(self)
|
||||
|
||||
names = 'packaging', 'six'
|
||||
names = 'packaging', 'pyparsing', 'six'
|
||||
VendorImporter(__name__, names).install()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue