Python Loader.load_name方法代码示例

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
 def get(self):
     pass_phrase = self.authenticate_request()
     if pass_phrase:
         if self.check_setup():
             loader = Loader(extension='html', search_dirs=['view', 'view/setup'])
             renderer = Renderer(file_extension='html',
                 search_dirs=['view/partials', 'view/setup'])
             template = loader.load_name('setup')
             html = renderer.render(template, {"pass": pass_phrase})
             self.write(html)
         else:
             self.write("setup already completed.")

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
    def generate_page(self, articles):
        view_model = {
                    "articles": articles,
                    "site_name": BaseController.settings["site_name"]
                    }
        self.attach_meta_data(view_model)

        loader = Loader(file_encoding='utf8', extension='html',
                        search_dirs=['view', ])
        renderer = Renderer(file_encoding='utf8', file_extension='html',
                            search_dirs=['view/partials'])
        template = loader.load_name('list')
        html = renderer.render(template, view_model)
        return html

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
    def get(self, article_name):

        article_name = article_name.lower()

        if article_name in BaseController.articles:

            article = BaseController.articles[article_name]

            # if content has not modified since last request
            # send a 304 not modified status
            modified_header_key = "If-Modified-Since"
            if modified_header_key in self.request.headers:
                if (self.request.headers["If-Modified-Since"] ==
                    article['modified_date']):
                    self.set_status(304)
                    return

            if (BaseController.settings['enable_caching'] and
                article_name in BaseController.cached_articles):
                html = BaseController.cached_articles[article_name]
            else:
                view_model = {
                "article": article,
                "site_name": BaseController.settings['site_name']
                }
                self.attach_meta_data(view_model)

                loader = Loader(file_encoding='utf8',
                                extension='html',
                                search_dirs=['view', ])
                renderer = Renderer(file_encoding='utf8',
                                    file_extension='html',
                                    search_dirs=['view/partials'])
                template = loader.load_name('article')
                html = renderer.render(template, view_model)

                # cache the html
                BaseController.cached_articles[article_name] = html

            # set http caching headers
            if "http_caching_max_age" in BaseController.settings:
                max_age = BaseController.settings["http_caching_max_age"]
            else:
                max_age = 60
            self.set_header("Cache-control", "max-age=%s" % max_age)
            self.set_header("Last-Modified", article['modified_date'])
            self.write(html)

        else:
            raise tornado.web.HTTPError(404)

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
def index():
    loader = Loader()
    template = loader.load_name('index')

    response = requests.get('http://www.unboxedconsulting.com/people/carl-whittaker')
    status = response.status_code
    if status == 200:
        content = response.content

        soup = BeautifulSoup(content)
        image = 'http://www.unboxedconsulting.com' + soup.select('a.front img')[0]['src']
    else:
        image = ''

    return pystache.render(
        template,
        {
            'has_caricature': status == 200,
            'image': image
        }
    )

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
    def get(self):

        if (BaseController.settings['enable_caching'] and
            BaseController.cached_home):
            html = BaseController.cached_home
            self.write(html)
        else:
            published_articles = []
            for article in BaseController.articles.values():
                if article['date'] is not None:
                    published_articles.append(article)

            articles = sorted(published_articles,
                              key=operator.itemgetter("date"),
                              reverse=True)

            max_articles_count = BaseController.settings["homepage_max_articles"]
            show_archive = False
            if len(articles) > max_articles_count:
                show_archive = True
                articles = articles[0:max_articles_count]

            view_model = {
                        "articles": articles,
                        "showArchive": show_archive,
                        "site_name": BaseController.settings["site_name"]
                        }
            self.attach_meta_data(view_model)
            loader = Loader(file_encoding='utf8', extension='html',
                        search_dirs=['view', ])
            renderer = Renderer(file_encoding='utf8', file_extension='html',
                            search_dirs=['view/partials'])
            template = loader.load_name('home')
            html = renderer.render(template, view_model)

            # cache the home page
            BaseController.cached_home = html

            self.write(html)

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
import os
import pystache
import gevent
import gevent.monkey
from gevent.pywsgi import WSGIServer
gevent.monkey.patch_all()

from pystache.loader import Loader

from flask import Flask, Response, request
app = Flask(__name__)


loader = Loader()
templates = {
    'index': loader.load_name('index')
}


@app.route('/')
def index():
    r = redis.Redis()
    ctx = {
        'temperature': r.get('temperature'),
    }

    return pystache.render(templates['index'], ctx)


@app.route('/current-temperature/')
def current_temperature():

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
from flask import Flask
from flask_compress import Compress
from flask_talisman import Talisman, GOOGLE_CSP_POLICY
app = Flask(__name__)
Compress(app)
GOOGLE_CSP_POLICY['style-src'] += ' cdnjs.cloudflare.com'
Talisman(app, content_security_policy=GOOGLE_CSP_POLICY)

from letterboxd import get_letterboxd_most_recently_watched_details

cache = SimpleCache()

loader = Loader()

template = loader.load_name('index')


def get_cached_result(func, key):
    cached_result = None

    try:
        cached_result = cache.get(key)
        if not cached_result:
            cached_result = func()
            cache.set(key, cached_result)
    except:
        pass

    return cached_result

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
 def test_load_name(self):
     loader = Loader(search_dirs=[DATA_DIR, LOADER_DATA_DIR],
                     extension='txt')
     template = loader.load_name('template')
     self.assertEqual(template, 'Test template file\n')

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
from pystache.loader import Loader
from pystache import render

from flask import Flask, abort, url_for

from flask_compress import Compress

from arguments import arguments


app = Flask(__name__)
Compress(app)

loader = Loader()

home_template = loader.load_name('templates/home')


def slugify(string):
    return string.lower().replace(' ', '-')


routes = {}

for challengers in arguments:
    for perm in itertools.permutations(challengers):
        slugs = tuple(slugify(c) for c in perm)

        routes[slugs] = perm

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
    # title_partial = {'page-title': 'Some cinder crap | {{title}}'}
    # renderer = Renderer(partials=title_partial)
    # renderer.search_dirs.append(TEMPLATE_DIR)
    # path = os.path.join(TEMPLATE_DIR, "master-template.mustache")
    # actual = renderer.render_path(path, test_obj)
    # print actual

    # step 1: render content in template
    content_renderer = Renderer()
    path = os.path.join(CLASS_TEMPLATE_DIR, "main-content-template.mustache")
    content_renderer.search_dirs.append(TEMPLATE_DIR)
    rendered_content = content_renderer.render_path(path, class_obj)

    # step 2: place rendered content into main template
    # - should have the following custom partials:
    #   - page title (define in object for page templates)
    #   - page content (rendered page content)
    #   - any other common partials that may lie outside the basic content area

    test_obj = {"title": class_obj["name"]}

    loader = Loader()
    # template = loader.read("title")
    title_partial = loader.load_name(os.path.join(CLASS_TEMPLATE_DIR, "title"))
    partials = {"page-title": title_partial, "main-content": rendered_content}
    renderer = Renderer(partials=partials)

    path = os.path.join(TEMPLATE_DIR, "master-template.mustache")
    actual = renderer.render_path(path, test_obj)
    print actual

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
import pystache
import gevent
import gevent.monkey
import redis
from gevent.pywsgi import WSGIServer
gevent.monkey.patch_all()

from pystache.loader import Loader

from flask import Flask, Response, request
app = Flask(__name__)


loader = Loader()
templates = {
    'comic': loader.load_name('comic')
}


@app.route('/')
def index():
    if request.headers.get('accept') == 'text/event-stream':
        r = redis.Redis()
        pubsub = r.pubsub()
        pubsub.subscribe(['comic'])

        def images():
            for msg in pubsub.listen():
                if msg['type'] == 'message':
                    yield 'event: comic\n'
                    yield 'data: %s\n\n' % msg['data']

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
else:
    print "Droplet named `biuVPN` exists"
print droplet.name, droplet.id, droplet.ip_address, droplet.status, \
    droplet.created_at

droplet_id = droplet.id
ip_address = droplet.ip_address

while not ip_address:
    print "Waiting Digital Ocean creating droplet ..."
    droplet.load()
    ip_address = droplet.ip_address
    sleep(5)

# Generate Ansible configuration files

print "Generating Ansible configuration files"

loader = Loader(extension="mustache", search_dirs=os.getcwd())
renderer = Renderer()

template = loader.load_name(os.getcwd() + "/" + "ansible_hosts")
result = renderer.render(template, {"ip_address": ip_address})
with open("ansible_hosts", 'w') as file_handler:
    file_handler.write(result)

template = loader.load_name(os.getcwd() + "/" + "biuVPN.yml")
result = renderer.render(template, {"ip_address": ip_address})
with open("biuVPN.yml", 'w') as file_handler:
    file_handler.write(result)

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
 def _fetch_template(self, template_name):
     loader = Loader(search_dirs=[ROOT_PATH+"/static/template/"])
     
     return loader.load_name(template_name)

# 需要导入模块: from pystache.loader import Loader [as 别名]
# 或者: from pystache.loader.Loader import load_name [as 别名]
 def test_load_name(self):
     loader = Loader(search_dirs=[DATA_DIR, LOADER_DATA_DIR], extension="txt")
     template = loader.load_name("template")
     self.assertEqual(template, "Test template file\n")