Hacked By AnonymousFox
�
�܋f�X � �� � d Z ddlZddlZddlZddlZddlZddlZddl m
Z
ddlmZ ddlm
Z
ddlmZ ddlmZ dd lmZ dd
lmZ ej rddlmZ ddlmZ d
edej e fd�Z G d� d� � Z G d� de� � Z G d� de� � Z G d� de� � Z G d� de� � Z G d� de� � Z! G d� de� � Z" G d� de� � 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)�open_if_exists)�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 �E/opt/cloudlinux/venv/lib64/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_sourceJ 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&