def render_try_finally(self, md):
result = ''
# first try to render the first block
try:
result = render_blocks(self.section, md)
# Then handle finally block
finally:
result = result + render_blocks(self.finallyBlock, md)
return result
def render(self, md):
d = {}
md._push(d)
try:
for name,expr in self.args:
if isinstance(expr, StringType):
d[name] = md[expr]
else:
d[name] = expr(md)
return render_blocks(self.section, md)
finally:
md._pop(1)
def render_try_except(self, md):
result = ''
# first we try to render the first block
try:
result = render_blocks(self.section, md)
except DTReturn:
raise
except:
# but an error occurs.. save the info.
t, v = sys.exc_info()[:2]
if isinstance(t, StringType):
errname = t
else:
errname = t.__name__
handler = self.find_handler(t)
if handler is None:
# we didn't find a handler, so reraise the error
raise
# found the handler block, now render it
try:
f = StringIO()
traceback.print_exc(100,f)
error_tb = f.getvalue()
ns = md.namespace(error_type=errname, error_value=v,
error_tb=error_tb)[0]
md._push_instance(ns)
return render_blocks(handler, md)
finally:
md._pop(1)
else:
# No errors have occurred, render the optional else block
if (self.elseBlock is None):
return result
else:
return result + render_blocks(self.elseBlock, md)
def render(self, md):
expr = self.expr
if expr is None:
t = self.__name__
if t[-5:] == 'Error' and __builtins__.has_key(t):
t = __builtins__[t]
else:
try:
t = expr.eval(md)
except:
t = 'Invalid Error Type Expression'
try:
v = render_blocks(self.section,md)
except:
v = 'Invalid Error Value'
raise t(v)
def render(self, md):
expr = self.expr
if isinstance(expr, StringTypes):
v = md[expr]
else:
v = expr(md)
if self.only:
_md = md
md = md.__class__()
if hasattr(_md, 'validate'):
md.validate = _md.validate
if self.mapping:
md._push(v)
else:
if isinstance(v, TupleType) and len(v) == 1:
v = v[0]
md._push_instance(v)
try:
return render_blocks(self.section, md)
finally:
md._pop(1)
def renderwob(self, md):
"""RENDER WithOutBatch"""
expr = self.expr
name = self.__name__
if expr is None:
sequence = md[name]
cache = {name: sequence }
else:
sequence = expr(md)
cache = None
if not sequence:
if self.elses:
return render_blocks(self.elses, md)
return ''
if isinstance(sequence, StringType):
raise InError('Strings are not allowed as input to the in tag.')
section = self.section
mapping = self.mapping
if self.sort_expr is not None:
self.sort = self.sort_expr.eval(md)
sequence = self.sort_sequence(sequence)
elif self.sort is not None:
sequence = self.sort_sequence(sequence)
if self.reverse_expr is not None and self.reverse_expr.eval(md):
sequence = self.reverse_sequence(sequence)
elif self.reverse is not None:
sequence = self.reverse_sequence(sequence)
vars = sequence_variables(sequence)
kw = vars.data
kw['mapping'] = mapping
l = len(sequence)
last = l - 1
push = md._push
pop = md._pop
render = render_blocks
get = self.args.get
if cache:
push(cache)
push(vars)
try:
result = []
append = result.append
validate = md.validate
for index in range(l):
if index == last:
kw['sequence-end'] = 1
client = sequence[index]
if validate is not None:
try:
vv = validate(sequence, sequence, None, client, md)
except:
vv = 0
if not vv:
if get('skip_unauthorized'):
if index == 1:
kw['sequence-start'] = 0
continue
raise ValidationError(index)
kw['sequence-index'] = index
if isinstance(client, TupleType) and len(client) == 2:
client = client[1]
if mapping:
push(client)
else:
md._push_instance(client)
try:
append(render(section, md))
finally:
pop()
if index == 0:
kw['sequence-start'] = 0
result = ''.join(result)
finally:
if cache:
pop()
pop()
return result
def renderwb(self, md):
expr = self.expr
name = self.__name__
if expr is None:
sequence = md[name]
cache = {name: sequence }
else:
sequence = expr(md)
cache = None
if not sequence:
if self.elses:
return render_blocks(self.elses, md)
return ''
if isinstance(sequence, StringType):
raise InError('Strings are not allowed as input to the in tag.')
section = self.section
params = self.args
mapping = self.mapping
if self.sort_expr is not None:
self.sort = self.sort_expr.eval(md)
sequence = self.sort_sequence(sequence)
elif self.sort is not None:
sequence = self.sort_sequence(sequence)
if self.reverse_expr is not None and self.reverse_expr.eval(md):
sequence = self.reverse_sequence(sequence)
elif self.reverse is not None:
sequence = self.reverse_sequence(sequence)
next = previous = 0
try:
start = int_param(params, md, 'start', 0)
except:
start=1
end = int_param(params, md, 'end', 0)
size = int_param(params, md, 'size', 0)
overlap = int_param(params, md, 'overlap', 0)
orphan = int_param(params, md, 'orphan', '3')
start, end, sz = opt(start, end, size, orphan, sequence)
if params.has_key('next'):
next = 1
if params.has_key('previous'):
previous = 1
last = end - 1
first = start - 1
try:
query_string = md['QUERY_STRING']
except:
query_string = ''
vars = sequence_variables(sequence,'?' + query_string,
self.start_name_re)
kw = vars.data
kw['mapping'] = mapping
kw['sequence-step-size'] = sz
kw['sequence-step-overlap'] = overlap
kw['sequence-step-start'] = start
kw['sequence-step-end'] = end
kw['sequence-step-start-index'] = start - 1
kw['sequence-step-end-index'] = end - 1
kw['sequence-step-orphan'] = orphan
push = md._push
pop = md._pop
render = render_blocks
if cache:
push(cache)
push(vars)
try:
if previous:
if first > 0:
pstart, pend, psize = opt(0, first+overlap,
sz, orphan, sequence)
kw['previous-sequence'] = 1
kw['previous-sequence-start-index'] = pstart - 1
kw['previous-sequence-end-index'] = pend - 1
kw['previous-sequence-size'] = pend + 1 - pstart
result=render(section,md)
elif self.elses:
result = render(self.elses, md)
else:
result = ''
elif next:
try:
# The following line is a sneaky way to test whether
# there are more items, without actually
# computing a length:
sequence[end]
except IndexError:
if self.elses:
result = render(self.elses, md)
else:
result = ''
else:
pstart, pend, psize = opt(end+1-overlap, 0,
sz, orphan, sequence)
kw['next-sequence'] = 1
kw['next-sequence-start-index'] = pstart - 1
kw['next-sequence-end-index'] = pend - 1
kw['next-sequence-size'] = pend + 1 - pstart
result = render(section, md)
else:
result = []
append = result.append
validate = md.validate
for index in range(first,end):
# preset
kw['previous-sequence'] = 0
# now more often defined then previously
kw['next-sequence'] = 0
if index==first or index==last:
# provide batching information
if first > 0:
pstart, pend, psize = opt(0, first + overlap,
sz, orphan, sequence)
if index == first:
kw['previous-sequence'] = 1
kw['previous-sequence-start-index'] = pstart - 1
kw['previous-sequence-end-index'] = pend - 1
kw['previous-sequence-size'] = pend + 1 - pstart
try:
# The following line is a sneaky way to
# test whether there are more items,
# without actually computing a length:
sequence[end]
pstart, pend, psize = opt(end + 1 - overlap, 0,
sz, orphan, sequence)
if index == last:
kw['next-sequence'] = 1
kw['next-sequence-start-index'] = pstart - 1
kw['next-sequence-end-index'] = pend - 1
kw['next-sequence-size'] = pend + 1 - pstart
except:
pass
if index == last:
kw['sequence-end'] = 1
client = sequence[index]
if validate is not None:
try:
vv = validate(sequence, sequence, None, client,md)
except:
vv = 0
if not vv:
if (params.has_key('skip_unauthorized') and
params['skip_unauthorized']):
if index == first:
kw['sequence-start'] = 0
continue
raise ValidationError(index)
kw['sequence-index'] = index
if isinstance(client, TupleType) and len(client) == 2:
client = client[1]
if mapping:
push(client)
else:
md._push_instance(client)
try:
append(render(section, md))
finally:
pop(1)
if index == first:
kw['sequence-start'] = 0
result = ''.join(result)
finally:
if cache:
pop()
pop()
return result
def __call__(self, client=None, mapping={}, **kw):
"""\
Generate a document from a document template.
The document will be generated by inserting values into the
format string specified when the document template was
created. Values are inserted using standard python named
string formats.
The optional argument 'client' is used to specify a object
containing values to be looked up. Values will be looked up
using getattr, so inheritence of values is supported. Note
that names beginning with '_' will not be looked up from the
client.
The optional argument, 'mapping' is used to specify a mapping
object containing values to be inserted.
Values to be inserted may also be specified using keyword
arguments.
Values will be inserted from one of several sources. The
sources, in the order in which they are consulted, are:
o Keyword arguments,
o The 'client' argument,
o The 'mapping' argument,
o The keyword arguments provided when the object was
created, and
o The 'mapping' argument provided when the template was
created.
"""
# print '============================================================'
# print '__called__'
# print self.raw
# print kw
# print client
# print mapping
# print '============================================================'
if mapping is None:
mapping = {}
if not hasattr(self, "_v_cooked"):
try:
changed = self.__changed__()
except:
changed = 1
self.cook()
if not changed:
self.__changed__(0)
pushed = None
try:
if isinstance(mapping, self.TemplateDict):
pushed = 0
except:
pass
globals = self.globals
if pushed is not None:
# We were passed a TemplateDict, so we must be a sub-template
md = mapping
push = md._push
if globals:
push(self.globals)
pushed = pushed + 1
else:
md = self.TemplateDict()
push = md._push
shared_globals = self.shared_globals
if shared_globals:
push(shared_globals)
if globals:
push(globals)
if mapping:
push(mapping)
md.validate = self.validate
if client is not None:
if isinstance(client, TupleType):
md.this = client[-1]
else:
md.this = client
pushed = 0
level = md.level
if level > 200:
raise SystemError("infinite recursion in document template")
md.level = level + 1
if client is not None:
if isinstance(client, TupleType):
# if client is a tuple, it represents a "path" of clients
# which should be pushed onto the md in order.
for ob in client:
md._push_instance(ob)
pushed += 1
else:
# otherwise its just a normal client object.
md._push_instance(client)
pushed += 1
if self._vars:
push(self._vars)
pushed += 1
if kw:
push(kw)
pushed += 1
try:
try:
result = render_blocks(self._v_blocks, md)
except DTReturn, v:
result = v.v
return result