python-liquid 2.1.0__py3-none-any.whl → 2.2.1__py3-none-any.whl

liquid/__init__.py

@@ -56,7 +56,7 @@ from .tag import Tag
 
 from . import future
 
-__version__ = "2.1.0"
+__version__ = "2.2.1"
 
 __all__ = (
     "AwareBoundTemplate",

liquid/ast.py

@@ -9,7 +9,9 @@ from enum import auto
 from typing import TYPE_CHECKING
 from typing import Collection
 from typing import Iterable
+from typing import Optional
 from typing import TextIO
+from typing import Union
 
 from .exceptions import DisabledTagError
 from .output import NullIO
@@ -104,7 +106,7 @@ class Node(ABC):
         """Return variables this node adds to the node's block scope."""
         return []
 
-    def partial_scope(self) -> Partial | None:
+    def partial_scope(self) -> Optional[Partial]:
         """Return information about a partial template loaded by this node."""
         return None
 
@@ -121,19 +123,30 @@ class Partial:
     """Partial template meta data.
 
     Args:
-        name: An expression resolving to the name associated with the partial template.
+        name: The name of the partial or an expression resolving to the name
+            associated with the partial template.
         scope: The kind of scope the partial template should have when loaded.
         in_scope: Names that will be added to the partial template scope.
+        key: A hash of the partial template name and any arguments the partial
+            template will be rendered with that might affect its scope. If a
+            key is provided, static analysis helpers will visit a partial
+            template once for each distinct key.
     """
 
-    __slots__ = ("name", "scope", "in_scope")
+    __slots__ = ("name", "scope", "in_scope", "key")
 
     def __init__(
-        self, name: Expression, scope: PartialScope, in_scope: Iterable[Identifier]
+        self,
+        name: Union[Expression, str],
+        scope: PartialScope,
+        in_scope: Iterable[Identifier],
+        *,
+        key: Optional[int] = None,
     ) -> None:
         self.name = name
         self.scope = scope
         self.in_scope = in_scope
+        self.key = key
 
 
 class IllegalNode(Node):

liquid/builtin/__init__.py

@@ -58,6 +58,7 @@ from .filters.string import replace_last
 from .filters.string import rstrip
 from .filters.string import slice_
 from .filters.string import split
+from .filters.string import squish
 from .filters.string import strip
 from .filters.string import strip_html
 from .filters.string import strip_newlines
@@ -175,6 +176,7 @@ def register(env: Environment) -> None:  # noqa: PLR0915
     env.add_filter("base64_decode", base64_decode)
     env.add_filter("base64_url_safe_encode", base64_url_safe_encode)
     env.add_filter("base64_url_safe_decode", base64_url_safe_decode)
+    env.add_filter("squish", squish)
 
     env.add_filter("find", find)
     env.add_filter("find_index", find_index)

liquid/builtin/filters/string.py

@@ -405,3 +405,12 @@ def base64_url_safe_decode(val: str) -> str:
         return base64.urlsafe_b64decode(val).decode()
     except binascii.Error as err:
         raise FilterError("invalid base64-encoded string", token=None) from err
+
+
+RE_WHITESPACE = re.compile(r"\s+")
+
+
+@string_filter
+def squish(val: str) -> str:
+    """Strip whitespace and replace whitespace with a single space."""
+    return RE_WHITESPACE.sub(" ", val.strip())

liquid/builtin/loaders/caching_file_system_loader.py

@@ -21,6 +21,8 @@ class CachingFileSystemLoader(CachingLoaderMixin, FileSystemLoader):
         search_path: One or more paths to search.
         encoding: Open template files with the given encoding.
         ext: A default file extension. Should include a leading period.
+        reject_symlinks: When `True`, reject paths to symlinks that resolve to files
+            outside the search path. Defaults to `False`.
         auto_reload: If `True`, automatically reload a cached template if it has been
             updated.
         namespace_key: The name of a global render context variable or loader keyword
@@ -39,6 +41,7 @@ class CachingFileSystemLoader(CachingLoaderMixin, FileSystemLoader):
         encoding: str = "utf-8",
         ext: Optional[str] = None,
         *,
+        reject_symlinks: bool = False,
         auto_reload: bool = True,
         namespace_key: str = "",
         capacity: int = 300,
@@ -54,4 +57,5 @@ class CachingFileSystemLoader(CachingLoaderMixin, FileSystemLoader):
             search_path=search_path,
             encoding=encoding,
             ext=ext,
+            reject_symlinks=reject_symlinks,
         )

liquid/builtin/loaders/file_system_loader.py

@@ -27,6 +27,8 @@ class FileSystemLoader(BaseLoader):
         search_path: One or more paths to search.
         encoding: Encoding to use when opening files.
         ext: A default file extension. Should include a leading period.
+        reject_symlinks: When `True`, reject paths to symlinks that resolve to files
+            outside the search path. Defaults to `False`.
     """
 
     def __init__(
@@ -35,6 +37,7 @@ class FileSystemLoader(BaseLoader):
         *,
         encoding: str = "utf-8",
         ext: Optional[str] = None,
+        reject_symlinks: bool = False,
     ):
         super().__init__()
         if not isinstance(search_path, Iterable) or isinstance(search_path, str):
@@ -43,6 +46,7 @@ class FileSystemLoader(BaseLoader):
         self.search_path = [Path(path) for path in search_path]
         self.encoding = encoding
         self.ext = ext
+        self.reject_symlinks = reject_symlinks
 
     def resolve_path(self, template_name: str) -> Path:
         """Return a path to the template identified by _template_name_.
@@ -56,14 +60,27 @@ class FileSystemLoader(BaseLoader):
         if self.ext and not template_path.suffix:
             template_path = template_path.with_suffix(self.ext)
 
-        if os.path.pardir in template_path.parts:
+        if os.path.pardir in template_path.parts or template_path.is_absolute():
             raise TemplateNotFoundError(template_name)
 
-        for path in self.search_path:
-            source_path = path.joinpath(template_path)
-            if not source_path.exists():
+        for base in self.search_path:
+            source_path = base.joinpath(template_path)
+
+            if not source_path.exists() or not source_path.is_file():
                 continue
+
+            if self.reject_symlinks:
+                try:
+                    resolved = source_path.resolve(strict=False)
+                    base_resolved = base.resolve(strict=False)
+                except OSError:
+                    continue
+
+                if not resolved.is_relative_to(base_resolved):
+                    continue
+
             return source_path
+
         raise TemplateNotFoundError(template_name)
 
     def _read(self, source_path: Path) -> tuple[str, float]:

liquid/builtin/tags/case_tag.py

@@ -11,7 +11,7 @@ from typing import Union
 from liquid.ast import BlockNode
 from liquid.ast import Node
 from liquid.builtin.expressions import parse_primitive
-from liquid.builtin.expressions.logical import _eq
+from liquid.builtin.expressions.logical import _eq  # type: ignore
 from liquid.exceptions import LiquidSyntaxError
 from liquid.expression import Expression
 from liquid.parser import get_parser
@@ -85,7 +85,7 @@ class CaseNode(Node):
                     count += count_
             # Only render `else` blocks if all preceding `when` blocks are falsy.
             # Multiple `else` blocks are OK.
-            elif isinstance(block, BlockNode) and default:
+            elif default:
                 count += block.render(context, buffer)
 
         return count
@@ -106,7 +106,7 @@ class CaseNode(Node):
                     count += count_
             # Only render `else` blocks if all preceding `when` blocks are falsy.
             # Multiple `else` blocks are OK.
-            elif isinstance(block, BlockNode) and default:
+            elif default:
                 count += await block.render_async(context, buffer)
 
         return count
@@ -145,7 +145,7 @@ class CaseTag(Tag):
 
         # Eat whitespace or junk between `case` and when/else/endcase
         while (
-            stream.current.kind != TOKEN_TAG
+            stream.current.kind not in (TOKEN_TAG, TOKEN_EOF)
             and stream.current.value not in ENDWHENBLOCK
         ):
             next(stream)

liquid/builtin/tags/comment_tag.py

@@ -37,7 +37,7 @@ class CommentNode(ast.Node):
     def __str__(self) -> str:
         return f"{{% comment %}}{self.text}{{% endcomment %}}"
 
-    def render_to_output(self, _: RenderContext, __: TextIO) -> int:
+    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:  # noqa: ARG002
         """Render the node to the output buffer."""
         return 0
 
@@ -61,7 +61,7 @@ class CommentTag(Tag):
 
         # A block `{% comment %}`
         token = stream.eat(TOKEN_TAG)
-        text = []
+        text: list[str] = []
 
         while True:
             if stream.current.kind == TOKEN_EOF:

liquid/builtin/tags/doc_tag.py

@@ -50,7 +50,7 @@ class DocTag(Tag):
 
         # This only happens if the doc tag is malformed
         token = stream.eat(TOKEN_TAG)
-        text = []
+        text: list[str] = []
 
         if stream.current.kind == TOKEN_EXPRESSION:
             raise LiquidSyntaxError("unexpected expression", token=stream.current)

liquid/builtin/tags/if_tag.py

@@ -152,7 +152,7 @@ class IfTag(Tag):
         condition = BooleanExpression.parse(self.env, tokens)
         parse_block = get_parser(self.env).parse_block
         consequence = parse_block(stream, ENDIFBLOCK)
-        alternatives = []
+        alternatives: list[ConditionalBlockNode] = []
 
         while stream.current.is_tag(TAG_ELSIF):
             # If the expression can't be parsed, eat the "elsif" block and

liquid/builtin/tags/render_tag.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING
 from typing import Iterable
 from typing import Optional
 from typing import TextIO
+from typing import Union
 
 from liquid.ast import Node
 from liquid.ast import Partial
@@ -21,11 +22,12 @@ from liquid.builtin.expressions import parse_identifier
 from liquid.builtin.expressions import parse_primitive
 from liquid.builtin.tags.for_tag import ForLoop
 from liquid.builtin.tags.include_tag import TAG_INCLUDE
+from liquid.exceptions import LiquidSyntaxError
 from liquid.exceptions import TemplateNotFoundError
 from liquid.tag import Tag
+from liquid.template import BoundTemplate
 from liquid.token import TOKEN_AS
 from liquid.token import TOKEN_FOR
-from liquid.token import TOKEN_STRING
 from liquid.token import TOKEN_TAG
 from liquid.token import TOKEN_WITH
 from liquid.token import TOKEN_WORD
@@ -50,7 +52,8 @@ class RenderNode(Node):
     def __init__(
         self,
         token: Token,
-        name: StringLiteral,
+        name: Union[StringLiteral, Identifier],
+        *,
         var: Optional[Expression] = None,
         loop: bool = False,
         alias: Optional[Identifier] = None,
@@ -77,14 +80,26 @@ class RenderNode(Node):
 
     def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
         """Render the node to the output buffer."""
-        try:
-            template = context.env.get_template(
-                self.name.value, context=context, tag=self.tag
+        if isinstance(self.name, Identifier):
+            # We're expecting an inline snippet.
+            template: Optional[BoundTemplate] = context.resolve(
+                self.name, token=self.token, default=None
             )
-        except TemplateNotFoundError as err:
-            err.token = self.name.token
-            err.template_name = context.template.full_name()
-            raise
+            if not isinstance(template, BoundTemplate):
+                raise TemplateNotFoundError(
+                    self.name,
+                    filename=context.template.full_name(),
+                    token=self.name.token,
+                )
+        else:
+            try:
+                template = context.env.get_template(
+                    self.name.value, context=context, tag=self.tag
+                )
+            except TemplateNotFoundError as err:
+                err.token = self.name.token
+                err.template_name = context.template.full_name()
+                raise
 
         # Evaluate keyword arguments once. Unlike 'include', 'render' can not
         # mutate variables in the outer scope, so there's no need to re-evaluate
@@ -145,14 +160,26 @@ class RenderNode(Node):
         self, context: RenderContext, buffer: TextIO
     ) -> int:
         """Render the node to the output buffer."""
-        try:
-            template = await context.env.get_template_async(
-                self.name.value, context=context, tag=self.tag
+        if isinstance(self.name, Identifier):
+            # We're expecting an inline snippet.
+            template: Optional[BoundTemplate] = context.resolve(
+                self.name, token=self.token, default=None
             )
-        except TemplateNotFoundError as err:
-            err.token = self.name.token
-            err.template_name = context.template.full_name()
-            raise
+            if not isinstance(template, BoundTemplate):
+                raise TemplateNotFoundError(
+                    self.name,
+                    filename=context.template.full_name(),
+                    token=self.name.token,
+                )
+        else:
+            try:
+                template = await context.env.get_template_async(
+                    self.name.value, context=context, tag=self.tag
+                )
+            except TemplateNotFoundError as err:
+                err.token = self.name.token
+                err.template_name = context.template.full_name()
+                raise
 
         # Evaluate keyword arguments once. Unlike 'include', 'render' can not
         # mutate variables in the outer scope, so there's no need to re-evaluate
@@ -215,7 +242,15 @@ class RenderNode(Node):
         self, static_context: RenderContext, *, include_partials: bool = True
     ) -> Iterable[Node]:
         """Return this node's children."""
-        if include_partials:
+        if isinstance(self.name, Identifier):
+            # We're expecting an inline snippet.
+            # Always visit inline snippets, even if include_partials is False.
+            template: Optional[BoundTemplate] = static_context.resolve(
+                self.name, token=self.token, default=None
+            )
+            if template:
+                yield from template.nodes
+        elif include_partials:
             name = self.name.evaluate(static_context)
             try:
                 template = static_context.env.get_template(
@@ -231,7 +266,14 @@ class RenderNode(Node):
         self, static_context: RenderContext, *, include_partials: bool = True
     ) -> Iterable[Node]:
         """Return this node's children."""
-        if include_partials:
+        if isinstance(self.name, Identifier):
+            # We're expecting an inline snippet.
+            template: Optional[BoundTemplate] = static_context.resolve(
+                self.name, token=self.token, default=None
+            )
+            if template:
+                return template.nodes
+        elif include_partials:
             name = await self.name.evaluate_async(static_context)
             try:
                 template = await static_context.env.get_template_async(
@@ -246,12 +288,11 @@ class RenderNode(Node):
 
     def expressions(self) -> Iterable[Expression]:
         """Return this node's expressions."""
-        yield self.name
         if self.var:
             yield self.var
         yield from (arg.value for arg in self.args)
 
-    def partial_scope(self) -> Partial | None:
+    def partial_scope(self) -> Optional[Partial]:
         """Return information about a partial template loaded by this node."""
         scope: list[Identifier] = [
             Identifier(arg.name, token=arg.token) for arg in self.args
@@ -267,7 +308,17 @@ class RenderNode(Node):
                     )
                 )
 
-        return Partial(name=self.name, scope=PartialScope.ISOLATED, in_scope=scope)
+        partial_name = self.name.value if isinstance(self.name, StringLiteral) else ""
+        partial_key = hash((partial_name, *[arg.name for arg in self.args]))
+
+        # Static analysis will use the parent template name if Partial.name is
+        # empty. Which is what we want for inline snippets.
+        return Partial(
+            name=partial_name,
+            scope=PartialScope.ISOLATED,
+            in_scope=scope,
+            key=partial_key,
+        )
 
 
 BIND_TAGS = frozenset((TOKEN_WITH, TOKEN_FOR))
@@ -284,12 +335,18 @@ class RenderTag(Tag):
         """Parse tokens from _stream_ into an AST node."""
         token = stream.eat(TOKEN_TAG)
         tokens = stream.into_inner(tag=token, eat=False)
-
-        # Need a string. 'render' does not accept identifiers that resolve to a string.
-        # This is the name of the template to be included.
-        tokens.expect(TOKEN_STRING)
-        name = parse_primitive(self.env, tokens)
-        assert isinstance(name, StringLiteral)
+        name: Union[Expression, Identifier] = parse_primitive(self.env, tokens)
+
+        if isinstance(name, Path):
+            head = name.head()
+            if len(name.path) != 1 or not isinstance(head, str):
+                raise LiquidSyntaxError(
+                    "expected an identifier, found a path",
+                    token=name.token,
+                )
+            name = Identifier(head, token=name.token)
+        elif not isinstance(name, StringLiteral):
+            raise LiquidSyntaxError("expected a string or identifier", token=name.token)
 
         alias: Optional[Identifier] = None
         var: Optional[Path] = None
@@ -311,4 +368,4 @@ class RenderTag(Tag):
 
         # Zero or more keyword arguments
         args = KeywordArgument.parse(self.env, tokens)
-        return self.node_class(token, name, var, loop, alias, args)
+        return self.node_class(token, name, var=var, loop=loop, alias=alias, args=args)

liquid/exceptions.py

@@ -169,9 +169,10 @@ class TemplateNotFoundError(LiquidError):
     def __init__(
         self,
         *args: object,
-        filename: Union[str, None] = None,
+        filename: Optional[str] = None,
+        token: Optional[Token] = None,
     ):
-        super().__init__(*args, token=None, template_name=filename)
+        super().__init__(*args, token=token, template_name=filename)
 
     def __str__(self) -> str:
         if not self.token:

liquid/extra/__init__.py

@@ -21,6 +21,7 @@ from .tags import BlockTag
 from .tags import CallTag
 from .tags import ExtendsTag
 from .tags import MacroTag
+from .tags import SnippetTag
 from .tags import TranslateTag
 from .tags import WithTag
 
@@ -38,7 +39,6 @@ __all__ = (
     "DateTime",
     "ExtendsTag",
     "GetText",
-    "IfNotTag",
     "index",
     "JSON",
     "MacroTag",
@@ -49,6 +49,7 @@ __all__ = (
     "script_tag",
     "sort_numeric",
     "stylesheet_tag",
+    "SnippetTag",
     "Translate",
     "Unit",
     "WithTag",

liquid/extra/filters/babel.py

@@ -66,7 +66,7 @@ class Currency:
             can not be resolved. Defaults to `"USD"`.
         locale_var: The name of a render context variable that resolves to the
             current locale. Defaults to `"locale"`.
-        default_locale : A fallback locale to use if `locale_var` can not be
+        default_locale: A fallback locale to use if `locale_var` can not be
             resolved. Defaults to `"en_US"`.
         format_var: The name of a render context variable that resolves to the
             current currency format string. Defaults to `"currency_format"`.

liquid/extra/tags/__init__.py

@@ -3,6 +3,7 @@ from .extends_tag import BlockTag
 from .extends_tag import ExtendsTag
 from .macro_tag import CallTag
 from .macro_tag import MacroTag
+from .snippet_tag import SnippetTag
 from .translate_tag import TranslateTag
 
 __all__ = (
@@ -11,5 +12,6 @@ __all__ = (
     "ExtendsTag",
     "CallTag",
     "MacroTag",
+    "SnippetTag",
     "TranslateTag",
 )

liquid/extra/tags/extends_tag.py

@@ -19,7 +19,6 @@ from liquid.ast import Node
 from liquid.ast import Partial
 from liquid.ast import PartialScope
 from liquid.builtin.expressions import Identifier
-from liquid.builtin.expressions import StringLiteral
 from liquid.builtin.expressions import parse_name
 from liquid.exceptions import RequiredBlockError
 from liquid.exceptions import StopRender
@@ -107,7 +106,7 @@ class ExtendsNode(Node):
     def partial_scope(self) -> Optional[Partial]:
         """Return information about a partial template loaded by this node."""
         return Partial(
-            name=StringLiteral(self.name.token, self.name),
+            name=self.name,
             scope=PartialScope.INHERITED,
             in_scope=[],
         )

liquid/extra/tags/snippet_tag.py

@@ -0,0 +1,107 @@
+"""The built-in _snippet_ tag.
+
+New in Python Liquid version 2.2.0.
+New in Shopify/liquid version 5.10.0.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import TextIO
+
+from liquid.ast import BlockNode
+from liquid.ast import Node
+from liquid.builtin.expressions import parse_identifier
+from liquid.parser import get_parser
+from liquid.tag import Tag
+from liquid.template import BoundTemplate
+from liquid.token import TOKEN_EOF
+from liquid.token import TOKEN_TAG
+from liquid.token import Token
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from liquid.builtin.expressions import Identifier
+    from liquid.context import RenderContext
+    from liquid.stream import TokenStream
+
+
+class SnippetNode(Node):
+    """The built-in _snippet_ tag."""
+
+    __slots__ = ("name", "block")
+
+    def __init__(self, token: Token, name: Identifier, block: BlockNode):
+        super().__init__(token)
+        self.name = name
+        self.block = block
+
+    def __str__(self) -> str:
+        return f"{{% snippet {self.name} %}}{self.block}{{% endsnippet %}}"
+
+    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:  # noqa: ARG002
+        """Render the node to the output buffer."""
+        # Don't render anything, just bind the block to its name.
+        context.assign(
+            self.name,
+            SnippetDrop(
+                context.env,
+                self.block.nodes,
+                context.template.name,
+                context.template.path,
+            ),
+        )
+        return 0
+
+    def children(
+        self,
+        static_context: RenderContext,  # noqa: ARG002
+        *,
+        include_partials: bool = True,  # noqa: ARG002
+    ) -> Iterable[Node]:
+        """Return this node's children."""
+        # Snippets are only visited when rendered so we get accurate variable
+        # scope analysis.
+        static_context.assign(
+            self.name,
+            SnippetDrop(
+                static_context.env,
+                self.block.nodes,
+                static_context.template.name,
+                static_context.template.path,
+            ),
+        )
+        return []
+
+    def template_scope(self) -> Iterable[Identifier]:
+        """Return variables this node adds to the template local scope."""
+        yield self.name
+
+
+class SnippetTag(Tag):
+    """The built-in _snippet_ tag."""
+
+    block = True
+    name = "snippet"
+    end = "endsnippet"
+    node_class = SnippetNode
+
+    ENDSNIPPETBLOCK = frozenset((end, TOKEN_EOF))
+
+    def parse(self, stream: TokenStream) -> SnippetNode:
+        """Parse tokens from _stream_ into an AST node."""
+        token = stream.eat(TOKEN_TAG)
+        tokens = stream.into_inner(tag=token)
+        name = parse_identifier(self.env, tokens)
+        tokens.expect_eos()
+        block = get_parser(self.env).parse_block(stream, self.ENDSNIPPETBLOCK)
+        stream.expect(TOKEN_TAG, value=self.end)
+        return self.node_class(token, name, block)
+
+
+class SnippetDrop(BoundTemplate):
+    """An template suitable for storing in a render context."""
+
+    def __str__(self) -> str:
+        return "SnippetDrop"

liquid/filter.py

@@ -54,8 +54,11 @@ def string_filter(_filter: FilterT) -> FilterT:
 
     @wraps(_filter)
     def wrapper(val: object, *args: Any, **kwargs: Any) -> Any:
-        if not isinstance(val, str):
+        if val is None:
+            val = ""
+        elif not isinstance(val, str):
             val = str(val)
+
         try:
             return _filter(val, *args, **kwargs)
         except TypeError as err:

liquid/static_analysis.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass
 from dataclasses import field
 from typing import TYPE_CHECKING
 from typing import Iterable
+from typing import Optional
 from typing import Union
 
 from .ast import BlockNode
@@ -126,7 +127,11 @@ class TemplateAnalysis:
     tags: dict[str, list[Span]]
 
 
-def _analyze(template: BoundTemplate, *, include_partials: bool) -> TemplateAnalysis:
+def analyze(template: BoundTemplate, *, include_partials: bool) -> TemplateAnalysis:
+    """Report variable, filters and tags used in the given template.
+
+    This is used by `BoundTemplate.analyze`.
+    """
     variables = _VariableMap()
     globals = _VariableMap()  # noqa: A001
     locals = _VariableMap()  # noqa: A001
@@ -139,15 +144,26 @@ def _analyze(template: BoundTemplate, *, include_partials: bool) -> TemplateAnal
     static_context = RenderContext(template)
 
     # Names of partial templates that have already been analyzed.
-    seen: set[str] = set()
-
-    def _visit(node: Node, template_name: str, scope: _StaticScope) -> None:
-        if template_name:
-            seen.add(template_name)
+    # Keys are hashes of partial template name and its arguments. If we've
+    # visited a template before but ith different arguments, later visits
+    # only record global variables so as not to double count locals, filters
+    # and tags.
+    seen: defaultdict[str, set[Optional[int]]] = defaultdict(set)
+
+    def _visit(
+        node: Node,
+        template_name: str,
+        scope: _StaticScope,
+        *,
+        just_globals: bool = False,
+    ) -> None:
+        if template_name and not just_globals:
+            seen[template_name].add(None)
 
         # Update tags from node.token
         if (
-            not isinstance(
+            not just_globals
+            and not isinstance(
                 node, (BlockNode, ConditionalBlockNode, MultiExpressionBlockNode)
             )
             and node.token.kind == TOKEN_TAG
@@ -156,11 +172,18 @@ def _analyze(template: BoundTemplate, *, include_partials: bool) -> TemplateAnal
 
         # Update variables from node.expressions()
         for expr in node.expressions():
-            _analyze_variables(expr, template_name, scope, globals, variables)
+            _analyze_variables(
+                expr,
+                template_name,
+                scope,
+                globals,
+                _VariableMap() if just_globals else variables,
+            )
 
-            # Update filters from expr
-            for name, span in _extract_filters(expr, template_name):
-                filters[name].append(span)
+            if not just_globals:
+                # Update filters from expr
+                for name, span in _extract_filters(expr, template_name):
+                    filters[name].append(span)
 
         # Update the template scope from node.template_scope()
         for ident in node.template_scope():
@@ -173,11 +196,23 @@ def _analyze(template: BoundTemplate, *, include_partials: bool) -> TemplateAnal
             )
 
         if partial := node.partial_scope():
-            partial_name = str(partial.name.evaluate(static_context))
+            partial_name = (
+                partial.name
+                if isinstance(partial.name, str)
+                else str(partial.name.evaluate(static_context))
+            )
 
-            if partial_name in seen:
+            # If we've seen this partial before but with different arguments,
+            # we might want to visit it again but only capture globals.
+            _just_globals = partial_name in seen
+            if partial.key in seen[partial_name]:
+                # We've visited this partial template before with the same
+                # arguments.
                 return
 
+            seen[partial_name].add(partial.key)
+            partial_name = partial_name or template_name
+
             partial_scope = (
                 _StaticScope(set(partial.in_scope))
                 if partial.scope == PartialScope.ISOLATED
@@ -187,8 +222,12 @@ def _analyze(template: BoundTemplate, *, include_partials: bool) -> TemplateAnal
             for child in node.children(
                 static_context, include_partials=include_partials
             ):
-                seen.add(partial_name)
-                _visit(child, partial_name, partial_scope)
+                _visit(
+                    child,
+                    partial_name,
+                    partial_scope,
+                    just_globals=just_globals or _just_globals,
+                )
 
             partial_scope.pop()
         else:
@@ -196,7 +235,7 @@ def _analyze(template: BoundTemplate, *, include_partials: bool) -> TemplateAnal
             for child in node.children(
                 static_context, include_partials=include_partials
             ):
-                _visit(child, template_name, scope)
+                _visit(child, template_name, scope, just_globals=just_globals)
             scope.pop()
 
     for node in template.nodes:
@@ -211,9 +250,13 @@ def _analyze(template: BoundTemplate, *, include_partials: bool) -> TemplateAnal
     )
 
 
-async def _analyze_async(
+async def analyze_async(
     template: BoundTemplate, *, include_partials: bool
 ) -> TemplateAnalysis:
+    """Report variable, filters and tags used in the given template.
+
+    This is used by `BoundTemplate.analyze_async`.
+    """
     variables = _VariableMap()
     globals = _VariableMap()  # noqa: A001
     locals = _VariableMap()  # noqa: A001
@@ -226,15 +269,22 @@ async def _analyze_async(
     static_context = RenderContext(template)
 
     # Names of partial templates that have already been analyzed.
-    seen: set[str] = set()
-
-    async def _visit(node: Node, template_name: str, scope: _StaticScope) -> None:
-        if template_name:
-            seen.add(template_name)
+    seen: defaultdict[str, set[Optional[int]]] = defaultdict(set)
+
+    async def _visit(
+        node: Node,
+        template_name: str,
+        scope: _StaticScope,
+        *,
+        just_globals: bool = False,
+    ) -> None:
+        if template_name and not just_globals:
+            seen[template_name].add(None)
 
         # Update tags from node.token
         if (
-            not isinstance(
+            not just_globals
+            and not isinstance(
                 node, (BlockNode, ConditionalBlockNode, MultiExpressionBlockNode)
             )
             and node.token.kind == TOKEN_TAG
@@ -243,11 +293,18 @@ async def _analyze_async(
 
         # Update variables from node.expressions()
         for expr in node.expressions():
-            _analyze_variables(expr, template_name, scope, globals, variables)
+            _analyze_variables(
+                expr,
+                template_name,
+                scope,
+                globals,
+                _VariableMap() if just_globals else variables,
+            )
 
-            # Update filters from expr
-            for name, span in _extract_filters(expr, template_name):
-                filters[name].append(span)
+            if not just_globals:
+                # Update filters from expr
+                for name, span in _extract_filters(expr, template_name):
+                    filters[name].append(span)
 
         # Update the template scope from node.template_scope()
         for ident in node.template_scope():
@@ -260,11 +317,23 @@ async def _analyze_async(
             )
 
         if partial := node.partial_scope():
-            partial_name = str(partial.name.evaluate(static_context))
+            partial_name = (
+                partial.name
+                if isinstance(partial.name, str)
+                else str(partial.name.evaluate(static_context))
+            )
 
-            if partial_name in seen:
+            # If we've seen this partial before but with different arguments,
+            # we might want to visit it again but only capture globals.
+            _just_globals = partial_name in seen
+            if partial.key in seen[partial_name]:
+                # We've visited this partial template before with the same
+                # arguments.
                 return
 
+            seen[partial_name].add(partial.key)
+            partial_name = partial_name or template_name
+
             partial_scope = (
                 _StaticScope(set(partial.in_scope))
                 if partial.scope == PartialScope.ISOLATED
@@ -274,8 +343,12 @@ async def _analyze_async(
             for child in await node.children_async(
                 static_context, include_partials=include_partials
             ):
-                seen.add(partial_name)
-                await _visit(child, partial_name, partial_scope)
+                await _visit(
+                    child,
+                    partial_name,
+                    partial_scope,
+                    just_globals=just_globals or _just_globals,
+                )
 
             partial_scope.pop()
         else:
@@ -283,7 +356,7 @@ async def _analyze_async(
             for child in await node.children_async(
                 static_context, include_partials=include_partials
             ):
-                await _visit(child, template_name, scope)
+                await _visit(child, template_name, scope, just_globals=just_globals)
             scope.pop()
 
     for node in template.nodes:

liquid/stream.py

@@ -16,7 +16,7 @@ from .token import reverse_operators
 class TokenStream:
     """Step through a sequence of tokens."""
 
-    eof = Token(TOKEN_EOF, "", -1, "")
+    eof = Token(TOKEN_EOF, TOKEN_EOF, -1, "")
 
     def __init__(
         self,

liquid/template.py

@@ -13,8 +13,11 @@ from typing import Mapping
 from typing import Optional
 from typing import TextIO
 from typing import Type
+from typing import TypedDict
 from typing import Union
 
+from .builtin.tags.comment_tag import CommentNode
+from .builtin.tags.doc_tag import DocNode
 from .context import FutureContext
 from .context import RenderContext
 from .exceptions import LiquidError
@@ -22,8 +25,8 @@ from .exceptions import LiquidInterrupt
 from .exceptions import LiquidSyntaxError
 from .exceptions import StopRender
 from .output import LimitedStringIO
-from .static_analysis import _analyze
-from .static_analysis import _analyze_async
+from .static_analysis import analyze
+from .static_analysis import analyze_async
 from .utils import ReadOnlyChainMap
 
 if TYPE_CHECKING:
@@ -262,11 +265,11 @@ class BoundTemplate:
             include_partials: If `True`, we will try to load partial templates and
                 analyze those templates too.
         """
-        return _analyze(self, include_partials=include_partials)
+        return analyze(self, include_partials=include_partials)
 
     async def analyze_async(self, *, include_partials: bool = True) -> TemplateAnalysis:
         """An async version of `analyze`."""
-        return await _analyze_async(self, include_partials=include_partials)
+        return await analyze_async(self, include_partials=include_partials)
 
     def variables(self, *, include_partials: bool = True) -> list[str]:
         """Return a list of variables used in this template without path segments.
@@ -520,6 +523,52 @@ class BoundTemplate:
         """Return a list of tag names used in this template."""
         return list((await self.analyze_async(include_partials=include_partials)).tags)
 
+    def comments(self) -> list[CommentNode]:
+        """Return a list of comment tag nodes found in this template.
+
+        Instances of `CommentNode` and `InlineCommentNode` have `token` and
+        `text` properties. Use `[node.text for node in template.comments()]` to
+        get a list of comment strings.
+
+        Note that this method does not try to load included or rendered
+        templates.
+        """
+        context = RenderContext(self)
+        nodes: list[CommentNode] = []
+
+        def visit(node: Node) -> None:
+            if isinstance(node, CommentNode):
+                nodes.append(node)
+
+            for child in node.children(context, include_partials=False):
+                visit(child)
+
+        for child in self.nodes:
+            visit(child)
+
+        return nodes
+
+    def docs(self) -> list[DocNode]:
+        """Return a list of doc tag nodes found in this template.
+
+        Instances of `DocNode` have `token` and `text` properties. Use
+        `[node.text for node in template.docs()]` to get a list of doc strings.
+        """
+        context = RenderContext(self)
+        nodes: list[DocNode] = []
+
+        def visit(node: Node) -> None:
+            if isinstance(node, DocNode):
+                nodes.append(node)
+
+            for child in node.children(context, include_partials=False):
+                visit(child)
+
+        for child in self.nodes:
+            visit(child)
+
+        return nodes
+
 
 class AwareBoundTemplate(BoundTemplate):
     """A `BoundTemplate` subclass with a `TemplateDrop` in the global namespace."""
@@ -559,6 +608,12 @@ class FutureAwareBoundTemplate(AwareBoundTemplate):
     context_class = FutureContext
 
 
+class _TemplateDropItems(TypedDict):
+    directory: str
+    name: str
+    suffix: str | None
+
+
 class TemplateDrop(Mapping[str, Optional[str]]):
     """Template meta data mapping."""
 
@@ -575,7 +630,7 @@ class TemplateDrop(Mapping[str, Optional[str]]):
         if "." in self.stem:
             self.suffix = self.stem.split(".")[-1]
 
-        self._items = {
+        self._items: _TemplateDropItems = {
             "directory": self.path.parent.name,
             "name": self.path.name.split(".")[0],
             "suffix": self.suffix,
@@ -594,7 +649,7 @@ class TemplateDrop(Mapping[str, Optional[str]]):
         return item in self._items
 
     def __getitem__(self, key: object) -> Optional[str]:
-        return self._items[str(key)]
+        return self._items[str(key)]  # type: ignore
 
     def __len__(self) -> int:
         return len(self._items)

{python_liquid-2.1.0.dist-info → python_liquid-2.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-liquid
-Version: 2.1.0
+Version: 2.2.1
 Summary: A Python engine for the Liquid template language.
 Project-URL: Change Log, https://github.com/jg-rp/liquid/blob/main/CHANGES.md
 Project-URL: Documentation, https://jg-rp.github.io/liquid/
@@ -19,9 +19,10 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Requires-Dist: babel>=2
 Requires-Dist: markupsafe>=3
 Requires-Dist: python-dateutil>=2.8.1

{python_liquid-2.1.0.dist-info → python_liquid-2.2.1.dist-info}/RECORD

@@ -1,11 +1,11 @@
-liquid/__init__.py,sha256=gQBAgPnQURpFuvzPsHbB0XVy2LtBlofIRTVfl4fyvjs,7696
+liquid/__init__.py,sha256=YIN6_DEfW6bv9bhNED8Pnl0Ryt3_uCPt1dvMIuw_Yfk,7696
 liquid/analyze_tags.py,sha256=Uc1nueKLRiIejs2JyQIC7u2pxp9l-5HJAMWlg-Qj1m8,7615
-liquid/ast.py,sha256=ec-c8F7B2_yj2FmYiOFnnvu2JSd7c4mzTDGlYeztQ_8,7653
+liquid/ast.py,sha256=4ZqSbuW4mv9IvoIMPk3OICUaOI1vPh8P8uFCrXI_3XA,8140
 liquid/context.py,sha256=gSJI1mj7mdcUfiQ09_XCEj5JxAosCGEX85Uuzl9apeI,21505
 liquid/environment.py,sha256=1X5WsOHcFvKAjljQcG3F-cQ9sfxzaiD-N3jGJOG5yHU,23940
-liquid/exceptions.py,sha256=hG4SklVAOg-FOy2Y3husZmQdAzvn4bpB7FaunaLHTnU,8299
+liquid/exceptions.py,sha256=FOc4KAOijF4WHrBGepvi0ycAYT5hu0rhdpsVb2C-ZHs,8336
 liquid/expression.py,sha256=Ozgajah2R5eg1yWA4ITFGaMFoOLt8GIjkE1NKqbBEzk,1143
-liquid/filter.py,sha256=-Mbrtui9ELPMpprJJN97GrpWJF47pzYSWGNM__p_A_k,6687
+liquid/filter.py,sha256=3NtqGk6nHNwe6ux3X6ZIzzcEMJNA_SaMrBmMQA8hf-I,6735
 liquid/lex.py,sha256=PrnnUWhXZO6novkO0KE-p4virh5cNJsg7m85sg2IUiw,8004
 liquid/limits.py,sha256=BxqiC4Ax5iadmh6jDRcUNjFfOvbMkvZ1a046R1Cb8UA,1700
 liquid/loader.py,sha256=R_RniSRszCXmRVZgXlu9WjV130cWvspVcC3vIVpf-qg,4381
@@ -15,14 +15,14 @@ liquid/output.py,sha256=1rgPmXGWUTut-aBBbHs-TCCZ2UGUhmbJYRmCsnqIOCk,1000
 liquid/parser.py,sha256=F8aC__UiUzz39lxhPr3sl67l-V-mrxkdn-4MAaCTWRE,3824
 liquid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 liquid/span.py,sha256=Z7Xb5V_h3WLvVmZUBebZeZkJFHKa33Bfcqq3S60SMSk,1122
-liquid/static_analysis.py,sha256=4p6-xwzqE0WKmtjiKtjkMPbHIFqYo9yue3bOksjUqF8,11975
-liquid/stream.py,sha256=nYBSjdgs5SkjAM7TTTkmZtc_DF1_KOvQrTGsjZXSrYE,4882
+liquid/static_analysis.py,sha256=iPUqxiufXyK5EoPZQ9WNRKAzkqBYiX1HaSfX8oZhL9c,14537
+liquid/stream.py,sha256=jbIATQRY1azN5BX91FfnhL3mgBcYDJ3ZlEjI9kfmfaA,4889
 liquid/stringify.py,sha256=TkRO0KbZVCY3usNV6EXfG6CbtWhuLoI7joxcrEArSNE,892
 liquid/tag.py,sha256=h5jexl6NjUQnM2py4s5db1ksh0s8vi31YHud5kHJt1E,1189
-liquid/template.py,sha256=hLylYHSf9_nkLUymfn8o1hGMrHRhiRfU_QRFMjLPw_A,22376
+liquid/template.py,sha256=ne1abyNX8Tytl-d-vAROxtn-hHt_-O4nrn0eb2b_5fU,24062
 liquid/token.py,sha256=gxqMGcGk1fWihz5gQ2BQJzqSEcY7tCAZiIjcdC34P1w,3995
 liquid/undefined.py,sha256=Y57D69YR6yXSHV4x1rg1xtoTe-6M49h-mqlSO7pcRSE,5673
-liquid/builtin/__init__.py,sha256=oEzqtKMvqvfoqzcN1Sq_Qbq094hySWNTCnE5Ga-CkcU,7018
+liquid/builtin/__init__.py,sha256=YNQlg5dzSBnU4asR_1yX111l6Cl1Rj_JqwEnOdT7l5U,7090
 liquid/builtin/content.py,sha256=HXo2ty2cQxsOkXJDhWmcAWC0ny73w9oABaer50zGp70,1122
 liquid/builtin/illegal.py,sha256=RRzzlqo2_scdtbMt_hZq0pr-7khgbxrdub9XH-_goPs,844
 liquid/builtin/output.py,sha256=4r_QJimFTbBdubhdIOG_nweROEOXiWHlp_xNmWXy564,2279
@@ -41,44 +41,45 @@ liquid/builtin/filters/array.py,sha256=dMuT15EASXU4ejmNBmawdi92u0f7y_JhqVaGoP48z
 liquid/builtin/filters/extra.py,sha256=m13_1nbZyRBl3CZV9WWGLlUZueRPt8cKPEHRAioqM_o,2710
 liquid/builtin/filters/math.py,sha256=A_K2wg5gxm5Ncj9zMGDX_Lt7jjx4bRr3CywbCiCtqxo,3925
 liquid/builtin/filters/misc.py,sha256=t2ZsaDLKRc1-8XxZaiEOh7oAMqFJ4N5-tzfbpLHbmIQ,3466
-liquid/builtin/filters/string.py,sha256=3Ub1z0VeCeAT07FaDVAazw2J9vFmpqtehtEtujNZxdg,11963
+liquid/builtin/filters/string.py,sha256=mWG-14HttAqyPA1atLmwdXjbxwDpAowookbadk_jijI,12164
 liquid/builtin/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-liquid/builtin/loaders/caching_file_system_loader.py,sha256=-9riAxL8933u_w1Ppweia-WkfFlxVU3aCspdiNyD5xQ,1931
+liquid/builtin/loaders/caching_file_system_loader.py,sha256=V4OLa6UGT-RELGiV4eu02TeLL4P_JIE2kMYMrO3qy8U,2158
 liquid/builtin/loaders/choice_loader.py,sha256=FE23RLMOiWmsRGZv9t6QmlG7bgMEUSblnucAv3j0SBM,2816
 liquid/builtin/loaders/dict_loader.py,sha256=8TdMJqaYPLwllmIiEmuZNXqH6UOOsi4HuJ2t5sztOOw,1785
-liquid/builtin/loaders/file_system_loader.py,sha256=VAS6C-oez9lvOq81Q8bPBb3JjHC2ltC2DvgPf32pdgE,3895
+liquid/builtin/loaders/file_system_loader.py,sha256=6CzmJnktLE9n6y8YYEtUZFa4nDsZ6vsAWIDwCg6_vE0,4528
 liquid/builtin/loaders/mixins.py,sha256=4Hj5wWGMOi3LqA9ZJYsUb4LFbG0a5DDb9H975G8nn58,5209
 liquid/builtin/loaders/package_loader.py,sha256=XP7LT3aMClgfBlI8OMyHOERlXTXEWmqFH7HskCnY3cs,3659
 liquid/builtin/tags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 liquid/builtin/tags/assign_tag.py,sha256=VTfkPbF-i0KLqMmaacBItFQHaBTP7ECWR-RvVh9Q6lY,2374
 liquid/builtin/tags/capture_tag.py,sha256=7bOG7qVwcqRx1eStb96AZKQ9tKLBjmzaYAe27LJTIm4,3037
-liquid/builtin/tags/case_tag.py,sha256=OUKu_UiUeJ8Q9C3FePNSSkRiiM6w44Ze5HIzuZj4Pxo,9073
-liquid/builtin/tags/comment_tag.py,sha256=KNM2heK7U9S7S9PiNjVilwS8kuABfILiVpgjAmLbb_8,2213
+liquid/builtin/tags/case_tag.py,sha256=8ZN3pWP6axr-y7XAGIDjOkTDis0KSxpw7m1ITSElOVw,9040
+liquid/builtin/tags/comment_tag.py,sha256=BMvee7nVBim_iDScKWbcUBCxNXzbBvguYfQUG3GM1y8,2250
 liquid/builtin/tags/cycle_tag.py,sha256=tbgnEiwENXIfRAKRsVg18KRsZwaNLOLZeuLy-0Xm5c0,3789
 liquid/builtin/tags/decrement_tag.py,sha256=WgkwWqjJgzjfEKffTKNw0ao6N0JxniadxGO_n1k8oZE,1660
-liquid/builtin/tags/doc_tag.py,sha256=2VjfL-todQK-ejjIdWIRP97jrKofb_eP8DVh6-q69NY,2044
+liquid/builtin/tags/doc_tag.py,sha256=luc2QI-4N7KF49vWak6dNm5Hs9jwlXTAfUlEsr6ZCNM,2055
 liquid/builtin/tags/echo_tag.py,sha256=VvYth9VuA-A9bsfGUOLlM4QxL_frsgWena3yBrrLKPI,1174
 liquid/builtin/tags/for_tag.py,sha256=vVSc9WJ0ZeLW8zgDwNs_dVr8qe9lrg92Ny90GmpO_Jo,9440
-liquid/builtin/tags/if_tag.py,sha256=u8Jqk-HaT-bK5deaoDltdmrLpL_0m3UM8a1_r9OXsjc,6560
+liquid/builtin/tags/if_tag.py,sha256=4hGDjQo33PXxsXui6pZ75Wx2BkEtt5SOiZoK3Yb2pL8,6588
 liquid/builtin/tags/ifchanged_tag.py,sha256=VpJNDhT7MFXcNmRrYiWcJ9whhaRXh81oe_phatS5_Kg,2734
 liquid/builtin/tags/include_tag.py,sha256=eAnjcbJ2-e0382TkrV2WJ9dACFWi_UNUeKG-QRuiOig,9220
 liquid/builtin/tags/increment_tag.py,sha256=SV2nrbE90l4iz36WCROqGE0RkkzztWUpU1_Pyp2DDQo,1662
 liquid/builtin/tags/inline_comment_tag.py,sha256=hLLtvaI-VpJxzFeoLTwDTj46g13A1ke6blqVo2MP0Cs,1357
 liquid/builtin/tags/liquid_tag.py,sha256=vQh2T8_3uBfTTgp6PNqi_bOhbRNv45eoo9yoOXcNyz8,5465
-liquid/builtin/tags/render_tag.py,sha256=h2np1g8gK43Kind2Mw5Sr9bR7cQg2k2dTAOsH-w2ZOY,11787
+liquid/builtin/tags/render_tag.py,sha256=iYWjKYQBmGHQVQ9OZgPZvVhraygFdmPzITin7cKJI5E,14309
 liquid/builtin/tags/tablerow_tag.py,sha256=qE5hIrlJXdKiLJ0u1YLgjnqt6GedWujfcfIO0b9x0d8,8947
 liquid/builtin/tags/unless_tag.py,sha256=udlHvVxILJsYfDaWRkj6Ynmnz2-2FF5RfkP0eizXt7k,6932
-liquid/extra/__init__.py,sha256=DNS-k6uH7-IvYu_6InPk38CmjW1orggBaj0rkBkvy74,2855
+liquid/extra/__init__.py,sha256=KrE9DAkwCAOLIaBHt73pnL6sb1tN5-UEKoQsX1b43Gg,2886
 liquid/extra/filters/__init__.py,sha256=tsEfSmaJvd6xN8DfKISPOm_KcHOmBVc4RSQqViD8NvY,733
 liquid/extra/filters/_json.py,sha256=Od7iJWKCWQzf1eZiIqOG1LGwx2JTiHCe95GO5DqgHYY,844
 liquid/extra/filters/array.py,sha256=QvuP2jPg0G4xgIGXOcCRvjpX0O5h7U-WpayAaYmYDdc,1590
-liquid/extra/filters/babel.py,sha256=ofFSAaUfOyRYC94_LEVLvEeyzrrh7YssVXRcwKBWQPg,19188
+liquid/extra/filters/babel.py,sha256=K0kvw8r5Xy4NwvX4qv-lym14rZ25gB4fCnHqj-IVagI,19187
 liquid/extra/filters/html.py,sha256=j6ghLorvxlVwAtyfVJlmB1tnroGJb8hD-uxUVALVSEQ,929
 liquid/extra/filters/translate.py,sha256=PDEgvmdOvg45ChAKLsaqtamOqaBWOFh4XzQC8igXIyE,13019
-liquid/extra/tags/__init__.py,sha256=IGL2PPie0T73DQRNB-BY3hKOq710ZzMvlW31qulhtI0,329
+liquid/extra/tags/__init__.py,sha256=iqB5oOPYhZey-dyljrgAjGeni4lK8Q9-rW2cGRHa4hw,383
 liquid/extra/tags/_with.py,sha256=QLlpY3oW8prCmutEXv1uUCMo_hloLd-sEbiMkMIbtXM,2627
-liquid/extra/tags/extends_tag.py,sha256=_X5wYKVtzSetuGlEUI9gl5nkUJmwEAS7sQIaZHBKexM,17978
+liquid/extra/tags/extends_tag.py,sha256=3PL1y1FHaeh6L4rA_Xz6wP6l5oHdiOY_u42ivS6c3xE,17893
 liquid/extra/tags/macro_tag.py,sha256=ErjPxOVB50KKn2qi7-2Icmrbx5Uldv2vUSj49TCs4bY,8749
+liquid/extra/tags/snippet_tag.py,sha256=8tFZWDvwhRId5IV0mNKhkFswJx3eTeAYs7-nAwiorNY,3155
 liquid/extra/tags/translate_tag.py,sha256=wv2uK9QtWDrArVeAWmH2QQ7fkM5EAM4gK2bWjlstcnE,12515
 liquid/future/__init__.py,sha256=5BUZi58WyWjPQDflh2C3sQJmuSKAZgNG_286ERyYKFE,79
 liquid/future/environment.py,sha256=Zx4RbgIOMmH5N_VH9poOGRLcSI9DAA5_EkUlP-L6ZlA,986
@@ -89,7 +90,7 @@ liquid/utils/chain_map.py,sha256=nxkw3wwF6ddlGarIuL7Ii2elm4dU80LySgdQx1oift0,151
 liquid/utils/html.py,sha256=TmqOOpRMsy7fqZLj7X5ybd_XQnWW2YDAVDwTP1Gwf40,1706
 liquid/utils/lru_cache.py,sha256=p7bXOGaUwJpLsREI2lGSzK6lLna5W_k_zNXKWnPJdos,4022
 liquid/utils/text.py,sha256=1SwDECNMaqnnZ05je_AZZgxqzZd6U-mvq5jNU3W1-Qk,841
-python_liquid-2.1.0.dist-info/METADATA,sha256=hWoZ7ptvnd2teO9UkGuQeDhpYCQxoTbhG42ndbWDwJ0,6694
-python_liquid-2.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_liquid-2.1.0.dist-info/licenses/LICENSE,sha256=yAFURzud5ERNHt1rZIPnTLJ92ep7q8y5yG9g5DUMR_E,1075
-python_liquid-2.1.0.dist-info/RECORD,,
+python_liquid-2.2.1.dist-info/METADATA,sha256=ttOrZWxcSER0sxi5fw52WvjFIqb07SMBFMj18TLp2gk,6745
+python_liquid-2.2.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+python_liquid-2.2.1.dist-info/licenses/LICENSE,sha256=yAFURzud5ERNHt1rZIPnTLJ92ep7q8y5yG9g5DUMR_E,1075
+python_liquid-2.2.1.dist-info/RECORD,,

{python_liquid-2.1.0.dist-info → python_liquid-2.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any