�
<��g�] � �P � d Z ddlZddlZddlZddlZddlZddlZddl Z ddl
mZ ddlm
Z
ddlmZ ddlmZ ddlmZ dd lmZ ej rdd
lmZ ddlmZ ded
ej e fd�Z G d� d� � Z G d� de� � Zej dk rdej d
ej ee!f fd�Z"ndej d
ej ee!f fd�Z" G d� de� � Z# G d� de� � Z$ G d� de� � Z% G d� de� � Z& G d� d e� � Z' G d!� d"e� � Z( G d#� d$e� � Z)dS )%zKAPI and implementations for loading templates from different data
sources.
� N)�abc)�sha1)�
import_module)�
ModuleType� )�TemplateNotFound)�internalcode)�Environment)�Template�template�returnc �* � g }| � d� � D ]z}t j j |v s9t j j rt j j |v s|t j j k rt
| � � �|r|dk r|� |� � �{|S )z�Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
�/�.)�split�os�path�sep�altsep�pardirr �append)r �pieces�pieces �^/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/jinja2/loaders.py�split_template_pathr s� � � �F�����$�$� !� !���G�K�5� � ����
!�#%�7�>�U�#:�#:�����&�&�"�8�,�,�,�
� !�u��|�|��M�M�%� � � ���M� c � � e Zd ZdZdZdddedej eej e ej ej g e
f f fd�Zdej e fd�Z
e dddd
edej ej eej f ddfd
�� � Zd S )�
BaseLoadera� Baseclass for all loaders. Subclass this and override `get_source` to
implement a custom loading mechanism. The environment provides a
`get_template` method that calls the loader's `load` method to get the
:class:`Template` object.
A very basic example for a loader that looks up templates on the file
system could look like this::
from jinja2 import BaseLoader, TemplateNotFound
from os.path import join, exists, getmtime
class MyLoader(BaseLoader):
def __init__(self, path):
self.path = path
def get_source(self, environment, template):
path = join(self.path, template)
if not exists(path):
raise TemplateNotFound(template)
mtime = getmtime(path)
with open(path) as f:
source = f.read()
return source, path, lambda: mtime == getmtime(path)
T�environmentr
r r
c �v � | j s$t t | � � j � d�� � �t |� � �)a� Get the template source, filename and reload helper for a template.
It's passed the environment and template name and has to return a
tuple in the form ``(source, filename, uptodate)`` or raise a
`TemplateNotFound` error if it can't locate the template.
The source part of the returned tuple must be the source of the
template as a string. The filename should be the name of the
file on the filesystem if it was loaded from there, otherwise
``None``. The filename is used by Python for the tracebacks
if no loader extension is used.
The last item in the tuple is the `uptodate` function. If auto
reloading is enabled it's always called to check if the template
changed. No arguments are passed so the function must store the
old state somewhere (for example in a closure). If it returns `False`
the template will be reloaded.
z$ cannot provide access to the source)�has_source_access�RuntimeError�type�__name__r )�selfr r s r �
get_sourcezBaseLoader.get_sourceK sF � �( �%� ����:�:�&�L�L�L�� �
� �x�(�(�(r c � � t d� � �)z�Iterates over all templates. If the loader does not support that
it should raise a :exc:`TypeError` which is the default behavior.
z-this loader cannot iterate over all templates)� TypeError�r% s r �list_templateszBaseLoader.list_templatese s � � �G�H�H�Hr N�name�globalsr c �H � d}|�i }| � ||� � \ }}}|j }|�|� ||||� � } | j }|�|� |||� � }|�#| j �|| _ |� | � � |j � ||||� � S )ac Loads a template. This method looks up the template in the cache
or loads one by calling :meth:`get_source`. Subclasses should not
override this method as loaders working on collections of other
loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
will not call this method but `get_source` directly.
N)r&