python-liquid 2.0.2__tar.gz → 2.2.0__tar.gz

{python_liquid-2.0.2 → python_liquid-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-liquid
-Version: 2.0.2
+Version: 2.2.0
 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
@@ -105,6 +106,7 @@ $ conda install -c conda-forge python-liquid
 
 - [Python Liquid2](https://github.com/jg-rp/python-liquid2): A new Python engine for Liquid with [extra features](https://jg-rp.github.io/python-liquid2/migration/#new-features).
 - [Ruby Liquid2](https://github.com/jg-rp/ruby-liquid2): Liquid2 templates for Ruby.
+- [Micro Liquid](https://github.com/jg-rp/micro-liquid): A stripped-down Liquid-like template engine for Python. You can think of it as a non-evaluating alternative to Python's [f-strings](https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals) or [t-strings](https://docs.python.org/3.14/whatsnew/3.14.html#whatsnew314-pep750).
 - [LiquidScript](https://github.com/jg-rp/liquidscript): A JavaScript engine for Liquid with a similar high-level API to Python Liquid.
 
 ## Quick Start

{python_liquid-2.0.2 → python_liquid-2.2.0}/README.md

@@ -75,6 +75,7 @@ $ conda install -c conda-forge python-liquid
 
 - [Python Liquid2](https://github.com/jg-rp/python-liquid2): A new Python engine for Liquid with [extra features](https://jg-rp.github.io/python-liquid2/migration/#new-features).
 - [Ruby Liquid2](https://github.com/jg-rp/ruby-liquid2): Liquid2 templates for Ruby.
+- [Micro Liquid](https://github.com/jg-rp/micro-liquid): A stripped-down Liquid-like template engine for Python. You can think of it as a non-evaluating alternative to Python's [f-strings](https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals) or [t-strings](https://docs.python.org/3.14/whatsnew/3.14.html#whatsnew314-pep750).
 - [LiquidScript](https://github.com/jg-rp/liquidscript): A JavaScript engine for Liquid with a similar high-level API to Python Liquid.
 
 ## Quick Start

{python_liquid-2.0.2 → python_liquid-2.2.0}/liquid/__init__.py

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

{python_liquid-2.0.2 → python_liquid-2.2.0}/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):

{python_liquid-2.0.2 → python_liquid-2.2.0}/liquid/builtin/__init__.py

@@ -21,6 +21,7 @@ from .filters.array import sort_natural
 from .filters.array import sum_
 from .filters.array import uniq
 from .filters.array import where
+from .filters.extra import escapejs
 from .filters.extra import safe
 from .filters.math import abs_
 from .filters.math import at_least
@@ -57,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
@@ -174,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)
@@ -197,3 +200,4 @@ def register(env: Environment) -> None:  # noqa: PLR0915
     env.add_filter("date", date)
 
     env.add_filter("safe", safe)
+    env.add_filter("escapejs", escapejs)

python_liquid-2.2.0/liquid/builtin/filters/extra.py

@@ -0,0 +1,83 @@
+"""Filters that don't exist in the reference implementation."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from liquid import Markup
+from liquid.filter import string_filter
+from liquid.filter import with_environment
+
+if TYPE_CHECKING:
+    from liquid import Environment
+
+
+@with_environment
+@string_filter
+def safe(val: str, *, environment: Environment) -> str:
+    """Return a copy of _val_ that will not be automatically HTML escaped on output."""
+    if environment.autoescape:
+        return Markup(val)
+    return val
+
+
+# `escapejs` is inspired by https://github.com/salesforce/secure-filters and Django's
+# escapejs filter, https://github.com/django/django/blob/485f483d49144a2ea5401442bc3b937a370b3ca6/django/utils/html.py#L63
+
+_ESCAPE_MAP = {
+    "\\": "\\u005C",
+    "'": "\\u0027",
+    '"': "\\u0022",
+    ">": "\\u003E",
+    "<": "\\u003C",
+    "&": "\\u0026",
+    "=": "\\u003D",
+    "-": "\\u002D",
+    ";": "\\u003B",
+    "`": "\\u0060",
+    "\u2028": "\\u2028",
+    "\u2029": "\\u2029",
+}
+
+_ESCAPE_MAP.update({chr(c): f"\\u{c:04X}" for c in range(32)})
+_ESCAPE_RE = re.compile("[" + re.escape("".join(_ESCAPE_MAP.keys())) + "]")
+
+
+@with_environment
+@string_filter
+def escapejs(val: str, *, environment: Environment) -> str:
+    """Escape characters for safe use in JavaScript string literals.
+
+    This filter escapes a string for embedding inside **JavaScript string
+    literals**, using either single or double quotes (e.g. `'...'` or `"..."`).
+    It replaces control characters and potentially dangerous symbols with
+    their corresponding Unicode escape sequences.
+
+    **Important:** This filter does **not** make strings safe for use in
+    JavaScript template literals (backtick strings), or in raw JavaScript
+    expressions. Use it only when placing data inside quoted JS strings
+    within inline `<script>` blocks or event handlers.
+
+    **Recommended alternatives:**
+        - Pass data using HTML `data-*` attributes and read them in JS via
+          `element.dataset`.
+        - For structured data, prefer a JSON-serialization approach using the
+          JSON filter.
+
+    Escaped characters include:
+        - ASCII control characters (U+0000 to U+001F)
+        - Characters like quotes, angle brackets, ampersands, equals signs
+        - Line/paragraph separators (U+2028, U+2029)
+
+    Args:
+        val: The input string to escape.
+        environment: The active Liquid environment
+
+    Returns:
+        A JavaScript-safe string, with problematic characters escaped as Unicode.
+    """
+    escaped = _ESCAPE_RE.sub(lambda m: _ESCAPE_MAP[m.group()], val)
+    if environment.autoescape:
+        return Markup(escaped)
+    return escaped

{python_liquid-2.0.2 → python_liquid-2.2.0}/liquid/builtin/filters/string.py

@@ -56,7 +56,35 @@ def downcase(val: str) -> str:
 @with_environment
 @string_filter
 def escape(val: str, *, environment: Environment) -> str:
-    """Return _val_ with the characters &, < and > converted to HTML-safe sequences."""
+    """Escape special characters in a string for safe use in HTML.
+
+    This filter replaces the characters `&`, `<`, `>`, `'`, and `"` with their
+    corresponding HTML-safe sequences:
+
+        - `&` -> `&amp;`
+        - `<` -> `&lt;`
+        - `>` -> `&gt;`
+        - `'` -> `&#39;`
+        - `"` -> `&#34;`
+
+    This helps prevent HTML injection (XSS) when rendering untrusted content in
+    HTML element bodies or attributes.
+
+    Important: This filter does **not** make strings safe for use in JavaScript,
+    including in `<script>` blocks, inline event handler attributes (e.g. `onerror`),
+    or other JavaScript contexts. For those cases, use the `escapejs` filter instead.
+
+    When `autoescape` is enabled in the environment, this filter uses the same
+    escaping logic as the environment (via `markupsafe.escape()`). Otherwise, it
+    falls back to Python's standard `html.escape()`.
+
+    Args:
+        val: The input string to escape.
+        environment: The current rendering environment.
+
+    Returns:
+        A string with HTML-special characters replaced by safe escape sequences.
+    """
     if environment.autoescape:
         return markupsafe_escape(str(val))
     return html.escape(val)
@@ -65,10 +93,14 @@ def escape(val: str, *, environment: Environment) -> str:
 @with_environment
 @string_filter
 def escape_once(val: str, *, environment: Environment) -> str:
-    """Return _val_ with the characters &, < and > converted to HTML-safe sequences.
+    """Escape a string for HTML, but avoid double-escaping existing entities.
 
-    It is safe to use `escape_one` on string values that already contain HTML escape
-    sequences.
+    Converts characters like `&`, `<`, and `>` to their HTML-safe sequences,
+    but leaves existing HTML entities untouched (e.g., `&amp;` stays `&amp;`).
+
+    This is useful when escaping content that may already be partially escaped.
+
+    See the `escape` filter for details and limitations.
     """
     if environment.autoescape:
         return Markup(val).unescape()
@@ -373,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())

{python_liquid-2.0.2 → python_liquid-2.2.0}/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,
         )

{python_liquid-2.0.2 → python_liquid-2.2.0}/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]:

{python_liquid-2.0.2 → python_liquid-2.2.0}/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

{python_liquid-2.0.2 → python_liquid-2.2.0}/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:

{python_liquid-2.0.2 → python_liquid-2.2.0}/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)

{python_liquid-2.0.2 → python_liquid-2.2.0}/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

{python_liquid-2.0.2 → python_liquid-2.2.0}/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)

{python_liquid-2.0.2 → python_liquid-2.2.0}/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:

{python_liquid-2.0.2 → python_liquid-2.2.0}/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",