python-liquid 2.1.0__tar.gz → 2.2.1__tar.gz

{python_liquid-2.1.0 → python_liquid-2.2.1}/PKG-INFO

@@ -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 → python_liquid-2.2.1}/liquid/__init__.py

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

{python_liquid-2.1.0 → python_liquid-2.2.1}/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.1.0 → python_liquid-2.2.1}/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)

{python_liquid-2.1.0 → python_liquid-2.2.1}/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())

{python_liquid-2.1.0 → python_liquid-2.2.1}/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.1.0 → python_liquid-2.2.1}/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.1.0 → python_liquid-2.2.1}/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)

{python_liquid-2.1.0 → python_liquid-2.2.1}/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.1.0 → python_liquid-2.2.1}/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.1.0 → python_liquid-2.2.1}/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.1.0 → python_liquid-2.2.1}/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.1.0 → python_liquid-2.2.1}/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.1.0 → python_liquid-2.2.1}/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",

{python_liquid-2.1.0 → python_liquid-2.2.1}/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"`.

{python_liquid-2.1.0 → python_liquid-2.2.1}/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",
 )

{python_liquid-2.1.0 → python_liquid-2.2.1}/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=[],
         )

python_liquid-2.2.1/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"

{python_liquid-2.1.0 → python_liquid-2.2.1}/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: