def __call__(self, environ, start_response): rl = core.request_local() rl.clear() rl["middleware"] = self req = wo.Request(environ) path = req.path_info if self.config.serve_resources and path.startswith(self.config.res_prefix): return self.resources(environ, start_response) else: if self.config.serve_controllers and path.startswith(self.config.controller_prefix): resp = self.controllers(req) else: if self.app: resp = req.get_response(self.app, catch_exc_info=True) else: resp = wo.Response(status="404 Not Found") content_type = resp.headers.get("Content-Type", "text/plain").lower() if self.config.inject_resources and "html" in content_type: body = resources.inject_resources(resp.body, encoding=resp.charset) if isinstance(body, unicode): resp.unicode_body = body else: resp.body = body core.request_local().clear() return resp(environ, start_response)
def lookup_provided_translator(_sval): mw = core.request_local().get('middleware') if not mw: return _sval try: return core.request_local()['middleware'].config.translator(_sval) except TypeError: log.warn(traceback.format_exc()) return _sval
def prepare(self): super(Resource, self).prepare() rl_resources = core.request_local().setdefault('resources', []) rl_location = core.request_local()['middleware'].config.inject_resources_location if self not in rl_resources: if self.location is '__use_middleware': self.location = rl_location for r in self.resources: r.req().prepare() rl_resources.append(self)
def unflatten_params(params): """This performs the first stage of validation. It takes a dictionary where some keys will be compound names, such as "form:subform:field" and converts this into a nested dict/list structure. It also performs unicode decoding, with the encoding specified in the middleware config. """ if isinstance(params, webob.MultiDict): params = params.mixed() mw = core.request_local().get('middleware') enc = mw.config.encoding if mw else 'utf-8' try: for p in params: if isinstance(params[p], str): params[p] = params[p].decode(enc) except UnicodeDecodeError: raise ValidationError('decode', Validator(encoding=enc)) out = {} for pname in params: dct = out elements = pname.split(':') for e in elements[:-1]: dct = dct.setdefault(e, {}) dct[elements[-1]] = params[pname] numdict_to_list(out) return out
def get_engine_name(template_name, mw=None): global engine_name_cache try: engine_name, template_path = template_name.split(':', 1) return engine_name except ValueError: pass try: return engine_name_cache[template_name] except KeyError: pass try: if mw is None: rl = core.request_local() mw = rl['middleware'] pref_rend_eng = mw.config.preferred_rendering_engines except (KeyError, AttributeError): pref_rend_eng = ['mako', 'genshi', 'cheetah', 'kid'] # find the first file in the preffered engines available for templating for engine_name in pref_rend_eng: if template_available(template_name, engine_name, mw): engine_name_cache[template_name] = engine_name return engine_name if not mw.config.strict_engine_selection: pref_rend_eng = ['mako', 'genshi', 'cheetah', 'kid'] for engine_name in pref_rend_eng: if template_available(template_name, engine_name): engine_name_cache[template_name] = engine_name return engine_name raise EngineError(engine_error_template % (template_name, template_name))
def get_rendering_extensions_lookup(mw): if mw is None: rl = core.request_local() mw = rl.get('middleware') if mw is None: return _default_rendering_extension_lookup return mw.config.rendering_extension_lookup
def get_engine_name(template_name, mw=None): global engine_name_cache try: engine_name, template_path = template_name.split(':', 1) return engine_name except ValueError: pass try: return engine_name_cache[template_name] except KeyError: pass try: if mw is None: rl = core.request_local() mw = rl['middleware'] pref_rend_eng = mw.config.preferred_rendering_engines except (KeyError, AttributeError): pref_rend_eng = ['mako', 'genshi', 'cheetah', 'kid'] #find the first file in the preffered engines that is available for templating for engine_name in pref_rend_eng: if template_available(template_name, engine_name, mw): engine_name_cache[template_name] = engine_name return engine_name if not mw.config.strict_engine_selection: pref_rend_eng = ['mako', 'genshi', 'cheetah', 'kid'] for engine_name in pref_rend_eng: if template_available(template_name, engine_name): engine_name_cache[template_name] = engine_name return engine_name raise EngineError("Could not find template for: %s. You may need to specify \ a template engine name in the widget like mako:%s, or change the middleware setup \ to include the template's templating language in your preferred_template_engines \ configuration. As a last resort, you may set strict_template_selection to false \ which will grab whatever template it finds if there one of your preferred template \ engines is not found."""%(template_name, template_name))
def load_engine(self, name, options={}, extra_vars_func=None): if name in self: raise EngineError("Template engine '%s' is already loaded" % name) # TODO -- produce a nicer message when dotted_template_lookup == None if name == 'mako': self[name] = dotted_template_lookup return self[name] orig_name = name if name == 'genshi_abs': name = 'genshi' options = dict(options) options.update({'genshi.search_path': '.'}) try: mw = core.request_local()['middleware'] factory = mw.config.available_rendering_engines[name] except (KeyError, AttributeError): mount_point = "python.templating.engines" for entrypoint in pk.iter_entry_points(mount_point): if entrypoint.name == name: factory = entrypoint.load() break else: raise EngineError("No template engine for '%s'" % name) self[orig_name] = factory(extra_vars_func, options)
def register_resource(modname, filename, whole_dir): """ API function for registering resources *for serving*. This should not be confused with resource registration for *injection*. A resource must be registered for serving for it to be also registered for injection. If the middleware is available, the resource is directly registered with the ResourcesApp. If the middleware is not available, the resource is stored in the request_local dict. When the middleware is later initialized, those waiting registrations are processed. """ rl = core.request_local() mw = rl.get('middleware') if mw: mw.resources.register(modname, filename, whole_dir) else: rl['queued_resources'] = rl.get('queued_resources', []) + [ (modname, filename, whole_dir) ] log.debug("No middleware in place. Queued %r->%r(%r) registration." % (modname, filename, whole_dir))
def __call__(self, html, resources=None, encoding=None): """Injects resources, if any, into html string when called. .. note:: Ignore the ``self`` parameter if seeing this as :func:`tw.core.resource_injector.inject_resources` docstring since it is an alias for an instance method of a private class. ``html`` must be a ``encoding`` encoded string. If ``encoding`` is not given it will be tried to be derived from a <meta>. """ if resources is None: resources = core.request_local().get('resources', None) if resources: encoding = encoding or find_charset(html) or 'utf-8' html = util.MultipleReplacer.__call__(self, html, resources, encoding) core.request_local().pop('resources', None) return html
def prepare(self): super(ResourceBundle, self).prepare() rl = core.request_local() rl_resources = rl.setdefault('resources', []) rl_location = rl['middleware'].config.inject_resources_location if self not in rl_resources: for r in self.resources: r.req().prepare()
def prepare(self): rl = core.request_local() if not self.no_inject: if not hasattr(self, 'link'): # TBD shouldn't we test for this in __new__ ? if not self.filename: raise pm.ParameterError( "Either 'link' or 'filename' must be specified") resources = rl['middleware'].resources self.link = resources.resource_path(self.modname or '__anon__', self.filename) super(Link, self).prepare()
def __init__(self, app, controllers=None, **config): self.app = app self.config = Config(**config) self.engines = template.EngineManager() self.resources = resources.ResourcesApp(self.config) self.controllers = controllers or ControllersApp() rl = core.request_local() for widget, path in rl.get("queued_controllers", []): self.controllers.register(widget, path) rl["queued_controllers"] = []
def prepare(self): super(Resource, self).prepare() rl = core.request_local() rl_resources = rl.setdefault('resources', []) rl_location = rl['middleware'].config.inject_resources_location if self not in rl_resources: if self.location is '__use_middleware': self.location = rl_location rl_resources.append(self)
def __init__(self, msg, validator=None, widget=None): self.widget = widget validator = validator or Validator mw = core.request_local().get('middleware') if isinstance(validator, Validator): msg = validator.msg_rewrites.get(msg, msg) if mw and msg in mw.config.validator_msgs: msg = mw.config.validator_msgs[msg] elif hasattr(validator, 'msgs') and msg in validator.msgs: msg = validator.msgs.get(msg, msg) msg = re.sub('\$(\w+)', lambda m: str(getattr(validator, m.group(1))), unicode(msg)) super(ValidationError, self).__init__(msg)
def __call__(self, environ, start_response): rl = core.request_local() rl.clear() rl['middleware'] = self req = wo.Request(environ) path = req.path_info if self.config.serve_resources and \ path.startswith(self.config.res_prefix): return self.resources(environ, start_response) else: if self.config.serve_controllers and \ path.startswith(self.config.controller_prefix): resp = self.controllers(req) else: if self.app: resp = req.get_response(self.app, catch_exc_info=True) else: resp = wo.Response(status="404 Not Found") ct = resp.headers.get('Content-Type', 'text/plain').lower() should_inject = ( self.config.inject_resources and 'html' in ct and not isinstance(resp.app_iter, types.GeneratorType) ) if should_inject: body = resources.inject_resources( resp.body, encoding=resp.charset, ) if isinstance(body, unicode): resp.unicode_body = body else: resp.body = body core.request_local().clear() return resp(environ, start_response)
def prepare(self): rl = core.request_local() if not self.no_inject: if not hasattr(self, 'link'): # TBD shouldn't we test for this in __new__ ? if not self.filename: raise pm.ParameterError( "Either 'link' or 'filename' must be specified" ) resources = rl['middleware'].resources self.link = resources.resource_path( self.modname or '__anon__', self.filename ) super(Link, self).prepare()
def lookup_provided_translator(_sval): mw = core.request_local().get('middleware') if not mw: return _sval try: translator = get_translator(mw.config.get_lang()) except AttributeError: try: translator = mw.config.translator except AttributeError: return _sval return translator(_sval)
def __call__(self, environ, start_response): rl = core.request_local() rl.clear() rl['middleware'] = self req = wo.Request(environ) path = req.path_info if self.config.serve_resources and \ path.startswith(self.config.res_prefix): return self.resources(environ, start_response) else: if self.config.serve_controllers and \ path.startswith(self.config.controller_prefix): resp = self.controllers(req) else: if self.app: resp = req.get_response(self.app, catch_exc_info=True) else: resp = wo.Response(status="404 Not Found") ct = resp.headers.get('Content-Type', 'text/plain').lower() should_inject = ( self.config.inject_resources and 'html' in ct and not isinstance(resp.app_iter, types.GeneratorType)) if should_inject: body = resources.inject_resources( resp.body, encoding=resp.charset, ) if isinstance(body, unicode): resp.unicode_body = body else: resp.body = body core.request_local().clear() return resp(environ, start_response)
def __call__(self, req): config = rl = core.request_local()['middleware'].config path = req.path_info.split('/')[1:] pre = config.controller_prefix.strip('/') if pre and path[0] != pre: return wo.Response(status="404 Not Found") path = path[1] if pre else path[0] widget_name = path or 'index' try: widget = self._widgets[widget_name] except KeyError: resp = wo.Response(status="404 Not Found") else: resp = widget.request(req) return resp
def __call__(self, req): config = rl = core.request_local()["middleware"].config path = req.path_info.split("/")[1:] pre = config.controller_prefix.strip("/") if pre and path[0] != pre: return wo.Response(status="404 Not Found") path = path[1] if pre else path[0] widget_name = path or "index" try: widget = self._widgets[widget_name] except KeyError: resp = wo.Response(status="404 Not Found") else: resp = widget.request(req) return resp
def __init__(self, app, controllers=None, **config): self.app = app self.config = Config(**config) self.resources = resources.ResourcesApp(self.config) self.controllers = controllers or ControllersApp() rl = core.request_local() # Load up controllers that wanted to be registered before we were ready for widget, path in rl.get('queued_controllers', []): self.controllers.register(widget, path) rl['queued_controllers'] = [] # Load up resources that wanted to be registered before we were ready for modname, filename, whole_dir in rl.get('queued_resources', []): self.resources.register(modname, filename, whole_dir) rl['queued_resources'] = []
def __init__(self, app, controllers=None, **config): self.app = app self.config = Config(**config) self.resources = resources.ResourcesApp(self.config) self.controllers = controllers or ControllersApp() rl = core.request_local() # Load up controllers that wanted to be registered before we were ready for widget, path in rl.get("queued_controllers", []): self.controllers.register(widget, path) rl["queued_controllers"] = [] # Load up resources that wanted to be registered before we were ready for modname, filename, whole_dir in rl.get("queued_resources", []): self.resources.register(modname, filename, whole_dir) rl["queued_resources"] = []
def register_controller(widget, path): """ API function for registering widget controllers. If the middleware is available, the widget is directly registered with the ControllersApp. If the middleware is not available, the widget is stored in the request_local dict. When the middleware is later initialized, those waiting registrations are processed. """ rl = core.request_local() mw = rl.get("middleware") if mw: mw.controllers.register(widget, path) else: rl["queued_controllers"] = rl.get("queued_controllers", []) + [(widget, path)] log.info("No middleware in place. Queued %r->%r registration." % (path, widget))
def __init__(self, app, controllers=None, **config): self.app = app self.config = Config(**config) self.engines = template.EngineManager() self.resources = resources.ResourcesApp(self.config) self.controllers = controllers or ControllersApp() rl = core.request_local() # Load up controllers that wanted to be registered before we were ready for widget, path in rl.get('queued_controllers', []): self.controllers.register(widget, path) rl['queued_controllers'] = [] # Load up resources that wanted to be registered before we were ready for modname, filename in rl.get('queued_resources', []): self.resources.register(modname, filename) rl['queued_resources'] = []
def __init__(self, msg, validator=None, widget=None): self.widget = widget validator = validator or Validator mw = core.request_local().get('middleware') if isinstance(validator, Validator): msg = validator.msg_rewrites.get(msg, msg) if mw and msg in mw.config.validator_msgs: msg = mw.config.validator_msgs[msg] elif hasattr(validator, 'msgs') and msg in validator.msgs: msg = validator.msgs.get(msg, msg) # In the event that the user specified a form-wide validator but # they did not specify a childerror message, show no error. if msg == 'childerror': msg = '' msg = re.sub('\$(\w+)', lambda m: str(getattr(validator, m.group(1))), unicode(msg)) super(ValidationError, self).__init__(msg)
def register_controller(widget, path): """ API function for registering widget controllers. If the middleware is available, the widget is directly registered with the ControllersApp. If the middleware is not available, the widget is stored in the request_local dict. When the middleware is later initialized, those waiting registrations are processed. """ rl = core.request_local() mw = rl.get('middleware') if mw: mw.controllers.register(widget, path) else: rl['queued_controllers'] = \ rl.get('queued_controllers', []) + [(widget, path)] log.debug("No middleware in place. Queued %r->%r registration." % (path, widget))
def get_template(self, template_name): """this is the emulated method that must return a template instance based on a given template name """ if not self.template_cache.has_key(template_name): # the template string is not yet loaded into the cache. # Do so now self.__load(template_name) try: # AUTO RELOADING will be activated only if user has # explicitly asked for it in the configuration # return the template, but first make sure it's not outdated # and if outdated, refresh the cache. if getattr(core.request_local()['middleware'].config, 'auto_reload_templates', False): return self.__check(self.template_cache[template_name]) except (AttributeError, KeyError): pass return self.template_cache[template_name]
def __init__(self, app, controllers=None, **config): self.app = app self.config = Config(**config) self.resources = resources.ResourcesApp(self.config) self.controllers = controllers or ControllersApp() rl = core.request_local() # Load up controllers that wanted to be registered before we were ready for widget, path in rl.get('queued_controllers', []): self.controllers.register(widget, path) rl['queued_controllers'] = [] # Load up resources that wanted to be registered before we were ready for modname, filename, whole_dir in rl.get('queued_resources', []): self.resources.register(modname, filename, whole_dir) rl['queued_resources'] = [] # Future resource registrations should know to just plug themselves into # me right away (instead of being queued). rl['middleware'] = self
def get_engine_name(template_name, mw=None): global engine_name_cache if template_name in engine_name_cache: return engine_name_cache[template_name] if ':' in template_name: engine_name = template_name.split(':', 1)[0] engine_name_cache[template_name] = engine_name return engine_name try: if mw is None: rl = core.request_local() mw = rl['middleware'] pref_rend_eng = mw.config.preferred_rendering_engines except (KeyError, AttributeError): pref_rend_eng = ['mako', 'genshi', 'jinja', 'kajiki', 'chameleon'] # find the first file in the preffered engines available for templating for engine_name in pref_rend_eng: try: get_source(engine_name, template_name, mw=mw) engine_name_cache[template_name] = engine_name return engine_name except IOError: pass if not mw.config.strict_engine_selection: pref_rend_eng = ['mako', 'genshi', 'jinja', 'kajiki', 'chameleon'] for engine_name in pref_rend_eng: try: get_source(engine_name, template_name, mw=mw) engine_name_cache[template_name] = engine_name return engine_name except IOError: pass raise ValueError("Could not find engine name for %s" % template_name)
def get_engine_name(template_name, mw=None): if template_name in engine_name_cache: return engine_name_cache[template_name] if ':' in template_name: engine_name = template_name.split(':', 1)[0] engine_name_cache[template_name] = engine_name return engine_name try: if mw is None: rl = core.request_local() mw = rl['middleware'] pref_rend_eng = mw.config.preferred_rendering_engines except (KeyError, AttributeError): pref_rend_eng = ['mako', 'genshi', 'jinja', 'kajiki', 'chameleon'] # find the first file in the preffered engines available for templating for engine_name in pref_rend_eng: try: get_source(engine_name, template_name, mw=mw) engine_name_cache[template_name] = engine_name return engine_name except IOError: pass if not mw.config.strict_engine_selection: pref_rend_eng = ['mako', 'genshi', 'jinja', 'kajiki', 'chameleon'] for engine_name in pref_rend_eng: try: get_source(engine_name, template_name, mw=mw) engine_name_cache[template_name] = engine_name return engine_name except IOError: pass raise ValueError("Could not find engine name for %s" % template_name)
def register_resource(modname, filename, whole_dir): """ API function for registering resources *for serving*. This should not be confused with resource registration for *injection*. A resource must be registered for serving for it to be also registered for injection. If the middleware is available, the resource is directly registered with the ResourcesApp. If the middleware is not available, the resource is stored in the request_local dict. When the middleware is later initialized, those waiting registrations are processed. """ rl = core.request_local() mw = rl.get('middleware') if mw: mw.resources.register(modname, filename, whole_dir) else: rl['queued_resources'] = rl.get('queued_resources', []) + [(modname, filename, whole_dir)] log.debug("No middleware in place. Queued %r->%r(%r) registration." % (modname, filename, whole_dir))
def prepare(self): resources = core.request_local()['middleware'].resources self.link = resources.resource_path( self.modname, self.filename, )
def prepare(self): resources = core.request_local()['middleware'].resources self.link = resources.register(self.modname, self.filename, whole_dir=True)
def lookup_provided_translator(_sval): mw = core.request_local().get('middleware') if not mw: return _sval return core.request_local()['middleware'].config.translator(_sval)