def getRender():
    """ get render for public pages """
    render = render_jinja(
        'templates',                      # set template directory
        encoding = 'utf-8',               # encoding
    )
    return render

def getAdminRender():
    render = render_jinja(
        'tpl/admin',
        encoding = 'utf-8'
    )

    return render

def getRender():
    render = render_jinja(
        'tpl',
        encoding = 'utf-8'
    )

    return render

def render(tmp_dir):
    gconf = config.data
    gconf['uptime'] = serverInfo()
    render = render_jinja([config.pp + 'templates/', config.pp + 'templates/' + tmp_dir], encoding='utf-8')
    render._lookup.globals.update(session=web.config._session, gconf=gconf)
    render._lookup.filters.update(filter.filters)

    return render

def load_render(views, **globals):
    '''Add the renderer to the shared context.'''
    render = render_jinja(views, encoding='utf-8',
                          extensions=['jinja2.ext.do'])
    render._lookup.globals.update(globals)
    def inner():
        web.ctx.render = render;
    return inner

def rendeHtml(template, **args):
    web.header('Content-Type', 'text/html')

    globals['v'] = time.time()
    globals['cookies'] = web.cookies()

    render = render_jinja(path + '/templates', encoding='utf-8', globals=globals)
    print path + '/templates'
    return getattr(render, template)(**args)

def getAdminRender():
    render = render_jinja(
            os.getcwd() + '/templates/admin',
            encoding = 'utf-8',
        )
    myFilters = {'avatar':templatefilters.avatar,'notnull':templatefilters.notnull,
        'formnote':templatefilters.formnote, 'content':templatefilters.content}
    render._lookup.filters.update(myFilters)
    return render

def load_render_with_assets(views, env, **globals):
    '''Add the renderer to the shared context.'''
    from webassets.ext.jinja2 import AssetsExtension
    render = render_jinja(views, encoding='utf-8',
                          extensions=['jinja2.ext.do', AssetsExtension])
    render._lookup.assets_environment = env
    render._lookup.globals.update(globals)
    def inner():
        web.ctx.render = render;
    return inner

 def GET(self, templatename):
     root_path = os.environ['ROOT_PATH']
     template_path = os.path.join(root_path, 'templates')        
     try:
         templatename = 'tests/%s' % templatename
         render = template.render_jinja(template_path)
         return getattr(render, templatename, '')()
     except:
         logging.exception("got an error in loading %s" %templatename)
         return 'template %s not found' % templatename

def render(template, context, locale=None):
    if locale:
        set_locale(locale)
    jinja = render_jinja(
        TEMPLATE_PATH,
        globals={'gettext' : ugettext_for_locale(LOCALE)},
        extensions=['jinja2.ext.i18n'],
        encoding='utf-8',
        )
    jinja._lookup.filters.update(TEMPLATE_FILTERS)
    template = jinja._lookup.get_template(template)
    return template.render(**context)

def index():
    import web
    from web.contrib.template import render_jinja
    from models import profile, database

    db = database.database()
    urls = (
                '/', 'hello'
                        )
    
    render = render_jinja(
                  'templates',                 # Set template directory.
                   encoding = 'utf-8',         # Encoding.
                           )

 def GET(self, page=None):
     try:
         page = int(page) if page else 1
     except ValueError:
         page = 1
     offset = (page - 1) * PER_PAGE
     db = web.database(dbn='sqlite', db=DB)
     quote_count = db.query("select count(*) as count from quote where channel='{}'".format(CHANNEL))[0].count
     quotes = db.select('quote', where="channel = '{}'".format(CHANNEL),
                        order='date desc', limit='$l', offset='$o',
                        vars={'l': PER_PAGE, 'o': offset})
     quotes = [fixDates(quote) for quote in quotes]
     pages = int(math.ceil(quote_count / PER_PAGE))
     render = render_jinja(TEMPLATES)
     return render.list(quotes=quotes, channel=CHANNEL,
                        analytics=GOOGLE_ANALYTICS, page=page, pages=pages)

urls = (
    '/', 'index',
    '/login', 'login',
    '/msg', 'msg',
    '/gender', 'gender',
    '/main', 'main',
    '/femain', 'femain',
   '/getMalePic', 'getMalePic',
   '/getFePic', 'getFePic',
    '/last', 'last',
    '/finalPic', 'finalPic'
)

#render = web.template.render('resource')
render = render_jinja(
        'resource',
        encoding = 'utf-8',
    )

app = web.application(urls, globals())
#web.config.debug = False
#session = web.session.Session(app, web.session.DiskStore('sessions'), initializer={'uid':0})
#session
if web.config.get('_session') is None:
    session = web.session.Session(app, web.session.DiskStore('sessions'),\
     {'uid': 0, 'color':'#444444', 'imgUrl':0})
    web.config._session = session
else:
    session = web.config._session

bksjw='http://bksjw.hust.edu.cn/'
hub='http://hub.hust.edu.cn/'

        s['count'] = 1
        count = s['count']
    s['count'] = count + 1
    s.close()
    return count
    
t_globals = {
            "ctx" : web.ctx,
            "team_infor" : db.select("team_infor")[0],
            "grade_dict" : grade_dict,
            "grade_manage_dict" : grade_manage_dict,
            "gravatar_dir" : r"/static/gravatar/",
            "visitor_count" : get_visitor,
        }

render = render_jinja(os.path.join(ABSPATH,"templates/"),encoding="utf-8",globals = t_globals)
render_admin = render_jinja(os.path.join(ABSPATH,"templates/admin/"),encoding="utf-8",globals = t_globals)



app = web.application(urls,globals())
application = app.wsgifunc()

store = web.session.DBStore(db, 'sessions')
sess = web.session.Session(app, store)

class Upload(object):
    
    def __init__(self,upfile):
        import os
        self.file = upfile

import web
import os
import numpy as np
import scipy.io as sio
from sklearn.svm import SVC

from web.contrib.template import render_jinja
from process_email import process_email, email_features
from spam_train import spam_train

template_dir = os.path.join(os.path.dirname(__file__), '.')
render = render_jinja(
    template_dir,
    encoding='utf-8',
)

model = None # store model so won't have to compute over and over

class index:
    def GET(self):
        return render.front(email="", error="")

    def POST(self):
        global model
        email = web.input().email

        if not email:
            error = "we need some email contents"
            return render.front(email=email, error=error)
        else:
            features = np.reshape(email_features(process_email(email)), (1, -1))

import web
import json
import core

from models import *
from web.contrib.template import render_jinja

view = render_jinja('view/visitor')

class create:
    def GET(self):
        return view.signup(user = User.status())

    def POST(self):
        """
        @return: json(@error)
        """
        try:
            User.create(dict(web.input()))
            return json.dumps({'error': 0})
        except AttributeError:
            # Missing information
            return json.dumps({'error': 1})
        except Exception as exception:
            errorCode =  int(exception.message)
            if errorCode > 1:
                return json.dumps({'error': errorCode})
            else:
                # Unknown error
                return json.dumps({'error': 9999})

    'social.backends.tripit.TripItOAuth',
    'social.backends.twilio.TwilioAuth',
    'social.backends.xing.XingOAuth',
    'social.backends.yandex.YandexOAuth2',
)
web.config[setting_name('LOGIN_REDIRECT_URL')] = '/done/'


urls = (
    '^/$', 'main',
    '^/done/$', 'done',
    '', social_app.app_social
)


render = render_jinja('templates/')


class main(object):
    def GET(self):
        return render.home()


class done(social_app.BaseViewClass):
    @strategy()
    def GET(self):
        user = self.get_current_user()
        return render.done(user=user, backends=backends(user))


engine = create_engine('sqlite:///test.db', echo=True)

import web
from web.contrib.template import render_jinja
import json

import ip_find

urls = ("/ip", "IPFind",
        "/api/ip/(.*)", "IPFindAPI")

app = web.application(urls, globals())
render = render_jinja("templates", encoding='utf-8')
ipInfo = ip_find.IPInfo("data/qqwry.dat")

def find_loc_by_ip(ip):
    try:
        i = ipInfo
        (c, a) = i.getIPAddr(ip);
        c = unicode(c, 'utf-8')
        a = unicode(a, 'utf-8')
    except:
        raise
    return (c, a)

class IPFind:
    def GET(self):
        return render.ip()

class IPFindAPI:
    def GET(self, ip):
        try:
            c, a = find_loc_by_ip(ip)

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Created on 20101205
Author: zkz
"""
from ua.common.bridge import moni as bridge_moni

import web
from web.contrib.template import render_jinja

urls = ("/page", "Page")

render = render_jinja("webapps/syst/templates/moni", encoding="utf-8")
app = web.application(urls, locals())


def notfound():
    return web.notfound(render.notfound())


app.notfound = notfound


def login_required(func):
    def new_func(*args, **argvkw):
        session = web.ctx.session
        if session.user == "anonymous" or session.user == "":
            #            return render.notlogin()
            raise web.seeother("/login?tip=%s" % u"请登录!")
        else:

    "social.backends.tripit.TripItOAuth",
    "social.backends.clef.ClefOAuth2",
    "social.backends.twilio.TwilioAuth",
    "social.backends.xing.XingOAuth",
    "social.backends.yandex.YandexOAuth2",
    "social.backends.podio.PodioOAuth2",
    "social.backends.mineid.MineIDOAuth2",
    "social.backends.wunderlist.WunderlistOAuth2",
)
web.config[setting_name("LOGIN_REDIRECT_URL")] = "/done/"


urls = ("^/$", "main", "^/done/$", "done", "", social_app.app_social)


render = render_jinja("templates/")


class main(object):
    def GET(self):
        return render.home()


class done(social_app.BaseViewClass):
    def GET(self):
        user = self.get_current_user()
        return render.done(user=user, backends=backends(user))


engine = create_engine("sqlite:///test.db", echo=True)