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

{python_liquid-1.12.0 → python_liquid-1.12.2}/.gitignore

@@ -76,6 +76,9 @@ ENV/
 # IDE
 .vscode/
 
+# System
+.DS_Store
+
 # Dev utils
 dev.py
 dump_golden.py

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-liquid
-Version: 1.12.0
+Version: 1.12.2
 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/
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.9
 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 :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.7
@@ -27,7 +28,7 @@ Requires-Dist: importlib-resources>=5.10.0
 Requires-Dist: python-dateutil>=2.8.1
 Requires-Dist: typing-extensions>=4.2.0
 Provides-Extra: autoescape
-Requires-Dist: markupsafe>=2.0.0; extra == 'autoescape'
+Requires-Dist: markupsafe<3,>=2; extra == 'autoescape'
 Description-Content-Type: text/markdown
 
 <h1 align="center">Python Liquid</h1>

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

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

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/filters/array.py

@@ -33,6 +33,7 @@ if TYPE_CHECKING:
     from liquid import Environment
 
 ArrayT = Union[List[Any], Tuple[Any, ...]]
+"""Array-like objects."""
 
 # Send objects with missing keys to the end when sorting a list.
 MAX_CH = chr(0x10FFFF)
@@ -74,9 +75,12 @@ def _lower(obj: Any) -> str:
 @with_environment
 @sequence_filter
 def join(
-    sequence: Iterable[object], separator: object = " ", *, environment: Environment
+    sequence: Iterable[object],
+    separator: object = " ",
+    *,
+    environment: Environment,
 ) -> str:
-    """Concatenate an array of strings."""
+    """Return a string by joining items in _sequence_, separated by _separator_."""
     if not isinstance(separator, str):
         separator = str(separator)
 
@@ -88,7 +92,7 @@ def join(
 
 @liquid_filter
 def first(obj: Any) -> object:
-    """Return the first item of an array."""
+    """Return the first item of collection _obj_."""
     if isinstance(obj, str):
         return None
 
@@ -103,7 +107,7 @@ def first(obj: Any) -> object:
 
 @liquid_filter
 def last(obj: Sequence[Any]) -> object:
-    """Return the last item of an array."""
+    """Return the last item of array-like object _obj_."""
     if isinstance(obj, str):
         return None
 
@@ -115,7 +119,7 @@ def last(obj: Sequence[Any]) -> object:
 
 @sequence_filter
 def concat(sequence: ArrayT, second_array: ArrayT) -> ArrayT:
-    """Return two arrays joined together."""
+    """Return the concatenation of _sequence_ and _second_array_."""
     if not isinstance(second_array, (list, tuple)):
         raise FilterArgumentError(
             f"concat expected an array, found {type(second_array).__name__}"
@@ -129,7 +133,7 @@ def concat(sequence: ArrayT, second_array: ArrayT) -> ArrayT:
 
 @sequence_filter
 def map_(sequence: ArrayT, key: object) -> List[object]:
-    """Create an array of values from a map."""
+    """Return an array/list of items in _sequence_ selected by _key_."""
     try:
         return [_getitem(itm, str(key), default=NIL) for itm in sequence]
     except TypeError as err:
@@ -144,9 +148,9 @@ def reverse(array: ArrayT) -> List[object]:
 
 @array_filter
 def sort(sequence: ArrayT, key: object = None) -> List[object]:
-    """Sorts items in an array in case-sensitive order.
+    """Return a copy of _sequence_ in ascending order.
 
-    When a key string is provided, objects without the key property should
+    When a key string is provided, objects without the key property will
     be at the end of the output list/array.
     """
     if key:
@@ -161,7 +165,11 @@ def sort(sequence: ArrayT, key: object = None) -> List[object]:
 
 @array_filter
 def sort_natural(sequence: ArrayT, key: object = None) -> List[object]:
-    """Sorts items in an array in case-insensitive order."""
+    """Return a copy of _sequence_ in ascending order, with case-insensitive comparison.
+
+    When a key string is provided, objects without the key property will
+    be at the end of the output list/array.
+    """
     if key:
         item_getter = partial(_getitem, key=str(key), default=MAX_CH)
         return sorted(sequence, key=lambda obj: _lower(item_getter(obj)))
@@ -171,7 +179,7 @@ def sort_natural(sequence: ArrayT, key: object = None) -> List[object]:
 
 @sequence_filter
 def where(sequence: ArrayT, attr: object, value: object = None) -> List[object]:
-    """Create an array from a map where _attr_ equals _value_."""
+    """Return a list of items from _sequence_ where _attr_ equals _value_."""
     if value is not None and not is_undefined(value):
         return [itm for itm in sequence if _getitem(itm, attr) == value]
 
@@ -180,7 +188,7 @@ def where(sequence: ArrayT, attr: object, value: object = None) -> List[object]:
 
 @sequence_filter
 def uniq(sequence: ArrayT, key: object = None) -> List[object]:
-    """Removes any duplicate elements in an array."""
+    """Return a copy of _sequence_ with duplicate elements removed."""
     # Note that we're not using a dict or set for deduplication because we need
     # to handle sequences containing unhashable objects, like dictionaries.
 
@@ -209,7 +217,7 @@ def uniq(sequence: ArrayT, key: object = None) -> List[object]:
 
 @sequence_filter
 def compact(sequence: ArrayT, key: object = None) -> List[object]:
-    """Removes any nil values from an array."""
+    """Return a copy of _sequence_ with any nil values removed."""
     if key is not None:
         try:
             return [itm for itm in sequence if itm[key] is not None]
@@ -220,7 +228,7 @@ def compact(sequence: ArrayT, key: object = None) -> List[object]:
 
 @sequence_filter
 def sum_(sequence: ArrayT, key: object = None) -> Union[float, int, Decimal]:
-    """Return the sum of all numeric elements in an array.
+    """Return the sum of all numeric elements in _sequence_.
 
     If _key_ is given, it is assumed that sequence items are mapping-like,
     and the values at _item[key]_ will be summed instead.

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/filters/extra.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 @with_environment
 @string_filter
 def safe(val: str, *, environment: Environment) -> str:
-    """Stringify and mark as safe."""
+    """Return a copy of _val_ that will not be automatically HTML escaped on output."""
     if environment.autoescape:
         return Markup(val)
     return val

python_liquid-1.12.2/liquid/builtin/filters/math.py

@@ -0,0 +1,134 @@
+"""Maths related filter functions."""
+
+import decimal
+import math
+from typing import Optional
+from typing import Union
+
+from liquid.context import is_undefined
+from liquid.exceptions import FilterArgumentError
+from liquid.filter import math_filter
+from liquid.filter import num_arg
+
+# TODO: Version 2 - Either handle all filter function argument type
+# conversions in a decorator or all in the function itself. Having these type
+# conversions split between decorators and calls to helper functions does not
+# help with readability, or make it easy to write good doc strings.
+
+
+@math_filter
+def abs_(num: Union[float, int]) -> Union[float, int]:
+    """Return the absolute value of number _num_."""
+    return abs(num)
+
+
+@math_filter
+def at_most(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return _val_ or _other_, whichever is smaller."""
+    other = num_arg(other, default=0)
+    return min(num, other)
+
+
+@math_filter
+def at_least(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return _val_ or _other_, whichever is greater."""
+    other = num_arg(other, default=0)
+    return max(num, other)
+
+
+@math_filter
+def ceil(num: Union[float, int]) -> Union[float, int]:
+    """Return _num_ rounded up to the next integer."""
+    return math.ceil(num)
+
+
+@math_filter
+def divided_by(num: Union[float, int], other: object) -> Union[float, int]:
+    """Return the result of dividing _num_ by _other_.
+
+    If both _num_ and _other_ are integers, integer division is performed.
+    """
+    other = num_arg(other, default=0)
+
+    try:
+        if isinstance(other, int) and isinstance(num, int):
+            return num // other
+        return num / other
+    except ZeroDivisionError as err:
+        # TODO: [VERSION_2] move inclusion of filter name in error messages to
+        # FilteredExpression, where the filter is applied.
+        raise FilterArgumentError(f"divided_by: can't divide by {other}") from err
+
+
+@math_filter
+def floor(num: Union[float, int]) -> Union[float, int]:
+    """Return _num_ rounded down to the next integer."""
+    return math.floor(num)
+
+
+@math_filter
+def minus(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return the result of subtracting _other_ from _num_."""
+    other = num_arg(other, default=0)
+
+    if isinstance(num, int) and isinstance(other, int):
+        return num - other
+    return float(decimal.Decimal(str(num)) - decimal.Decimal(str(other)))
+
+
+@math_filter
+def plus(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return the result of adding _other_ to _num_."""
+    other = num_arg(other, default=0)
+
+    if isinstance(num, int) and isinstance(other, int):
+        return num + other
+    return float(decimal.Decimal(str(num)) + decimal.Decimal(str(other)))
+
+
+@math_filter
+def round_(num: Union[float, int], ndigits: Optional[int] = None) -> Union[float, int]:
+    """Returns the result of rounding _num_ to _ndigits_ decimal digits."""
+    if ndigits is None or is_undefined(ndigits):
+        return round(num)
+
+    try:
+        _ndigits = num_arg(ndigits)
+    except FilterArgumentError:
+        # Probably a string that can't be case to an int or float
+        return round(num)
+
+    if isinstance(_ndigits, float):
+        _ndigits = int(_ndigits)
+
+    if _ndigits < 0:
+        return 0
+    if _ndigits == 0:
+        return round(num)
+
+    return round(num, _ndigits)
+
+
+@math_filter
+def times(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return the result of multiplying _num_ by _other_."""
+    other = num_arg(other, default=0)
+
+    if isinstance(num, int) and isinstance(other, int):
+        return num * other
+    return float(decimal.Decimal(str(num)) * decimal.Decimal(str(other)))
+
+
+@math_filter
+def modulo(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return the remainder of dividing _num_ by _other_."""
+    other = num_arg(other, default=0)
+
+    try:
+        if isinstance(num, int) and isinstance(other, int):
+            return num % other
+        return float(decimal.Decimal(str(num)) % decimal.Decimal(str(other)))
+    except ZeroDivisionError as err:
+        # TODO: [VERSION_2] move inclusion of filter name in error messages to
+        # FilteredExpression, where the filter is applied.
+        raise FilterArgumentError(f"modulo: can't divide by {other}") from err

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/filters/misc.py

@@ -1,4 +1,4 @@
-"""Miscellaneous filters."""
+"""Miscellaneous filter functions."""
 from __future__ import annotations
 
 import datetime
@@ -27,7 +27,10 @@ if TYPE_CHECKING:
 
 @liquid_filter
 def size(obj: Any) -> int:
-    """Return the length of an array or string."""
+    """Return the length of _obj_.
+
+    _obj_ could be a dict, list, string or any class implementing _len_.
+    """
     try:
         return len(obj)
     except TypeError:
@@ -36,7 +39,7 @@ def size(obj: Any) -> int:
 
 @liquid_filter
 def default(obj: Any, default_: object = "", *, allow_false: bool = False) -> Any:
-    """Return a default value if the input is nil, false, or empty."""
+    """Return _obj_, or _default_ if _obj_ is nil, false, or empty."""
     _obj = obj
 
     # Return the default value immediately if the object defines a
@@ -69,7 +72,7 @@ def date(  # noqa: PLR0912 PLR0911
     *,
     environment: Environment,
 ) -> str:
-    """Format a datetime according the the given format string."""
+    """Return a string representation of _dat_ using format string _fmt_."""
     if is_undefined(dat):
         return ""
 

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/filters/string.py

@@ -1,4 +1,5 @@
 """Filter functions that operate on strings."""
+
 from __future__ import annotations
 
 import base64
@@ -38,7 +39,10 @@ if TYPE_CHECKING:
 
 @string_filter
 def append(val: str, arg: object) -> str:
-    """Concatenate two strings."""
+    """Return a copy of _val_ concatenated with _arg_.
+
+    If _arg_ is not a string, it will be converted to one before concatenation.
+    """
     if not isinstance(arg, str):
         arg = str(arg)
     return val + arg
@@ -46,20 +50,20 @@ def append(val: str, arg: object) -> str:
 
 @string_filter
 def capitalize(val: str) -> str:
-    """Make sure the first character of _val_ is upper case and the rest lowercase."""
+    """Return _val_ with the first character in uppercase and the rest lowercase."""
     return val.capitalize()
 
 
 @string_filter
 def downcase(val: str) -> str:
-    """Make all characters in a string lower case."""
+    """Return a copy of _val_ with all characters converted to lowercase."""
     return val.lower()
 
 
 @with_environment
 @string_filter
 def escape(val: str, *, environment: Environment) -> str:
-    """Convert the characters &, < and > in string s to HTML-safe sequences."""
+    """Return _val_ with the characters &, < and > converted to HTML-safe sequences."""
     if environment.autoescape:
         return markupsafe_escape(str(val))
     return html.escape(val)
@@ -68,7 +72,11 @@ def escape(val: str, *, environment: Environment) -> str:
 @with_environment
 @string_filter
 def escape_once(val: str, *, environment: Environment) -> str:
-    """Convert the characters &, < and > in string s to HTML-safe sequences."""
+    """Return _val_ with the characters &, < and > converted to HTML-safe sequences.
+
+    It is safe to use `escape_one` on string values that already contain HTML escape
+    sequences.
+    """
     if environment.autoescape:
         return Markup(val).unescape()
     return html.escape(html.unescape(val))
@@ -76,7 +84,7 @@ def escape_once(val: str, *, environment: Environment) -> str:
 
 @string_filter
 def lstrip(val: str) -> str:
-    """Remove leading whitespace."""
+    """Return a copy of _val_ with leading whitespace removed."""
     return val.lstrip()
 
 
@@ -86,7 +94,7 @@ RE_LINETERM = re.compile(r"\r?\n")
 @with_environment
 @string_filter
 def newline_to_br(val: str, *, environment: Environment) -> str:
-    """Convert LF or CRLF to `<br />`, plus a newline."""
+    """Return a copy of _val_ with LF or CRLF converted to `<br />`, plus a newline."""
     # The reference implementation was changed to replace "\r\n" as well as "\n",
     # but they don't seem to care about "\r" (Mac OS).
     if environment.autoescape:
@@ -97,25 +105,25 @@ def newline_to_br(val: str, *, environment: Environment) -> str:
 
 @string_filter
 def prepend(val: str, arg: str) -> str:
-    """Concatenate string value to argument string."""
+    """Return a copy of _arg_ concatenated with _val_."""
     return soft_str(arg) + val
 
 
 @string_filter
 def remove(val: str, arg: str) -> str:
-    """Remove all occurrences of argument string from value."""
+    """Return a copy of _val_ with all occurrences of _arg_ removed."""
     return val.replace(soft_str(arg), "")
 
 
 @string_filter
 def remove_first(val: str, arg: str) -> str:
-    """Remove the first occurrence of the argument string from value."""
+    """Return a copy of _val_ with the first occurrence of _arg_ removed."""
     return val.replace(soft_str(arg), "", 1)
 
 
 @string_filter
 def remove_last(val: str, arg: str) -> str:
-    """Remove the last occurrence of the argument string from value."""
+    """Return a copy of _val_ with last occurrence of _arg_ removed."""
     try:
         before, _, after = val.rpartition(soft_str(arg))
     except ValueError:
@@ -128,19 +136,19 @@ def remove_last(val: str, arg: str) -> str:
 
 @string_filter
 def replace(val: str, seq: str, sub: str = "") -> str:
-    """Replace occurrences of _seq_ in _val_ with _sub_."""
+    """Return a copy of _val_ with each occurrence of _seq_ replaced with _sub_."""
     return val.replace(soft_str(seq), soft_str(sub))
 
 
 @string_filter
 def replace_first(val: str, seq: str, sub: str = "") -> str:
-    """Replace the first occurrence of _seq_ in _val_ with _sub_."""
+    """Return a copy of _val_ with the first occurrence of _seq_ replaced with _sub_."""
     return val.replace(soft_str(seq), soft_str(sub), 1)
 
 
 @string_filter
 def replace_last(val: str, seq: str, sub: str) -> str:
-    """Replace the last occurrence of _seq_ in _val_ with _sub_."""
+    """Return a copy of _val_ with the last occurrence of _seq_ replaced with _sub_."""
     try:
         before, _, after = val.rpartition(soft_str(seq))
     except ValueError:
@@ -153,7 +161,7 @@ def replace_last(val: str, seq: str, sub: str) -> str:
 
 @string_filter
 def upcase(val: str) -> str:
-    """Make all characters in a string upper case."""
+    """Return a copy of _val_ with all characters converted to uppercase."""
     return val.upper()
 
 
@@ -211,7 +219,7 @@ def slice_(val: Any, start: Any, length: Any = 1) -> Union[str, List[object]]:
 
 @string_filter
 def split(val: str, seq: str) -> List[str]:
-    """Split a string into a list of string, using the argument as a delimiter."""
+    """Return a list of strings from splitting _value_ on _seq_."""
     if not seq:
         return list(val)
 
@@ -220,20 +228,20 @@ def split(val: str, seq: str) -> List[str]:
 
 @string_filter
 def strip(val: str) -> str:
-    """Remove leading and trailing whitespace."""
+    """Return a copy of _val_ with leading and trailing whitespace removed."""
     return val.strip()
 
 
 @string_filter
 def rstrip(val: str) -> str:
-    """Remove trailing whitespace."""
+    """Return a copy of _val_ with trailing whitespace removed."""
     return val.rstrip()
 
 
 @with_environment
 @string_filter
 def strip_html(val: str, *, environment: Environment) -> str:
-    """Return the given HTML with all HTML tags removed."""
+    """Return a copy of _val_ with all HTML tags removed."""
     stripped = strip_tags(val)
     if environment.autoescape and isinstance(val, Markup):
         return Markup(stripped)
@@ -243,7 +251,7 @@ def strip_html(val: str, *, environment: Environment) -> str:
 @with_environment
 @string_filter
 def strip_newlines(val: str, *, environment: Environment) -> str:
-    """Return the given string with all newline characters removed."""
+    """Return ta copy of _val_ with all newline characters removed."""
     if environment.autoescape:
         val = markupsafe_escape(val)
         return Markup(RE_LINETERM.sub("", val))
@@ -252,7 +260,7 @@ def strip_newlines(val: str, *, environment: Environment) -> str:
 
 @string_filter
 def truncate(val: str, num: Any = 50, end: str = "...") -> str:
-    """Truncate a string if it is longer than the specified number of characters."""
+    """Return a copy of _val_ truncated to _num_ characters."""
     if is_undefined(num):
         raise FilterArgumentError("truncate expected an integer, found Undefined")
 
@@ -273,7 +281,7 @@ MAX_TRUNC_WORDS = (1 << 31) - 1
 
 @string_filter
 def truncatewords(val: str, num: Any = 15, end: str = "...") -> str:
-    """Shorten a string down to the given number of words."""
+    """Return a copy of _val_ truncated to at most _num_ words."""
     if is_undefined(num):
         raise FilterArgumentError("truncate expected an integer, found Undefined")
 
@@ -306,7 +314,7 @@ def truncatewords(val: str, num: Any = 15, end: str = "...") -> str:
 @with_environment
 @string_filter
 def url_encode(val: str, *, environment: Environment) -> str:
-    """Percent encode a string so it is useable in a URL."""
+    """Return a percent-encoded copy of _val_ so it is useable in a URL."""
     if environment.autoescape:
         return Markup(urllib.parse.quote_plus(val))
     return urllib.parse.quote_plus(val)
@@ -314,20 +322,20 @@ def url_encode(val: str, *, environment: Environment) -> str:
 
 @string_filter
 def url_decode(val: str) -> str:
-    """Decode a string that has been URL encoded."""
+    """Return a copy of _val_ after decoding percent-encoded sequences."""
     # Assuming URL decoded strings are all unsafe.
     return urllib.parse.unquote_plus(val)
 
 
 @string_filter
 def base64_encode(val: str) -> str:
-    """Encode a string to base64."""
+    """Return _val_ encoded in base64."""
     return base64.b64encode(val.encode()).decode()
 
 
 @string_filter
 def base64_decode(val: str) -> str:
-    """Decode a string from base64.
+    """Return _val_ decoded as base64.
 
     The decoded value is assumed to be UTF-8 and will be decoded as UTF-8.
     """
@@ -339,13 +347,13 @@ def base64_decode(val: str) -> str:
 
 @string_filter
 def base64_url_safe_encode(val: str) -> str:
-    """Encode a string to URL safe base64."""
+    """Return _val_ encoded in URL-safe base64."""
     return base64.urlsafe_b64encode(val.encode()).decode()
 
 
 @string_filter
 def base64_url_safe_decode(val: str) -> str:
-    """Decode a URL safe string from base64.
+    """Return _val_ decoded as URL-safe base64.
 
     The decoded value is assumed to be UTF-8 and will be decoded as UTF-8.
     """

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/loaders/base_loader.py

@@ -1,4 +1,5 @@
 """Base template loader."""
+
 from __future__ import annotations
 
 from abc import ABC
@@ -48,7 +49,7 @@ class BaseLoader(ABC):  # noqa: B024
 
     Attributes:
         caching_loader (bool): Indicates if this loader implements its own cache.
-            Setting this sto `True` will cause the `Environment` to disable its cache
+            Setting this to `True` will cause the `Environment` to disable its cache
             when initialized with a caching loader.
     """
 

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/statement.py

@@ -60,4 +60,6 @@ class Statement(Tag):
     def parse(self, stream: TokenStream) -> StatementNode:
         tok = stream.current
         expect(stream, TOKEN_STATEMENT)
-        return self.node_class(tok, self.env.parse_filtered_expression_value(tok.value))
+        return self.node_class(
+            tok, self.env.parse_filtered_expression_value(tok.value, tok.linenum)
+        )

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/tags/assign_tag.py

@@ -65,8 +65,8 @@ class AssignTag(Tag):
     block = False
     node_class = AssignNode
 
-    def _parse_expression(self, value: str) -> Expression:
-        return self.env.parse_filtered_expression_value(value)
+    def _parse_expression(self, value: str, linenum: int) -> Expression:
+        return self.env.parse_filtered_expression_value(value, linenum)
 
     def parse(self, stream: TokenStream) -> AssignNode:
         expect(stream, TOKEN_TAG, value=TAG_ASSIGN)
@@ -83,5 +83,9 @@ class AssignTag(Tag):
             )
 
         return self.node_class(
-            tok, AssignmentExpression(name, self._parse_expression(right))
+            tok,
+            AssignmentExpression(
+                name,
+                self._parse_expression(right, stream.current.linenum),
+            ),
         )

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/tags/decrement_tag.py

@@ -63,7 +63,9 @@ class DecrementTag(Tag):
             tok=tok,
             identifier=str(
                 parse_unchained_identifier(
-                    ExprTokenStream(tokenize(stream.current.value))
+                    ExprTokenStream(
+                        tokenize(stream.current.value, stream.current.linenum)
+                    )
                 )
             ),
         )

{python_liquid-1.12.0 → python_liquid-1.12.2}/liquid/builtin/tags/echo_tag.py

@@ -30,8 +30,8 @@ class EchoTag(Tag):
     block = False
     node_class = EchoNode
 
-    def _parse_expression(self, value: str) -> Expression:
-        return self.env.parse_filtered_expression_value(value)
+    def _parse_expression(self, value: str, linenum: int) -> Expression:
+        return self.env.parse_filtered_expression_value(value, linenum)
 
     def parse(self, stream: TokenStream) -> Node:  # noqa: D102
         expect(stream, TOKEN_TAG, value=TAG_ECHO)
@@ -42,5 +42,5 @@ class EchoTag(Tag):
             expr: Expression = NIL
         else:
             expect(stream, TOKEN_EXPRESSION)
-            expr = self._parse_expression(stream.current.value)
+            expr = self._parse_expression(stream.current.value, tok.linenum)
         return self.node_class(tok, expression=expr)