Chip 2011 November/CHIP_2011_11.iso/Programy/Narzedzia/Calibre/calibre-0.8.18.msi/file_262/ast.pyo

Python Compiled Bytecode | 2011-09-09 | 6.7 KB | 203 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.7)

from _ast import *
from _ast import __version__

def parse(expr, filename = '<unknown>', mode = 'exec'):
    return compile(expr, filename, mode, PyCF_ONLY_AST)


def literal_eval(node_or_string):
    _safe_names = {
        'None': None,
        'True': True,
        'False': False }
    if isinstance(node_or_string, basestring):
        node_or_string = parse(node_or_string, mode = 'eval')
    if isinstance(node_or_string, Expression):
        node_or_string = node_or_string.body

    def _convert(node):
        if isinstance(node, Str):
            return node.s
        if None(node, Num):
            return node.n
        if None(node, Tuple):
            return tuple(map(_convert, node.elts))
        if None(node, List):
            return list(map(_convert, node.elts))
        if None(node, Dict):
            return (dict,)((lambda .0: pass)(zip(node.keys, node.values)))
        if None(node, Name) or node.id in _safe_names:
            return _safe_names[node.id]
        if isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)) and isinstance(node.right, Num) and isinstance(node.right.n, complex) and isinstance(node.left, Num) and isinstance(node.left.n, (int, long, float)):
            left = node.left.n
            right = node.right.n
            if isinstance(node.op, Add):
                return left + right
            return None - right
        raise ValueError('malformed string')

    return _convert(node_or_string)


def dump(node, annotate_fields = True, include_attributes = False):

    def _format(node):
        if isinstance(node, AST):
            fields = [ (a, _format(b)) for a, b in iter_fields(node) ]
            rv = '%s(%s' % (node.__class__.__name__, ', '.join((lambda .0: pass)(fields) if annotate_fields else (lambda .0: pass)(fields)))
            if include_attributes and node._attributes:
                if not fields or ', ':
                    pass
                rv += ' '
                None += (rv, ', '.join)((lambda .0: pass)(node._attributes))
            return rv + ')'
        if None(node, list):
            return '[%s]' % (', '.join,)((lambda .0: pass)(node))
        return None(node)

    if not isinstance(node, AST):
        raise TypeError('expected AST, got %r' % node.__class__.__name__)
    return _format(node)


def copy_location(new_node, old_node):
    for attr in ('lineno', 'col_offset'):
        if attr in old_node._attributes and attr in new_node._attributes and hasattr(old_node, attr):
            setattr(new_node, attr, getattr(old_node, attr))
            continue
    return new_node


def fix_missing_locations(node):

    def _fix(node, lineno, col_offset):
        if 'lineno' in node._attributes:
            if not hasattr(node, 'lineno'):
                node.lineno = lineno
            else:
                lineno = node.lineno
        if 'col_offset' in node._attributes:
            if not hasattr(node, 'col_offset'):
                node.col_offset = col_offset
            else:
                col_offset = node.col_offset
        for child in iter_child_nodes(node):
            _fix(child, lineno, col_offset)


    _fix(node, 1, 0)
    return node


def increment_lineno(node, n = 1):
    if 'lineno' in node._attributes:
        node.lineno = getattr(node, 'lineno', 0) + n
    for child in walk(node):
        if 'lineno' in child._attributes:
            child.lineno = getattr(child, 'lineno', 0) + n
            continue
    return node


def iter_fields(node):
    for field in node._fields:

        try:
            yield (field, getattr(node, field))
        continue
        except AttributeError:
            continue





def iter_child_nodes(node):
    for name, field in iter_fields(node):
        if isinstance(field, AST):
            yield field
            continue
        if isinstance(field, list):
            for item in field:
                if isinstance(item, AST):
                    yield item
                    continue
            return None


def get_docstring(node, clean = True):
    if not isinstance(node, (FunctionDef, ClassDef, Module)):
        raise TypeError("%r can't have docstrings" % node.__class__.__name__)
    if node.body and isinstance(node.body[0], Expr) and isinstance(node.body[0].value, Str):
        if clean:
            import inspect
            return inspect.cleandoc(node.body[0].value.s)
        return None.body[0].value.s


def walk(node):
    deque = deque
    import collections
    todo = deque([
        node])
    while todo:
        node = todo.popleft()
        todo.extend(iter_child_nodes(node))
        yield node


class NodeVisitor(object):

    def visit(self, node):
        method = 'visit_' + node.__class__.__name__
        visitor = getattr(self, method, self.generic_visit)
        return visitor(node)


    def generic_visit(self, node):
        for field, value in iter_fields(node):
            if isinstance(value, list):
                for item in value:
                    if isinstance(item, AST):
                        self.visit(item)
                        continue
                    if isinstance(value, AST):
                        self.visit(value)
                        continue
                    return None



class NodeTransformer(NodeVisitor):

    def generic_visit(self, node):
        for field, old_value in iter_fields(node):
            old_value = getattr(node, field, None)
            if isinstance(old_value, list):
                new_values = []
                for value in old_value:
                    if isinstance(value, AST):
                        value = self.visit(value)
                        if value is None:
                            continue
                        elif not isinstance(value, AST):
                            new_values.extend(value)
                            continue

                    new_values.append(value)

                old_value[:] = new_values
                continue
            if isinstance(old_value, AST):
                new_node = self.visit(old_value)
                if new_node is None:
                    delattr(node, field)
                else:
                    setattr(node, field, new_node)
        return node