PK 6>g4>F zope/__init__.py# namespace package boilerplate
try:
__import__('pkg_resources').declare_namespace(__name__)
except ImportError, e:
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)
PK m4L< zope/__init__.pyc;
h
Dc @ sO y e d i e Wn1 e j
o% Z d k l Z e e e Z n Xd S( s
pkg_resources( s extend_pathN( s
__import__s declare_namespaces __name__s ImportErrors es pkgutils extend_paths __path__( s es extend_paths __path__( ( s+ build/bdist.linux-i686/egg/zope/__init__.pys ? s
PK Ҿ4 zope/tales/__init__.py##############################################################################
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Template Attribute Language - Expression Syntax
$Id: __init__.py 27165 2004-08-17 11:20:31Z hdima $
"""
PK Ҿ4@5O O zope/tales/tales.py##############################################################################
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""TALES
An implementation of a TAL expression engine
$Id: tales.py 27081 2004-08-12 19:56:31Z srichter $
"""
import re
from zope.interface import implements
try:
from zope import tal
except ImportError:
tal = None
if tal:
from zope.tal.interfaces import ITALExpressionEngine
from zope.tal.interfaces import ITALExpressionCompiler
from zope.tal.interfaces import ITALExpressionErrorInfo
from zope.tales.interfaces import ITALESIterator
NAME_RE = r"[a-zA-Z][a-zA-Z0-9_]*"
_parse_expr = re.compile(r"(%s):" % NAME_RE).match
_valid_name = re.compile('%s$' % NAME_RE).match
class TALESError(Exception):
"""Error during TALES evaluation"""
class Undefined(TALESError):
'''Exception raised on traversal of an undefined path'''
class CompilerError(Exception):
'''TALES Compiler Error'''
class RegistrationError(Exception):
'''Expression type or base name registration Error'''
_default = object()
class Iterator(object):
"""TALES Iterator
"""
if tal:
implements(ITALESIterator)
def __init__(self, name, seq, context):
"""Construct an iterator
Iterators are defined for a name, a sequence, or an iterator and a
context, where a context simply has a setLocal method:
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
A local variable is not set until the iterator is used:
>>> int("foo" in context.vars)
0
We can create an iterator on an empty sequence:
>>> it = Iterator('foo', (), context)
An iterator works as well:
>>> it = Iterator('foo', {"apple":1, "pear":1, "orange":1}, context)
>>> it.next()
True
>>> it = Iterator('foo', {}, context)
>>> it.next()
False
>>> it = Iterator('foo', iter((1, 2, 3)), context)
>>> it.next()
True
>>> it.next()
True
"""
self._seq = seq
self._iter = i = iter(seq)
self._nextIndex = 0
self._name = name
self._setLocal = context.setLocal
# This is tricky. We want to know if we are on the last item,
# but we can't know that without trying to get it. :(
self._last = False
try:
self._next = i.next()
except StopIteration:
self._done = True
else:
self._done = False
def next(self):
"""Advance the iterator, if possible.
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> bool(it.next())
True
>>> context.vars['foo']
'apple'
>>> bool(it.next())
True
>>> context.vars['foo']
'pear'
>>> bool(it.next())
True
>>> context.vars['foo']
'orange'
>>> bool(it.next())
False
>>> it = Iterator('foo', {"apple":1, "pear":1, "orange":1}, context)
>>> bool(it.next())
True
>>> bool(it.next())
True
>>> bool(it.next())
True
>>> bool(it.next())
False
>>> it = Iterator('foo', (), context)
>>> bool(it.next())
False
>>> it = Iterator('foo', {}, context)
>>> bool(it.next())
False
If we can advance, set a local variable to the new value.
"""
# Note that these are *NOT* Python iterators!
if self._done:
return False
self._item = v = self._next
try:
self._next = self._iter.next()
except StopIteration:
self._done = True
self._last = True
self._nextIndex += 1
self._setLocal(self._name, v)
return True
def index(self):
"""Get the iterator index
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> int(bool(it.next()))
1
>>> it.index()
0
>>> int(bool(it.next()))
1
>>> it.index()
1
>>> int(bool(it.next()))
1
>>> it.index()
2
"""
index = self._nextIndex - 1
if index < 0:
raise TypeError("No iteration position")
return index
def number(self):
"""Get the iterator position
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> int(bool(it.next()))
1
>>> it.number()
1
>>> int(bool(it.next()))
1
>>> it.number()
2
>>> int(bool(it.next()))
1
>>> it.number()
3
"""
return self._nextIndex
def even(self):
"""Test whether the position is even
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.even()
False
>>> it.next()
True
>>> it.even()
True
>>> it.next()
True
>>> it.even()
False
"""
return not (self._nextIndex % 2)
def odd(self):
"""Test whether the position is odd
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.odd()
True
>>> it.next()
True
>>> it.odd()
False
>>> it.next()
True
>>> it.odd()
True
"""
return bool(self._nextIndex % 2)
def parity(self):
"""Return 'odd' or 'even' depending on the position's parity
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.parity()
'odd'
>>> it.next()
True
>>> it.parity()
'even'
>>> it.next()
True
>>> it.parity()
'odd'
"""
if self._nextIndex % 2:
return 'odd'
return 'even'
def letter(self, base=ord('a'), radix=26):
"""Get the iterator position as a lower-case letter
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.letter()
'a'
>>> it.next()
True
>>> it.letter()
'b'
>>> it.next()
True
>>> it.letter()
'c'
"""
index = self._nextIndex - 1
if index < 0:
raise TypeError("No iteration position")
s = ''
while 1:
index, off = divmod(index, radix)
s = chr(base + off) + s
if not index: return s
def Letter(self):
"""Get the iterator position as an upper-case letter
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.Letter()
'A'
>>> it.next()
True
>>> it.Letter()
'B'
>>> it.next()
True
>>> it.Letter()
'C'
"""
return self.letter(base=ord('A'))
def Roman(self, rnvalues=(
(1000,'M'),(900,'CM'),(500,'D'),(400,'CD'),
(100,'C'),(90,'XC'),(50,'L'),(40,'XL'),
(10,'X'),(9,'IX'),(5,'V'),(4,'IV'),(1,'I')) ):
"""Get the iterator position as an upper-case roman numeral
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.Roman()
'I'
>>> it.next()
True
>>> it.Roman()
'II'
>>> it.next()
True
>>> it.Roman()
'III'
"""
n = self._nextIndex
s = ''
for v, r in rnvalues:
rct, n = divmod(n, v)
s = s + r * rct
return s
def roman(self):
"""Get the iterator position as a lower-case roman numeral
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.roman()
'i'
>>> it.next()
True
>>> it.roman()
'ii'
>>> it.next()
True
>>> it.roman()
'iii'
"""
return self.Roman().lower()
def start(self):
"""Test whether the position is the first position
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.start()
True
>>> it.next()
True
>>> it.start()
False
>>> it.next()
True
>>> it.start()
False
>>> it = Iterator('foo', {}, context)
>>> it.start()
False
>>> it.next()
False
>>> it.start()
False
"""
return self._nextIndex == 1
def end(self):
"""Test whether the position is the last position
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.end()
False
>>> it.next()
True
>>> it.end()
False
>>> it.next()
True
>>> it.end()
True
>>> it = Iterator('foo', {}, context)
>>> it.end()
False
>>> it.next()
False
>>> it.end()
False
"""
return self._last
def item(self):
"""Get the iterator value
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.item()
'apple'
>>> it.next()
True
>>> it.item()
'pear'
>>> it.next()
True
>>> it.item()
'orange'
>>> it = Iterator('foo', {1:2}, context)
>>> it.next()
True
>>> it.item()
1
"""
if self._nextIndex == 0:
raise TypeError("No iteration position")
return self._item
def length(self):
"""Get the length of the iterator sequence
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.length()
3
You can even get the length of a mapping:
>>> it = Iterator('foo', {"apple":1, "pear":2, "orange":3}, context)
>>> it.length()
3
But you can't get the length of an iterable which doesn't
support len():
>>> class MyIter(object):
... def __init__(self, seq):
... self._next = iter(seq).next
... def __iter__(self):
... return self
... def next(self):
... return self._next()
>>> it = Iterator('foo', MyIter({"apple":1, "pear":2}), context)
>>> it.length()
Traceback (most recent call last):
...
TypeError: len() of unsized object
"""
return len(self._seq)
class ErrorInfo(object):
"""Information about an exception passed to an on-error handler."""
if tal:
implements(ITALExpressionErrorInfo)
def __init__(self, err, position=(None, None)):
if isinstance(err, Exception):
self.type = err.__class__
self.value = err
else:
self.type = err
self.value = None
self.lineno = position[0]
self.offset = position[1]
class ExpressionEngine(object):
'''Expression Engine
An instance of this class keeps a mutable collection of expression
type handlers. It can compile expression strings by delegating to
these handlers. It can provide an expression Context, which is
capable of holding state and evaluating compiled expressions.
'''
if tal:
implements(ITALExpressionCompiler)
def __init__(self):
self.types = {}
self.base_names = {}
self.namespaces = {}
self.iteratorFactory = Iterator
def registerFunctionNamespace(self, namespacename, namespacecallable):
"""Register a function namespace
namespace - a string containing the name of the namespace to
be registered
namespacecallable - a callable object which takes the following
parameter:
context - the object on which the functions
provided by this namespace will
be called
This callable should return an object which
can be traversed to get the functions provided
by the this namespace.
example:
class stringFuncs(object):
def __init__(self,context):
self.context = str(context)
def upper(self):
return self.context.upper()
def lower(self):
return self.context.lower()
engine.registerFunctionNamespace('string',stringFuncs)
"""
self.namespaces[namespacename] = namespacecallable
def getFunctionNamespace(self, namespacename):
""" Returns the function namespace """
return self.namespaces[namespacename]
def registerType(self, name, handler):
if not _valid_name(name):
raise RegistrationError, (
'Invalid expression type name "%s".' % name)
types = self.types
if name in types:
raise RegistrationError, (
'Multiple registrations for Expression type "%s".' %
name)
types[name] = handler
def getTypes(self):
return self.types
def registerBaseName(self, name, object):
if not _valid_name(name):
raise RegistrationError, 'Invalid base name "%s".' % name
base_names = self.base_names
if name in base_names:
raise RegistrationError, (
'Multiple registrations for base name "%s".' % name)
base_names[name] = object
def getBaseNames(self):
return self.base_names
def compile(self, expression):
m = _parse_expr(expression)
if m:
type = m.group(1)
expr = expression[m.end():]
else:
type = "standard"
expr = expression
try:
handler = self.types[type]
except KeyError:
raise CompilerError, (
'Unrecognized expression type "%s".' % type)
return handler(type, expr, self)
def getContext(self, contexts=None, **kwcontexts):
if contexts is not None:
if kwcontexts:
kwcontexts.update(contexts)
else:
kwcontexts = contexts
return Context(self, kwcontexts)
def getCompilerError(self):
return CompilerError
class Context(object):
'''Expression Context
An instance of this class holds context information that it can
use to evaluate compiled expressions.
'''
if tal:
implements(ITALExpressionEngine)
position = (None, None)
source_file = None
def __init__(self, engine, contexts):
self._engine = engine
self.contexts = contexts
self.setContext('nothing', None)
self.setContext('default', _default)
self.repeat_vars = rv = {}
# Wrap this, as it is visible to restricted code
self.setContext('repeat', rv)
self.setContext('loop', rv) # alias
self.vars = vars = contexts.copy()
self._vars_stack = [vars]
# Keep track of what needs to be popped as each scope ends.
self._scope_stack = []
def setContext(self, name, value):
# Hook to allow subclasses to do things like adding security proxies
self.contexts[name] = value
def beginScope(self):
self.vars = vars = self.vars.copy()
self._vars_stack.append(vars)
self._scope_stack.append([])
def endScope(self):
self._vars_stack.pop()
self.vars = self._vars_stack[-1]
scope = self._scope_stack.pop()
# Pop repeat variables, if any
i = len(scope)
while i:
i = i - 1
name, value = scope[i]
if value is None:
del self.repeat_vars[name]
else:
self.repeat_vars[name] = value
def setLocal(self, name, value):
self.vars[name] = value
def setGlobal(self, name, value):
for vars in self._vars_stack:
vars[name] = value
def getValue(self, name, default=None):
value = default
for vars in self._vars_stack:
value = vars.get(name, default)
if value is not default:
break
return value
def setRepeat(self, name, expr):
expr = self.evaluate(expr)
if not expr:
return self._engine.iteratorFactory(name, (), self)
it = self._engine.iteratorFactory(name, expr, self)
old_value = self.repeat_vars.get(name)
self._scope_stack[-1].append((name, old_value))
self.repeat_vars[name] = it
return it
def evaluate(self, expression):
if isinstance(expression, str):
expression = self._engine.compile(expression)
__traceback_supplement__ = (
TALESTracebackSupplement, self, expression)
return expression(self)
evaluateValue = evaluate
def evaluateBoolean(self, expr):
return not not self.evaluate(expr)
def evaluateText(self, expr):
text = self.evaluate(expr)
if text is self.getDefault() or text is None:
return text
return unicode(text)
def evaluateStructure(self, expr):
return self.evaluate(expr)
evaluateStructure = evaluate
def evaluateMacro(self, expr):
# TODO: Should return None or a macro definition
return self.evaluate(expr)
evaluateMacro = evaluate
def createErrorInfo(self, err, position):
return ErrorInfo(err, position)
def getDefault(self):
return _default
def setSourceFile(self, source_file):
self.source_file = source_file
def setPosition(self, position):
self.position = position
class TALESTracebackSupplement(object):
"""Implementation of zope.exceptions.ITracebackSupplement"""
def __init__(self, context, expression):
self.context = context
self.source_url = context.source_file
self.line = context.position[0]
self.column = context.position[1]
self.expression = repr(expression)
def getInfo(self, as_html=0):
import pprint
data = self.context.contexts.copy()
if 'modules' in data:
del data['modules'] # the list is really long and boring
s = pprint.pformat(data)
if not as_html:
return ' - Names:\n %s' % s.replace('\n', '\n ')
else:
from cgi import escape
return 'Names:%s
' % (escape(s))
return None
PK Ҿ4a0
zope/tales/pythonexpr.py##############################################################################
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Generic Python Expression Handler
$Id: pythonexpr.py 27081 2004-08-12 19:56:31Z srichter $
"""
class PythonExpr(object):
def __init__(self, name, expr, engine):
text = '\n'.join(expr.splitlines()) # normalize line endings
text = '(' + text + ')' # Put text in parens so newlines don't matter
self.text = text
try:
code = self._compile(text, '')
except SyntaxError, e:
raise engine.getCompilerError()(str(e))
self._code = code
self._varnames = code.co_names
def _compile(self, text, filename):
return compile(text, filename, 'eval')
def _bind_used_names(self, econtext, builtins):
# Bind template variables
names = {}
vars = econtext.vars
marker = self
if not isinstance(builtins, dict):
builtins = builtins.__dict__
for vname in self._varnames:
val = vars.get(vname, marker)
if val is not marker:
names[vname] = val
elif vname not in builtins:
# Fall back to using expression types as variable values.
val = econtext._engine.getTypes().get(vname, marker)
if val is not marker:
val = ExprTypeProxy(vname, val, econtext)
names[vname] = val
names['__builtins__'] = builtins
return names
def __call__(self, econtext):
__traceback_info__ = self.text
vars = self._bind_used_names(econtext, __builtins__)
return eval(self._code, vars)
def __str__(self):
return 'Python expression "%s"' % self.text
def __repr__(self):
return '' % self.text
class ExprTypeProxy(object):
'''Class that proxies access to an expression type handler'''
def __init__(self, name, handler, econtext):
self._name = name
self._handler = handler
self._econtext = econtext
def __call__(self, text):
return self._handler(self._name, text,
self._econtext._engine)(self._econtext)
PK Ҿ4ǖ9' ' zope/tales/expressions.py##############################################################################
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Basic Page Template expression types.
$Id: expressions.py 27079 2004-08-12 19:45:55Z srichter $
"""
import re
from zope.interface import implements
from zope.tales.tales import _valid_name, _parse_expr, NAME_RE, Undefined
from zope.tales.interfaces import ITALESExpression, ITALESFunctionNamespace
Undefs = (Undefined, AttributeError, KeyError, TypeError, IndexError)
_marker = object()
namespace_re = re.compile('(\w+):(.+)')
def simpleTraverse(object, path_items, econtext):
"""Traverses a sequence of names, first trying attributes then items.
"""
for name in path_items:
next = getattr(object, name, _marker)
if next is not _marker:
object = next
elif hasattr(object, '__getitem__'):
object = object[name]
else:
raise NameError, name
return object
class SubPathExpr(object):
def __init__(self, path, traverser, engine):
self._traverser = traverser
self._engine = engine
# Parse path
compiledpath = []
currentpath = []
for element in str(path).strip().split('/'):
if not element:
raise engine.getCompilerError()(
'Path element may not be empty in %r' % path)
if element.startswith('?'):
if currentpath:
compiledpath.append(tuple(currentpath))
currentpath = []
if not _valid_name(element[1:]):
raise engine.getCompilerError()(
'Invalid variable name "%s"' % element[1:])
compiledpath.append(element[1:])
else:
match = namespace_re.match(element)
if match:
if currentpath:
compiledpath.append(tuple(currentpath))
currentpath = []
namespace, functionname = match.groups()
if not _valid_name(namespace):
raise engine.getCompilerError()(
'Invalid namespace name "%s"' % namespace)
if not _valid_name(functionname):
raise engine.getCompilerError()(
'Invalid function name "%s"' % functionname)
try:
compiledpath.append(
self._engine.getFunctionNamespace(namespace))
except KeyError:
raise engine.getCompilerError()(
'Unknown namespace "%s"' % namespace)
currentpath.append(functionname)
else:
currentpath.append(element)
if currentpath:
compiledpath.append(tuple(currentpath))
first = compiledpath[0]
base = first[0]
if callable(first):
# check for initial function
raise engine.getCompilerError()(
'Namespace function specified in first subpath element')
elif isinstance(first, basestring):
# check for initial ?
raise engine.getCompilerError()(
'Dynamic name specified in first subpath element')
if base and not _valid_name(base):
raise engine.getCompilerError()(
'Invalid variable name "%s"' % element)
self._base = base
compiledpath[0] = first[1:]
self._compiled_path = tuple(compiledpath)
def _eval(self, econtext,
isinstance=isinstance):
vars = econtext.vars
compiled_path = self._compiled_path
base = self._base
if base == 'CONTEXTS' or not base: # Special base name
ob = econtext.contexts
else:
ob = vars[base]
if isinstance(ob, DeferWrapper):
ob = ob()
for element in compiled_path:
if isinstance(element, tuple):
ob = self._traverser(ob, element, econtext)
elif isinstance(element, basestring):
val = vars[element]
# If the value isn't a string, assume it's a sequence
# of path names.
if isinstance(val, basestring):
val = (val,)
ob = self._traverser(ob, val, econtext)
elif callable(element):
ob = element(ob)
# TODO: Once we have n-ary adapters, use them.
if ITALESFunctionNamespace.providedBy(ob):
ob.setEngine(econtext)
else:
raise "Waagh!"
return ob
class PathExpr(object):
"""One or more subpath expressions, separated by '|'."""
implements(ITALESExpression)
# _default_type_names contains the expression type names this
# class is usually registered for.
_default_type_names = (
'standard',
'path',
'exists',
'nocall',
)
def __init__(self, name, expr, engine, traverser=simpleTraverse):
self._s = expr
self._name = name
paths = expr.split('|')
self._subexprs = []
add = self._subexprs.append
for i in range(len(paths)):
path = paths[i].lstrip()
if _parse_expr(path):
# This part is the start of another expression type,
# so glue it back together and compile it.
add(engine.compile('|'.join(paths[i:]).lstrip()))
break
add(SubPathExpr(path, traverser, engine)._eval)
def _exists(self, econtext):
for expr in self._subexprs:
try:
expr(econtext)
except Undefs:
pass
else:
return 1
return 0
def _eval(self, econtext):
for expr in self._subexprs[:-1]:
# Try all but the last subexpression, skipping undefined ones.
try:
ob = expr(econtext)
except Undefs:
pass
else:
break
else:
# On the last subexpression allow exceptions through.
ob = self._subexprs[-1](econtext)
if self._name == 'nocall':
return ob
# Call the object if it is callable.
if hasattr(ob, '__call__'):
return ob()
return ob
def __call__(self, econtext):
if self._name == 'exists':
return self._exists(econtext)
return self._eval(econtext)
def __str__(self):
return '%s expression (%s)' % (self._name, `self._s`)
def __repr__(self):
return '' % (self._name, `self._s`)
_interp = re.compile(r'\$(%(n)s)|\${(%(n)s(?:/[^}]*)*)}' % {'n': NAME_RE})
class StringExpr(object):
implements(ITALESExpression)
def __init__(self, name, expr, engine):
self._s = expr
if '%' in expr:
expr = expr.replace('%', '%%')
self._vars = vars = []
if '$' in expr:
# Use whatever expr type is registered as "path".
path_type = engine.getTypes()['path']
parts = []
for exp in expr.split('$$'):
if parts: parts.append('$')
m = _interp.search(exp)
while m is not None:
parts.append(exp[:m.start()])
parts.append('%s')
vars.append(path_type(
'path', m.group(1) or m.group(2), engine))
exp = exp[m.end():]
m = _interp.search(exp)
if '$' in exp:
raise engine.getCompilerError()(
'$ must be doubled or followed by a simple path')
parts.append(exp)
expr = ''.join(parts)
self._expr = expr
def __call__(self, econtext):
vvals = []
for var in self._vars:
v = var(econtext)
vvals.append(v)
return self._expr % tuple(vvals)
def __str__(self):
return 'string expression (%s)' % `self._s`
def __repr__(self):
return '' % `self._s`
class NotExpr(object):
implements(ITALESExpression)
def __init__(self, name, expr, engine):
self._s = expr = expr.lstrip()
self._c = engine.compile(expr)
def __call__(self, econtext):
return int(not econtext.evaluateBoolean(self._c))
def __repr__(self):
return '' % `self._s`
class DeferWrapper(object):
def __init__(self, expr, econtext):
self._expr = expr
self._econtext = econtext
def __str__(self):
return str(self())
def __call__(self):
return self._expr(self._econtext)
class DeferExpr(object):
implements(ITALESExpression)
def __init__(self, name, expr, compiler):
self._s = expr = expr.lstrip()
self._c = compiler.compile(expr)
def __call__(self, econtext):
return DeferWrapper(self._c, econtext)
def __repr__(self):
return '' % `self._s`
class SimpleModuleImporter(object):
"""Minimal module importer with no security."""
def __getitem__(self, module):
mod = self._get_toplevel_module(module)
path = module.split('.')
for name in path[1:]:
mod = getattr(mod, name)
return mod
def _get_toplevel_module(self, module):
# This can be overridden to add security proxies.
return __import__(module)
PK Ҿ4Ɗt
t
zope/tales/interfaces.py##############################################################################
#
# Copyright (c) 2003 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Interface that describes the 'macros' attribute of a PageTemplate.
$Id: interfaces.py 25177 2004-06-02 13:17:31Z jim $
"""
from zope.interface import Interface
try:
from zope import tal
except ImportError:
tal = None
class ITALESFunctionNamespace(Interface):
"""Function namespaces can be used in TALES path expressions to extract
information in non-default ways."""
def setEngine(engine):
"""Sets the engine that is used to evaluate TALES expressions."""
class ITALESExpression(Interface):
"""TALES expression
These are expression handlers that handle a specific type of
expression in TALES, e.g. path or string expression.
"""
def __call__(econtext):
"""Evaluate expression according to the given execution
context 'econtext' and return computed value.
"""
if tal is not None:
from zope.tal.interfaces import ITALIterator
class ITALESIterator(ITALIterator):
"""TAL Iterator provided by TALES
Values of this iterator are assigned to items in the repeat namespace.
For example, with a TAL statement like: tal:repeat="item items",
an iterator will be assigned to "repeat/item". The iterator
provides a number of handy methods useful in writing TAL loops.
The results are undefined of calling any of the methods except
'length' before the first iteration.
"""
def index():
"""Return the position (starting with "0") within the iteration
"""
def number():
"""Return the position (starting with "1") within the iteration
"""
def even():
"""Return whether the current position is even
"""
def odd():
"""Return whether the current position is odd
"""
def start():
"""Return whether the current position is the first position
"""
def end():
"""Return whether the current position is the last position
"""
def letter():
"""Return the position (starting with "a") within the iteration
"""
def Letter():
"""Return the position (starting with "A") within the iteration
"""
def roman():
"""Return the position (starting with "i") within the iteration
"""
def Roman():
"""Return the position (starting with "I") within the iteration
"""
def item():
"""Return the item at the current position
"""
def length():
"""Return whether the length of the sequence
Note that this may fail if the TAL iterator was created on a Python
iterator.
"""
PK Ҿ4iYc c zope/tales/engine.py##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Expression engine configuration and registration.
Each expression engine can have its own expression types and base names.
$Id: engine.py 25177 2004-06-02 13:17:31Z jim $
"""
from zope.tales.tales import ExpressionEngine
from zope.tales.expressions import PathExpr, StringExpr, NotExpr, DeferExpr
from zope.tales.expressions import SimpleModuleImporter
from zope.tales.pythonexpr import PythonExpr
def Engine():
e = ExpressionEngine()
reg = e.registerType
for pt in PathExpr._default_type_names:
reg(pt, PathExpr)
reg('string', StringExpr)
reg('python', PythonExpr)
reg('not', NotExpr)
reg('defer', DeferExpr)
e.registerBaseName('modules', SimpleModuleImporter())
return e
Engine = Engine()
PK Ҿ4hAE% % zope/tales/DEPENDENCIES.cfgzope.interface
zope.tal
zope.testing
PK m4( zope/tales/__init__.pyc;
}?3Dc @ s
d Z d S( se Template Attribute Language - Expression Syntax
$Id: __init__.py 27165 2004-08-17 11:20:31Z hdima $
N( s __doc__( ( ( s1 build/bdist.linux-i686/egg/zope/tales/__init__.pys ? s PK m4JAm m zope/tales/tales.pyc;
}?3Dc @ s d Z d k Z d k l Z y d k l Z Wn e j
o
e Z n Xe o8 d k l Z d k l
Z
d k l Z d k l
Z
n d Z e i d e i Z e i d
e i Z d e f d YZ d
e f d YZ d e f d YZ d e f d YZ e Z d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d S( si TALES
An implementation of a TAL expression engine
$Id: tales.py 27081 2004-08-12 19:56:31Z srichter $
N( s
implements( s tal( s ITALExpressionEngine( s ITALExpressionCompiler( s ITALExpressionErrorInfo( s ITALESIterators [a-zA-Z][a-zA-Z0-9_]*s (%s):s %s$s
TALESErrorc B s t Z d Z RS( s Error during TALES evaluation( s __name__s
__module__s __doc__( ( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys
TALESError) s s Undefinedc B s t Z d Z RS( s2 Exception raised on traversal of an undefined path( s __name__s
__module__s __doc__( ( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys Undefined, s s
CompilerErrorc B s t Z d Z RS( s TALES Compiler Error( s __name__s
__module__s __doc__( ( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys
CompilerError/ s s RegistrationErrorc B s t Z d Z RS( s/ Expression type or base name registration Error( s __name__s
__module__s __doc__( ( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys RegistrationError2 s s Iteratorc B s. t Z d Z e o e e n d Z d Z d Z d Z d Z
d Z d Z e
d d d
Z d Z d d
f d d f d d f d d f d d f d d f d d f d d f d d f d d f d d! f d" d# f d$ d% f f
d& Z d' Z d( Z d) Z d* Z d+ Z RS(, s TALES Iterator
c C s | | _ t | | _ } d | _ | | _ | i
| _ t | _
y | i | _ Wn t j
o t | _ n Xt | _ d S( su Construct an iterator
Iterators are defined for a name, a sequence, or an iterator and a
context, where a context simply has a setLocal method:
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
A local variable is not set until the iterator is used:
>>> int("foo" in context.vars)
0
We can create an iterator on an empty sequence:
>>> it = Iterator('foo', (), context)
An iterator works as well:
>>> it = Iterator('foo', {"apple":1, "pear":1, "orange":1}, context)
>>> it.next()
True
>>> it = Iterator('foo', {}, context)
>>> it.next()
False
>>> it = Iterator('foo', iter((1, 2, 3)), context)
>>> it.next()
True
>>> it.next()
True
i N( s seqs selfs _seqs iters _iters is
_nextIndexs names _names contexts setLocals _setLocals Falses _lasts nexts _nexts
StopIterations Trues _done( s selfs names seqs contexts i( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys __init__? s " c C s | i o t Sn | i | _ } y | i i | _ Wn% t j
o t | _ t | _
n X| i d 7_ | i | i
| t Sd S( s Advance the iterator, if possible.
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> bool(it.next())
True
>>> context.vars['foo']
'apple'
>>> bool(it.next())
True
>>> context.vars['foo']
'pear'
>>> bool(it.next())
True
>>> context.vars['foo']
'orange'
>>> bool(it.next())
False
>>> it = Iterator('foo', {"apple":1, "pear":1, "orange":1}, context)
>>> bool(it.next())
True
>>> bool(it.next())
True
>>> bool(it.next())
True
>>> bool(it.next())
False
>>> it = Iterator('foo', (), context)
>>> bool(it.next())
False
>>> it = Iterator('foo', {}, context)
>>> bool(it.next())
False
If we can advance, set a local variable to the new value.
i N( s selfs _dones Falses _nexts _items vs _iters nexts
StopIterations Trues _lasts
_nextIndexs _setLocals _name( s selfs v( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys nexts s (
c C s2 | i d } | d j o t d n | Sd S( s Get the iterator index
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> int(bool(it.next()))
1
>>> it.index()
0
>>> int(bool(it.next()))
1
>>> it.index()
1
>>> int(bool(it.next()))
1
>>> it.index()
2
i i s No iteration positionN( s selfs
_nextIndexs indexs TypeError( s selfs index( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys index s
c C s | i Sd S( s Get the iterator position
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> int(bool(it.next()))
1
>>> it.number()
1
>>> int(bool(it.next()))
1
>>> it.number()
2
>>> int(bool(it.next()))
1
>>> it.number()
3
N( s selfs
_nextIndex( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys number s c C s | i d Sd S( s| Test whether the position is even
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.even()
False
>>> it.next()
True
>>> it.even()
True
>>> it.next()
True
>>> it.even()
False
i N( s selfs
_nextIndex( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys even s c C s t | i d Sd S( sw Test whether the position is odd
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.odd()
True
>>> it.next()
True
>>> it.odd()
False
>>> it.next()
True
>>> it.odd()
True
i N( s bools selfs
_nextIndex( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys odd s c C s | i d o d Sn d Sd S( s Return 'odd' or 'even' depending on the position's parity
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.parity()
'odd'
>>> it.next()
True
>>> it.parity()
'even'
>>> it.next()
True
>>> it.parity()
'odd'
i s odds evenN( s selfs
_nextIndex( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys parity s s ai c C s| | i d } | d j o t d n d } xE n o= t | | \ } } t | | | } | o | Sq3 q: Wd S( s Get the iterator position as a lower-case letter
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.letter()
'a'
>>> it.next()
True
>>> it.letter()
'b'
>>> it.next()
True
>>> it.letter()
'c'
i i s No iteration positions N(
s selfs
_nextIndexs indexs TypeErrors ss divmods radixs offs chrs base( s selfs bases radixs indexs offs s( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys letter s
c C s | i d t d Sd S( s Get the iterator position as an upper-case letter
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.Letter()
'A'
>>> it.next()
True
>>> it.Letter()
'B'
>>> it.next()
True
>>> it.Letter()
'C'
s bases AN( s selfs letters ord( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys Letter. s i s Mi s CMi s Di s CDid s CiZ s XCi2 s Li( s XLi
s Xi s IXi s Vi s IVi s Ic C sQ | i } d } x7 | D]/ \ } } t | | \ } } | | | } q W| Sd S( s Get the iterator position as an upper-case roman numeral
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.Roman()
'I'
>>> it.next()
True
>>> it.Roman()
'II'
>>> it.next()
True
>>> it.Roman()
'III'
s N( s selfs
_nextIndexs ns ss rnvaluess vs rs divmods rct( s selfs rnvaluess rcts ns ss rs v( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys RomanB s c C s | i i Sd S( s Get the iterator position as a lower-case roman numeral
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.roman()
'i'
>>> it.next()
True
>>> it.roman()
'ii'
>>> it.next()
True
>>> it.roman()
'iii'
N( s selfs Romans lower( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys roman^ s c C s | i d j Sd S( s* Test whether the position is the first position
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.start()
True
>>> it.next()
True
>>> it.start()
False
>>> it.next()
True
>>> it.start()
False
>>> it = Iterator('foo', {}, context)
>>> it.start()
False
>>> it.next()
False
>>> it.start()
False
i N( s selfs
_nextIndex( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys startr s c C s | i Sd S( s Test whether the position is the last position
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.end()
False
>>> it.next()
True
>>> it.end()
False
>>> it.next()
True
>>> it.end()
True
>>> it = Iterator('foo', {}, context)
>>> it.end()
False
>>> it.next()
False
>>> it.end()
False
N( s selfs _last( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys end s c C s+ | i d j o t d n | i Sd S( s Get the iterator value
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.next()
True
>>> it.item()
'apple'
>>> it.next()
True
>>> it.item()
'pear'
>>> it.next()
True
>>> it.item()
'orange'
>>> it = Iterator('foo', {1:2}, context)
>>> it.next()
True
>>> it.item()
1
i s No iteration positionN( s selfs
_nextIndexs TypeErrors _item( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys item s c C s t | i Sd S( s Get the length of the iterator sequence
>>> context = Context(ExpressionEngine(), {})
>>> it = Iterator('foo', ("apple", "pear", "orange"), context)
>>> it.length()
3
You can even get the length of a mapping:
>>> it = Iterator('foo', {"apple":1, "pear":2, "orange":3}, context)
>>> it.length()
3
But you can't get the length of an iterable which doesn't
support len():
>>> class MyIter(object):
... def __init__(self, seq):
... self._next = iter(seq).next
... def __iter__(self):
... return self
... def next(self):
... return self._next()
>>> it = Iterator('foo', MyIter({"apple":1, "pear":2}), context)
>>> it.length()
Traceback (most recent call last):
...
TypeError: len() of unsized object
N( s lens selfs _seq( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys length s ( s __name__s
__module__s __doc__s tals
implementss ITALESIterators __init__s nexts indexs numbers evens odds paritys ords letters Letters Romans romans starts ends items length( ( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys Iterator8 s$ 4 7 s ErrorInfoc B s5 t Z d Z e o e e n e e f d Z RS( s= Information about an exception passed to an on-error handler.c C sY t | t o | i | _ | | _ n | | _ t | _ | d | _ | d | _
d S( Ni i ( s
isinstances errs Exceptions __class__s selfs types values Nones positions linenos offset( s selfs errs position( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys __init__ s
( s __name__s
__module__s __doc__s tals
implementss ITALExpressionErrorInfos Nones __init__( ( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys ErrorInfo s s ExpressionEnginec B s t Z d Z e o e e n d Z d Z d Z d Z d Z
d Z d Z d Z
e d Z d
Z RS( s+ Expression Engine
An instance of this class keeps a mutable collection of expression
type handlers. It can compile expression strings by delegating to
these handlers. It can provide an expression Context, which is
capable of holding state and evaluating compiled expressions.
c C s( h | _ h | _ h | _ t | _ d S( N( s selfs typess
base_namess
namespacess Iterators iteratorFactory( s self( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys __init__ s c C s | | i | Names:%s
(
s pprints selfs contexts contextss copys datas pformats ss as_htmls replaces cgis escapes None( s selfs as_htmls pprints ss escapes data( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys getInfo s
( s __name__s
__module__s __doc__s __init__s getInfo( ( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys TALESTracebackSupplement s ( s __doc__s res zope.interfaces
implementss zopes tals ImportErrors Nones zope.tal.interfacess ITALExpressionEngines ITALExpressionCompilers ITALExpressionErrorInfos zope.tales.interfacess ITALESIterators NAME_REs compiles matchs _parse_exprs _valid_names Exceptions
TALESErrors Undefineds
CompilerErrors RegistrationErrors objects _defaults Iterators ErrorInfos ExpressionEngines Contexts TALESTracebackSupplement( s Contexts ITALESIterators tals _parse_exprs _valid_names res RegistrationErrors ITALExpressionErrorInfos _defaults TALESTracebackSupplements Undefineds
CompilerErrors ITALExpressionCompilers
implementss Iterators NAME_REs ITALExpressionEngines ExpressionEngines
TALESErrors ErrorInfo( ( s. build/bdist.linux-i686/egg/zope/tales/tales.pys ? s2
mwPK m4̼n zope/tales/pythonexpr.pyc;
}?3Dc @ s6 d Z d e f d YZ d e f d YZ d S( s\ Generic Python Expression Handler
$Id: pythonexpr.py 27081 2004-08-12 19:56:31Z srichter $
s
PythonExprc B s> t Z d Z d Z d Z d Z d Z d Z RS( Nc C s d i | i } d | d } | | _ y | i | d } Wn- t j
o! } | i
t | n X| | _ | i
| _ d S( Ns
s (s )s ( s joins exprs
splitliness texts selfs _compiles codes SyntaxErrors es engines getCompilerErrors strs _codes co_namess _varnames( s selfs names exprs engines codes es text( ( s3 build/bdist.linux-i686/egg/zope/tales/pythonexpr.pys __init__ s c C s t | | d Sd S( Ns eval( s compiles texts filename( s selfs texts filename( ( s3 build/bdist.linux-i686/egg/zope/tales/pythonexpr.pys _compile s c C s h } | i } | } t | t o
| i } n x | i D] } | i | | } | | j o | | | ( s selfs text( s self( ( s3 build/bdist.linux-i686/egg/zope/tales/pythonexpr.pys __repr__? s ( s __name__s
__module__s __init__s _compiles _bind_used_namess __call__s __str__s __repr__( ( ( s3 build/bdist.linux-i686/egg/zope/tales/pythonexpr.pys
PythonExpr s s
ExprTypeProxyc B s t Z d Z d Z d Z RS( s7 Class that proxies access to an expression type handlerc C s | | _ | | _ | | _ d S( N( s names selfs _names handlers _handlers econtexts _econtext( s selfs names handlers econtext( ( s3 build/bdist.linux-i686/egg/zope/tales/pythonexpr.pys __init__E s c C s) | i | i | | i i | i Sd S( N( s selfs _handlers _names texts _econtexts _engine( s selfs text( ( s3 build/bdist.linux-i686/egg/zope/tales/pythonexpr.pys __call__J s ( s __name__s
__module__s __doc__s __init__s __call__( ( ( s3 build/bdist.linux-i686/egg/zope/tales/pythonexpr.pys
ExprTypeProxyC s N( s __doc__s objects
PythonExprs
ExprTypeProxy( s
PythonExprs
ExprTypeProxy( ( s3 build/bdist.linux-i686/egg/zope/tales/pythonexpr.pys ? s 0PK m4/)4 )4 zope/tales/expressions.pyc;
}?3Dc @ s> d Z d k Z d k l Z d k l Z l Z l Z l Z d k l
Z
l Z e e e
e e f Z e Z e i d Z d Z d e f d YZ d e f d
YZ e i d h d e < Z d
e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d S( sa Basic Page Template expression types.
$Id: expressions.py 27079 2004-08-12 19:45:55Z srichter $
N( s
implements( s _valid_names _parse_exprs NAME_REs Undefined( s ITALESExpressions ITALESFunctionNamespaces
(\w+):(.+)c C si x^ | D]V } t | | t } | t j o
| } q t | d o | | } q t | q W| Sd S( sG Traverses a sequence of names, first trying attributes then items.
s __getitem__N( s
path_itemss names getattrs objects _markers nexts hasattrs NameError( s objects
path_itemss econtexts names next( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys simpleTraverse s
s SubPathExprc B s t Z d Z e d Z RS( Nc C s | | _ | | _ g } g } xt | i i
d D]} | o | i d | n | i
d oi | o | i t | g } n t | d o | i d | d n | i | d q: t i | }
|
o | o | i t | g } n |
i \ } } t | o | i d | n t | o | i d | n y | i | i i | Wn) t j
o | i d | n X| i | q: | i | q: W| o | i t | n | d } | d } t | o | i d
n' t | t o | i d n | o t | o | i d | n | | _ | d | d ( s selfs _names _s( s self( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __repr__ s (
s __name__s
__module__s __doc__s
implementss ITALESExpressions _default_type_namess simpleTraverses __init__s _existss _evals __call__s __str__s __repr__( ( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys PathExpr s
s \$(%(n)s)|\${(%(n)s(?:/[^}]*)*)}s ns
StringExprc B s6 t Z e e d Z d Z d Z d Z RS( Nc C sw | | _ d | j o | i d d } n g | _ } d | j o$| i d } g } x | i
d D] } | o | i d n t
i | } x | t j oy | i | | i | i d | i | d | i d p
| i d | | | i } t
i | } q Wd | j o | i d n | i | ql Wd
i | } n | | _ d S( Ns %s %%s $s paths $$s %si i s. $ must be doubled or followed by a simple paths ( s exprs selfs _ss replaces _varss varss engines getTypess path_types partss splits exps appends _interps searchs ms Nones starts groups ends getCompilerErrors joins _expr( s selfs names exprs engines varss ms partss exps path_type( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __init__ s0
2
c C sH g } x* | i D] } | | } | i | q W| i t | Sd S( N( s vvalss selfs _varss vars econtexts vs appends _exprs tuple( s selfs econtexts vvalss vs var( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __call__ s
c C s d | i
Sd S( Ns string expression (%s)( s selfs _s( s self( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __str__ s c C s d | i
Sd S( Ns ( s selfs _s( s self( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __repr__ s ( s __name__s
__module__s
implementss ITALESExpressions __init__s __call__s __str__s __repr__( ( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys
StringExpr s
s NotExprc B s- t Z e e d Z d Z d Z RS( Nc C s) | i | _ } | i | | _ d S( N( s exprs lstrips selfs _ss engines compiles _c( s selfs names exprs engine( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __init__ s c C s t | i | i Sd S( N( s ints econtexts evaluateBooleans selfs _c( s selfs econtext( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __call__
s c C s d | i
Sd S( Ns ( s selfs _s( s self( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __repr__ s ( s __name__s
__module__s
implementss ITALESExpressions __init__s __call__s __repr__( ( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys NotExpr s
s DeferWrapperc B s# t Z d Z d Z d Z RS( Nc C s | | _ | | _ d S( N( s exprs selfs _exprs econtexts _econtext( s selfs exprs econtext( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __init__ s c C s t | Sd S( N( s strs self( s self( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __str__ s c C s | i | i Sd S( N( s selfs _exprs _econtext( s self( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __call__ s ( s __name__s
__module__s __init__s __str__s __call__( ( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys DeferWrapper s s DeferExprc B s- t Z e e d Z d Z d Z RS( Nc C s) | i | _ } | i | | _ d S( N( s exprs lstrips selfs _ss compilers compiles _c( s selfs names exprs compiler( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __init__# s c C s t | i | Sd S( N( s DeferWrappers selfs _cs econtext( s selfs econtext( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __call__' s c C s d | i
Sd S( Ns ( s selfs _s( s self( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __repr__* s ( s __name__s
__module__s
implementss ITALESExpressions __init__s __call__s __repr__( ( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys DeferExpr s
s SimpleModuleImporterc B s t Z d Z d Z d Z RS( s) Minimal module importer with no security.c C sJ | i | } | i d } x! | d D] } t | | } q) W| Sd S( Ns .i ( s selfs _get_toplevel_modules modules mods splits paths names getattr( s selfs modules names paths mod( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys __getitem__1 s c C s t | Sd S( N( s
__import__s module( s selfs module( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys _get_toplevel_module8 s ( s __name__s
__module__s __doc__s __getitem__s _get_toplevel_module( ( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys SimpleModuleImporter. s ( s __doc__s res zope.interfaces
implementss zope.tales.taless _valid_names _parse_exprs NAME_REs Undefineds zope.tales.interfacess ITALESExpressions ITALESFunctionNamespaces AttributeErrors KeyErrors TypeErrors
IndexErrors Undefss objects _markers compiles namespace_res simpleTraverses SubPathExprs PathExprs _interps
StringExprs NotExprs DeferWrappers DeferExprs SimpleModuleImporter( s _interps namespace_res DeferExprs _parse_exprs _valid_names res
StringExprs simpleTraverses SubPathExprs _markers Undefineds SimpleModuleImporters PathExprs
implementss NotExprs Undefss DeferWrappers ITALESFunctionNamespaces NAME_REs ITALESExpression( ( s4 build/bdist.linux-i686/egg/zope/tales/expressions.pys ? s
eH + PK m4U$/ / zope/tales/interfaces.pyc;
}?3Dc @ s d Z d k l Z y d k l Z Wn e j
o
e Z n Xd e f d YZ d e f d YZ e e j o' d k l
Z
d e
f d YZ n d
S( sx Interface that describes the 'macros' attribute of a PageTemplate.
$Id: interfaces.py 25177 2004-06-02 13:17:31Z jim $
( s Interface( s tals ITALESFunctionNamespacec B s t Z d Z d Z RS( si Function namespaces can be used in TALES path expressions to extract
information in non-default ways.c C s d S( s; Sets the engine that is used to evaluate TALES expressions.N( ( s engine( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys setEngine s ( s __name__s
__module__s __doc__s setEngine( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys ITALESFunctionNamespace s s ITALESExpressionc B s t Z d Z d Z RS( s TALES expression
These are expression handlers that handle a specific type of
expression in TALES, e.g. path or string expression.
c C s d S( ss Evaluate expression according to the given execution
context 'econtext' and return computed value.
N( ( s econtext( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys __call__( s ( s __name__s
__module__s __doc__s __call__( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys ITALESExpression! s ( s ITALIterators ITALESIteratorc B sz t Z d Z d Z d Z d Z d Z d Z d Z d Z d Z
d Z d
Z d Z
d Z RS(
s TAL Iterator provided by TALES
Values of this iterator are assigned to items in the repeat namespace.
For example, with a TAL statement like: tal:repeat="item items",
an iterator will be assigned to "repeat/item". The iterator
provides a number of handy methods useful in writing TAL loops.
The results are undefined of calling any of the methods except
'length' before the first iteration.
c C s d S( sI Return the position (starting with "0") within the iteration
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys index= s c C s d S( sI Return the position (starting with "1") within the iteration
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys numberA s c C s d S( s8 Return whether the current position is even
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys evenE s c C s d S( s7 Return whether the current position is odd
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys oddI s c C s d S( sF Return whether the current position is the first position
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys startM s c C s d S( sE Return whether the current position is the last position
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys endQ s c C s d S( sI Return the position (starting with "a") within the iteration
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys letterU s c C s d S( sI Return the position (starting with "A") within the iteration
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys LetterY s c C s d S( sI Return the position (starting with "i") within the iteration
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys roman] s c C s d S( sI Return the position (starting with "I") within the iteration
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys Romana s c C s d S( s4 Return the item at the current position
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys iteme s c C s d S( s Return whether the length of the sequence
Note that this may fail if the TAL iterator was created on a Python
iterator.
N( ( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys lengthi s ( s __name__s
__module__s __doc__s indexs numbers evens odds starts ends letters Letters romans Romans items length( ( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys ITALESIterator0 s N( s __doc__s zope.interfaces Interfaces zopes tals ImportErrors Nones ITALESFunctionNamespaces ITALESExpressions zope.tal.interfacess ITALIterators ITALESIterator( s ITALESIterators ITALESFunctionNamespaces tals Interfaces ITALESExpressions ITALIterator( ( s3 build/bdist.linux-i686/egg/zope/tales/interfaces.pys ? s
PK m4ք zope/tales/engine.pyc;
}?3Dc @ sb d Z d k l Z d k l Z l Z l Z l Z d k l Z d k l
Z
d Z e Z d S( s Expression engine configuration and registration.
Each expression engine can have its own expression types and base names.
$Id: engine.py 25177 2004-06-02 13:17:31Z jim $
( s ExpressionEngine( s PathExprs
StringExprs NotExprs DeferExpr( s SimpleModuleImporter( s
PythonExprc C s t } | i } x t i D] } | | t q W| d t | d t | d t | d t
| i d t | Sd S( Ns strings pythons nots defers modules(
s ExpressionEngines es registerTypes regs PathExprs _default_type_namess pts
StringExprs
PythonExprs NotExprs DeferExprs registerBaseNames SimpleModuleImporter( s es pts reg( ( s/ build/bdist.linux-i686/egg/zope/tales/engine.pys Engine s
N( s __doc__s zope.tales.taless ExpressionEngines zope.tales.expressionss PathExprs
StringExprs NotExprs DeferExprs SimpleModuleImporters zope.tales.pythonexprs
PythonExprs Engine( s Engines NotExprs SimpleModuleImporters DeferExprs
StringExprs
PythonExprs ExpressionEngines PathExpr( ( s/ build/bdist.linux-i686/egg/zope/tales/engine.pys ? s
PK m4 EGG-INFO/requires.txtzope.interface
zope.talPK m4,x6 6 EGG-INFO/PKG-INFOMetadata-Version: 1.0
Name: zope.tales
Version: 3.0.0
Summary: Zope 3 Template Application Language Expression Syntax (TALES)
Home-page: http://svn.zope.org/zope.tales/tags/3.0.0
Author: Zope Corporation and Contributors
Author-email: zope3-dev@zope.org
License: ZPL 2.1
Description: UNKNOWN
Platform: UNKNOWN
PK 1m4 EGG-INFO/not-zip-safePK m4 EGG-INFO/top_level.txtzope
PK m4 EGG-INFO/namespace_packages.txtzope
PK m4\6 EGG-INFO/SOURCES.txtCHANGES.txt
INSTALL.txt
README.txt
develop.py
setup.cfg
setup.cfg.in
setup.py
test.py
src/zope/__init__.py
src/zope.tales.egg-info/PKG-INFO
src/zope.tales.egg-info/SOURCES.txt
src/zope.tales.egg-info/namespace_packages.txt
src/zope.tales.egg-info/not-zip-safe
src/zope.tales.egg-info/requires.txt
src/zope.tales.egg-info/top_level.txt
src/zope/tales/DEPENDENCIES.cfg
src/zope/tales/__init__.py
src/zope/tales/engine.py
src/zope/tales/expressions.py
src/zope/tales/interfaces.py
src/zope/tales/pythonexpr.py
src/zope/tales/tales.py
src/zope/tales/tests/__init__.py
src/zope/tales/tests/simpleexpr.py
src/zope/tales/tests/test_expressions.py
src/zope/tales/tests/test_tales.py
workspace/__init__.py
workspace/develop.py
PK 6>g4>F zope/__init__.pyPK m4L< zope/__init__.pycPK Ҿ4 zope/tales/__init__.pyPK Ҿ4@5O O zope/tales/tales.pyPK Ҿ4a0
U zope/tales/pythonexpr.pyPK Ҿ4ǖ9' ' ` zope/tales/expressions.pyPK Ҿ4Ɗt
t
zope/tales/interfaces.pyPK Ҿ4iYc c zope/tales/engine.pyPK Ҿ4hAE% % ? zope/tales/DEPENDENCIES.cfgPK m4( zope/tales/__init__.pycPK m4JAm m ϝ zope/tales/tales.pycPK m4̼n zope/tales/pythonexpr.pycPK m4/)4 )4 zope/tales/expressions.pycPK m4U$/ / O zope/tales/interfaces.pycPK m4ք d zope/tales/engine.pycPK m4 Kj EGG-INFO/requires.txtPK m4,x6 6 j EGG-INFO/PKG-INFOPK 1m4 k EGG-INFO/not-zip-safePK m4 -l EGG-INFO/top_level.txtPK m4 fl EGG-INFO/namespace_packages.txtPK m4\6 l EGG-INFO/SOURCES.txtPK o