FM / mako

/opt/alt/python27/lib/python2.7/site-packages/mako/

/opt/alt/python27/lib/python2.7/site-packages/mako

Name	Size	Mode	Actions
ext/	-	0755	rm
ast.py	5659	0644	edit dl rm
ast.pyc	5335	0644	edit dl rm
ast.pyo	5407	0644	edit dl rm
cache.py	7735	0644	edit dl rm
cache.pyc	8231	0644	edit dl rm
cache.pyo	8243	0644	edit dl rm
codegen.py	48874	0644	edit dl rm
codegen.pyc	37343	0644	edit dl rm
codegen.pyo	37815	0644	edit dl rm
exceptions.py	12210	0644	edit dl rm
exceptions.pyc	13224	0644	edit dl rm
exceptions.pyo	13298	0644	edit dl rm
filters.py	5787	0644	edit dl rm
filters.pyc	7374	0644	edit dl rm
filters.pyo	7410	0644	edit dl rm
lexer.py	16772	0644	edit dl rm
lexer.pyc	12650	0644	edit dl rm
lexer.pyo	12806	0644	edit dl rm
lookup.py	12880	0644	edit dl rm
lookup.pyc	11548	0644	edit dl rm
lookup.pyo	11548	0644	edit dl rm
parsetree.py	20391	0644	edit dl rm
parsetree.pyc	24245	0644	edit dl rm
parsetree.pyo	24494	0644	edit dl rm
pygen.py	9485	0644	edit dl rm
pygen.pyc	7391	0644	edit dl rm
pygen.pyo	7462	0644	edit dl rm
pyparser.py	18596	0644	edit dl rm
pyparser.pyc	23093	0644	edit dl rm
pyparser.pyo	23265	0644	edit dl rm
runtime.py	26734	0644	edit dl rm
runtime.pyc	32479	0644	edit dl rm
runtime.pyo	32695	0644	edit dl rm
template.py	24864	0644	edit dl rm
template.pyc	21767	0644	edit dl rm
template.pyo	21840	0644	edit dl rm
util.py	12880	0644	edit dl rm
util.pyc	16957	0644	edit dl rm
util.pyo	17066	0644	edit dl rm
_ast_util.py	25615	0644	edit dl rm
_ast_util.pyc	33648	0644	edit dl rm
_ast_util.pyo	33892	0644	edit dl rm
__init__.py	247	0644	edit dl rm
__init__.pyc	181	0644	edit dl rm
__init__.pyo	181	0644	edit dl rm

Edit: /opt/alt/python27/lib/python2.7/site-packages/mako/ast.py (5659B)

# mako/ast.py
# Copyright (C) 2006-2012 the Mako authors and contributors <see AUTHORS file>
#
# This module is part of Mako and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php

"""utilities for analyzing expressions and blocks of Python
code, as well as generating Python from AST nodes"""

from mako import exceptions, pyparser, util
import re

class PythonCode(object):
    """represents information about a string containing Python code"""
    def __init__(self, code, **exception_kwargs):
        self.code = code

# represents all identifiers which are assigned to at some point in
        # the code
        self.declared_identifiers = set()

# represents all identifiers which are referenced before their
        # assignment, if any
        self.undeclared_identifiers = set()

# note that an identifier can be in both the undeclared and declared
        # lists.

# using AST to parse instead of using code.co_varnames,
        # code.co_names has several advantages:
        # - we can locate an identifier as "undeclared" even if
        # its declared later in the same block of code
        # - AST is less likely to break with version changes
        # (for example, the behavior of co_names changed a little bit
        # in python version 2.5)
        if isinstance(code, basestring):
            expr = pyparser.parse(code.lstrip(), "exec", **exception_kwargs)
        else:
            expr = code

f = pyparser.FindIdentifiers(self, **exception_kwargs)
        f.visit(expr)

class ArgumentList(object):
    """parses a fragment of code as a comma-separated list of expressions"""
    def __init__(self, code, **exception_kwargs):
        self.codeargs = []
        self.args = []
        self.declared_identifiers = set()
        self.undeclared_identifiers = set()
        if isinstance(code, basestring):
            if re.match(r"\S", code) and not re.match(r",\s*$", code):
                # if theres text and no trailing comma, insure its parsed
                # as a tuple by adding a trailing comma
                code  += ","
            expr = pyparser.parse(code, "exec", **exception_kwargs)
        else:
            expr = code

f = pyparser.FindTuple(self, PythonCode, **exception_kwargs)
        f.visit(expr)

class PythonFragment(PythonCode):
    """extends PythonCode to provide identifier lookups in partial control
    statements

e.g.
        for x in 5:
        elif y==9:
        except (MyException, e):
    etc.
    """
    def __init__(self, code, **exception_kwargs):
        m = re.match(r'^(\w+)(?:\s+(.*?))?:\s*(#|$)', code.strip(), re.S)
        if not m:
            raise exceptions.CompileException(
                          "Fragment '%s' is not a partial control statement" %
                          code, **exception_kwargs)
        if m.group(3):
            code = code[:m.start(3)]
        (keyword, expr) = m.group(1,2)
        if keyword in ['for','if', 'while']:
            code = code + "pass"
        elif keyword == 'try':
            code = code + "pass\nexcept:pass"
        elif keyword == 'elif' or keyword == 'else':
            code = "if False:pass\n" + code + "pass"
        elif keyword == 'except':
            code = "try:pass\n" + code + "pass"
        elif keyword == 'with':
            code = code + "pass"
        else:
            raise exceptions.CompileException(
                                "Unsupported control keyword: '%s'" %
                                keyword, **exception_kwargs)
        super(PythonFragment, self).__init__(code, **exception_kwargs)

class FunctionDecl(object):
    """function declaration"""
    def __init__(self, code, allow_kwargs=True, **exception_kwargs):
        self.code = code
        expr = pyparser.parse(code, "exec", **exception_kwargs)

f = pyparser.ParseFunc(self, **exception_kwargs)
        f.visit(expr)
        if not hasattr(self, 'funcname'):
            raise exceptions.CompileException(
                              "Code '%s' is not a function declaration" % code,
                              **exception_kwargs)
        if not allow_kwargs and self.kwargs:
            raise exceptions.CompileException(
                                "'**%s' keyword argument not allowed here" %
                                self.argnames[-1], **exception_kwargs)

def get_argument_expressions(self, include_defaults=True):
        """return the argument declarations of this FunctionDecl as a printable
        list."""

namedecls = []
        defaults = [d for d in self.defaults]
        kwargs = self.kwargs
        varargs = self.varargs
        argnames = [f for f in self.argnames]
        argnames.reverse()
        for arg in argnames:
            default = None
            if kwargs:
                arg = "**" + arg
                kwargs = False
            elif varargs:
                arg = "*" + arg
                varargs = False
            else:
                default = len(defaults) and defaults.pop() or None
            if include_defaults and default:
                namedecls.insert(0, "%s=%s" %
                            (arg,
                            pyparser.ExpressionGenerator(default).value()
                            )
                        )
            else:
                namedecls.insert(0, arg)
        return namedecls

class FunctionArgs(FunctionDecl):
    """the argument portion of a function declaration"""

def __init__(self, code, **kwargs):
        super(FunctionArgs, self).__init__("def ANON(%s):pass" % code,
                **kwargs)

cmd: