o .d w@sjdZddlmZddlZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl!m#Z#ddl!m$Z$ddl!m%Z%ddl!m&Z&dd l!m'Z'dd!l(m)Z)dd"l*m+Z+dd#l,m-Z-dd$l.m/Z/dd%l0m1Z1dd&l2m3Z3er dd'l4m5Z5dd(lm6Z6dd)l7m8Z8dd*l7m9Z9dd+l7m:Z:dd,l;mZ>Gd.d/d/Z?ed0d1dZdKdLZ@dMdNdOdPdQe+jAedRdQdRdSddQdTdUdfd[dXdYZBdS)\zCShared configuration from which templates can be loaded and parsed.) annotationsN) lru_cache) TYPE_CHECKING)Any)Callable)ClassVar)Dict)Iterator)Mapping)MutableMapping)Optional)Tuple)Type)Union)ast)builtin)loaders) InnerTagMap) TagAnalysis) Undefined)Error)LiquidSyntaxError)TemplateInheritanceError)lookup_warning)parse_boolean_expression)$parse_boolean_expression_with_parens)parse_conditional_expression)(parse_conditional_expression_with_parens)parse_filtered_expression)parse_loop_expression) get_lexer)Mode) get_parser) TokenStream) BoundTemplate)LRUCache)Path)Context)BooleanExpression)FilteredExpression)LoopExpression)Tag)Tokenc@seZdZUdZdZded<dZded<dZded<dZded <e Z d d d d de j de dddddddddfdyd,d-Zdzd/d0Zd{d2d3Zd|d7d8Zd}dd?ZddBdCZ D   dddIdJZ dddKdLZ dddMdNZ dddQdRZ dddSdTZddWdXZddYdZZ [ddd\dd`daZdddbddddeZdddbddfdgZ dddidjZ  dddqdrZ dddtduZ! dddwdxZ"dS) EnvironmentaShared configuration from which templates can be loaded and parsed. An `Environment` is where you might register custom tags and filters, or store global context variables that should be included with every template. Args: tag_start_string: The sequence of characters indicating the start of a liquid tag. tag_end_string: The sequence of characters indicating the end of a liquid tag. statement_start_string: The sequence of characters indicating the start of an output statement. statement_end_string: The sequence of characters indicating the end of an output statement. template_comments: If `True`, enable template comments. Where, by default, anything between `{#` and `#}` is considered a comment. `False`. comment_start_string: The sequence of characters indicating the start of a comment. `comment_start_string` to have any effect. comment_end_string: The sequence of characters indicating the end of a comment. `comment_end_string` to have any effect. tolerance: Indicates how tolerant to be of errors. Must be one of `Mode.LAX`, `Mode.WARN` or `Mode.STRICT`. loader: A template loader. If you want to use the builtin "render" or "include" tags, a loader must be configured. `liquid.loaders.DictLoader`. undefined: A subclass of `Undefined` that represents undefined values. Could be one of the built-in undefined types, `Undefined`, `DebugUndefined` or `StrictUndefined`. undefined type that silently ignores undefined values. strict_filters: If `True`, will raise an exception upon finding an undefined filter. Otherwise undefined filters are silently ignored. Defaults to `True`. autoescape: If `True`, all context values will be HTML-escaped before output unless they've been explicitly marked as "safe". Requires the package Markupsafe. auto_reload: If `True`, loaders that have an `uptodate` callable will reload template source data automatically. For deployments where template sources don't change between service reloads, setting auto_reload to `False` can yield an increase in performance by avoiding calls to `uptodate`. `. cache_size: The capacity of the template cache in number of templates. . If `cache_size` is `None` or less than `1`, it has the effect of setting `auto_reload` to `False`. expression_cache_size: The capacity of each of the common expression caches. `, disabling expression caching. globals: An optional mapping that will be added to the context of any template loaded from this environment. Attributes: context_depth_limit: Class attribute.The maximum number of times a render context can be extended or wrapped before a `ContextDepthError` is raised. local_namespace_limit: Class attribute. The maximum number of bytes (according to sys.getsizeof) allowed in a template's local namespace, per render, before a `LocalNamespaceLimitError` exception is raised. Note that we only count the size of the local namespace values, not its keys. loop_iteration_limit: Class attribute. The maximum number of loop iterations allowed before a `liquid.exceptions.LoopIterationLimitError` is raised. output_stream_limit: Class attribute. The maximum number of bytes that can be written to a template's output stream, per render, before an `OutputStreamLimitError` exception is raised. undefined: The undefined type. When an identifier can not be resolved, an instance of `undefined` is returned. strict_filters: Indicates if an undefined filter should raise an exception or be ignored. autoescape: Indicates if auto-escape is enabled. tags: A dictionary mapping tag names to `liquid.tag.Tag` instances. filters: A dictionary mapping filter names to callable objects implementing a filter's behavior. mode: The current tolerance mode. cache: The template cache. auto_reload: Indicates if automatic reloading of templates is enabled. template_class: `Environment.get_template` and `Environment.from_string` return an instance of :attr:`Environment.template_class`. `liquid.template.BoundTemplate`. globals: A dictionary of variables that will be added to the context of every template rendered from the environment. z ClassVar[int]context_depth_limitNzClassVar[Optional[int]]loop_iteration_limitlocal_namespace_limitoutput_stream_limit{%%}{{}}FT,{##}rtag_start_stringstrtag_end_stringstatement_start_stringstatement_end_string strip_tagsbool tolerancer!loaderOptional[loaders.BaseLoader] undefinedType[Undefined]strict_filters autoescape auto_reload cache_sizeintglobalsOptional[Mapping[str, object]]template_commentscomment_start_stringcomment_end_stringexpression_cache_sizecCs||_||_||_||_||_|pti|_| pi|_||_ ||_ ||_ |j s.d|_ d|_ ||_ | |_ | |_i|_i|_||_| rS| dkrS|jjsSt| |_| |_nd|_d|_||_||j\|_|_|_|_|_|_|dS)NrF)r:r<r=r>r?r DictLoaderrBrKrMrNrOrDrFrGtagsfiltersmodecaching_loaderr%cacherHrP_get_expression_parsersparse_boolean_expression_value*parse_boolean_expression_value_with_parens"parse_conditional_expression_value.parse_conditional_expression_value_with_parensparse_filtered_expression_valueparse_loop_expression_valuesetup_tags_and_filters)selfr:r<r=r>r?rArBrDrFrGrHrIrKrMrNrOrPraJ/var/www/Matress/matenv/lib/python3.10/site-packages/liquid/environment.py__init__sD    zEnvironment.__init__returnc Cs2t|j|j|j|j|j|j|j|j|j df S)N statement) hashr=r>r:r<rNrOrUr?rSgetr`rararb__hash__s zEnvironment.__hash__ Callable[[str], Iterator[Token]]cCst|j|j|j|j|j|jS)z(Return a tokenizer for this environment.)r r:r<r=r>rNrOrhrararb tokenizerszEnvironment.tokenizertag Type[Tag]NonecCs|||j|j<dS)zRegister a liquid tag with the environment. Built-in tags are registered for you automatically with every new `Environment`. Args: tag: The tag to register. N)rSname)r`rlrararbadd_tag szEnvironment.add_tagrofuncCallable[..., Any]cCs||j|<dS)aPRegister a filter function with the environment. Args: name: The filter's name. Does not need to match the function name. This is what you'll use to apply the filter to an expression in a liquid template. func: Any callable that accepts at least one argument, the result of the expression the filter is applied to. If the filter needs access to the active environment or render context, use `liquid.filer.with_context` and/or `liquid.filter.with_environment` decorators. N)rT)r`rorqrararb add_filters zEnvironment.add_filtercCst|dS)z1Add default tags and filters to this environment.N)rregisterrhrararbr_$sz"Environment.setup_tags_and_filterssource ast.ParseTreecCs"t|}||}|t|S)zParse `source` as a liquid template. More often than not you'll want to use `Environment.from_string` instead. )r"rkparser#)r`ruparser token_iterrararbrw(s zEnvironment.parserQpathOptional[Union[str, Path]]matterr$c Csxz||}Wn&ttfy}z||_||_|d}~wty-}ztd|d}~ww|j|||||||dS)a5Parse the given string as a liquid template. Args: source: The liquid template source code. name: Optional name of the template. Available as `Template.name`. path: Optional path or identifier to the origin of the template. globals: An optional mapping of context variables made available every time the resulting template is rendered. matter: Optional mapping containing variables associated with the template. Could be "front matter" or other meta data. Nzunexpected liquid parsing error)envrorz parse_treerKr|) rwrrfilenameru Exceptionrtemplate_class make_globals)r`rurorzrKr|r~errrararb from_string1s& zEnvironment.from_stringcCsr|jdur!|j|}t|tr!|jr|jr!|j|||S|j j ||||d}|jdur7||j|<|S)aLoad and parse a template using the configured loader. Args: name: The template's name. The loader is responsible for interpreting the name. It could be the name of a file or some other identifier. globals: A mapping of context variables made available every time the resulting template is rendered. Raises: TemplateNotFound: if a template with the given name can not be found. NrK) rWrg isinstancer$rH is_up_to_daterKupdaterrBloadr`rorKcachedtemplaterararb get_templateUs     zEnvironment.get_templatecs|jdur&|j|}t|tr&|jr|IdHr&|j|||S|j j ||||dIdH}|jdur?||j|<|S)z#An async version of `get_template`.Nr) rWrgrr$rHis_up_to_date_asyncrKrrrB load_asyncrrararbget_template_asyncrs        zEnvironment.get_template_asynckwargsobjectcKs|jj|||fi|S)aLoad and parse a template with arbitrary loader arguments. This method bypasses the environment's template cache. You should use a caching loader instead when the loader requires extra keyword arguments. _New in version 1.9.0._ )rBload_with_argsr`rorKrrararbget_template_with_argss z"Environment.get_template_with_argscs |jj|||fi|IdHS)zWAn async version of `get_template_with_args`. _New in version 1.9.0._ N)rBload_with_args_asyncrrararbget_template_with_args_asyncs z(Environment.get_template_with_args_asynccontext 'Context'cKs|jj||fi|S)zLoad and parse a template with reference to a render context. This method bypasses the environment's template cache. You should consider using a caching loader. )rBload_with_contextr`rrorrararbget_template_with_contexts z%Environment.get_template_with_contextcs|jj||fi|IdHS)z0An async version of `get_template_with_context`.N)rBload_with_context_asyncrrararbget_template_with_context_asyncsz+Environment.get_template_with_context_async) inner_tagsrOptional[InnerTagMap]rcCst||t|||dS)akAnalyze tags in template source text. Unlike template static or contextual analysis, a tag audit does not parse the template source text into an AST, nor does it attempt to load partial templates from `{% include %}` or `{% render %}` tags. Args: source: The source text of the template. name: A name or identifier for the template. inner_tags: A mapping of block tags to a list of allowed "inner" tags for the block. For example, `{% if %}` blocks are allowed to contain `{% elsif %}` and `{% else %}` tags. )r}rotokensr)rlistrk)r`rurorrararbanalyze_tags_from_strings z$Environment.analyze_tags_from_string)rrOptional['Context']cKsB|r|jjd||d|}n|jj||d}|j|j|j|dS)aAudit template tags without parsing source text into an abstract syntax tree. This is useful for identifying unknown, misplaced and unbalanced tags in a template's source text. See also `liquid.template.BoundTemplate.analyze`. Args: name: The template's name or identifier, as you would use with `Environment.get_template`. Use `Environment.analyze_tags_from_string` to audit tags in template text without using a template loader. context: An optional render context the loader might use to modify the template search space. If given, uses `liquid.loaders.BaseLoader.get_source_with_context` from the current loader. inner_tags: A mapping of block tags to a list of allowed "inner" tags for the block. For example, `{% if %}` blocks are allowed to contain `{% elsif %}` and `{% else %}` tags. kwargs: Loader context. r template_name)rrorNra)rBget_source_with_context get_sourcerrurr`rorrrtemplate_sourcerararb analyze_tagsszEnvironment.analyze_tagscsP|r|jjd||d|IdH}n |jj||dIdH}|j|j|j|dS)z/An async version of `Environment.analyze_tags`.rN)r}rrra)rBget_source_with_context_asyncget_source_asyncrrurrrararbanalyze_tags_asyncs  zEnvironment.analyze_tags_asyncDict[str, object]cCs|r i|j|St|jS)z2Combine environment globals with template globals.)rKdict)r`rKrararbrs zEnvironment.make_globalsexcUnion[Type[Error], Error]msg Optional[str]linenum Optional[int]cCsbt|ts |||d}n|js||_|jtjkr||jtjkr/tjt |t |j dddSdS)zHRaise, warn or ignore the given exception according to the current mode.)r)category stacklevelN) rrrrUr!STRICTWARNwarningswarnr;r __class__)r`rrrrararberrors    zEnvironment.errormaxsizecCs.||_||j\|_|_|_|_|_|_dS)zCreate or replace cached versions of the common expression parsers. If `maxsize` is less than `1`, no expression caching will happen. Args: maxsize: The maximum size of each expression cache. N)rPrXrYrZr[r\r]r^)r`rrararbset_expression_cache_size.s z%Environment.set_expression_cache_sizeTuple[Callable[[str], 'BooleanExpression'], Callable[[str], 'BooleanExpression'], Callable[[str], 'FilteredExpression'], Callable[[str], 'FilteredExpression'], Callable[[str], 'FilteredExpression'], Callable[[str], 'LoopExpression']]cCsd|dkr*t|dtt|dtt|dtt|dtt|dtt|dtfSttttttfS)Nr)rrrrrrr)r`rIrararbrX@s       z#Environment._get_expression_parsers)"r:r;r<r;r=r;r>r;r?r@rAr!rBrCrDrErFr@rGr@rHr@rIrJrKrLrMr@rNr;rOr;rPrJ)rdrJ)rdrj)rlrmrdrn)ror;rqrrrdrn)rdrn)rur;rdrv)rQNNN) rur;ror;rzr{rKrLr|rLrdr$)N)ror;rKrLrdr$)ror;rKrLrrrdr$)rrror;rr;rdr$)r)rur;ror;rrrdr) ror;rrrrrr;rdr)rKrLrdr)NN)rrrrrrrdrn)r)rrJrdrn)rIrJrdr)#__name__ __module__ __qualname____doc__r/__annotations__r0r1r2r$rr!rrrcrirkrprsr_rwrrrrrrrrrrrrrrXrarararbr-5s  R    U     '     +   r- rr:r;r<r=r>r?r@rAr!rBrCrDrErFrGrHrIrJrKrLrMrNrOrPrdcCsptdid|d|d|d|d|d|d|d|d |d | d | d | d | d| d|d|d|S)z=Return an `Environment` initialized with the given arguments.r:r<r=r>r?rArBrDrFrGrHrIrKrMrNrOrPNra)r-)r:r<r=r>r?rArBrDrFrGrHrIrKrMrNrOrPrararbget_implicit_environment]sF     rr3r4r5r6FTr7r8r9rur$cCs~tdid|d|d|d|d|d|ddd |d |d | d | d | ddd| d|d|d|}|j|| dS)a Parse a template, automatically creating an `Environment` to bind it to. Other than `source`, all arguments are passed to the implicit `Environment`, which might have been cached from previous calls to `Template`. Args: source: A Liquid template source string. tag_start_string: The sequence of characters indicating the start of a liquid tag. tag_end_string: The sequence of characters indicating the end of a liquid tag. statement_start_string: The sequence of characters indicating the start of an output statement. statement_end_string: The sequence of characters indicating the end of an output statement. template_comments: If `True`, enable template comments. Where, by default, anything between `{#` and `#}` is considered a comment. comment_start_string: The sequence of characters indicating the start of a comment. `comment_start_string` to have any effect. comment_end_string: The sequence of characters indicating the end of a comment. `template_comments` must be `True` for `comment_end_string` to have any effect. tolerance: Indicates how tolerant to be of errors. Must be one of `Mode.LAX`, `Mode.WARN` or `Mode.STRICT`. undefined: A subclass of `Undefined` that represents undefined values. Could be one of the built-in undefined types, `Undefined`, `DebugUndefined` or `StrictUndefined`. ignores undefined values. strict_filters: If `True`, will raise an exception upon finding an undefined filter. Otherwise undefined filters are silently ignored. `True`. autoescape: If `True`, all context values will be HTML-escaped before output unless they've been explicitly marked as "safe". Requires the package Markupsafe. auto_reload: If `True`, loaders that have an `uptodate` callable will reload template source data automatically. For deployments where template sources don't change between service reloads, setting auto_reload to `False` can yield an increase in performance by avoiding calls to `uptodate`. Defaults to `True`. cache_size: The capacity of the template cache in number of templates. Defaults to 300. If `cache_size` is `None` or less than `1`, it has the effect of setting `auto_reload` to `False`. expression_cache_size: The capacity of each of the common expression caches. `, disabling expression caching. globals: An optional mapping that will be added to the context of any template loaded from this environment. r:r<r=r>r?rArBNrDrFrGrHrIrKrMrNrOrPrra)rr)rur:r<r=r>r?rArDrFrGrHrIrKrMrNrOrPr}rararbTemplatesHE     r)$r:r;r<r;r=r;r>r;r?r@rAr!rBrCrDrErFr@rGr@rHr@rIrJrKrLrMr@rNr;rOr;rPrJrdr-)$rur;r:r;r<r;r=r;r>r;r?r@rAr!rDrErFr@rGr@rHr@rIrJrKrLrMr@rNr;rOr;rPrJrdr$)Cr __future__rr functoolsrtypingrrrrrr r r r r rrliquidrrrliquid.analyze_tagsrrliquid.contextrliquid.exceptionsrrrrliquid.expressionsrrrrrr liquid.lexr liquid.moder! liquid.parser" liquid.streamr#liquid.templater$ liquid.utilsr%pathlibr&r'liquid.expressionr(r)r* liquid.tagr+ liquid.tokenr,r-rrrrarararbs                                           , 0