def app(environ, start_response):
response_code = '200 OK'
response_type = ('Content-Type', 'text/HTML')
start_response(response_code, [response_type])
for item in assets:
separator = item.split('.')
if separator[1] == 'js':
js.append(item)
elif separator[1] == 'css':
css.append(item)
env = Environment(loader=FileSystemLoader('.'))
template = env.get_template('index.html')
print(template.render(css0=css, js0=js))
def model_run(self, model_context):
from camelot.view.action_steps import PrintHtml
import datetime
import os
from jinja import Environment, FileSystemLoader
from pkg_resources import resource_filename
fileloader = FileSystemLoader(
resource_filename(rms.__name__, 'templates'))
e = Environment(loader=fileloader)
resursa = model_context.get_object()
context = {
'header': resursa.nume,
'title': 'Raport resurse',
'style': '.label { font-weight:bold; }',
'activitati': resursa.activitati,
'footer': str(datetime.datetime.now().year)
}
t = e.get_template('resurse_logistice.html')
yield PrintHtml(t.render(context))
def get(self):
providers = [{'title': p.title, 'url': p.url, \
'example_url': p.example_url, \
'description': p.__doc__} \
for p in self.providers]
providers.sort(
lambda x, y: cmp(x['title'].lower(), y['title'].lower()))
if 'Development' in os.environ['SERVER_SOFTWARE']:
production = False
else:
production = True
env = Environment(loader=FileSystemLoader(os.path.dirname(__file__)))
tmpl = env.get_template('index.jinja')
hostname = os.environ['HTTP_HOST'].lower()
self.response.out.write(
tmpl.render(providers=providers,
production=production,
hostname=hostname))
def model_run(self, model_context):
from camelot.view.action_steps import PrintHtml
import datetime
import os
from jinja import Environment, FileSystemLoader
from pkg_resources import resource_filename
fileloader = FileSystemLoader(
resource_filename(rms.__name__, 'templates'))
e = Environment(loader=fileloader)
activitate = model_context.get_object()
context = {
'header': activitate.nume,
'title': 'Raport activitate',
'style': '.label { font-weight:bold; }',
'coordonator': activitate.coordonator,
'aprobata': activitate.aprobata,
'membrii': activitate.membrii,
'res_fin': activitate.res_fin,
'res_log': activitate.res_logistice,
'footer': str(datetime.datetime.now().year)
}
t = e.get_template('activitate.html')
yield PrintHtml(t.render(context))
objects provided by werkzeug. The subclasses know about their charset
and implement some additional functionallity like the ability to link
to view functions.
:copyright: (c) 2009 by the Werkzeug Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from os.path import dirname, join
from jinja import Environment, FileSystemLoader
from werkzeug.local import Local, LocalManager
from werkzeug.utils import redirect
from werkzeug.wrappers import BaseRequest, BaseResponse
local = Local()
local_manager = LocalManager([local])
template_env = Environment(loader=FileSystemLoader(
join(dirname(__file__), 'templates'), use_memcache=False))
exported_views = {}
def export(string, template=None, **extra):
"""
Decorator for registering view functions and adding
templates to it.
"""
def wrapped(f):
endpoint = (f.__module__ + '.' + f.__name__)[16:]
if template is not None:
old_f = f
def f(**kwargs):
rv = old_f(**kwargs)
objects provided by werkzeug. The subclasses know about their charset
and implement some additional functionallity like the ability to link
to view functions.
:copyright: (c) 2009 by the Werkzeug Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from os.path import dirname, join
from jinja import Environment, FileSystemLoader
from werkzeug import BaseRequest, BaseResponse, Local, LocalManager, redirect
local = Local()
local_manager = LocalManager([local])
template_env = Environment(
loader=FileSystemLoader(join(dirname(__file__), 'templates'),
use_memcache=False)
)
exported_views = {}
def export(string, template=None, **extra):
"""
Decorator for registering view functions and adding
templates to it.
"""
def wrapped(f):
endpoint = (f.__module__ + '.' + f.__name__)[16:]
if template is not None:
old_f = f
def f(**kwargs):
rv = old_f(**kwargs)
def _init_(self, app):
self.app = app
def __call__(self, environ, start_response):
response = self.app(environ, start_response).decode()
if response.find('<body>') > -1:
head1, head = response.split('<head>')
datahead, endhead = head.split('</head>')
head2, body = endhead.split('<body>')
databody, endbody = body.split('</body>')
yield (head1 + data + endbody).encode()
else:
yield (response).encode()
def app(environ, start_response):
response_code = '200 OK'
response_type = ('Content-Type', 'text/HTML')
start_response(response_code, [response_type])
return ''''''
app = WsgiTopBottomMiddleware(app)
request = Request.blank('/index.html')
env = Environment(loader=FileSystemLoader('.'))
template = env.get_template('index.html')
print(template.render(js=scripts, css=styles))
print(request.get_response(app))
import web
from minuteman import models
from jinja import Environment, FileSystemLoader
urls = ('/(\d*)', 'index')
env = Environment(loader=FileSystemLoader('templates'))
class index:
def GET(self, id):
db_session = models.get_session()
if id:
m = db_session.query(models.Minutes).filter_by(id=id).first()
if m:
print env.get_template('minutesinfo.jinja').render(minutes=m)
else:
print "mal"
else:
print env.get_template('minuteslist.jinja').render(
minutes=db_session.query(models.Minutes))
web.webapi.internalerror = web.debugerror
if __name__ == "__main__":
web.run(urls, globals(), web.reloader)
import db, auth, utils
import web, markdown2
import re, datetime, random, string, math, os
from jinja import Environment, FileSystemLoader
from jinja.filters import simplefilter
from sanitize import HTML as sanitize
from dispatcher import modes, jt
from urllib import quote
env = Environment(loader=FileSystemLoader('templates'),
auto_escape=True,
friendly_traceback=False)
env_atom = Environment(loader=FileSystemLoader('feeds'),
auto_escape=True,
friendly_traceback=False)
# Jinja monkeypatch: done for 1.1
def finish_var(value, ctx):
self = env
if value is None:
return ''
elif value is self.undefined_singleton:
return str(value)
elif getattr(value, 'jinja_no_finalization', False):
return value
if self.default_filters:
value = self.apply_filters(value, ctx, self.default_filters)
if isinstance(value, str):
value = value.decode('utf8')
from jinja import Environment, FileSystemLoader
from werkzeug import Response, Local, LocalManager, cached_property
from werkzeug.routing import Map, Rule
TEMPLATE_PATH = path.join(path.dirname(__file__), 'templates')
STATIC_PATH = path.join(path.dirname(__file__), 'static')
ALLOWED_SCHEMES = frozenset(['http', 'https', 'ftp', 'ftps'])
URL_CHARS = 'abcdefghijkmpqrstuvwxyzABCDEFGHIJKLMNPQRST23456789'
local = Local()
local_manager = LocalManager([local])
application = local('application')
url_map = Map([Rule('/static/<file>', endpoint='static', build_only=True)])
jinja_env = Environment(loader=FileSystemLoader(TEMPLATE_PATH))
def expose(rule, **kw):
def decorate(f):
kw['endpoint'] = f.__name__
url_map.add(Rule(rule, **kw))
return f
return decorate
def url_for(endpoint, _external=False, **values):
return local.url_adapter.build(endpoint, values, force_external=_external)
jinja_env.globals['url_for'] = url_for
def render_template(template, **context):
return Response(jinja_env.get_template(template).render(**context),
def do_wrd(value):
return value.split(".")[0]
@stringfilter
def do_crtobr(value):
return value
@stringfilter
def do_rightpart(value):
return value.split(None, 1)[1]
env = Environment()
env.loader = FileSystemLoader('.')
env.filters['oms'] = do_oms
env.filters['wrd'] = do_wrd
env.filters['crtobr'] = do_crtobr
env.filters['rightpart'] = do_rightpart
def print_page0(filename, data):
info = {"fname": filename, "data": data}
tpl = env.get_template("page0.html")
return tpl.render(info)
def print_page1(data):
info = {}
for key, val in data.items():
# context locals. these two objects are use by the application to
# bind objects to the current context. A context is defined as the
# current thread and the current greenlet if there is greenlet support.
# the `get_request` and `get_application` functions look up the request
# and application objects from this local manager.
local = Local()
local_manager = LocalManager([local])
# proxy objects
request = local('request')
application = local('application')
url_adapter = local('url_adapter')
# let's use jinja for templates this time
template_path = path.join(path.dirname(__file__), 'templates')
jinja_env = Environment(loader=FileSystemLoader(template_path))
# the collected url patterns
url_map = Map([Rule('/shared/<path:file>', endpoint='shared')])
endpoints = {}
_par_re = re.compile(r'\n{2,}')
_entity_re = re.compile(r'&([^;]+);')
_striptags_re = re.compile(r'(<!--.*-->|<[^>]*>)')
from htmlentitydefs import name2codepoint
html_entities = name2codepoint.copy()
html_entities['apos'] = 39
del name2codepoint
# Released under terms of the MIT/X/Expat Licence. See COPYING for details.
import logging
from twisted.web import server, resource, static, xmlrpc, soap
from twisted.application import internet
from twisted.internet import reactor
from jinja import Environment, FileSystemLoader
import ibid
from ibid.source import IbidSourceFactory
from ibid.event import Event
from ibid.config import Option, IntOption
from ibid.utils import locate_resource
templates = Environment(loader=FileSystemLoader(
locate_resource('ibid', 'templates')))
class Index(resource.Resource):
def __init__(self, name, *args, **kwargs):
resource.Resource.__init__(self, *args, **kwargs)
self.name = name
self.log = logging.getLogger('source.%s' % name)
self.template = templates.get_template('index.html')
def render_GET(self, request):
return self.template.render(rpc=ibid.rpc.keys()).encode('utf-8')
class Message(resource.Resource):
def __init__(self, name, *args, **kwargs):
