$var
'.encode('utf-8')) 11 >>> os.close(fd) The template loader accepts a list of directory paths that are then used when searching for template files, in the given order: >>> loader = TemplateLoader([os.path.dirname(path)]) The `load()` method first checks the template cache whether the requested template has already been loaded. If not, it attempts to locate the template file, and returns the corresponding `Template` object: >>> from genshi.template import MarkupTemplate >>> template = loader.load(os.path.basename(path)) >>> isinstance(template, MarkupTemplate) True Template instances are cached: requesting a template with the same name results in the same instance being returned: >>> loader.load(os.path.basename(path)) is template True The `auto_reload` option can be used to control whether a template should be automatically reloaded when the file it was loaded from has been changed. Disable this automatic reloading to improve performance. >>> os.remove(path) NF strictTc C s ddl m} || _| jdu rg | _n t| jttfs | jg| _|| _ || _|p)| | _|| _ || _ |dur>t |ds>t d|| _ t|| _i | _t | _dS )a Create the template laoder. :param search_path: a list of absolute path names that should be searched for template files, or a string containing a single absolute path; alternatively, any item on the list may be a ''load function'' that is passed a filename and returns a file-like object and some metadata :param auto_reload: whether to check the last modification time of template files, and reload them if they have changed :param default_encoding: the default encoding to assume when loading templates; defaults to UTF-8 :param max_cache_size: the maximum number of templates to keep in the cache :param default_class: the default `Template` subclass to use when instantiating templates :param variable_lookup: the variable lookup mechanism; either "strict" (the default), "lenient", or a custom lookup class :param allow_exec: whether to allow Python code blocks in templates :param callback: (optional) a callback function that is invoked after a template was initialized by this loader; the function is passed the template object as only argument. This callback can be used for example to add any desired filters to the template :see: `LenientLookup`, `StrictLookup` :note: Changed in 0.5: Added the `allow_exec` argument r )MarkupTemplateN__call__z-The "callback" parameter needs to be callable)genshi.template.markupr r isinstancelisttuple auto_reloaddefault_encoding default_classvariable_lookup allow_exechasattr TypeErrorcallbackr _cache _uptodate threadingRLock_lock) r r r r max_cache_sizer r r r" r r r r r Q s$ zTemplateLoader.__init__c C s | j }d |d< |S )Nr' )__dict__copyr stater r r __getstate__ s zTemplateLoader.__getstate__c C s || _ t | _d S N)r) r% r& r' r+ r r r __setstate__ s zTemplateLoader.__setstate__c C s |du r| j }| j}|r |rtj|s tjtj||}tj|}|}| j zz(| j | }| j s?|W W | j S | j | }|durT| rT|W W | j S W n ttfy` Y nw d} tj|rstj|g}d} n"|rtj|rtj|} | |vrt|| g }d} n|std|D ]`} t| tjrt| } z | |\} }} }W n ty Y qw z+| r| }| j|| | ||d}| jr| | || j |< || j |< W t| dr| n t| dr| w w | W | j S t||| j w )a[ Load the template with the given name. If the `filename` parameter is relative, this method searches the search path trying to locate a template matching the given name. If the file name is an absolute path, the search path is ignored. If the requested template is not found, a `TemplateNotFound` exception is raised. Otherwise, a `Template` object is returned that represents the parsed template. Template instances are cached to avoid having to parse the same template file more than once. Thus, subsequent calls of this method with the same template file name will return the same `Template` object (unless the ``auto_reload`` option is enabled and the file was changed since the last parse.) If the `relative_to` parameter is provided, the `filename` is interpreted as being relative to that path. :param filename: the relative path of the template file to load :param relative_to: the filename of the template from which the new template is being loaded, or ``None`` if the template is being loaded directly :param cls: the class of the template object to instantiate :param encoding: the encoding of the template to load; defaults to the ``default_encoding`` of the loader instance :return: the loaded `Template` instance :raises TemplateNotFound: if a template with the given name could not be found NFTz(Search path for templates not configured)encodingclose) r r ospathisabsjoindirnamenormpathr' acquirer# r releaser$ KeyErrorOSErrorr r r six string_typesr IOError _instantiater" r r1 r )r filename relative_toclsr0 r cachekeytmpluptodater4 r6 loadfuncfilepathfileobjr r r load sz 8 5 zTemplateLoader.loadc C s( |du r| j }||||| || j| jdS )a Instantiate and return the `Template` object based on the given class and parameters. This function is intended for subclasses to override if they need to implement special template instantiation logic. Code that just uses the `TemplateLoader` should use the `load` method instead. :param cls: the class of the template object to instantiate :param fileobj: a readable file-like object containing the template source :param filepath: the absolute path to the template file :param filename: the path to the template file relative to the search path :param encoding: the encoding of the template to load; defaults to the ``default_encoding`` of the loader instance :return: the loaded `Template` instance :rtype: `Template` N)rG r@ loaderr0 lookupr )r r r )r rB rH rG r@ r0 r r r r? s zTemplateLoader._instantiatec fdd}|S )a Loader factory for loading templates from a local directory. :param path: the path to the local directory containing the templates :return: the loader function to load templates from the given directory :rtype: ``function`` c s> t j| t d}t j fdd} | ||fS )Nrbc s t j kS r. )r2 r3 getmtimer rG mtimer r r$ " s zITemplateLoader.directory.