class GenshiTemplateRenderer(object):
implements(ITemplateRenderer)
def __init__(self,
path,
lookup,
macro=None,
logger=None,
template_class=None):
self.logger = logger or logging.getLogger(__name__)
self.path = path
self.lookup = lookup
self.template_class = template_class
# XXX: This is dirty
self.settings = {}
registry = get_current_registry()
if registry is not None:
self.settings = registry.settings
self.default_domain = self.settings.get('genshi.default_domain')
# the i18n is available
if lookup.translate is not None:
# XXX: This is a very dirty hack, too
# but this is how Pyramid does - getting request from local thread
# IChameleonLookup doesn't provide pluralize there, so we need to
# get by it ourself
pluralize = None
if hasattr(lookup, 'pluralize'):
# pluralize should be added to the lookup, but it is not there
# see will it be there in the future
# this is mainly for test right now
pluralize = lookup.pluralize
else:
request = get_current_request()
if request is not None:
pluralize = get_localizer(request).pluralize
self.adaptor = TranslationStringAdaptor(
lookup.translate,
pluralize,
default_domain=self.default_domain)
self._translator = Translator(self.adaptor)
# no i18n available, just use translator with NullTranslations
else:
self._translator = Translator()
auto_reload = self.settings.get('genshi.auto_reload', True)
self._loader = TemplateLoader(callback=self._tmpl_loaded,
auto_reload=auto_reload)
def translate(self, *args, **kwargs):
kwargs.setdefault('domain', self.default_domain)
ts = TranslationString(*args, **kwargs)
if self.lookup.translate is not None:
return self.lookup.translate(ts)
return ts
def _tmpl_loaded(self, tmpl):
"""Called when a template is loadded by loader
"""
self._translator.setup(tmpl)
@property
def loader(self):
"""Genshi template loader
"""
return self._loader
@property
def translator(self):
"""Genshi i18n translator filter
"""
return self._translator
@property
def template(self):
"""Loaded Genshi Template
"""
tmpl = self.loader.load(os.path.abspath(self.path),
cls=self.template_class)
return tmpl
def render(self, **values):
"""Render template with values
"""
values.setdefault('_', self.translate)
stream = self.template.generate(**values)
method = self.settings.get('genshi.method', 'html')
fmt = self.settings.get('genshi.default_format', method)
encoding = self.settings.get('genshi.default_encoding', 'utf8')
kwargs = {}
doctype = self.settings.get('genshi.default_doctype', None)
if doctype is not None:
kwargs['doctype'] = doctype
body = stream.render(method=fmt, encoding=encoding, **kwargs)
return body
# implement ITemplateRenderer interface
def implementation(self):
return self.render
def __call__(self, value, system):
try:
system.update(value)
except (TypeError, ValueError):
raise ValueError('renderer was passed non-dictionary as value')
result = self.render(**system)
return result
class GenshiTemplateRenderer(object):
implements(ITemplateRenderer)
def __init__(
self,
path,
lookup,
macro=None,
logger=None,
template_class=None,
):
self.logger = logger or logging.getLogger(__name__)
self.path = path
self.lookup = lookup
self.template_class = template_class
# XXX: This is dirty
self.settings = {}
registry = get_current_registry()
if registry is not None:
self.settings = registry.settings
self.default_domain = self.settings.get('genshi.default_domain')
# the i18n is available
if lookup.translate is not None:
# XXX: This is a very dirty hack, too
# but this is how Pyramid does - getting request from local thread
# IChameleonLookup doesn't provide pluralize there, so we need to
# get by it ourself
pluralize = None
if hasattr(lookup, 'pluralize'):
# pluralize should be added to the lookup, but it is not there
# see will it be there in the future
# this is mainly for test right now
pluralize = lookup.pluralize
else:
request = get_current_request()
if request is not None:
pluralize = get_localizer(request).pluralize
self.adaptor = TranslationStringAdaptor(
lookup.translate,
pluralize,
default_domain=self.default_domain
)
self._translator = Translator(self.adaptor)
# no i18n available, just use translator with NullTranslations
else:
self._translator = Translator()
auto_reload = self.settings.get('genshi.auto_reload', True)
self._loader = TemplateLoader(callback=self._tmpl_loaded,
auto_reload=auto_reload)
def translate(self, *args, **kwargs):
kwargs.setdefault('domain', self.default_domain)
ts = TranslationString(*args, **kwargs)
if self.lookup.translate is not None:
return self.lookup.translate(ts)
return ts
def _tmpl_loaded(self, tmpl):
"""Called when a template is loadded by loader
"""
self._translator.setup(tmpl)
@property
def loader(self):
"""Genshi template loader
"""
return self._loader
@property
def translator(self):
"""Genshi i18n translator filter
"""
return self._translator
@property
def template(self):
"""Loaded Genshi Template
"""
tmpl = self.loader.load(
os.path.abspath(self.path),
cls=self.template_class,
)
return tmpl
def render(self, **values):
"""Render template with values
"""
values.setdefault('_', self.translate)
stream = self.template.generate(**values)
method = self.settings.get('genshi.method', 'html')
fmt = self.settings.get('genshi.default_format', method)
encoding = self.settings.get('genshi.default_encoding', 'utf8')
kwargs = {}
doctype = self.settings.get('genshi.default_doctype', None)
if doctype is not None:
kwargs['doctype'] = doctype
body = stream.render(method=fmt, encoding=encoding, **kwargs)
return body
# implement ITemplateRenderer interface
def implementation(self):
return self.render
def __call__(self, value, system):
try:
system.update(value)
except (TypeError, ValueError):
raise ValueError('renderer was passed non-dictionary as value')
result = self.render(**system)
return result
class GenshiTemplateRenderer(object):
def __init__(
self,
path,
settings,
package=None,
template_class=None,
):
self.path = path
self.settings = settings
self.package = package
self.template_class = template_class
self.default_domain = self.settings.get('genshi.default_domain')
auto_reload = asbool(self.settings.get('genshi.auto_reload', True))
self.loader = TemplateLoader(
self._load_asset,
callback=self._tmpl_loaded,
auto_reload=auto_reload,
)
# should we enable i18n?
i18n = asbool(self.settings.get('genshi.i18n', True))
if i18n:
self.adaptor = TranslationStringAdaptor(
self.localizer.translate,
self.localizer.pluralize,
default_domain=self.default_domain)
self.translator = Translator(self.adaptor)
# no i18n available, just use translator with NullTranslations
else:
self.translator = Translator()
def _load_asset(self, filename):
"""Load pyramid asset resource
"""
if ':' not in filename:
raise IOError('Not a asset style path')
resolver = AssetResolver(self.package)
filepath = resolver.resolve(filename).abspath()
fileobj = open(filepath, 'rt')
mtime = os.path.getmtime(filepath)
def _uptodate():
return mtime == os.path.getmtime(filepath)
return filepath, filename, fileobj, _uptodate
@property
def localizer(self):
request = get_current_request()
localizer = get_localizer(request)
return localizer
def translate(self, *args, **kwargs):
kwargs.setdefault('domain', self.default_domain)
ts = TranslationString(*args, **kwargs)
if self.localizer is not None:
return self.localizer.translate(ts)
return ts
def _tmpl_loaded(self, tmpl):
"""Called when a template is loadded by loader
"""
self.translator.setup(tmpl)
@property
def template(self):
"""Loaded Genshi Template
"""
tmpl = self.loader.load(
os.path.abspath(self.path),
cls=self.template_class,
)
return tmpl
def render(self, **values):
"""Render template with values
"""
values.setdefault('_', self.translate)
stream = self.template.generate(**values)
method = self.settings.get('genshi.method', 'html')
fmt = self.settings.get('genshi.default_format', method)
encoding = self.settings.get('genshi.default_encoding', 'utf8')
doctype = self.settings.get('genshi.default_doctype', None)
kwargs = {}
if doctype is not None:
kwargs['doctype'] = doctype
body = stream.render(method=fmt, encoding=encoding, **kwargs)
return body
def __call__(self, value, system):
try:
system.update(value)
except (TypeError, ValueError):
raise ValueError('renderer was passed non-dictionary as value')
result = self.render(**system)
return result
class GenshiTemplateRenderer(object):
def __init__(
self,
path,
settings,
package=None,
template_class=None,
):
self.path = path
self.settings = settings
self.package = package
self.template_class = template_class
self.default_domain = self.settings.get('genshi.default_domain')
auto_reload = asbool(self.settings.get('genshi.auto_reload', True))
self.loader = TemplateLoader(
self._load_asset,
callback=self._tmpl_loaded,
auto_reload=auto_reload,
)
# should we enable i18n?
i18n = asbool(self.settings.get('genshi.i18n', True))
if i18n:
self.adaptor = TranslationStringAdaptor(
self.localizer.translate,
self.localizer.pluralize,
default_domain=self.default_domain
)
self.translator = Translator(self.adaptor)
# no i18n available, just use translator with NullTranslations
else:
self.translator = Translator()
def _load_asset(self, filename):
"""Load pyramid asset resource
"""
if ':' not in filename:
raise IOError('Not a asset style path')
resolver = AssetResolver(self.package)
filepath = resolver.resolve(filename).abspath()
fileobj = open(filepath, 'rt')
mtime = os.path.getmtime(filepath)
def _uptodate():
return mtime == os.path.getmtime(filepath)
return filepath, filename, fileobj, _uptodate
@property
def localizer(self):
request = get_current_request()
localizer = get_localizer(request)
return localizer
def translate(self, *args, **kwargs):
kwargs.setdefault('domain', self.default_domain)
ts = TranslationString(*args, **kwargs)
if self.localizer is not None:
return self.localizer.translate(ts)
return ts
def _tmpl_loaded(self, tmpl):
"""Called when a template is loadded by loader
"""
self.translator.setup(tmpl)
@property
def template(self):
"""Loaded Genshi Template
"""
tmpl = self.loader.load(
os.path.abspath(self.path),
cls=self.template_class,
)
return tmpl
def render(self, **values):
"""Render template with values
"""
values.setdefault('_', self.translate)
stream = self.template.generate(**values)
method = self.settings.get('genshi.method', 'html')
fmt = self.settings.get('genshi.default_format', method)
encoding = self.settings.get('genshi.default_encoding', 'utf8')
doctype = self.settings.get('genshi.default_doctype', None)
kwargs = {}
if doctype is not None:
kwargs['doctype'] = doctype
body = stream.render(method=fmt, encoding=encoding, **kwargs)
return body
def __call__(self, value, system):
try:
system.update(value)
except (TypeError, ValueError):
raise ValueError('renderer was passed non-dictionary as value')
result = self.render(**system)
return result
