71 lines
2.5 KiB
Python
71 lines
2.5 KiB
Python
from utemplate import recompile
|
|
|
|
_loader = None
|
|
|
|
|
|
class Template:
|
|
"""A template object.
|
|
|
|
:param template: The filename of the template to render, relative to the
|
|
configured template directory.
|
|
"""
|
|
@classmethod
|
|
def initialize(cls, template_dir='templates',
|
|
loader_class=recompile.Loader):
|
|
"""Initialize the templating subsystem.
|
|
|
|
:param template_dir: the directory where templates are stored. This
|
|
argument is optional. The default is to load
|
|
templates from a *templates* subdirectory.
|
|
:param loader_class: the ``utemplate.Loader`` class to use when loading
|
|
templates. This argument is optional. The default
|
|
is the ``recompile.Loader`` class, which
|
|
automatically recompiles templates when they
|
|
change.
|
|
"""
|
|
global _loader
|
|
_loader = loader_class(None, template_dir)
|
|
|
|
def __init__(self, template):
|
|
if _loader is None: # pragma: no cover
|
|
self.initialize()
|
|
#: The name of the template
|
|
self.name = template
|
|
self.template = _loader.load(template)
|
|
|
|
def generate(self, *args, **kwargs):
|
|
"""Return a generator that renders the template in chunks, with the
|
|
given arguments."""
|
|
return self.template(*args, **kwargs)
|
|
|
|
def render(self, *args, **kwargs):
|
|
"""Render the template with the given arguments and return it as a
|
|
string."""
|
|
return ''.join(self.generate(*args, **kwargs))
|
|
|
|
def generate_async(self, *args, **kwargs):
|
|
"""Return an asynchronous generator that renders the template in
|
|
chunks, using the given arguments."""
|
|
class sync_to_async_iter():
|
|
def __init__(self, iter):
|
|
self.iter = iter
|
|
|
|
def __aiter__(self):
|
|
return self
|
|
|
|
async def __anext__(self):
|
|
try:
|
|
return next(self.iter)
|
|
except StopIteration:
|
|
raise StopAsyncIteration
|
|
|
|
return sync_to_async_iter(self.generate(*args, **kwargs))
|
|
|
|
async def render_async(self, *args, **kwargs):
|
|
"""Render the template with the given arguments asynchronously and
|
|
return it as a string."""
|
|
response = ''
|
|
async for chunk in self.generate_async(*args, **kwargs):
|
|
response += chunk
|
|
return response
|