def __call__(self):
settings = get_settings()
self.organization_name = settings.organization_name
self.campaign = self.context.get_fundraising_campaign()
self.page = self.context.get_fundraising_campaign_page()
self.donation_receipt_legal = self.campaign.donation_receipt_legal
self.products = []
if self.context.products:
for product in self.context.products:
price, quantity, product_uuid = product.split('|', 2)
total = int(price) * int(quantity)
product = uuidToObject(product_uuid)
if not product:
continue
if product.donation_only:
price = total
quantity = '-'
self.products.append({
'price': price,
'quantity': quantity,
'product': product,
'total': total,
})
self.is_personal = self.page.is_personal()
module = os.sys.modules[martian.util.caller_module()]
_prefix = os.path.dirname(module.__file__)
pt = PageTemplateFile('donation_templates/receipt.pt')
return pt.pt_render({'view': self})
class GooglechartField(BaseField):
"""
"""
read_template = PageTemplateFile('googlechart_read.pt')
edit_template = PageTemplateFile('googlechart_edit.pt')
def validate(self, submittedValue):
"""
"""
errors = []
# no validation needed (we do not want to parse the GoogleChart
# param)
return errors
def processInput(self, submittedValue):
"""
"""
lines = submittedValue.replace('\r', '').split('\n')
params = {}
for l in lines:
if "=" in l:
(key, value) = l.split('=')
else:
key = l
value = ''
params[key] = value
return params
class NumberField(BaseField):
"""
"""
read_template = PageTemplateFile('number_read.pt')
edit_template = PageTemplateFile('number_edit.pt')
def validate(self, submittedValue):
"""
"""
errors = []
fieldname = self.context.id
if self.context.number_type == "INTEGER":
try:
long(submittedValue)
except:
errors.append(fieldname + PlominoTranslate(
_(" must be an integer (submitted value was: "),
self.context) + submittedValue + ")")
elif self.context.number_type == "FLOAT":
try:
float(submittedValue)
except:
errors.append(fieldname + PlominoTranslate(
_(" must be a float (submitted value was: "), self.context)
+ submittedValue + ")")
elif self.context.number_type == "DECIMAL":
try:
Decimal(str(submittedValue))
except:
errors.append(fieldname + PlominoTranslate(
_(" must be a decimal (submitted value was: "),
self.context) + submittedValue + ")")
return errors
def processInput(self, submittedValue):
"""
"""
if self.context.number_type == "INTEGER":
return long(submittedValue)
elif self.context.number_type == "FLOAT":
return float(submittedValue)
elif self.context.number_type == "DECIMAL":
return Decimal(str(submittedValue))
else:
return submittedValue
def format_value(self, v):
"""
"""
str_v = ""
if v not in (None, "") and self.context.format:
try:
str_v = self.context.format % v
except TypeError:
str_v = "Formatting error"
else:
str_v = str(v)
return str_v
def get_pt(self, text=b'<html />'):
with tempfile.NamedTemporaryFile(mode='wb', delete=False) as f:
f.write(text)
self.addCleanup(os.unlink, f.name)
pt = PageTemplateFile(f.name)
pt.read()
return pt
def get_pt(self, text):
f = open(self.TEMPFILENAME, "wb")
f.write(text)
f.close()
pt = PageTemplateFile(self.TEMPFILENAME)
pt.read()
return pt
class SelectionField(BaseField):
"""
"""
read_template = PageTemplateFile('selection_read.pt')
edit_template = PageTemplateFile('selection_edit.pt')
def getSelectionList(self, doc):
""" Return the values list.
Format: label|value, use label as value if no label.
"""
# if formula available, use formula, else use manual entries
f = self.context.selectionlistformula
if f:
# if no doc provided (if OpenForm action), we use the PlominoForm
if doc:
obj = doc
else:
obj = self.context
try:
s = self.context.runFormulaScript(
SCRIPT_ID_DELIMITER.join(['field',
self.context.getParentNode().id,
self.context.id, 'SelectionListFormula']),
obj,
f)
except PlominoScriptException, e:
p = self.context.absolute_url_path()
e.reportError(
'%s field selection list formula failed' %
self.context.id,
path=p + '/getSettings?key=selectionlistformula')
s = []
else:
def get_pt(self, text):
f = open(self.TEMPFILENAME, "wb")
f.write(text)
f.close()
pt = PageTemplateFile(self.TEMPFILENAME)
pt.read()
return pt
def render_javascript(charts, packages):
"""Render the javascript for the charts and packages"""
render_charts = []
for chart in charts:
if 'charttype' in chart and 'data' in chart:
render_charts.append(chart)
if len(render_charts) == 0:
return None
pagetemplate = PageTemplateFile('templates/javascript.pt')
context = {'packages': "'%s'" % ','.join(packages),
'charts': render_charts}
return pagetemplate.pt_render(namespace=context)
class SelectionField(SelectionFieldBase):
"""
"""
implements(ISelectionField)
plomino_field_parameters = {
'interface': ISelectionField,
'label': "Chosen",
'index_type': "KeywordIndex"
}
read_template = PageTemplateFile('chosen_read.pt')
edit_template = PageTemplateFile('chosen_edit.pt')
def render_javascript(charts, packages):
"""Render the javascript for the charts and packages"""
render_charts = []
for chart in charts:
if 'charttype' in chart and 'data' in chart:
render_charts.append(chart)
if len(render_charts) == 0:
return None
pagetemplate = PageTemplateFile('templates/javascript.pt')
context = {
'packages': "'%s'" % ','.join(packages),
'charts': render_charts
}
return pagetemplate.pt_render(namespace=context)
class AttachmentField(BaseField):
"""
"""
read_template = PageTemplateFile('attachment_read.pt')
edit_template = PageTemplateFile('attachment_edit.pt')
def processInput(self, strValue):
"""
"""
# only called in during validation
if not strValue:
return None
strValue = normalizeString(strValue)
return {strValue: 'application/unknown'}
class TeaserRenderer(object):
template = PageTemplateFile('teaser.pt')
def __init__(self, context, data, request):
self.context = context
self.data = data
self.request = request
def __call__(self):
return self.template(options=self)
@property
def display_columns(self):
return int(self.data.display_columns)
@property
def table_rows(self):
count = len(self.teasers)
if count == 1:
return count
rows = count / 2
if count % 2 != 0:
rows += 1
return rows
@instance_property
def teasers(self):
return get_teasers(self.context, self.data, self.request)
def render(self):
if self.__searchFailed:
r = '''<div class="error" id="post-search-timeout">
<p><strong>Posts Failed to Load</strong></p>
<p>Sorry, the posts failed to load, because the server
took too long to respond.
<em>Please try again later.</em>
</p>
</div>'''
else:
if not self.__updated:
raise UpdateNotCalled()
pageTemplate = PageTemplateFile(self.pageTemplateFileName)
onlyGroup = False
if self.view.group_count() == 1:
onlyGroup = self.view.group_count()
onlyAuthor = False
if self.view.author_count() == 1:
onlyAuthor = self.view.author_count()
if self.posts:
r = pageTemplate(view=self, onlyGroup=onlyGroup, onlyAuthor=onlyAuthor)
else:
r = '<p id="post-search-none">No posts found.</p>'
return r
class BooleanField(BaseField):
"""
"""
read_template = PageTemplateFile('boolean_read.pt')
edit_template = PageTemplateFile('boolean_edit.pt')
def processInput(self, strValue):
"""
"""
if type(strValue) is bool:
return strValue
if strValue == "1":
return True
else:
return False
def render(self):
if not self.__updated:
raise interfaces.UpdateNotCalled
pageTemplate = PageTemplateFile(self.pageTemplateFileName)
return pageTemplate(view=self,
requiredWidgetsArray=self.requiredWidgetsArray)
def update(self):
self.updated = True
self.pageTemplate = PageTemplateFile(self.pageTemplateFileName)
self.finalSize = self.get_final_size()
self.finalWidth = self.finalSize[0]
self.finalHeight = self.finalSize[1]
self.imageUrl = self.get_image_url()
def render(self):
if not self.__updated:
raise UpdateNotCalled
pageTemplate = PageTemplateFile(self.pageTemplateFileName)
retval = pageTemplate(view=self,
currentSite=self.currentSite,
siteMemberships=self.siteMemberships)
return retval
def render(self):
if not self.__updated:
raise UpdateNotCalled
pageTemplate = PageTemplateFile(self.pageTemplateFileName)
retval = pageTemplate(visibility=self.visibility,
webVisibility=self.webVisibility,
emailVisibility=self.emailVisibility)
return retval
def main(argv=None):
if argv is None:
argv = sys.argv[1:]
if not len(argv) == 1:
print "Usage: grok2html OUTDIR"
sys.exit(1)
source_dir = os.path.dirname(__file__)
www_dir = os.path.abspath(argv[0])
if not os.path.isdir(www_dir):
print "OUTDIR '%s' does not exist." % (www_dir, )
sys.exit(1)
os.chdir(source_dir)
rest_files = []
rest_files.append(
RestFile('index', os.path.join(source_dir, 'index.txt'),
os.path.join(www_dir, 'index.html')))
rest_files.append(
RestFile('about', os.path.join(source_dir, 'about.txt'),
os.path.join(www_dir, 'about.html')))
rest_files.append(
RestFile('tutorial', os.path.join(source_dir, 'tutorial.txt'),
os.path.join(www_dir, 'tutorial.html')))
rest_files.append(
RestFile('mini-index',
os.path.join(source_dir, 'minitutorials', 'index.txt'),
os.path.join(www_dir, 'minitutorials', 'index.html')))
rest_files.append(
RestFile('searching',
os.path.join(source_dir, 'minitutorials', 'searching.txt'),
os.path.join(www_dir, 'minitutorials', 'searching.html')))
rest_files.append(
RestFile('macros',
os.path.join(source_dir, 'minitutorials', 'macros.txt'),
os.path.join(www_dir, 'minitutorials', 'macros.html')))
rest_files.append(
RestFile('testing',
os.path.join(source_dir, 'minitutorials', 'testing.txt'),
os.path.join(www_dir, 'minitutorials', 'testing.html')))
rest_files.append(
RestFile('xmlrpc',
os.path.join(source_dir, 'minitutorials', 'xmlrpc.txt'),
os.path.join(www_dir, 'minitutorials', 'xmlrpc.html')))
rest_files.append(
RestFile('permissions',
os.path.join(source_dir, 'minitutorials', 'permissions.txt'),
os.path.join(www_dir, 'minitutorials', 'permissions.html')))
rest_files.append(
RestFile(
'zc.buildout',
'http://svn.zope.org/*checkout*/zc.buildout/trunk/doc/tutorial.txt',
os.path.join(www_dir, 'minitutorials', 'buildout.html')))
template = PageTemplateFile(os.path.join(source_dir, 'template.pt'))
create_html(rest_files, template)
class RecaptchaField(BaseField):
"""
"""
implements(IRecaptchaField)
plomino_field_parameters = {
'interface': IRecaptchaField,
'label': "Recaptcha",
}
read_template = PageTemplateFile('recaptcha_read.pt')
edit_template = PageTemplateFile('recaptcha_edit.pt')
def validate(self, submittedValue):
"""
"""
errors = self.restrictedTraverse('@@captcha').verify()
return errors
def exportData(self, context, out):
template = PageTemplateFile('xml/%s' % _FILENAME,
globals()) # .__of__(context.getSite())
info = self._getExportInfo(context)
if info:
context.writeDataFile('%s' % _FILENAME,
template(info=info).encode('utf-8'),
'text/xml')
print >> out, "GenericSetup Configuration for ldap exported"
def render(self):
if not self.__updated:
raise UpdateNotCalled()
if self.results:
pageTemplate = PageTemplateFile(self.pageTemplateFileName)
r = pageTemplate(view=self)
else:
r = '<p id="file-search-none">No files found.</p>'
return r
class DbUploadField(BaseField):
"""
"""
implements(IDbUploadField)
plomino_field_parameters = {'interface': IDbUploadField,
'label':"DB upload",
'index_type':"ZCTextIndex"}
read_template = PageTemplateFile('templates/dbupload_read.pt')
edit_template = PageTemplateFile('templates/dbupload_edit.pt')
def validate(self, submittedValue):
"""
validate
"""
errors = []
return errors
def processInput(self, submittedValue):
"""
"""
# only called in during validation
if not submittedValue:
return None
if isinstance(submittedValue, FileUpload):
doc = self.context.REQUEST.PARENTS[0]
import pdb;pdb.set_trace()
#strValue = normalizeString(strValue)
#return {strValue: 'application/unknown'}
def getIcon(self):
"""
def update(self):
self.updated = True
self.pageTemplate = PageTemplateFile(self.pageTemplateFileName)
self.finalSize = self.get_final_size()
self.finalWidth = self.finalSize[0]
self.finalHeight = self.finalSize[1]
self.imageUrl = self.get_image_url()
self.image = self.smallImage if self.resizeNeeded else self.origImg
# --=mpj17=-- The page template uses self.image.ct, rather than
# self.image.contentType because it will drop the attribute if it
# is None, but self.image.contentType is never None, just ''.
# A similar issue hits self.sizes and self.srcset below
ct = self.image.contentType
self.image.ct = ct if ct else None
def panellayout(_context, name, title, description, template, layer):
component = {
'name': name,
'title': title,
'description': description,
'template': PageTemplateFile(template),
}
adapter = lambda request: component
_context.action(
discriminator=('panellayout', name, layer),
callable=handler,
args=('registerAdapter', adapter, (layer, ), ILayout, name,
_context.info),
)
def render(self):
if not self.__updated:
raise UpdateNotCalled
retval = ''
feed_urls = self.feed_config.urls
feeds = []
for url in feed_urls:
fname = md5.new(url).hexdigest()
try:
dataDir = locateDataDirectory('groupserver.GSFeedParser.data')
v = pickle.load(file(os.path.join(dataDir, fname)))
feeds.append(v)
except:
pass
pageTemplate = self.cookedTemplates.get(self.atomTemplate)
if not pageTemplate:
pageTemplate = PageTemplateFile(self.atomTemplate)
self.cookedTemplates.add(self.atomTemplate, pageTemplate)
for feed in feeds:
for entry in feed.entries:
if entry.has_key('content'):
if isinstance(entry.content[0], unicode):
content = entry.content
else:
content = entry.content[0]
else:
content = getattr(entry, 'summary', '')
if isinstance(content, dict):
content = content.value
retval += pageTemplate(view=self, entry=entry)
return retval
def render(self):
if not self.__updated:
raise UpdateNotCalled
if self.__searchFailed:
r = '''<div class="error" id="topic-serch-timeout">
<p><strong>Topics Failed to Load</strong></p>
<p>Sorry, the topics failed to load, because the server
took too long to respond.
<em>Please try again later.</em>
</p>
</div>'''
else:
pageTemplate = PageTemplateFile(self.pageTemplateFileName)
group_count = self.view.group_count()
if group_count == 1:
onlyGroup = True
else:
onlyGroup = False
if self.topics:
r = pageTemplate(view=self, onlyGroup=onlyGroup)
else:
r = '<p id="topic-search-none">No topics found.</p>'
return r
class NameField(BaseField):
"""
"""
read_template = PageTemplateFile('name_read.pt')
edit_template = PageTemplateFile('name_edit.pt')
def _getNamesIds(self):
""" Return Plone members as [(name, userid), ...]
Honor the restricttogroup field and the portal's do_not_list_users
property.
"""
if self.context.restricttogroup:
group = self.context.portal_groups.getGroupById(
self.context.restricttogroup)
if group:
names_ids = [
(m.getProperty("fullname"), m.getProperty('id'))
for m in group.getGroupMembers()]
else:
return []
elif self.context.getParentDatabase().do_not_list_users:
return None
else:
names_ids = [
(m.getProperty("fullname"), m.getId())
for m in self.context.getPortalMembers()]
names_ids.sort(key=lambda (username, userid): username.lower())
return names_ids
def getSelectionList(self, doc=None):
""" Fullname/ID list in selectionlist format: fullname|userid
"""
names_ids = self._getNamesIds()
if not names_ids:
return None
s = ['|']
for username, userid in names_ids:
if not username:
s.append("%s|%s" % (userid, userid))
else:
s.append("%s|%s" % (username, userid))
return s
def getFullname(self, userid):
""" Return member fullname if available
"""
if not userid:
return ''
mt = api.portal.get().portal_membership
user = mt.getMemberById(userid)
if user:
fullname = user.getProperty('fullname')
if fullname:
return fullname
else:
return userid
else:
return userid
def getFilteredNames(self, filter):
""" Return a JSON list of users, filtered by id or name.
"""
names_ids = self._getNamesIds()
if filter:
names_ids = [
{'id': userid, 'text': username}
for (username, userid) in names_ids[:20]
if filter.lower() in username.lower()
or filter.lower() in userid.lower()]
return json.dumps(
{'results': names_ids, 'total': len(names_ids)})
def getCurrent(self, values):
if isinstance(values, basestring):
values = [values]
return ["%s:%s" % (id, self.getFullname(id)) for id in values]
def __init__(self, *args, **kwargs):
self.target_language = None
if kwargs.has_key('target_language'):
self.target_language = kwargs['target_language']
kwargs.pop('target_language')
PageTemplateFile.__init__(self, *args, **kwargs)
def render(self):
if not self.__updated:
raise UpdateNotCalled
pageTemplate = PageTemplateFile(self.pageTemplateFileName)
return pageTemplate(view=self)
class GooglevisualizationField(BaseField):
""" GooglevisualizationField allows to render a datatable using the
Google Visualization tools.
The field value should be list of lists. Each child list contains the
values for the columns declared in the Google Visualization javascript
code.
Example:
If the columns declaration is:
gvisudata.addColumn('string', 'Name');
gvisudata.addColumn('string', 'Manager');
gvisudata.addColumn('string', 'ToolTip');
(typical case when using orgchart package) then the field value should
look like:
[['\'Mike\',\'Mike<div style="color:red; font-style:italic">President</div>\'', "''", "'The pres'"],
["'Tim'", "'Mike'", "'vp'"],
["'Tom'", "'Mike'", "'chief'"]]
Notes:
- strings must be enclosed in quotes (as they will be inserted in JS code)
- when editing the field value from the form, the rows are separated with a
newline, and the cells are separated with a pipe:
'Mike','Mike<div style="color:red; font-style:italic">President</div>'|''|'The pres'
'Tim'|'Mike'|'vp'
'Tom'|'Mike'|'chief'
More information about Google Visualization javascript APIs:
http://code.google.com/intl/en/apis/visualization/documentation/
"""
read_template = PageTemplateFile('googlevisualization_read.pt')
edit_template = PageTemplateFile('googlevisualization_edit.pt')
def validate(self, submittedValue):
"""
"""
errors = []
# no validation needed
return errors
def processInput(self, submittedValue):
"""
"""
lines = submittedValue.replace('\r', '').split('\n')
datatable = []
for l in lines:
datatable.append(l.split('|'))
return datatable
def jscode(self, datatable):
""" Return Google visualization JS code
"""
if type(datatable) is dict:
# if dict, we convert it to googleviz compliant array
labels = datatable.keys()
labels.sort()
tmp = []
for label in labels:
valuelist = ["'%s'" % label]
for e in asList(datatable[label]):
if isinstance(e, basestring):
valuelist.append("'%s'" % e)
else:
valuelist.append(str(e))
tmp.append(valuelist)
datatable = tmp
rows = []
i = 0
for row in datatable:
j = 0
for cell in row:
rows.append(
js_row_template % {
'chartid': self.chartid,
'row_nr': i,
'col_nr': j,
'cell': cell
})
j = j + 1
i = i + 1
js = js_func_template % {
'jssettings': self.jssettings,
'chartid': self.chartid,
'num_rows': str(len(datatable)),
'rows': ''.join(rows)
}
return js
def render(path, options):
tpl = PageTemplateFile(path, globals())
ns = tpl.pt_getContext((), options)
return tpl.pt_render(ns)
def pt_getContext(self, args=(), options={}, **kw):
rval = PageTemplateFile.pt_getContext(self, args=args)
options.update(rval)
return options
def pt_getContext(self, args=(), options={}, **kw):
"""Add our data into ZPT's defaults"""
rval = PageTemplateFile.pt_getContext(self, args=args)
options.update(rval)
return options
text = RichText(title=u'Text', required=False)
view_more_url = TextLine(
title=u'View More URL',
required=False,
)
count = Int(
title=u'Number of items to display, per source',
required=False,
default=6,
)
DAVIZ_TPL = PageTemplateFile('pt/zoom_cell_daviz.pt')
GENERIC_TPL = PageTemplateFile('pt/zoom_cell_generic.pt')
tile_zooms = {
'http://www.eea.europa.eu/portal_types/' + 'DavizVisualization#DavizVisualization':
DAVIZ_TPL,
}
class DavizListingTile(PersistentCoverTile):
""" Base class for Daviz listing tiles
It accepts both ElasticSearch and Sparql query objects.
"""
is_configurable = False
class DatagridField(BaseField):
"""
"""
implements(IDatagridField)
plomino_field_parameters = {
'interface': IDatagridField,
'label': "Datagrid",
'index_type': "ZCTextIndex"
}
read_template = PageTemplateFile('datagrid_read.pt')
edit_template = PageTemplateFile('datagrid_edit.pt')
def getParameters(self):
"""
"""
return self.jssettings
def processInput(self, submittedValue):
"""
"""
try:
return json.loads(submittedValue)
except:
return []
def rows(self, value, rendered=False):
"""
"""
if value is None or value == "":
value = []
if isinstance(value, basestring):
return value
if isinstance(value, DateTime):
value = DateToString(value)
if isinstance(value, dict):
if rendered:
value = value['rendered']
else:
value = value['rawdata']
return value
def tojson(self, value, rendered=False):
"""
"""
rows = self.rows(value, rendered)
return json.dumps(rows)
def getActionLabel(self, action_id):
"""
"""
db = self.context.getParentDatabase()
if action_id == "add":
label = PlominoTranslate("datagrid_add_button_label", db)
child_form_id = self.associated_form
if child_form_id is not None:
child_form = db.getForm(child_form_id)
if child_form:
label += " " + child_form.Title()
return label
if action_id == "delete":
return PlominoTranslate("datagrid_delete_button_label", db)
if action_id == "edit":
return PlominoTranslate("datagrid_edit_button_label", db)
return ""
def getFieldValue(self, form, doc, editmode, creation, request):
"""
"""
fieldValue = BaseField.getFieldValue(self, form, doc, editmode,
creation, request)
if not fieldValue:
return fieldValue
# if doc is not a PlominoDocument, no processing needed
if not doc or doc.isNewDocument():
return fieldValue
rawValue = fieldValue
mode = self.context.getFieldMode()
mapped_fields = []
if self.field_mapping:
mapped_fields = [f.strip() for f in self.field_mapping.split(',')]
# item names is set by `PlominoForm.createDocument`
item_names = doc.getItem(self.context.id + '_itemnames')
if mapped_fields:
if not item_names:
item_names = mapped_fields
# fieldValue is a array, where we must replace raw values with
# rendered values
child_form_id = self.associated_form
if child_form_id is not None:
db = self.context.getParentDatabase()
child_form = db.getForm(child_form_id)
# zip is procrustean: we get the longest of mapped_fields or
# fieldValue
mapped = []
for row in fieldValue:
if len(row) < len(item_names):
row = (row + [''] * (len(item_names) - len(row)))
row = dict(zip(item_names, row))
mapped.append(row)
fieldValue = mapped
fields = {}
for f in mapped_fields + item_names:
fields[f] = None
fields = fields.keys()
field_objs = [child_form.getFormField(f) for f in fields]
# avoid bad field ids
field_objs = [f for f in field_objs if f is not None]
#DBG fields_to_render = [f.id for f in field_objs if f.getFieldType() not in ["DATETIME", "NUMBER", "TEXT", "RICHTEXT"]]
#DBG fields_to_render = [f.id for f in field_objs if f.getFieldType() not in ["DOCLINK", ]]
fields_to_render = [
f.id for f in field_objs if f.getFieldMode() in [
"DISPLAY",
] or f.getFieldType() not in ["TEXT", "RICHTEXT"]
]
if fields_to_render:
rendered_values = []
for row in fieldValue:
row['Form'] = child_form_id
row['Plomino_Parent_Document'] = doc.id
tmp = TemporaryDocument(db,
child_form,
row,
real_doc=doc)
tmp = tmp.__of__(db)
for f in fields:
if f in fields_to_render:
row[f] = tmp.getRenderedItem(f)
rendered_values.append(row)
fieldValue = rendered_values
if mapped_fields and child_form_id:
mapped = []
for row in fieldValue:
mapped.append([row[c] for c in mapped_fields])
fieldValue = mapped
return {'rawdata': rawValue, 'rendered': fieldValue}
def get(self):
my_pt = PageTemplateFile('main.pt')
context = {'rows': ['apple', 'banana', 'carrot'], 'foo':'bar'}
self.response.out.write(my_pt.pt_render(namespace=context))
def render(path, options):
tpl = PageTemplateFile(path, globals())
ns = tpl.pt_getContext((), options)
return tpl.pt_render(ns)
