python-liquid 1.12.2__tar.gz → 1.13.0__tar.gz

{python_liquid-1.12.2 → python_liquid-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-liquid
-Version: 1.12.2
+Version: 1.13.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/
@@ -31,6 +31,11 @@ Provides-Extra: autoescape
 Requires-Dist: markupsafe<3,>=2; extra == 'autoescape'
 Description-Content-Type: text/markdown
 
+> [!IMPORTANT]  
+> 🎉 Announcing the release of [Python Liquid2](https://github.com/jg-rp/python-liquid2) 🎉 See the [migration guide](https://jg-rp.github.io/python-liquid2/migration/) and the list of [new features](https://jg-rp.github.io/python-liquid2/migration/#new-features).
+
+---
+
 <h1 align="center">Python Liquid</h1>
 
 <p align="center">
@@ -120,7 +125,8 @@ print(template.render(you="Liquid"))  # "Hello, Liquid!"
 
 ## Related Projects
 
-- [liquid-babel](https://github.com/jg-rp/liquid-babel) Internationalization and localization for Liquid templates.
+- [Python Liquid2](https://github.com/jg-rp/python-liquid2): A new Python pakage for Liquid, with extra features.
+- [liquid-babel](https://github.com/jg-rp/liquid-babel): Internationalization and localization for Liquid templates.
 - [LiquidScript](https://github.com/jg-rp/liquidscript): A JavaScript and TypeScript engine for Liquid with a similar high-level API to Python Liquid.
 - [django-liquid](https://github.com/jg-rp/django-liquid): A Django template backend for Liquid. Render Liquid templates in your Django apps.
 - [Flask-Liquid](https://github.com/jg-rp/Flask-Liquid): A Flask extension for Liquid. Render Liquid templates in your Flask applications.

{python_liquid-1.12.2 → python_liquid-1.13.0}/README.md

@@ -1,3 +1,8 @@
+> [!IMPORTANT]  
+> 🎉 Announcing the release of [Python Liquid2](https://github.com/jg-rp/python-liquid2) 🎉 See the [migration guide](https://jg-rp.github.io/python-liquid2/migration/) and the list of [new features](https://jg-rp.github.io/python-liquid2/migration/#new-features).
+
+---
+
 <h1 align="center">Python Liquid</h1>
 
 <p align="center">
@@ -87,7 +92,8 @@ print(template.render(you="Liquid"))  # "Hello, Liquid!"
 
 ## Related Projects
 
-- [liquid-babel](https://github.com/jg-rp/liquid-babel) Internationalization and localization for Liquid templates.
+- [Python Liquid2](https://github.com/jg-rp/python-liquid2): A new Python pakage for Liquid, with extra features.
+- [liquid-babel](https://github.com/jg-rp/liquid-babel): Internationalization and localization for Liquid templates.
 - [LiquidScript](https://github.com/jg-rp/liquidscript): A JavaScript and TypeScript engine for Liquid with a similar high-level API to Python Liquid.
 - [django-liquid](https://github.com/jg-rp/django-liquid): A Django template backend for Liquid. Render Liquid templates in your Django apps.
 - [Flask-Liquid](https://github.com/jg-rp/Flask-Liquid): A Flask extension for Liquid. Render Liquid templates in your Flask applications.

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/__init__.py

@@ -46,7 +46,7 @@ from .static_analysis import ContextualTemplateAnalysis
 
 from . import future
 
-__version__ = "1.12.2"
+__version__ = "1.13.0"
 
 __all__ = (
     "AwareBoundTemplate",

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/builtin/tags/case_tag.py

@@ -1,4 +1,5 @@
 """Tag and node definition for the built-in "case" tag."""
+
 from __future__ import annotations
 
 import sys
@@ -193,14 +194,16 @@ class CaseTag(Tag):
 
     def _parse_case_expression(self, expr: str, linenum: int) -> Expression:
         stream = ExpressionTokenStream(
-            tokenize_common_expression(expr, linenum=linenum)
+            tokenize_common_expression(expr, linenum=linenum),
+            shorthand_indexes=self.env.shorthand_indexes,
         )
         return parse_common_expression(stream)
 
     def _parse_when_expression(self, expr: str, linenum: int) -> List[Expression]:
         expressions = []
         stream = ExpressionTokenStream(
-            tokenize_common_expression(expr, linenum=linenum)
+            tokenize_common_expression(expr, linenum=linenum),
+            shorthand_indexes=self.env.shorthand_indexes,
         )
 
         while True:

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/environment.py

@@ -1,8 +1,10 @@
 """Shared configuration from which templates can be loaded and parsed."""
+
 from __future__ import annotations
 
 import warnings
 from functools import lru_cache
+from functools import partial
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Callable
@@ -154,6 +156,10 @@ class Environment:
     # Whether to output blocks that only contain only whitespace when rendered.
     render_whitespace_only_blocks: bool = False
 
+    # When `True`, accept indexes without enclosing square brackets in paths to
+    # variables. Defaults to `False`.
+    shorthand_indexes: bool = False
+
     def __init__(
         self,
         tag_start_string: str = r"{%",
@@ -578,29 +584,77 @@ class Environment:
     def _get_expression_parsers(
         self, cache_size: int = 0
     ) -> Tuple[
-        Callable[[str, int], "BooleanExpression"],
-        Callable[[str, int], "BooleanExpression"],
-        Callable[[str, int], "FilteredExpression"],
-        Callable[[str, int], "FilteredExpression"],
-        Callable[[str, int], "FilteredExpression"],
-        Callable[[str, int], "LoopExpression"],
+        Callable[[str, int], BooleanExpression],
+        Callable[[str, int], BooleanExpression],
+        Callable[[str, int], FilteredExpression],
+        Callable[[str, int], FilteredExpression],
+        Callable[[str, int], FilteredExpression],
+        Callable[[str, int], LoopExpression],
     ]:
         if cache_size >= 1:
             return (
-                lru_cache(maxsize=cache_size)(parse_boolean_expression),
-                lru_cache(maxsize=cache_size)(parse_boolean_expression_with_parens),
-                lru_cache(maxsize=cache_size)(parse_conditional_expression),
-                lru_cache(maxsize=cache_size)(parse_conditional_expression_with_parens),
-                lru_cache(maxsize=cache_size)(parse_filtered_expression),
-                lru_cache(maxsize=cache_size)(parse_loop_expression),
+                lru_cache(maxsize=cache_size)(
+                    partial(
+                        parse_boolean_expression,
+                        shorthand_indexes=self.shorthand_indexes,
+                    )
+                ),
+                lru_cache(maxsize=cache_size)(
+                    partial(
+                        parse_boolean_expression_with_parens,
+                        shorthand_indexes=self.shorthand_indexes,
+                    )
+                ),
+                lru_cache(maxsize=cache_size)(
+                    partial(
+                        parse_conditional_expression,
+                        shorthand_indexes=self.shorthand_indexes,
+                    )
+                ),
+                lru_cache(maxsize=cache_size)(
+                    partial(
+                        parse_conditional_expression_with_parens,
+                        shorthand_indexes=self.shorthand_indexes,
+                    )
+                ),
+                lru_cache(maxsize=cache_size)(
+                    partial(
+                        parse_filtered_expression,
+                        shorthand_indexes=self.shorthand_indexes,
+                    )
+                ),
+                lru_cache(maxsize=cache_size)(
+                    partial(
+                        parse_loop_expression,
+                        shorthand_indexes=self.shorthand_indexes,
+                    )
+                ),
             )
         return (
-            parse_boolean_expression,
-            parse_boolean_expression_with_parens,
-            parse_conditional_expression,
-            parse_conditional_expression_with_parens,
-            parse_filtered_expression,
-            parse_loop_expression,
+            partial(
+                parse_boolean_expression,
+                shorthand_indexes=self.shorthand_indexes,
+            ),
+            partial(
+                parse_boolean_expression_with_parens,
+                shorthand_indexes=self.shorthand_indexes,
+            ),
+            partial(
+                parse_conditional_expression,
+                shorthand_indexes=self.shorthand_indexes,
+            ),
+            partial(
+                parse_conditional_expression_with_parens,
+                shorthand_indexes=self.shorthand_indexes,
+            ),
+            partial(
+                parse_filtered_expression,
+                shorthand_indexes=self.shorthand_indexes,
+            ),
+            partial(
+                parse_loop_expression,
+                shorthand_indexes=self.shorthand_indexes,
+            ),
         )
 
 

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/expressions/boolean/parse.py

@@ -1,4 +1,5 @@
 """Functions for parsing boolean expressions."""
+
 from typing import Callable
 from typing import Dict
 
@@ -188,9 +189,15 @@ parse_range = make_parse_range(parse_simple_obj)
 TOKEN_MAP[TOKEN_LPAREN] = parse_range
 
 
-def parse(expr: str, linenum: int = 1) -> BooleanExpression:
+def parse(
+    expr: str, linenum: int = 1, *, shorthand_indexes: bool = False
+) -> BooleanExpression:
     """Parse a string as a "standard" boolean expression."""
-    return BooleanExpression(parse_obj(TokenStream(tokenize(expr, linenum))))
+    return BooleanExpression(
+        parse_obj(
+            TokenStream(tokenize(expr, linenum), shorthand_indexes=shorthand_indexes)
+        )
+    )
 
 
 def parse_grouped_expression(stream: TokenStream) -> Expression:
@@ -261,13 +268,17 @@ def parse_obj_with_parens(
     return left
 
 
-def parse_with_parens(expr: str, linenum: int = 1) -> BooleanExpression:
+def parse_with_parens(
+    expr: str, linenum: int = 1, *, shorthand_indexes: bool = False
+) -> BooleanExpression:
     """Parse a string as a boolean expression.
 
     This function handles expressions containing the logical `not` operator and
     parentheses for grouping terms.
     """
-    stream = TokenStream(tokenize_with_parens(expr, linenum))
+    stream = TokenStream(
+        tokenize_with_parens(expr, linenum), shorthand_indexes=shorthand_indexes
+    )
     rv = BooleanExpression(parse_obj_with_parens(stream))
     peek_typ = stream.peek[1]
     if peek_typ == TOKEN_RPAREN:

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/expressions/common.py

@@ -1,4 +1,5 @@
 """Patterns and parse functions common to multiple built-in expression types."""
+
 from __future__ import annotations
 
 import re
@@ -145,10 +146,17 @@ def parse_identifier(stream: "TokenStream") -> Identifier:
             stream.next_token()
             stream.expect(TOKEN_RBRACKET)
         elif typ == TOKEN_FLOAT:
-            raise LiquidSyntaxError(
-                f"expected an identifier, found {val!r}",
-                linenum=pos,
-            )
+            if stream.shorthand_indexes:
+                path.extend(
+                    IdentifierPathElement(to_int(i)) for i in val.rstrip(".").split(".")
+                )
+            else:
+                raise LiquidSyntaxError(
+                    f"expected an identifier, found {val!r}",
+                    linenum=pos,
+                )
+        elif typ == TOKEN_INTEGER and stream.shorthand_indexes:
+            path.append(IdentifierPathElement(to_int(val)))
         elif typ == TOKEN_DOT:
             pass
         else:
@@ -194,7 +202,7 @@ def parse_unchained_identifier(stream: "TokenStream") -> Identifier:
 
 
 def make_parse_range(
-    parse_obj: Callable[["TokenStream"], Expression]
+    parse_obj: Callable[["TokenStream"], Expression],
 ) -> Callable[["TokenStream"], RangeLiteral]:
     """Return a function that parses range expressions using _parse_obj_."""
 
@@ -246,6 +254,8 @@ _IDENT_TOKENS = frozenset(
         TOKEN_IDENTINDEX,
         TOKEN_DOT,
         TOKEN_LBRACKET,
+        TOKEN_INTEGER,
+        TOKEN_FLOAT,
     )
 )
 
@@ -259,7 +269,7 @@ def _parse_common_identifier(stream: "TokenStream") -> Identifier:
     path: IdentifierPath = []
 
     while True:
-        _, _type, value = stream.current
+        pos, _type, value = stream.current
         if _type == TOKEN_IDENTIFIER:
             path.append(IdentifierPathElement(value))
         elif _type == TOKEN_IDENTINDEX:
@@ -269,6 +279,19 @@ def _parse_common_identifier(stream: "TokenStream") -> Identifier:
             path.append(_parse_common_identifier(stream))
             stream.next_token()
             stream.expect(TOKEN_RBRACKET)
+        elif _type == TOKEN_FLOAT:
+            if stream.shorthand_indexes:
+                path.extend(
+                    IdentifierPathElement(to_int(i))
+                    for i in value.rstrip(".").split(".")
+                )
+            else:
+                raise LiquidSyntaxError(
+                    f"expected an identifier, found {value!r}",
+                    linenum=pos,
+                )
+        elif _type == TOKEN_INTEGER and stream.shorthand_indexes:
+            path.append(IdentifierPathElement(to_int(value)))
         elif _type == TOKEN_DOT:
             pass
 

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/expressions/conditional/parse.py

@@ -1,4 +1,5 @@
 """Functions for parsing non-standard conditional expressions."""
+
 from functools import partial
 from typing import Dict
 from typing import Iterable
@@ -65,13 +66,15 @@ split_at_first_if = partial(_split_at_first, _type=TOKEN_IF)
 split_at_first_else = partial(_split_at_first, _type=TOKEN_ELSE)
 
 
-def _parse_filter(tokens: List[Token], linenum: int) -> Filter:
+def _parse_filter(
+    tokens: List[Token], linenum: int, *, shorthand_indexes: bool = False
+) -> Filter:
     if not tokens:
         raise LiquidSyntaxError(
             "unexpected pipe or missing filter name", linenum=linenum
         )
 
-    stream = TokenStream(iter(tokens))
+    stream = TokenStream(iter(tokens), shorthand_indexes=shorthand_indexes)
     stream.expect(TOKEN_IDENTIFIER)
     name = stream.current[2]
 
@@ -108,13 +111,17 @@ def _parse_filter(tokens: List[Token], linenum: int) -> Filter:
     return Filter(name, args, kwargs)
 
 
-def parse(expr: str, linenum: int = 1) -> FilteredExpression:
+def parse(
+    expr: str, linenum: int = 1, *, shorthand_indexes: bool = False
+) -> FilteredExpression:
     """Parse a conditional expression string."""
     tokens = tokenize(expr, linenum)
     standard_tokens, _conditional_tokens = split_at_first_if(tokens)
 
     # This expression includes filters.
-    _expr = parse_standard_filtered(iter(standard_tokens), linenum)
+    _expr = parse_standard_filtered(
+        iter(standard_tokens), linenum, shorthand_indexes=shorthand_indexes
+    )
 
     if not _conditional_tokens:
         # A standard filtered expression
@@ -126,7 +133,10 @@ def parse(expr: str, linenum: int = 1) -> FilteredExpression:
     )
 
     if conditional_tokens:
-        condition = parse_boolean_obj(TokenStream(iter(conditional_tokens)), linenum)
+        condition = parse_boolean_obj(
+            TokenStream(iter(conditional_tokens), shorthand_indexes=shorthand_indexes),
+            linenum,
+        )
 
     else:
         # A missing condition (an `if` with nothing after it).
@@ -138,7 +148,7 @@ def parse(expr: str, linenum: int = 1) -> FilteredExpression:
 
         if alternative_tokens:
             alternative: Optional[Expression] = parse_standard_filtered(
-                iter(alternative_tokens), linenum
+                iter(alternative_tokens), linenum, shorthand_indexes=shorthand_indexes
             )
         else:
             alternative = None
@@ -156,7 +166,9 @@ def parse(expr: str, linenum: int = 1) -> FilteredExpression:
     return ConditionalExpression(_expr, tail_filters, condition, alternative)
 
 
-def parse_with_parens(expr: str, linenum: int = 1) -> FilteredExpression:
+def parse_with_parens(
+    expr: str, linenum: int = 1, shorthand_indexes: bool = False
+) -> FilteredExpression:
     """Parse a conditional expression string.
 
     This parse function handles logical `not` and grouping terms with parentheses.
@@ -165,7 +177,9 @@ def parse_with_parens(expr: str, linenum: int = 1) -> FilteredExpression:
     standard_tokens, _conditional_tokens = split_at_first_if(tokens)
 
     # This expression includes filters.
-    _expr = parse_standard_filtered(iter(standard_tokens), linenum)
+    _expr = parse_standard_filtered(
+        iter(standard_tokens), linenum, shorthand_indexes=shorthand_indexes
+    )
 
     if not _conditional_tokens:
         # A standard filtered expression
@@ -178,7 +192,8 @@ def parse_with_parens(expr: str, linenum: int = 1) -> FilteredExpression:
 
     if conditional_tokens:
         condition = parse_boolean_obj_with_parens(
-            TokenStream(iter(conditional_tokens)), linenum
+            TokenStream(iter(conditional_tokens), shorthand_indexes=shorthand_indexes),
+            linenum,
         )
     else:
         # A missing condition (an `if` with nothing after it).
@@ -190,7 +205,7 @@ def parse_with_parens(expr: str, linenum: int = 1) -> FilteredExpression:
 
         if alternative_tokens:
             alternative: Optional[Expression] = parse_standard_filtered(
-                iter(alternative_tokens), linenum
+                iter(alternative_tokens), linenum, shorthand_indexes=shorthand_indexes
             )
         else:
             alternative = None
@@ -199,7 +214,7 @@ def parse_with_parens(expr: str, linenum: int = 1) -> FilteredExpression:
 
     if _filter_tokens:
         tail_filters = [
-            _parse_filter(_tokens, linenum)
+            _parse_filter(_tokens, linenum, shorthand_indexes=shorthand_indexes)
             for _tokens in split_at_pipe(iter(_filter_tokens))
         ]
     else:

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/expressions/filtered/parse.py

@@ -2,7 +2,9 @@
 
 Like those found in output statements and assign tags.
 """
+
 from itertools import islice
+from typing import Callable
 from typing import Dict
 from typing import Iterable
 from typing import Iterator
@@ -43,7 +45,7 @@ from liquid.token import TOKEN_RANGE_LITERAL
 from liquid.token import TOKEN_STRING
 from liquid.token import TOKEN_TRUE
 
-TOKEN_MAP = {
+TOKEN_MAP: Dict[str, Callable[[TokenStream], Expression]] = {
     TOKEN_FALSE: parse_boolean,
     TOKEN_TRUE: parse_boolean,
     TOKEN_NIL: parse_nil,
@@ -126,7 +128,7 @@ def split_at_comma(
 
 
 def bucket_args(
-    arguments: Iterable[Tuple[str, Expression]]
+    arguments: Iterable[Tuple[str, Expression]],
 ) -> Tuple[List[Expression], Dict[str, Expression]]:  # pragma: no cover
     """Split filter arguments into positional and keyword arguments."""
     args = []
@@ -166,12 +168,16 @@ def parse_args(
         yield parse_arg(arg_tokens)
 
 
-def parse_arg(tokens: List[Token]) -> Tuple[str, Expression]:  # pragma: no cover
+def parse_arg(
+    tokens: List[Token], *, shorthand_indexes: bool = False
+) -> Tuple[str, Expression]:  # pragma: no cover
     """Parse a single argument from a list of tokens."""
     if len(tokens) > 1 and tokens[1][1] == TOKEN_COLON:
         # A named/keyword parameter/argument
-        return tokens[0][2], parse_obj(TokenStream(islice(tokens, 2, None)))
-    return "", parse_obj(TokenStream(iter(tokens)))
+        return tokens[0][2], parse_obj(
+            TokenStream(islice(tokens, 2, None), shorthand_indexes=shorthand_indexes)
+        )
+    return "", parse_obj(TokenStream(iter(tokens), shorthand_indexes=shorthand_indexes))
 
 
 # _parse_filter has replaced the parse_* functions above in the name of better syntax
@@ -179,13 +185,15 @@ def parse_arg(tokens: List[Token]) -> Tuple[str, Expression]:  # pragma: no cove
 # be depreciated as we approach Python Liquid version 2 and then removed.
 
 
-def _parse_filter(tokens: List[Token], linenum: int) -> Filter:
+def _parse_filter(
+    tokens: List[Token], linenum: int, *, shorthand_indexes: bool = False
+) -> Filter:
     if not tokens:
         raise LiquidSyntaxError(
             "unexpected pipe or missing filter name", linenum=linenum
         )
 
-    stream = TokenStream(iter(tokens))
+    stream = TokenStream(iter(tokens), shorthand_indexes=shorthand_indexes)
     stream.expect(TOKEN_IDENTIFIER)
     name = stream.current[2]
 
@@ -222,10 +230,12 @@ def _parse_filter(tokens: List[Token], linenum: int) -> Filter:
     return Filter(name, args, kwargs)
 
 
-def parse_from_tokens(tokens: Iterator[Token], linenum: int = 1) -> FilteredExpression:
+def parse_from_tokens(
+    tokens: Iterator[Token], linenum: int = 1, *, shorthand_indexes: bool = False
+) -> FilteredExpression:
     """Parse an expression with zero or more filters from a token iterator."""
     parts = tuple(split_at_first_pipe(tokens))
-    stream = TokenStream(iter(parts[0]))
+    stream = TokenStream(iter(parts[0]), shorthand_indexes=shorthand_indexes)
     left = parse_obj(stream)
 
     if stream.peek[1] != TOKEN_EOF:
@@ -237,10 +247,17 @@ def parse_from_tokens(tokens: Iterator[Token], linenum: int = 1) -> FilteredExpr
     if len(parts) == 1:
         return FilteredExpression(left)
 
-    filters = [_parse_filter(_tokens, linenum) for _tokens in split_at_pipe(parts[1])]
+    filters = [
+        _parse_filter(_tokens, linenum, shorthand_indexes=shorthand_indexes)
+        for _tokens in split_at_pipe(parts[1])
+    ]
     return FilteredExpression(left, filters)
 
 
-def parse(expr: str, linenum: int = 1) -> FilteredExpression:
+def parse(
+    expr: str, linenum: int = 1, *, shorthand_indexes: bool = False
+) -> FilteredExpression:
     """Parse an expression string with zero or more filters."""
-    return parse_from_tokens(tokenize(expr, linenum))
+    return parse_from_tokens(
+        tokenize(expr, linenum), shorthand_indexes=shorthand_indexes
+    )

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/expressions/loop/parse.py

@@ -2,6 +2,7 @@
 
 Like those found in `for` and `tablerow` tags.
 """
+
 from typing import Callable
 from typing import Dict
 from typing import Tuple
@@ -109,9 +110,11 @@ def parse_loop_arguments(stream: TokenStream) -> Tuple[Dict[str, LoopArgument],
     return arguments, _reversed
 
 
-def parse(expr: str, linenum: int = 1) -> LoopExpression:
+def parse(
+    expr: str, linenum: int = 1, *, shorthand_indexes: bool = False
+) -> LoopExpression:
     """Parse a loop expression string."""
-    stream = TokenStream(tokenize(expr, linenum))
+    stream = TokenStream(tokenize(expr, linenum), shorthand_indexes=shorthand_indexes)
     stream.expect(TOKEN_IDENTIFIER)
     name = next(stream)[2]
 

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/expressions/stream.py

@@ -19,13 +19,15 @@ if TYPE_CHECKING:
 class TokenStream:
     """Step through or iterate a stream of tokens."""
 
-    def __init__(self, tokeniter: Iterator[Token]):
+    def __init__(self, tokeniter: Iterator[Token], *, shorthand_indexes: bool = False):
         self.iter = tokeniter
         self._pushed: Deque[Token] = deque()
 
         self.current: Token = (0, TOKEN_INITIAL, "")
         next(self)
 
+        self.shorthand_indexes = shorthand_indexes
+
     class TokenStreamIterator:
         """An iterable token stream."""
 

{python_liquid-1.12.2 → python_liquid-1.13.0}/liquid/extra/tags/if_not.py

@@ -6,7 +6,6 @@ logical `not` operator and grouping terms with parentheses.
 
 from liquid.builtin.tags.if_tag import IfTag
 from liquid.expression import Expression
-from liquid.expressions import parse_boolean_expression_with_parens
 from liquid.parse import expect
 from liquid.stream import TokenStream
 from liquid.token import TOKEN_EXPRESSION
@@ -20,6 +19,6 @@ class IfNotTag(IfTag):
     def parse_expression(self, stream: TokenStream) -> Expression:
         """Pare a boolean expression from a stream of tokens."""
         expect(stream, TOKEN_EXPRESSION)
-        return parse_boolean_expression_with_parens(
+        return self.env.parse_boolean_expression_value_with_parens(
             stream.current.value, stream.current.linenum
         )

{python_liquid-1.12.2 → python_liquid-1.13.0}/pyproject.toml

@@ -211,6 +211,7 @@ select = [
 
 # TODO: review ignores
 ignore = [
+  "A005",
   "S105",
   "S101",
   "D107",