FM / distlib

/usr/lib/python2.7/site-packages/pip/_vendor/distlib/

/usr/lib/python2.7/site-packages/pip/_vendor/distlib

Name	Size	Mode	Actions
_backport/	-	0755	rm
compat.py	40801	0644	edit dl rm
compat.pyc	39710	0644	edit dl rm
compat.pyo	39655	0644	edit dl rm
database.py	49672	0644	edit dl rm
database.pyc	49350	0644	edit dl rm
database.pyo	49350	0644	edit dl rm
index.py	21085	0644	edit dl rm
index.pyc	20060	0644	edit dl rm
index.pyo	20060	0644	edit dl rm
locators.py	51013	0644	edit dl rm
locators.pyc	45978	0644	edit dl rm
locators.pyo	45926	0644	edit dl rm
manifest.py	14810	0644	edit dl rm
manifest.pyc	12154	0644	edit dl rm
manifest.pyo	11992	0644	edit dl rm
markers.py	6282	0644	edit dl rm
markers.pyc	8175	0644	edit dl rm
markers.pyo	8047	0644	edit dl rm
metadata.py	38833	0644	edit dl rm
metadata.pyc	35146	0644	edit dl rm
metadata.pyo	35058	0644	edit dl rm
resources.py	10766	0644	edit dl rm
resources.pyc	13969	0644	edit dl rm
resources.pyo	13969	0644	edit dl rm
scripts.py	15224	0644	edit dl rm
scripts.pyc	12464	0644	edit dl rm
scripts.pyo	12464	0644	edit dl rm
util.py	52991	0644	edit dl rm
util.pyc	56868	0644	edit dl rm
util.pyo	56370	0644	edit dl rm
version.py	23711	0644	edit dl rm
version.pyc	26396	0644	edit dl rm
version.pyo	26310	0644	edit dl rm
wheel.py	39115	0644	edit dl rm
wheel.pyc	31157	0644	edit dl rm
wheel.pyo	31075	0644	edit dl rm
__init__.py	581	0644	edit dl rm
__init__.pyc	1341	0644	edit dl rm
__init__.pyo	1341	0644	edit dl rm

Edit: /usr/lib/python2.7/site-packages/pip/_vendor/distlib/markers.py (6282B)

# -*- coding: utf-8 -*-
#
# Copyright (C) 2012-2013 Vinay Sajip.
# Licensed to the Python Software Foundation under a contributor agreement.
# See LICENSE.txt and CONTRIBUTORS.txt.
#
"""Parser for the environment markers micro-language defined in PEP 345."""

import ast
import os
import sys
import platform

from .compat import python_implementation, string_types
from .util import in_venv

__all__ = ['interpret']

class Evaluator(object):
    """
    A limited evaluator for Python expressions.
    """

operators = {
        'eq': lambda x, y: x == y,
        'gt': lambda x, y: x > y,
        'gte': lambda x, y: x >= y,
        'in': lambda x, y: x in y,
        'lt': lambda x, y: x < y,
        'lte': lambda x, y: x <= y,
        'not': lambda x: not x,
        'noteq': lambda x, y: x != y,
        'notin': lambda x, y: x not in y,
    }

allowed_values = {
        'sys_platform': sys.platform,
        'python_version': '%s.%s' % sys.version_info[:2],
        # parsing sys.platform is not reliable, but there is no other
        # way to get e.g. 2.7.2+, and the PEP is defined with sys.version
        'python_full_version': sys.version.split(' ', 1)[0],
        'os_name': os.name,
        'platform_in_venv': str(in_venv()),
        'platform_release': platform.release(),
        'platform_version': platform.version(),
        'platform_machine': platform.machine(),
        'platform_python_implementation': python_implementation(),
    }

def __init__(self, context=None):
        """
        Initialise an instance.

:param context: If specified, names are looked up in this mapping.
        """
        self.context = context or {}
        self.source = None

def get_fragment(self, offset):
        """
        Get the part of the source which is causing a problem.
        """
        fragment_len = 10
        s = '%r' % (self.source[offset:offset + fragment_len])
        if offset + fragment_len < len(self.source):
            s += '...'
        return s

def get_handler(self, node_type):
        """
        Get a handler for the specified AST node type.
        """
        return getattr(self, 'do_%s' % node_type, None)

def evaluate(self, node, filename=None):
        """
        Evaluate a source string or node, using ``filename`` when
        displaying errors.
        """
        if isinstance(node, string_types):
            self.source = node
            kwargs = {'mode': 'eval'}
            if filename:
                kwargs['filename'] = filename
            try:
                node = ast.parse(node, **kwargs)
            except SyntaxError as e:
                s = self.get_fragment(e.offset)
                raise SyntaxError('syntax error %s' % s)
        node_type = node.__class__.__name__.lower()
        handler = self.get_handler(node_type)
        if handler is None:
            if self.source is None:
                s = '(source not available)'
            else:
                s = self.get_fragment(node.col_offset)
            raise SyntaxError("don't know how to evaluate %r %s" % (
                node_type, s))
        return handler(node)

def get_attr_key(self, node):
        assert isinstance(node, ast.Attribute), 'attribute node expected'
        return '%s.%s' % (node.value.id, node.attr)

def do_attribute(self, node):
        if not isinstance(node.value, ast.Name):
            valid = False
        else:
            key = self.get_attr_key(node)
            valid = key in self.context or key in self.allowed_values
        if not valid:
            raise SyntaxError('invalid expression: %s' % key)
        if key in self.context:
            result = self.context[key]
        else:
            result = self.allowed_values[key]
        return result

def do_boolop(self, node):
        result = self.evaluate(node.values[0])
        is_or = node.op.__class__ is ast.Or
        is_and = node.op.__class__ is ast.And
        assert is_or or is_and
        if (is_and and result) or (is_or and not result):
            for n in node.values[1:]:
                result = self.evaluate(n)
                if (is_or and result) or (is_and and not result):
                    break
        return result

def do_compare(self, node):
        def sanity_check(lhsnode, rhsnode):
            valid = True
            if isinstance(lhsnode, ast.Str) and isinstance(rhsnode, ast.Str):
                valid = False
            #elif (isinstance(lhsnode, ast.Attribute)
            #      and isinstance(rhsnode, ast.Attribute)):
            #    klhs = self.get_attr_key(lhsnode)
            #    krhs = self.get_attr_key(rhsnode)
            #    valid = klhs != krhs
            if not valid:
                s = self.get_fragment(node.col_offset)
                raise SyntaxError('Invalid comparison: %s' % s)

lhsnode = node.left
        lhs = self.evaluate(lhsnode)
        result = True
        for op, rhsnode in zip(node.ops, node.comparators):
            sanity_check(lhsnode, rhsnode)
            op = op.__class__.__name__.lower()
            if op not in self.operators:
                raise SyntaxError('unsupported operation: %r' % op)
            rhs = self.evaluate(rhsnode)
            result = self.operators[op](lhs, rhs)
            if not result:
                break
            lhs = rhs
            lhsnode = rhsnode
        return result

def do_expression(self, node):
        return self.evaluate(node.body)

def do_name(self, node):
        valid = False
        if node.id in self.context:
            valid = True
            result = self.context[node.id]
        elif node.id in self.allowed_values:
            valid = True
            result = self.allowed_values[node.id]
        if not valid:
            raise SyntaxError('invalid expression: %s' % node.id)
        return result

def do_str(self, node):
        return node.s

def interpret(marker, execution_context=None):
    """
    Interpret a marker and return a result depending on environment.

:param marker: The marker to interpret.
    :type marker: str
    :param execution_context: The context used for name lookup.
    :type execution_context: mapping
    """
    return Evaluator(execution_context).evaluate(marker.strip())

cmd: