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

liquid/_filter.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import decimal
+import re
+from collections.abc import Callable, Generator, Iterable, Mapping
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import TYPE_CHECKING, Concatenate
+
+from ._drop import liquid_object, liquid_primitive
+from ._missing import MISSING
+from ._nothing import NOTHING
+from .exceptions import LiquidFilterError, LiquidFilterInterrupt
+
+if TYPE_CHECKING:
+    import datetime as dt
+
+    from ._context import RenderContext
+    from .environment import Environment
+    from .tokens import Token
+
+
+type Filter = Callable[Concatenate[FilterContext, object, ...], object]
+
+RE_DIGITS = re.compile(r"^[0-9]+")
+
+
+@dataclass(slots=True)
+class FilterContext:
+    """Liquid config, state and utilities for filter implementations."""
+
+    context: RenderContext
+    span: Token
+
+    missing: object = field(init=False)
+    env: Environment = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.missing = MISSING
+        self.env = self.context.env
+
+    def get_item(self, obj: object, key: object, default: object = MISSING) -> object:
+        """Get `key` from `obj` with Shopify/liquid semantics."""
+        if isinstance(obj, str) and isinstance(key, str):
+            return key if key in obj else None
+
+        if isinstance(obj, (int, float, Decimal)) and isinstance(
+            key, (int, float, Decimal)
+        ):
+            return obj == key
+
+        if self.is_nil(obj):
+            raise LiquidFilterInterrupt(
+                f"can't read property {obj}[{key}]",
+                token=self.span,
+                source=self.context.template.source,
+                name=self.context.template.name,
+            )
+
+        if not (isinstance(obj, Mapping) or liquid_object(obj)):
+            raise LiquidFilterError(
+                f"can't read property {obj}[{key}]",
+                token=self.span,
+                source=self.context.template.source,
+                name=self.context.template.name,
+            )
+
+        result, _ = self.context.resolve_path(obj, [key])  # pyright: ignore[reportUnknownArgumentType]
+        return default if result == NOTHING else result
+
+    def resolve(self, name: object) -> object:
+        return self.context.resolve(name)
+
+    def input_array(self, obj: object) -> list[object]:
+        """Coerce `obj` to a list suitable for filters that expect an array input."""
+        if liquid_primitive(obj):
+            obj = obj.__liquid__("array", self.context)
+
+        if isinstance(obj, (list, tuple)):
+            return _flatten(obj)  # pyright: ignore[reportUnknownArgumentType]
+
+        return [obj]
+
+    def is_nil(self, obj: object) -> bool:
+        """Return true if `obj` is Liquid nullish."""
+        return self.context.env.is_nil(obj)
+
+    def truthy(self, obj: object) -> bool:
+        """Return true if `obj` is Liquid truthy."""
+        return self.context.env.truthy(obj, self.context)
+
+    def to_int(self, obj: object) -> int:
+        """Coerce `obj` to an integer."""
+        if self.is_nil(obj):
+            raise LiquidFilterError(
+                "invalid integer",
+                token=self.span,
+                source=self.context.template.source,
+                name=self.context.template.name,
+            )
+        return self.context.env.to_int(obj, self.context, self.span)
+
+    def to_numeric(self, obj: object, default: int | Decimal) -> float | int | Decimal:
+        """Coerce `obj` to an integer, float or Decimal."""
+        if isinstance(obj, str):
+            try:
+                return int(obj)
+            except ValueError:
+                pass
+
+            try:
+                return float(obj)
+            except ValueError:
+                pass
+
+            # This is different than env.to_numeric
+            if match := RE_DIGITS.match(obj):
+                return int(match.group())
+
+            return default
+
+        return self.context.env.to_numeric(obj, self.context, default)
+
+    def to_decimal(self, obj: object, default: Decimal | int) -> Decimal | int:
+        if self.is_nil(obj):
+            return default
+
+        if obj is True:
+            return default
+
+        if isinstance(obj, int):
+            return obj
+
+        try:
+            return Decimal(str(obj))
+        except (ValueError, TypeError, decimal.InvalidOperation):
+            if isinstance(obj, str):
+                match = RE_DIGITS.match(obj)
+                if match:
+                    return Decimal(match.group())
+            return default
+
+    def to_str[T](self, obj: object, default: T) -> str | T:
+        """Coerce `obj` to a string."""
+        return (
+            default
+            if obj is None
+            else self.context.env.to_str(obj, self.context, self.span)
+        )
+
+    def to_date(self, obj: object) -> dt.datetime | None:
+        """Coerce `obj` to a datatime, or ``None`` if `obj` can not be interpreted as a datetime."""
+        return self.env.to_date(obj, self.context, self.span)
+
+    def error(self, message: str) -> LiquidFilterError:
+        """Return a Liquid exception with suitable error context data."""
+        return LiquidFilterError(
+            message,
+            token=self.span,
+            source=self.context.template.source,
+            name=self.context.template.name,
+        )
+
+
+def _flatten(it: Iterable[object], level: int = 5) -> list[object]:
+
+    def flatten_(it: Iterable[object], level: int = 5) -> Generator[object]:
+        for obj in it:
+            if level < 1 or not isinstance(obj, (list, tuple)):
+                yield obj
+            else:
+                yield from flatten_(obj, level=level - 1)  # pyright: ignore[reportUnknownArgumentType]
+
+    return list(flatten_(it, level))

liquid/_io.py

@@ -0,0 +1,18 @@
+class StringBuffer:
+    """An output text buffer that keeps track of its own length."""
+
+    def __init__(self) -> None:
+        self._parts: list[str] = []
+        self._length = 0
+
+    def write(self, s: str) -> None:
+        """Write `s` to the buffer."""
+        self._parts.append(s)
+        self._length += len(s)
+
+    def __len__(self) -> int:
+        return self._length
+
+    def getvalue(self) -> str:
+        """Return the contents of the buffer."""
+        return "".join(self._parts)

liquid/_lax_parser_mixin.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING, Protocol
+
+from . import expressions, tokens
+from ._parser import PRECEDENCE_LOWEST
+from .exceptions import LiquidSyntaxError
+from .tags import ErrorNode
+from .tokens import Token, TokenKind, span
+
+if TYPE_CHECKING:
+    from ._markup import Expression, Markup
+    from ._parser import Precedence
+
+
+class _LegacyParserProtocol(Protocol):
+    def parse_output(self) -> Markup: ...
+    def parse_tag(self) -> Markup: ...
+    def parse_expression(
+        self,
+        precedence: Precedence = PRECEDENCE_LOWEST,
+        *,
+        infix: bool = False,
+        expect_end_of_expression: bool = False,
+    ) -> Expression: ...
+    def current(self) -> Token: ...
+    def next(self) -> Token: ...
+    def kind(self) -> TokenKind: ...
+    def carry_whitespace_control(self) -> None: ...
+
+
+class LaxParserMixin(ABC, _LegacyParserProtocol):
+    """A legacy Liquid parser that captures and suppresses syntax errors.
+
+    Other parse-time errors such as ``ResourceLimitError`` will still be raised.
+    """
+
+    __slots__ = ()
+
+    def parse_output(self) -> Markup:
+        try:
+            return super().parse_output()  # type: ignore
+        except LiquidSyntaxError as err:
+            return self.error(err)
+
+    def parse_tag(self) -> Markup:
+        try:
+            return super().parse_tag()  # type: ignore
+        except LiquidSyntaxError as err:
+            return self.error(err)
+
+    def parse_expression(
+        self,
+        precedence: Precedence = PRECEDENCE_LOWEST,
+        *,
+        infix: bool = False,
+        expect_end_of_expression: bool = False,
+    ) -> Expression:
+        start_token = self.current()
+
+        try:
+            return super().parse_expression(  # type: ignore
+                precedence,
+                infix=infix,
+                expect_end_of_expression=expect_end_of_expression,
+            )
+        except LiquidSyntaxError as err:
+            while self.kind() not in (
+                tokens.TOKEN_WC,
+                tokens.TOKEN_TAG_END,
+                tokens.TOKEN_OUT_END,
+            ):
+                self.pos += 1  # type: ignore
+
+            return expressions.ErrorExpr(span(start_token, self.current()), err)
+
+    def error(self, err: LiquidSyntaxError) -> ErrorNode:
+        # Skip tokens up to the next delimiter.
+        start_token = self.current()
+
+        while 1:
+            match self.kind():
+                case (
+                    tokens.TOKEN_EOI
+                    | tokens.TOKEN_COMMENT_END
+                    | tokens.TOKEN_COMMENT_START
+                    | tokens.TOKEN_OUT_END
+                    | tokens.TOKEN_OUT_START
+                    | tokens.TOKEN_TAG_END
+                    | tokens.TOKEN_TAG_START
+                ):
+                    break
+                case tokens.TOKEN_WC:
+                    self.carry_whitespace_control()
+                case _:
+                    self.pos += 1  # type: ignore
+
+        end_token = self.next()
+        return ErrorNode(span(start_token, end_token), err)

liquid/_lexer.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from .exceptions import ResourceLimitError
+from .tokens import TOKEN_WC
+
+if TYPE_CHECKING:
+    import re
+
+    from .environment import Environment
+    from .tokens import Token, TokenKind
+
+
+type State = Callable[[], State | None]
+
+
+class Lexer:
+    """Template source tokenizer."""
+
+    __slots__ = (
+        "length",
+        "pos",
+        "source",
+        "start",
+        "tokens",
+    )
+
+    def __init__(self, env: Environment, source: str) -> None:
+        self.source = source
+        self.length = len(source)
+        self.start = 0
+        self.pos = 0
+        self.tokens: list[Token] = []
+
+    @classmethod
+    def tokenize(cls, env: Environment, source: str) -> list[Token]:
+        lexer = cls(env, source)
+        try:
+            lexer.run()
+        except RecursionError:
+            raise ResourceLimitError("maximum recursion depth exceeded")
+        return lexer.tokens
+
+    def run(self) -> None:
+        state: State | None = self.scan_markup
+        while state:
+            state = state()
+
+    def emit(self, kind: TokenKind) -> None:
+        self.tokens.append((kind, self.start, self.pos))
+        self.start = self.pos
+
+    def index(self, pattern: re.Pattern[str]) -> int | None:
+        if match := pattern.search(self.source, self.pos):
+            return match.start()
+        return None
+
+    def scan(self, pattern: re.Pattern[str]) -> str | None:
+        if match := pattern.match(self.source, self.pos):
+            self.pos = match.end()
+            return match[0]
+        return None
+
+    def scan_until(self, pattern: re.Pattern[str]) -> str | None:
+        if match := pattern.search(self.source, self.pos):
+            self.pos = match.start()
+            return self.source[self.start : match.start()]
+        return None
+
+    def skip(self, pattern: re.Pattern[str]) -> bool:
+        if match := pattern.match(self.source, self.pos):
+            self.pos = match.end()
+            self.start = self.pos
+            return True
+        return False
+
+    def skip_until(self, pattern: re.Pattern[str]) -> re.Match[str] | None:
+        if match := pattern.search(self.source, self.pos):
+            self.pos = match.start()
+            return match
+        return None
+
+    def accept_whitespace_control(self) -> bool:
+        if self.pos < self.length and self.source[self.pos] == "-":
+            self.pos += 1
+            self.emit(TOKEN_WC)
+            return True
+        return False
+
+    def scan_markup(self) -> State | None:
+        raise NotImplementedError