python-liquid 2.3.6__py3-none-any.whl → 3.0.0__py3-none-any.whl

liquid/builtin/filters/array.py

@@ -1,329 +0,0 @@
-"""Filter functions that operate on arrays."""
-
-from __future__ import annotations
-
-from decimal import Decimal
-from functools import partial
-from itertools import chain
-from itertools import islice
-from operator import getitem
-from typing import TYPE_CHECKING
-from typing import Any
-from typing import Iterable
-from typing import Sequence
-from typing import Union
-
-from liquid import Markup
-from liquid.builtin.expressions import Nil
-from liquid.exceptions import FilterArgumentError
-from liquid.exceptions import FilterError
-from liquid.exceptions import FilterItemTypeError
-from liquid.filter import decimal_arg
-from liquid.filter import liquid_filter
-from liquid.filter import sequence_filter
-from liquid.filter import with_environment
-from liquid.undefined import is_undefined
-
-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)
-
-# Unique object for use with the uniq filter.
-MISSING = object()
-
-
-@with_environment
-@sequence_filter
-def join(
-    left: Iterable[object],
-    separator: object = " ",
-    *,
-    environment: Environment,
-) -> str:
-    """Return concatenated items in _left_ separated by _separator_.
-
-    Items in _left_ will be coerced to a string if they are not already
-    strings, as will _separator_.
-    """
-    if not isinstance(separator, str):
-        separator = str(separator)
-
-    if environment.autoescape and separator == " ":
-        separator = Markup(" ")
-
-    return separator.join(_str_if_not(item) for item in left)
-
-
-@with_environment
-@liquid_filter
-def first(left: Any, *, environment: Environment) -> object:
-    """Return the first item in collection _left_.
-
-    If _left_ is not a collection or it is empty, `None` is returned.
-    """
-    if isinstance(left, str):
-        # Honor the opt-in Ruby-compat flag, matching the `.first` property path.
-        if environment.string_first_and_last:
-            return left[0] if left else None
-        return None
-
-    if isinstance(left, dict):
-        left = list(islice(left.items(), 1))
-
-    try:
-        return getitem(left, 0)
-    except (TypeError, KeyError, IndexError):
-        return None
-
-
-@with_environment
-@liquid_filter
-def last(obj: Sequence[Any], *, environment: Environment) -> object:
-    """Return the last item in collection _left_.
-
-    If _left_ is not a collection or it is empty, `None` is returned.
-    """
-    if isinstance(obj, str):
-        # Honor the opt-in Ruby-compat flag, matching the `.last` property path.
-        if environment.string_first_and_last:
-            return obj[-1] if obj else None
-        return None
-
-    try:
-        return getitem(obj, -1)
-    except (TypeError, KeyError, IndexError):
-        return None
-
-
-@sequence_filter
-def concat(sequence: ArrayT, second_array: ArrayT) -> ArrayT:
-    """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__}"
-        )
-
-    if is_undefined(sequence):
-        return second_array
-
-    return list(chain(sequence, second_array))
-
-
-@sequence_filter
-def map_(sequence: ArrayT, key: object) -> list[object]:
-    """Return an array/list of items in _sequence_ selected by _key_."""
-    try:
-        return [_getitem(itm, str(key), default=_NULL) for itm in sequence]
-    except TypeError as err:
-        raise FilterError("can't map sequence", token=None) from err
-
-
-@sequence_filter
-def reverse(array: ArrayT) -> list[object]:
-    """Reverses the order of the items in an array."""
-    return list(reversed(array))
-
-
-@sequence_filter
-def sort(sequence: ArrayT, key: object = None) -> list[object]:
-    """Return a copy of _sequence_ in ascending order.
-
-    When a key string is provided, objects without the key property will
-    be at the end of the output list/array.
-    """
-    if key:
-        key_func = partial(_getitem, key=str(key), default=MAX_CH)
-        return sorted(sequence, key=key_func)
-
-    try:
-        return sorted(sequence)
-    except TypeError as err:
-        raise FilterError("can't sort sequence", token=None) from err
-
-
-@sequence_filter
-def sort_natural(sequence: ArrayT, key: object = None) -> list[object]:
-    """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)))
-
-    return sorted(sequence, key=_lower)
-
-
-@sequence_filter
-def where(sequence: ArrayT, attr: object, value: object = None) -> list[object]:
-    """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]
-
-    return [itm for itm in sequence if _getitem(itm, attr) not in (False, None)]
-
-
-@sequence_filter
-def reject(sequence: ArrayT, attr: object, value: object = None) -> list[object]:
-    """Return a list of items from _sequence_ where _attr_ is not equal to _value_."""
-    if attr is None or is_undefined(attr):
-        return []
-
-    if value is not None and not is_undefined(value):
-        return [itm for itm in sequence if _getitem(itm, attr) != value]
-
-    return [itm for itm in sequence if _getitem(itm, attr) in (False, None)]
-
-
-@sequence_filter
-def find(sequence: ArrayT, attr: object, value: object = None) -> object:
-    """Return the first item from _sequence_ where _attr_ is equal to _value_."""
-    if value is not None and not is_undefined(value):
-        return next((itm for itm in sequence if _getitem(itm, attr) == value), None)
-
-    return next(
-        (itm for itm in sequence if _getitem(itm, attr) not in (False, None)), None
-    )
-
-
-@sequence_filter
-def find_index(
-    sequence: ArrayT, attr: object, value: object = None
-) -> Union[int, None]:
-    """Return the index of first item from _sequence_ where _attr_ equals _value_."""
-    if value is not None and not is_undefined(value):
-        return next(
-            (i for i, itm in enumerate(sequence) if _getitem(itm, attr) == value), None
-        )
-
-    return next(
-        (
-            i
-            for i, itm in enumerate(sequence)
-            if _getitem(itm, attr) not in (False, None)
-        ),
-        None,
-    )
-
-
-@sequence_filter
-def has(sequence: ArrayT, attr: object, value: object = None) -> bool:
-    """Return true if any items in _sequence_ have _attr_ equal to _value_."""
-    if value is not None and not is_undefined(value):
-        return any((itm for itm in sequence if _getitem(itm, attr) == value))
-
-    return any((itm for itm in sequence if _getitem(itm, attr) not in (False, None)))
-
-
-@sequence_filter
-def uniq(sequence: ArrayT, key: object = None) -> list[object]:
-    """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.
-
-    # This is probably quite slow.
-    if key is not None:
-        keys = []
-        result = []
-        for obj in sequence:
-            try:
-                item = obj[key]
-            except KeyError:
-                item = MISSING
-            except TypeError as err:
-                raise FilterArgumentError(
-                    f"can't read property '{key}' of {obj}", token=None
-                ) from err
-
-            if item not in keys:
-                keys.append(item)
-                result.append(obj)
-
-        return result
-
-    return [obj for i, obj in enumerate(sequence) if sequence.index(obj) == i]
-
-
-@sequence_filter
-def compact(sequence: ArrayT, key: object = None) -> list[object]:
-    """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]
-        except TypeError as err:
-            raise FilterArgumentError(
-                f"can't read property '{key}'", token=None
-            ) from err
-    return [itm for itm in sequence if itm is not None]
-
-
-@sequence_filter
-def sum_(sequence: ArrayT, key: object = None) -> Union[float, int, Decimal]:
-    """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.
-    """
-    if key is not None and not is_undefined(key):
-        rv = sum(decimal_arg(_getitem(elem, key, 0), 0) for elem in sequence)
-    else:
-        rv = sum(decimal_arg(elem, 0) for elem in sequence)
-    if isinstance(rv, Decimal):
-        return float(rv)
-    return rv
-
-
-def _str_if_not(val: object) -> str:
-    if not isinstance(val, str):
-        return str(val)
-    return val
-
-
-def _getitem(sequence: Any, key: object, default: object = None) -> Any:
-    """Helper for the map filter.
-
-    Same as sequence[key], but returns a default value if key does not exist
-    in sequence, and handles some corner cases so as to mimic Shopify/Liquid
-    behavior.
-    """
-    try:
-        return getitem(sequence, key)
-    except (KeyError, IndexError):
-        return default
-    except TypeError as err:
-        if sequence is None:
-            raise FilterItemTypeError(str(err), token=None) from err
-        if isinstance(sequence, str) and isinstance(key, str) and key in sequence:
-            return key
-        if isinstance(sequence, int) and isinstance(key, int):
-            return sequence == key
-        if not hasattr(sequence, "__getitem__"):
-            raise
-        return default
-
-
-def _lower(obj: Any) -> str:
-    """Helper for the sort filter."""
-    try:
-        return str(obj).lower()
-    except AttributeError:
-        return ""
-
-
-class _Null:
-    """A null without a token for use in the map filter."""
-
-    def __eq__(self, other: object) -> bool:
-        return other is None or isinstance(other, (_Null, Nil))
-
-    def __str__(self) -> str:  # pragma: no cover
-        return ""
-
-
-_NULL = _Null()

liquid/builtin/filters/extra.py

@@ -1,83 +0,0 @@
-"""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

liquid/builtin/filters/math.py

@@ -1,129 +0,0 @@
-"""Maths related filter functions."""
-
-import decimal
-import math
-from typing import Optional
-from typing import Union
-
-from liquid.exceptions import FilterArgumentError
-from liquid.filter import math_filter
-from liquid.filter import num_arg
-from liquid.undefined import is_undefined
-
-
-@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:
-        raise FilterArgumentError(
-            f"divided_by: can't divide by {other}", token=None
-        ) 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:
-        raise FilterArgumentError(
-            f"modulo: can't divide by {other}", token=None
-        ) from err

liquid/builtin/filters/misc.py

@@ -1,137 +0,0 @@
-"""Miscellaneous filter functions."""
-
-from __future__ import annotations
-
-import datetime as dt
-import decimal
-import functools
-from typing import TYPE_CHECKING
-from typing import Any
-from typing import Union
-
-from dateutil import parser
-
-from liquid import Markup
-from liquid.builtin.expressions import is_empty
-from liquid.exceptions import FilterArgumentError
-from liquid.filter import liquid_filter
-from liquid.filter import with_environment
-from liquid.undefined import is_undefined
-
-if TYPE_CHECKING:
-    from liquid import Environment
-
-
-@liquid_filter
-def size(obj: Any) -> int:
-    """Return the length of _obj_.
-
-    _obj_ could be a dict, list, string or any class implementing _len_.
-    """
-    try:
-        return len(obj)
-    except TypeError:
-        return 0
-
-
-@liquid_filter
-def default(obj: Any, default_: object = "", *, allow_false: bool = False) -> Any:
-    """Return _obj_, or _default_ if _obj_ is nil, false, or empty."""
-    _obj = obj
-
-    # Return the default value immediately if the object defines a
-    # `force_liquid_default` property.
-    if hasattr(obj, "force_liquid_default") and obj.force_liquid_default:
-        return default_
-
-    if hasattr(obj, "__liquid__"):
-        _obj = obj.__liquid__()
-
-    # Liquid 0, 0.0, 0b0, 0X0, 0o0 and Decimal("0") are not falsy.
-    if not isinstance(obj, bool) and isinstance(obj, (int, float, decimal.Decimal)):
-        return obj
-
-    if allow_false is True and _obj is False:
-        return obj
-
-    if _obj in (None, False) or is_empty(_obj):
-        return default_
-
-    return obj
-
-
-@with_environment
-@liquid_filter
-def date(
-    dat: Union[dt.datetime, str, int],
-    fmt: str,
-    *,
-    environment: Environment,
-) -> str:
-    """Return a string representation of _dat_ using format string _fmt_."""
-    if is_undefined(dat):
-        return ""
-
-    if is_undefined(fmt):
-        return str(dat)
-
-    date_ = dt.datetime.now() if dat in ("now", "today") else _to_date(dat)
-
-    if date_ is None:
-        if isinstance(dat, (str, int)):
-            # Input is returned unchanged. This is consistent
-            # with the reference implementation.
-            return str(dat)
-        raise FilterArgumentError(
-            f"date expected datetime.datetime, found {type(dat).__name__}",
-            token=None,
-        )
-
-    try:
-        rv = date_.strftime(fmt)
-    except ValueError as err:
-        # This is not uncommon on Windows when a format string contains
-        # directives that are not officially supported by Python.
-
-        # Handle "%s" as a special case.
-        if fmt == r"%s":
-            return str(date_.timestamp()).split(".")[0]
-        raise FilterArgumentError(str(err), token=None) from err
-
-    if environment.autoescape and isinstance(fmt, Markup):
-        return Markup(rv)
-    return rv
-
-
-@functools.lru_cache(maxsize=10)
-def _to_date(  # noqa: PLR0911
-    d: object,
-) -> Union[dt.datetime, None]:
-    if isinstance(d, dt.datetime):
-        return d
-
-    if isinstance(d, dt.date):
-        return dt.datetime.combine(d, dt.time.min)
-
-    if isinstance(d, str):
-        if d.isdigit():
-            # The reference implementation does not support string
-            # representations of negative integers either.
-            return dt.datetime.fromtimestamp(int(d))
-
-        try:
-            return parser.parse(d)
-        except parser.ParserError:
-            # Input is returned unchanged. This is consistent
-            # with the reference implementation.
-            return None
-
-    if isinstance(d, int):
-        try:
-            return dt.datetime.fromtimestamp(d)
-        except (OverflowError, OSError):
-            # Testing on Windows shows that it can't handle some
-            # negative integers.
-            return None
-
-    return None