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

liquid/filters/sort.py

@@ -0,0 +1,148 @@
+import math
+import re
+from decimal import Decimal
+from functools import cmp_to_key
+from operator import getitem
+from typing import Any, Literal
+
+from .._filter import FilterContext
+
+
+def sort(context: FilterContext, left: object, key: object = None) -> list[object]:
+    left = context.input_array(left)
+
+    def compare(a: object, b: object) -> Literal[-1, 0, 1]:
+        nil_a = context.is_nil(a)
+        nil_b = context.is_nil(b)
+
+        if nil_a and nil_b:
+            return 0
+
+        if nil_a and not nil_b:
+            return 1
+
+        if not nil_a and nil_b:
+            return -1
+
+        try:
+            if a < b:  # type: ignore
+                return -1
+
+            if a > b:  # type: ignore
+                return 1
+
+            return 0
+        except TypeError:
+            raise context.error(
+                f"comparison with {type(a).__class__!r} and {type(b).__class__!r} failed"
+            ) from None
+
+    if context.is_nil(key):
+        return sorted(context.input_array(left), key=cmp_to_key(compare))
+
+    return sorted(
+        context.input_array(left),
+        key=cmp_to_key(
+            lambda a, b: compare(
+                context.get_item(a, key, None), context.get_item(b, key, None)
+            )
+        ),
+    )
+
+
+def sort_natural(
+    context: FilterContext, left: object, key: object = None
+) -> list[object]:
+    left = context.input_array(left)
+
+    def compare(a: object, b: object) -> Literal[-1, 0, 1]:
+        nil_a = context.is_nil(a)
+        nil_b = context.is_nil(b)
+
+        if nil_a and nil_b:
+            return 0
+
+        if nil_a and not nil_b:
+            return 1
+
+        if not nil_a and nil_b:
+            return -1
+
+        a = context.to_str(a, "").lower()
+        b = context.to_str(b, "").lower()
+
+        if a < b:
+            return -1
+
+        if a > b:
+            return 1
+
+        return 0
+
+    if context.is_nil(key):
+        return sorted(context.input_array(left), key=cmp_to_key(compare))
+
+    return sorted(
+        context.input_array(left),
+        key=cmp_to_key(
+            lambda a, b: compare(
+                context.get_item(a, key, None), context.get_item(b, key, None)
+            )
+        ),
+    )
+
+
+RE_NUMERIC = re.compile(r"-?\d+")
+
+
+def sort_numeric(
+    context: FilterContext, left: object, key: object = None
+) -> list[object]:
+    left = context.input_array(left)
+
+    def compare(a: object, b: object) -> Literal[-1, 0, 1]:
+        a = _ints(a)
+        b = _ints(b)
+
+        try:
+            if a < b:
+                return -1
+
+            if a > b:
+                return 1
+
+            return 0
+        except TypeError:
+            raise context.error(
+                f"comparison with {type(a).__class__!r} and {type(b).__class__!r} failed"
+            ) from None
+
+    if context.is_nil(key):
+        return sorted(context.input_array(left), key=cmp_to_key(compare))
+
+    return sorted(
+        context.input_array(left),
+        key=cmp_to_key(
+            lambda a, b: compare(_getitem(a, key, None), _getitem(b, key, None))
+        ),
+    )
+
+
+def _getitem(sequence: Any, key: object, default: object = None) -> Any:
+    try:
+        return getitem(sequence, key)
+    except (KeyError, IndexError, TypeError):
+        return default
+
+
+def _ints(obj: object) -> tuple[int | float | Decimal, ...]:
+    if isinstance(obj, bool):
+        return (math.inf,)
+    if isinstance(obj, (int, float, Decimal)):
+        return (obj,)
+
+    ints = tuple(int(n) for n in RE_NUMERIC.findall(str(obj)))
+
+    if not ints:
+        return (math.inf,)
+    return ints

liquid/filters/split.py

@@ -0,0 +1,34 @@
+import re
+
+import markupsafe
+
+from .._filter import FilterContext
+
+RE_S = re.compile(r"\s")
+
+
+def split(context: FilterContext, left: object, sep: object) -> list[str]:
+    left_ = context.to_str(left, "")
+
+    if not left_:
+        return []
+
+    sep_ = context.to_str(sep, "")
+
+    if not sep_:
+        return list(left_)
+
+    if left_ == sep_:
+        return []
+
+    result: list[str]
+
+    if sep_ == " ":
+        result = [markupsafe.Markup(s) for s in RE_S.split(left_)]
+    else:
+        result = left_.split(sep_)
+
+    if result[-1] == "":
+        result.pop()
+
+    return result

liquid/filters/squish.py

@@ -0,0 +1,9 @@
+import re
+
+from .._filter import FilterContext
+
+RE_WHITESPACE = re.compile(r"\s+")
+
+
+def squish(context: FilterContext, left: object) -> str:
+    return RE_WHITESPACE.sub(" ", context.to_str(left, "").strip())

liquid/filters/strip.py

@@ -0,0 +1,13 @@
+from .._filter import FilterContext
+
+
+def strip(context: FilterContext, left: object) -> str:
+    return context.to_str(left, "").strip()
+
+
+def lstrip(context: FilterContext, left: object) -> str:
+    return context.to_str(left, "").lstrip()
+
+
+def rstrip(context: FilterContext, left: object) -> str:
+    return context.to_str(left, "").rstrip()

liquid/filters/strip_html.py

@@ -0,0 +1,19 @@
+import re
+
+import markupsafe
+
+from .._filter import FilterContext
+
+RE_HTML_BLOCKS = re.compile(
+    r"<script.*?</script>|<!--.*?-->|<style.*?</style>", re.DOTALL
+)
+
+RE_HTML_TAGS = re.compile("<.*?>", re.DOTALL)
+
+
+def strip_html(context: FilterContext, left: object) -> str:
+    left = context.to_str(left, "")
+    stripped = RE_HTML_TAGS.sub("", RE_HTML_BLOCKS.sub("", context.to_str(left, "")))
+    return (
+        markupsafe.Markup(stripped) if isinstance(left, markupsafe.Markup) else stripped
+    )

liquid/filters/strip_newlines.py

@@ -0,0 +1,17 @@
+import re
+
+import markupsafe
+
+from .._filter import FilterContext
+
+RE_NEWLINES = re.compile(r"\r?\n")
+
+
+def strip_newlines(context: FilterContext, left: object) -> str:
+    left_ = context.to_str(left, "")
+    stripped = RE_NEWLINES.sub("", left_)
+    return (
+        markupsafe.Markup(stripped)
+        if isinstance(left_, markupsafe.Markup)
+        else stripped
+    )

liquid/filters/sum.py

@@ -0,0 +1,21 @@
+from decimal import Decimal
+
+from .._filter import FilterContext
+
+
+def sum_(
+    context: FilterContext, left: object, prop: object = None
+) -> int | float | Decimal:
+    if type(left) is bool:
+        return 0
+
+    if isinstance(left, (int, float, Decimal)):
+        return left
+
+    if context.is_nil(prop):
+        return sum(context.to_decimal(obj, 0) for obj in context.input_array(left))
+
+    return sum(
+        context.to_decimal(context.get_item(obj, prop), 0)
+        for obj in context.input_array(left)
+    )

liquid/filters/times.py

@@ -0,0 +1,13 @@
+from decimal import Decimal
+
+from .._filter import FilterContext
+
+
+def times(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/translate.py

@@ -0,0 +1,380 @@
+from __future__ import annotations
+
+import re
+from gettext import NullTranslations
+from typing import TYPE_CHECKING, Any, cast
+
+from markupsafe import Markup
+
+from .. import expressions
+from .._messages import MESSAGES, MessageText, TranslatableFilter, Translations
+
+if TYPE_CHECKING:
+    from .._filter import FilterContext
+    from .._markup import Expression
+
+
+class BaseTranslateFilter:
+    """Base class for the default translation filters.
+
+    Parameters
+    ----------
+    translations_var
+        The name of a render context variable that resolves to a gettext `Translations`
+        class. Defaults to ``"translations"``.
+    default_translations
+        A fallback translations class to use if `translations_var` can not be resolves.
+        Defaults to ``NullTranslations``.
+    message_interpolation
+        If `True` (default), perform printf-style string interpolation on the translated
+        message, using keyword arguments passed to the filter function.
+    """
+
+    re_vars = re.compile(r"(?<!%)%\((\w+)\)s")
+
+    def __init__(
+        self,
+        *,
+        translations_var: str = "translations",
+        default_translations: Translations | None = None,
+        message_interpolation: bool = True,
+    ) -> None:
+        self.translations_var = translations_var
+        self.default_translations = default_translations or NullTranslations()
+        self.message_interpolation = message_interpolation
+
+    def format_message(
+        self, context: FilterContext, message_text: str, message_vars: dict[str, Any]
+    ) -> str:
+        """Return the message string formatted with the given message variables."""
+        with context.context.extend(namespace=message_vars):
+            _vars = {
+                k: context.env.serialize(
+                    context.resolve(k), context.context, context.span
+                )
+                for k in self.re_vars.findall(message_text)
+            }
+
+        # Missing variables get replaced by the current `Undefined` type and we're
+        # converting all values to a string, so a KeyError or a ValueError should
+        # be impossible.
+        return message_text % _vars
+
+    def _resolve_translations(
+        self, context: FilterContext
+    ) -> Translations | NullTranslations:
+        result = context.resolve(self.translations_var)
+        if context.is_nil(result):
+            return self.default_translations
+        return cast("Translations", result)
+
+
+class Translate(BaseTranslateFilter, TranslatableFilter):
+    """A Liquid filter for translating strings to other languages.
+
+    Depending on the keyword arguments provided when the resulting filter
+    is called, it could behave like gettext, ngettext, pgettext or npgettext.
+    """
+
+    def __call__(
+        self,
+        context: FilterContext,
+        left: object,
+        message_context: object = None,
+        **kwargs: Any,
+    ) -> str:
+        """Apply the filter and return the result."""
+        autoescape = context.env.autoescape
+        left_ = context.to_str(left, "")
+
+        translations = self._resolve_translations(context)
+
+        plural = kwargs.pop("plural", None)
+        n = _count(kwargs.get("count"))
+
+        if plural is not None and n is not None:
+            plural = context.to_str(plural, "")
+
+            if message_context is not None:
+                text = translations.npgettext(
+                    context.to_str(message_context, ""),
+                    left_,
+                    plural,
+                    n,
+                )
+            else:
+                text = translations.ngettext(left_, plural, n)
+        elif message_context is not None:
+            text = translations.pgettext(
+                context.to_str(message_context, ""),
+                left_,
+            )
+        else:
+            text = translations.gettext(left_)
+
+        if autoescape:
+            text = Markup(text)
+
+        if self.message_interpolation:
+            text = self.format_message(context, text, kwargs)
+
+        return text
+
+    def message(
+        self,
+        left: Expression,
+        filter_: expressions.Filtered,
+        lineno: int,
+    ) -> MessageText | None:
+        if not isinstance(left, expressions.StringLiteral):
+            return None
+
+        if not filter_.args:
+            return MessageText(
+                lineno=lineno,
+                funcname="gettext",
+                message=(left.value,),
+            )
+
+        if not isinstance(filter_.args[0], expressions.KeywordArgument):
+            context_: Expression | None = filter_.args[0]
+        else:
+            context_ = None
+
+        plural: Expression | None = None
+        for arg in filter_.args:
+            if (
+                isinstance(arg, expressions.KeywordArgument)
+                and arg.name.value == "plural"
+            ):
+                plural = arg.expr
+
+        # Translate our filters into standard *gettext argument specs.
+
+        if isinstance(plural, expressions.StringLiteral):
+            if isinstance(context_, expressions.StringLiteral):
+                funcname = "npgettext"
+                message: MESSAGES = ((context_.value, "c"), left.value, plural.value)
+            else:
+                funcname = "ngettext"
+                message = (left.value, plural.value)
+        elif plural is not None:
+            # Don't attempt to extract any messages if plural is given but not a string
+            # literal.
+            return None
+        elif isinstance(context_, expressions.StringLiteral):
+            funcname = "pgettext"
+            message = ((context_.value, "c"), left.value)
+        else:
+            funcname = "gettext"
+            message = (left.value,)
+
+        return MessageText(
+            lineno=lineno,
+            funcname=funcname,
+            message=message,
+        )
+
+
+class GetText(BaseTranslateFilter, TranslatableFilter):
+    """A Liquid filter equivalent of `gettext.gettext`."""
+
+    def __call__(
+        self,
+        context: FilterContext,
+        left: object,
+        **kwargs: Any,
+    ) -> str:
+        autoescape = context.env.autoescape
+        left_ = context.to_str(left, "")
+        translations = self._resolve_translations(context)
+        text = translations.gettext(left_)
+
+        if autoescape:
+            text = Markup(text)
+
+        if self.message_interpolation:
+            text = self.format_message(context, text, kwargs)
+
+        return text
+
+    def message(
+        self,
+        left: Expression,
+        filter_: expressions.Filtered,
+        lineno: int,
+    ) -> MessageText | None:
+        if not isinstance(left, expressions.StringLiteral):
+            return None
+
+        return MessageText(
+            lineno=lineno,
+            funcname="gettext",
+            message=(left.value,),
+        )
+
+
+class NGetText(BaseTranslateFilter, TranslatableFilter):
+    """A Liquid filter equivalent of `gettext.ngettext`."""
+
+    def __call__(
+        self,
+        context: FilterContext,
+        left: object,
+        plural: str,
+        count: object,
+        **kwargs: Any,
+    ) -> str:
+        """Apply the filter and return the result."""
+        left_ = context.to_str(left, "")
+
+        plural = context.to_str(plural, "")
+        count = int(context.to_numeric(count, 1))
+
+        translations = self._resolve_translations(context)
+        text = translations.ngettext(left_, plural, count)
+
+        if context.env.autoescape:
+            text = Markup(text)
+
+        if self.message_interpolation:
+            text = self.format_message(context, text, kwargs)
+
+        return text
+
+    def message(
+        self,
+        left: Expression,
+        filter_: expressions.Filtered,
+        lineno: int,
+    ) -> MessageText | None:
+        if len(filter_.args) < 1:
+            return None
+
+        plural = filter_.args[0]
+
+        if not isinstance(left, expressions.StringLiteral) or not isinstance(
+            plural, expressions.StringLiteral
+        ):
+            return None
+
+        return MessageText(
+            lineno=lineno,
+            funcname="ngettext",
+            message=(left.value, plural.value),
+        )
+
+
+class PGetText(BaseTranslateFilter, TranslatableFilter):
+    """A Liquid filter equivalent of `gettext.pgettext`."""
+
+    def __call__(
+        self,
+        context: FilterContext,
+        left: object,
+        message_context: str,
+        **kwargs: Any,
+    ) -> str:
+        left_ = context.to_str(left, "")
+        message_context = context.to_str(message_context, "")
+
+        translations = self._resolve_translations(context)
+        text = translations.pgettext(message_context, left_)
+
+        if context.env.autoescape:
+            text = Markup(text)
+
+        if self.message_interpolation:
+            text = self.format_message(context, text, kwargs)
+
+        return text
+
+    def message(
+        self,
+        left: Expression,
+        filter_: expressions.Filtered,
+        lineno: int,
+    ) -> MessageText | None:
+        if len(filter_.args) < 1:
+            return None
+
+        ctx = filter_.args[0]
+
+        if not isinstance(left, expressions.StringLiteral) or not isinstance(
+            ctx, expressions.StringLiteral
+        ):
+            return None
+
+        return MessageText(
+            lineno=lineno,
+            funcname="pgettext",
+            message=((ctx.value, "c"), left.value),
+        )
+
+
+class NPGetText(BaseTranslateFilter, TranslatableFilter):
+    """A Liquid filter equivalent of `gettext.npgettext`."""
+
+    def __call__(
+        self,
+        context: FilterContext,
+        left: object,
+        message_context: str,
+        plural: str,
+        count: object,
+        **kwargs: Any,
+    ) -> str:
+        left_ = context.to_str(left, "")
+        message_context = context.to_str(message_context, "")
+        plural = context.to_str(plural, "")
+        count = int(context.to_numeric(count, default=1))
+
+        translations = self._resolve_translations(context)
+        text = translations.npgettext(
+            message_context,
+            left_,
+            plural,
+            count,
+        )
+
+        if context.env.autoescape:
+            text = Markup(text)
+
+        if self.message_interpolation:
+            text = self.format_message(context, text, kwargs)
+
+        return text
+
+    def message(
+        self,
+        left: Expression,
+        filter_: expressions.Filtered,
+        lineno: int,
+    ) -> MessageText | None:
+        if len(filter_.args) < 2:
+            return None
+
+        ctx = filter_.args[0]
+        plural = filter_.args[1]
+
+        if (
+            not isinstance(left, expressions.StringLiteral)
+            or not isinstance(plural, expressions.StringLiteral)
+            or not isinstance(ctx, expressions.StringLiteral)
+        ):
+            return None
+
+        return MessageText(
+            lineno=lineno,
+            funcname="npgettext",
+            message=((ctx.value, "c"), left.value, plural.value),
+        )
+
+
+def _count(val: Any) -> int | None:
+    if val in (None, False, True):
+        return None
+    try:
+        return int(val)
+    except ValueError:
+        return None

liquid/filters/truncate.py

@@ -0,0 +1,39 @@
+import re
+
+from .._filter import FilterContext
+
+MAX_TRUNC_WORDS = 2147483647
+
+RE_S = re.compile(r"\s+")
+
+
+def truncate(
+    context: FilterContext, left: object, length: object = 50, end: object = "..."
+) -> str:
+    left_ = context.to_str(left, "")
+    length_ = context.to_int(length)
+
+    if len(left_) <= length_:
+        return left_
+
+    end_ = context.to_str(end, "")
+    stop = 0 if length_ < len(end_) else length_ - len(end_)
+    return left_[0:stop] + end_
+
+
+def truncate_words(
+    context: FilterContext, left: object, word_count: object = 15, end: object = "..."
+) -> str:
+    left_ = context.to_str(left, "")
+    word_count_ = max(context.to_int(word_count), 1)
+
+    if word_count_ >= MAX_TRUNC_WORDS:
+        return left_
+
+    end_ = context.to_str(end, "")
+    words = RE_S.split(left_.strip())
+
+    if len(words) <= word_count_:
+        return left_
+
+    return " ".join(words[:word_count_]) + end_