File Manager

X7ROOT File Manager

Current Path: /usr/lib64/python2.7/site-packages/coverage

usr / lib64 / python2.7 / site-packages / coverage /

📁 ..
📄 __init__.py(4.4 KB)
📄 __init__.pyc(2.29 KB)
📄 __init__.pyo(2.29 KB)
📄 __main__.py(100 B)
📄 __main__.pyc(308 B)
📄 __main__.pyo(308 B)
📄 annotate.py(2.92 KB)
📄 annotate.pyc(3.1 KB)
📄 annotate.pyo(3.1 KB)
📄 backward.py(3.97 KB)
📄 backward.pyc(4.3 KB)
📄 backward.pyo(4.3 KB)
📄 bytecode.py(2.27 KB)
📄 bytecode.pyc(3.29 KB)
📄 bytecode.pyo(3.29 KB)
📄 cmdline.py(24.16 KB)
📄 cmdline.pyc(20.01 KB)
📄 cmdline.pyo(19.96 KB)
📄 codeunit.py(4.34 KB)
📄 codeunit.pyc(5.19 KB)
📄 codeunit.pyo(5.19 KB)
📄 collector.py(12.7 KB)
📄 collector.pyc(9.14 KB)
📄 collector.pyo(9.08 KB)
📄 config.py(6.86 KB)
📄 config.pyc(7.67 KB)
📄 config.pyo(7.67 KB)
📄 control.py(26.58 KB)
📄 control.pyc(21.95 KB)
📄 control.pyo(21.95 KB)
📄 data.py(8.63 KB)
📄 data.pyc(9.65 KB)
📄 data.pyo(9.65 KB)
📄 execfile.py(4.78 KB)
📄 execfile.pyc(3.45 KB)
📄 execfile.pyo(3.45 KB)
📄 files.py(9.8 KB)
📄 files.pyc(10.62 KB)
📄 files.pyo(10.62 KB)
📄 html.py(11.84 KB)
📄 html.pyc(11.24 KB)
📄 html.pyo(11.15 KB)
📁 htmlfiles
📄 misc.py(4.08 KB)
📄 misc.pyc(6.13 KB)
📄 misc.pyo(6.13 KB)
📄 parser.py(23.65 KB)
📄 parser.pyc(17.16 KB)
📄 parser.pyo(17 KB)
📄 phystokens.py(7.07 KB)
📄 phystokens.pyc(5.3 KB)
📄 phystokens.pyo(5.24 KB)
📄 report.py(2.96 KB)
📄 report.pyc(2.86 KB)
📄 report.pyo(2.86 KB)
📄 results.py(8.86 KB)
📄 results.pyc(9.29 KB)
📄 results.pyo(9.23 KB)
📄 summary.py(2.9 KB)
📄 summary.pyc(2.88 KB)
📄 summary.pyo(2.88 KB)
📄 templite.py(5.57 KB)
📄 templite.pyc(4.8 KB)
📄 templite.pyo(4.61 KB)
📄 tracer.so(15.91 KB)
📄 version.py(336 B)
📄 version.pyc(361 B)
📄 version.pyo(361 B)
📄 xmlreport.py(5.57 KB)
📄 xmlreport.pyc(4.86 KB)
📄 xmlreport.pyo(4.86 KB)

Editing: templite.py

"""A simple Python template renderer, for a nano-subset of Django syntax."""

# Coincidentally named the same as http://code.activestate.com/recipes/496702/

import re, sys

class Templite(object):
    """A simple template renderer, for a nano-subset of Django syntax.

Supported constructs are extended variable access::

loops::

{% for var in list %}...{% endfor %}

and ifs::

{% if var %}...{% endif %}

Comments are within curly-hash markers::

{# This will be ignored #}

Construct a Templite with the template text, then use `render` against a
    dictionary context to create a finished string.

"""
    def __init__(self, text, *contexts):
        """Construct a Templite with the given `text`.

`contexts` are dictionaries of values to use for future renderings.
        These are good for filters and global values.

"""
        self.text = text
        self.context = {}
        for context in contexts:
            self.context.update(context)

# Split the text to form a list of tokens.
        toks = re.split(r"(?s)({{.*?}}|{%.*?%}|{#.*?#})", text)

# Parse the tokens into a nested list of operations.  Each item in the
        # list is a tuple with an opcode, and arguments.  They'll be
        # interpreted by TempliteEngine.
        #
        # When parsing an action tag with nested content (if, for), the current
        # ops list is pushed onto ops_stack, and the parsing continues in a new
        # ops list that is part of the arguments to the if or for op.
        ops = []
        ops_stack = []
        for tok in toks:
            if tok.startswith('{{'):
                # Expression: ('exp', expr)
                ops.append(('exp', tok[2:-2].strip()))
            elif tok.startswith('{#'):
                # Comment: ignore it and move on.
                continue
            elif tok.startswith('{%'):
                # Action tag: split into words and parse further.
                words = tok[2:-2].strip().split()
                if words[0] == 'if':
                    # If: ('if', (expr, body_ops))
                    if_ops = []
                    assert len(words) == 2
                    ops.append(('if', (words[1], if_ops)))
                    ops_stack.append(ops)
                    ops = if_ops
                elif words[0] == 'for':
                    # For: ('for', (varname, listexpr, body_ops))
                    assert len(words) == 4 and words[2] == 'in'
                    for_ops = []
                    ops.append(('for', (words[1], words[3], for_ops)))
                    ops_stack.append(ops)
                    ops = for_ops
                elif words[0].startswith('end'):
                    # Endsomething.  Pop the ops stack
                    ops = ops_stack.pop()
                    assert ops[-1][0] == words[0][3:]
                else:
                    raise SyntaxError("Don't understand tag %r" % words)
            else:
                ops.append(('lit', tok))

assert not ops_stack, "Unmatched action tag: %r" % ops_stack[-1][0]
        self.ops = ops

def render(self, context=None):
        """Render this template by applying it to `context`.

`context` is a dictionary of values to use in this rendering.

"""
        # Make the complete context we'll use.
        ctx = dict(self.context)
        if context:
            ctx.update(context)

# Run it through an engine, and return the result.
        engine = _TempliteEngine(ctx)
        engine.execute(self.ops)
        return "".join(engine.result)

class _TempliteEngine(object):
    """Executes Templite objects to produce strings."""
    def __init__(self, context):
        self.context = context
        self.result = []

def execute(self, ops):
        """Execute `ops` in the engine.

Called recursively for the bodies of if's and loops.

"""
        for op, args in ops:
            if op == 'lit':
                self.result.append(args)
            elif op == 'exp':
                try:
                    self.result.append(str(self.evaluate(args)))
                except:
                    exc_class, exc, _ = sys.exc_info()
                    new_exc = exc_class("Couldn't evaluate {{ %s }}: %s"
                                        % (args, exc))
                    raise new_exc
            elif op == 'if':
                expr, body = args
                if self.evaluate(expr):
                    self.execute(body)
            elif op == 'for':
                var, lis, body = args
                vals = self.evaluate(lis)
                for val in vals:
                    self.context[var] = val
                    self.execute(body)
            else:
                raise AssertionError("TempliteEngine doesn't grok op %r" % op)

def evaluate(self, expr):
        """Evaluate an expression.

`expr` can have pipes and dots to indicate data access and filtering.

"""
        if "|" in expr:
            pipes = expr.split("|")
            value = self.evaluate(pipes[0])
            for func in pipes[1:]:
                value = self.evaluate(func)(value)
        elif "." in expr:
            dots = expr.split('.')
            value = self.evaluate(dots[0])
            for dot in dots[1:]:
                try:
                    value = getattr(value, dot)
                except AttributeError:
                    value = value[dot]
                if hasattr(value, '__call__'):
                    value = value()
        else:
            value = self.context[expr]
        return value

X7ROOT File Manager

Editing: templite.py

Upload File

Create Folder