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

liquid/filters/divided_by.py

@@ -0,0 +1,21 @@
+from decimal import Decimal
+
+from .._filter import FilterContext
+
+
+def divided_by(
+    context: FilterContext, left: object, right: object
+) -> int | float | Decimal:
+    left = context.to_numeric(left, 0)
+    right = context.to_numeric(right, 0)
+
+    if right == 0:
+        raise context.error("divide by zero")
+
+    if isinstance(left, int) and isinstance(right, int):
+        return left // right
+
+    if isinstance(left, Decimal) or isinstance(right, Decimal):
+        return float(Decimal(str(left)) / Decimal(str(right)))
+
+    return left / right

liquid/filters/downcase.py

@@ -0,0 +1,5 @@
+from .._filter import FilterContext
+
+
+def downcase(context: FilterContext, left: object) -> str:
+    return context.to_str(left, "").lower()

liquid/filters/escape.py

@@ -0,0 +1,56 @@
+import html
+import re
+
+import markupsafe
+
+from .._filter import FilterContext
+
+
+def escape(context: FilterContext, left: object) -> str:
+    left_ = context.to_str(left, "")
+    return (
+        markupsafe.escape(str(left_))
+        if context.env.autoescape
+        else html.escape(left_).replace("'", "'")
+    )
+
+
+def escape_once(context: FilterContext, left: object) -> str:
+    left_ = context.to_str(left, "")
+    return (
+        markupsafe.Markup(left_).unescape()
+        if context.env.autoescape
+        else html.escape(html.unescape(left_)).replace("'", "'")
+    )
+
+
+_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())) + "]")
+
+
+def escapejs(context: FilterContext, left: object) -> str:
+    escaped = _ESCAPE_RE.sub(lambda m: _ESCAPE_MAP[m.group()], context.to_str(left, ""))
+    if context.env.autoescape:
+        return markupsafe.Markup(escaped)
+    return escaped
+
+
+def safe(context: FilterContext, left: object) -> str:
+    return (
+        markupsafe.Markup(left) if context.env.autoescape else context.to_str(left, "")
+    )

liquid/filters/find.py

@@ -0,0 +1,56 @@
+from .._filter import FilterContext
+
+
+def find(
+    context: FilterContext, left: object, prop: object, value: object = None
+) -> object:
+    left = context.input_array(left)
+
+    if context.is_nil(value):
+        for obj in left:
+            val = context.get_item(obj, prop)
+            if not context.is_nil(val) and val is not False:
+                return obj
+        return None
+
+    for obj in left:
+        if context.get_item(obj, prop) == value:
+            return obj
+
+    return None
+
+
+def find_index(
+    context: FilterContext, left: object, prop: object, value: object = None
+) -> int | None:
+    left = context.input_array(left)
+
+    if context.is_nil(value):
+        for i, obj in enumerate(left):
+            val = context.get_item(obj, prop)
+            if not context.is_nil(val) and val is not False:
+                return i
+
+        return None
+
+    for i, obj in enumerate(left):
+        if context.get_item(obj, prop) == value:
+            return i
+
+    return None
+
+
+def has(
+    context: FilterContext, left: object, prop: object, value: object = None
+) -> bool:
+    left = context.input_array(left)
+
+    if context.is_nil(value):
+        for obj in left:
+            val = context.get_item(obj, prop)
+            if not context.is_nil(val) and val is not False:
+                return True
+
+        return False
+
+    return any(context.get_item(obj, prop) == value for obj in left)

liquid/filters/first.py

@@ -0,0 +1,19 @@
+from collections.abc import Mapping, Sequence
+from itertools import islice
+
+from .._drop import liquid_iterable
+from .._filter import FilterContext
+
+
+def first(context: FilterContext, left: object) -> object:
+    if liquid_iterable(left):
+        it = left.__liquid_iter__(0, None, False)
+        return next(iter(it), None)
+
+    if isinstance(left, Sequence):
+        return left[0] if left else None  # pyright: ignore[reportUnknownVariableType]
+
+    if isinstance(left, Mapping):
+        return next(islice(left.items(), 1), None)  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
+
+    return None

liquid/filters/floor.py

@@ -0,0 +1,8 @@
+import math
+from decimal import Decimal
+
+from .._filter import FilterContext
+
+
+def floor(context: FilterContext, left: object) -> int | float | Decimal:
+    return math.floor(context.to_numeric(left, 0))

liquid/filters/html.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import html
+from typing import TYPE_CHECKING
+
+import markupsafe
+
+if TYPE_CHECKING:
+    from .._filter import FilterContext
+
+
+def stylesheet_tag(context: FilterContext, left: object) -> str:
+    tag = '<link href="{}" rel="stylesheet" type="text/css" media="all" />'
+    if context.env.autoescape:
+        return markupsafe.Markup(tag).format(str(left))
+    return tag.format(html.escape(context.to_str(left, "")))
+
+
+def script_tag(context: FilterContext, left: object) -> str:
+    tag = '<script src="{}" type="text/javascript"></script>'
+    if context.env.autoescape:
+        return markupsafe.Markup(tag).format(str(left))
+    return tag.format(html.escape(context.to_str(left, "")))

liquid/filters/index.py

@@ -0,0 +1,12 @@
+from .._filter import FilterContext
+
+
+def index(context: FilterContext, left: object, obj: object) -> object:
+    """Return the zero-based index of an array item.
+
+    `None` is returned if `obj` is not in `left`.
+    """
+    try:
+        return context.input_array(left).index(obj)
+    except ValueError:
+        return None

liquid/filters/join.py

@@ -0,0 +1,13 @@
+import markupsafe
+
+from .._filter import FilterContext
+
+
+def join(context: FilterContext, left: object, sep: object = " ") -> str:
+    left_ = context.input_array(left)
+    sep_ = context.to_str(sep, " ")
+
+    if context.env.autoescape and sep_ == " ":
+        sep_ = markupsafe.Markup(sep_)
+
+    return sep_.join(context.to_str(obj, "") for obj in left_)

liquid/filters/json_.py

@@ -0,0 +1,30 @@
+import json
+from collections.abc import Callable
+from typing import Any
+
+from .._filter import FilterContext
+
+
+class JSON:
+    """Serialize an object to a JSON formatted string.
+
+    Parameters
+    ----------
+    default
+        A function passed to ``json.dumps``. This function is called in the event that the
+        JSONEncoder does not know how to serialize an object. Defaults to `None`.
+    """
+
+    name = "json"
+
+    def __init__(self, default: Callable[[Any], Any] | None = None):
+        self.default = default
+
+    def __call__(
+        self,
+        context: FilterContext,
+        left: object,
+        indent: object | None = None,
+    ) -> str:
+        indent = context.to_int(indent) if indent else None
+        return json.dumps(left, default=self.default, indent=indent)

liquid/filters/last.py

@@ -0,0 +1,17 @@
+from collections.abc import Sequence
+
+from .._filter import FilterContext
+from ..drops import Range, Undefined
+
+
+def last(context: FilterContext, left: object) -> object:
+    if isinstance(left, Range):
+        return left.stop
+
+    if isinstance(left, Sequence):
+        return left[-1] if left else None  # pyright: ignore[reportUnknownVariableType]
+
+    if isinstance(left, Undefined):
+        left.poke()
+
+    return None

liquid/filters/map.py

@@ -0,0 +1,5 @@
+from .._filter import FilterContext
+
+
+def map_(context: FilterContext, left: object, prop: object) -> list[object]:
+    return [context.get_item(obj, prop) for obj in context.input_array(left)]

liquid/filters/minus.py

@@ -0,0 +1,13 @@
+from decimal import Decimal
+
+from .._filter import FilterContext
+
+
+def minus(context: FilterContext, left: object, right: object) -> int | float:
+    left = context.to_numeric(left, 0)
+    right = context.to_numeric(right, 0)
+
+    if isinstance(left, int) and isinstance(right, int):
+        return left - right
+
+    return float(Decimal(str(left)) - Decimal(str(right)))

liquid/filters/modulo.py

@@ -0,0 +1,18 @@
+from decimal import Decimal
+
+from .._filter import FilterContext
+
+
+def modulo(
+    context: FilterContext, left: object, right: object
+) -> int | float | Decimal:
+    left = context.to_numeric(left, 0)
+    right = context.to_numeric(right, 0)
+
+    if right == 0:
+        raise context.error("divide by zero")
+
+    if isinstance(left, int) and isinstance(right, int):
+        return left % right
+
+    return float(Decimal(str(left)) % Decimal(str(right)))

liquid/filters/newline_to_br.py

@@ -0,0 +1,16 @@
+import re
+
+import markupsafe
+
+from .._filter import FilterContext
+
+RE_LINETERM = re.compile(r"\r?\n")
+
+
+def newline_to_br(context: FilterContext, left: object) -> str:
+    if context.env.autoescape:
+        return markupsafe.Markup(
+            RE_LINETERM.sub("<br />\n", markupsafe.escape(context.to_str(left, "")))
+        )
+
+    return RE_LINETERM.sub("<br />\n", context.to_str(left, ""))

liquid/filters/plus.py

@@ -0,0 +1,13 @@
+from decimal import Decimal
+
+from .._filter import FilterContext
+
+
+def plus(context: FilterContext, left: object, right: object) -> int | float:
+    left = context.to_numeric(left, 0)
+    right = context.to_numeric(right, 0)
+
+    if isinstance(left, int) and isinstance(right, int):
+        return left + right
+
+    return float(Decimal(str(left)) + Decimal(str(right)))

liquid/filters/prepend.py

@@ -0,0 +1,5 @@
+from .._filter import FilterContext
+
+
+def prepend(context: FilterContext, left: object, right: object) -> str:
+    return context.to_str(right, "") + context.to_str(left, "")

liquid/filters/reject.py

@@ -0,0 +1,19 @@
+from .._filter import FilterContext
+
+
+def reject(
+    context: FilterContext, left: object, prop: object, value: object = None
+) -> list[object]:
+    left = context.input_array(left)
+
+    if context.is_nil(prop):
+        return []
+
+    def _filter(obj: object) -> bool:
+        val = context.get_item(obj, prop)
+        return not context.truthy(val)
+
+    if context.is_nil(value):
+        return list(filter(_filter, left))
+
+    return [obj for obj in left if context.get_item(obj, prop) != value]

liquid/filters/remove.py

@@ -0,0 +1,36 @@
+from .._filter import FilterContext
+
+
+def remove(context: FilterContext, left: object, right: object) -> str:
+    left_ = context.to_str(left, "")
+    right_ = context.to_str(right, "")
+
+    if not right_:
+        return left_
+
+    return left_.replace(right_, "")
+
+
+def remove_first(context: FilterContext, left: object, right: object) -> str:
+    left_ = context.to_str(left, "")
+    right_ = context.to_str(right, "")
+
+    if not right_:
+        return left_
+
+    return left_.replace(right_, "", 1)
+
+
+def remove_last(context: FilterContext, left: object, right: object) -> str:
+    left_ = context.to_str(left, "")
+    right_ = context.to_str(right, "")
+
+    if not right_:
+        return left_
+
+    before, _, after = left_.rpartition(right_)
+
+    if before:
+        return before + after
+
+    return left_

liquid/filters/replace.py

@@ -0,0 +1,32 @@
+from .._filter import FilterContext
+
+
+def replace(
+    context: FilterContext, left: object, sub: object, rep: object = None
+) -> str:
+    return context.to_str(left, "").replace(
+        context.to_str(sub, ""), context.to_str(rep, "")
+    )
+
+
+def replace_first(
+    context: FilterContext, left: object, sub: object, rep: object = None
+) -> str:
+    return context.to_str(left, "").replace(
+        context.to_str(sub, ""), context.to_str(rep, ""), 1
+    )
+
+
+def replace_last(context: FilterContext, left: object, sub: object, rep: object) -> str:
+    left_ = context.to_str(left, "")
+    sub_ = context.to_str(sub, "")
+
+    if not sub_:
+        return left_ + context.to_str(rep, "")
+
+    before, _, after = left_.rpartition(sub_)
+
+    if before:
+        return before + context.to_str(rep, "") + after
+
+    return left_

liquid/filters/reverse.py

@@ -0,0 +1,5 @@
+from .._filter import FilterContext
+
+
+def reverse(context: FilterContext, left: object) -> list[object]:
+    return list(reversed(context.input_array(left)))

liquid/filters/round.py

@@ -0,0 +1,35 @@
+import math
+from decimal import ROUND_HALF_UP, Decimal
+
+from .._filter import FilterContext
+
+
+def round_(
+    context: FilterContext, left: object, decimal_places: object = None
+) -> int | float | Decimal:
+    left = context.to_numeric(left, 0)
+
+    if context.is_nil(decimal_places):
+        return _round_up(left)
+
+    to = context.to_numeric(decimal_places, 0)
+
+    if to == 0:
+        return _round_up(left)
+
+    if to < 0:
+        return 0
+
+    if left == 0:
+        return 0
+
+    return _round_up(left, math.floor(to))
+
+
+def _round_up(x: float | Decimal, digits: int = 0) -> int | float:
+    if isinstance(x, int):
+        return x
+
+    quantum = Decimal(1).scaleb(-digits)
+    result = Decimal(str(x)).quantize(quantum, rounding=ROUND_HALF_UP)
+    return int(result) if digits == 0 else float(result)

liquid/filters/size.py

@@ -0,0 +1,25 @@
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+
+from .._drop import liquid_iterable
+from .._filter import FilterContext
+from ..drops import Undefined
+
+
+def size(context: FilterContext, left: object) -> int:
+    if isinstance(left, (float, bool)):
+        return 0
+
+    if isinstance(left, (int, Decimal)):
+        return 8
+
+    if isinstance(left, Undefined):
+        return 0
+
+    if isinstance(left, (Sequence, Mapping)):
+        return len(left)  # pyright: ignore[reportUnknownArgumentType]
+
+    if liquid_iterable(left):
+        return left.__liquid_iter__(0, None, False).length
+
+    return 0

liquid/filters/slice.py

@@ -0,0 +1,39 @@
+from decimal import Decimal
+
+from .._filter import FilterContext
+
+MAX_SLICE_ARG: int = (2**53) - 1
+MIN_SLICE_ARG: int = -(2**53) + 1
+
+
+def slice_(
+    context: FilterContext, left: object, offset: object, length: object = None
+) -> str | list[object]:
+    if not isinstance(left, (list, tuple, str)):
+        left = context.to_str(left, "")
+
+    offset = _clamp(_to_integer(context, offset))
+    length = 1 if context.is_nil(length) else _clamp(_to_integer(context, length))
+
+    start = len(left) + offset if offset < 0 else offset  # type: ignore
+    return [] if length < 1 else left[start : start + length]  # type: ignore
+
+
+def _clamp(i: int) -> int:
+    return max(min(i, MAX_SLICE_ARG), MIN_SLICE_ARG)
+
+
+def _to_integer(context: FilterContext, obj: object) -> int:
+    if isinstance(obj, int):
+        return obj
+
+    if isinstance(obj, (float, Decimal)) and "." not in str(obj):
+        return int(obj)
+
+    if context.is_nil(obj):
+        raise context.error("invalid integer")
+
+    try:
+        return int(context.to_str(obj, "").lstrip())
+    except ValueError:
+        raise context.error("invalid integer") from None