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

liquid/drops/range.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._nothing import NOTHING
+from .._slice import slice_range
+from ..exceptions import ResourceLimitError
+from .iterable import IterableDrop
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from .._context import RenderContext
+    from .._drop import ContextHint
+
+
+class Range:
+    __slots__ = ("start", "stop")
+
+    def __init__(self, start: int, stop: int) -> None:
+        self.start = start
+        self.stop = stop
+
+    def __liquid_getattr__(self, name: str, context: RenderContext) -> object:
+        match name:
+            case "first":
+                return self.start
+            case "last":
+                return self.stop
+            case "size":
+                return len(self)
+            case _:
+                raise KeyError
+
+    def __liquid_hasattr__(self, name: str, context: RenderContext) -> bool:
+        return name in ("first", "last", "size")
+
+    def __liquid_iter__(
+        self, offset: int, limit: int | None, reversed_: bool
+    ) -> IterableDrop[int]:
+        it = slice_range(range(self.start, self.stop), offset, limit, reversed_)
+        return IterableDrop(it, len(it))
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, Range)
+            and self.start == other.start
+            and self.stop == other.stop
+        )
+
+    def __len__(self) -> int:
+        return 0 if self.stop < self.start else self.stop - self.start + 1
+
+    def __bool__(self) -> bool:
+        return len(self) > 0
+
+    def __str__(self) -> str:
+        return f"{self.start}..{self.stop}"
+
+    def __liquid__(self, hint: ContextHint, context: RenderContext) -> object:
+        match hint:
+            case "output" | "string":
+                return str(self)
+            case "index" | "property" | "object":
+                return self
+            case "boolean":
+                return len(self) > 0
+            case "array":
+                if len(self) > 1_000_000:  # XXX: arbitrary limit
+                    raise ResourceLimitError("range limit reached")
+                return list(self.__liquid_iter__(0, None, False))
+            case _:
+                return NOTHING
+
+    def __iter__(self) -> Iterator[int]:
+        return iter(range(self.start, self.stop + 1))

liquid/drops/self_.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._nothing import NOTHING
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._drop import ContextHint
+
+
+class Self:
+    __slots__ = ("context",)
+
+    def __init__(self, context: RenderContext) -> None:
+        super().__init__()
+        self.context = context
+
+    def __liquid_hasattr__(self, name: str, context: RenderContext) -> bool:
+        # Argument context is not necessarily the same as instance context.
+        return name in self.context.scope
+
+    def __liquid_getattr__(self, name: str, context: RenderContext) -> object:
+        # Argument context is not necessarily the same as instance context.
+        return self.context.resolve(name)
+
+    def __liquid__(self, hint: ContextHint, context: RenderContext) -> object:
+        match hint:
+            case "output" | "string":
+                return str(self)
+            case "object":
+                return self
+            case "array":
+                return [self]
+            case _:
+                return NOTHING
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Self) and self.context is other.context
+
+    def __str__(self) -> str:
+        return "Liquid::SelfDrop"
+
+    def __contains__(self, item: object) -> bool:
+        return False

liquid/drops/tablerowloop.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._nothing import NOTHING
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._drop import ContextHint
+
+
+class TableRowLoop:
+    """Table row helper variables."""
+
+    __slots__ = (
+        "col",
+        "cols",
+        "index",
+        "length",
+        "row",
+    )
+
+    def __init__(self, length: int, cols: int) -> None:
+        self.length = length
+        self.cols = cols
+
+        self.col = 1
+        self.index = 0
+        self.row = 1
+
+    def __liquid_hasattr__(self, name: str, context: RenderContext) -> bool:
+        return name in (
+            "length",
+            "index",
+            "index0",
+            "rindex",
+            "rindex0",
+            "first",
+            "last",
+            "col",
+            "col0",
+            "col_first",
+            "col_last",
+            "row",
+        )
+
+    def __liquid_getattr__(self, name: str, context: RenderContext) -> object:
+        if name == "first":
+            return self.index == 0
+
+        if name == "index":
+            return self.index + 1
+
+        if name == "index0":
+            return self.index
+
+        if name == "last":
+            return self.index == self.length - 1
+
+        if name == "length":
+            return self.length
+
+        if name == "rindex":
+            return self.length - self.index
+
+        if name == "rindex0":
+            return self.length - self.index - 1
+
+        if name == "col":
+            return self.col
+
+        if name == "col_first":
+            return self.col == 1
+
+        if name == "col_last":
+            return self.col == self.cols
+
+        if name == "col0":
+            return self.col - 1
+
+        if name == "row":
+            return self.row
+
+        raise AttributeError
+
+    def __getitem__(self, key: str) -> int:
+        if key == "first":
+            return self.index == 0
+
+        if key == "index":
+            return self.index + 1
+
+        if key == "index0":
+            return self.index
+
+        if key == "last":
+            return self.index == self.length - 1
+
+        if key == "length":
+            return self.length
+
+        if key == "rindex":
+            return self.length - self.index
+
+        if key == "rindex0":
+            return self.length - self.index - 1
+
+        if key == "col":
+            return self.col
+
+        if key == "col_first":
+            return self.col == 1
+
+        if key == "col_last":
+            return self.col == self.cols
+
+        if key == "col0":
+            return self.col - 1
+
+        if key == "row":
+            return self.row
+
+        raise KeyError(key)
+
+    def __liquid__(self, hint: ContextHint, context: RenderContext) -> object:
+        match hint:
+            case "output" | "string" | "object":
+                return str(self)
+            case _:
+                return NOTHING
+
+    def __bool__(self) -> bool:
+        return True
+
+    def step(self) -> None:
+        self.index += 1
+
+        if self.col == self.cols:
+            self.col = 1
+            self.row += 1
+        else:
+            self.col += 1

liquid/drops/undefined.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Never
+
+from .._nothing import Nothing
+from ..exceptions import UndefinedVariableError
+from .iterable import IterableDrop
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
+    from .._context import RenderContext
+    from .._drop import ContextHint
+    from ..tokens import Token
+
+
+class Blank:
+    def __liquid__(self, hint: ContextHint, context: RenderContext) -> object:
+        match hint:
+            case "output" | "string":
+                return ""
+            case "numeric":
+                return 0
+            case _:
+                return self
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, (Blank, Empty)):
+            return False
+
+        if other is None or other is False or isinstance(other, Undefined):
+            return True
+
+        if isinstance(other, str):
+            return not other or other.isspace()
+
+        if isinstance(other, (list, tuple, dict)):
+            return not other
+
+        return False
+
+    def __lt__(self, other: object) -> bool:
+        return False
+
+    def __str__(self) -> str:
+        return ""
+
+    def __bool__(self) -> bool:
+        return True
+
+
+BLANK = Blank()
+
+
+class Empty:
+    def __liquid__(self, hint: ContextHint, context: RenderContext) -> object:
+        match hint:
+            case "output" | "string":
+                return ""
+            case "numeric":
+                return 0
+            case _:
+                return self
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Empty):
+            return True
+
+        if other is None or isinstance(other, Blank):
+            return False
+
+        if isinstance(other, (list, tuple, dict, str)):
+            return not other
+
+        return False
+
+    def __lt__(self, other: object) -> bool:
+        return False
+
+    def __str__(self) -> str:
+        return ""
+
+    def __bool__(self) -> bool:
+        return True
+
+
+EMPTY = Empty()
+
+
+class Undefined:
+    __slots__ = ("path", "source", "template_name", "token")
+
+    def __init__(
+        self, path: str, token: Token, source: str, template_name: str
+    ) -> None:
+        self.path = path
+        self.token = token
+        self.source = source
+        self.template_name = template_name
+
+    def poke(self) -> None:
+        pass
+
+    def __liquid_getattr__(self, name: str, context: RenderContext) -> object:
+        if name in ("first", "last", "size"):
+            return self
+        raise AttributeError
+
+    def __liquid_hasattr__(self, name: str, context: RenderContext) -> bool:
+        return name in ("first", "last", "size")
+
+    def __liquid__(self, hint: ContextHint, context: RenderContext) -> object:
+        match hint:
+            case "output" | "string":
+                return ""
+            case "index" | "property" | "object":
+                return None
+            case "numeric":
+                return 0
+            case "boolean":
+                return False
+            case "array":
+                return []
+
+    def __str__(self) -> str:
+        return ""
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __len__(self) -> int:
+        return 3
+
+    def __liquid_iter__(
+        self, start: int, end: int | None, reversed_: bool
+    ) -> IterableDrop[object]:
+        return IterableDrop[object]([], 0)
+
+    def __eq__(self, other: object) -> bool:
+        return other is None or isinstance(other, (Undefined, Nothing, Blank))
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.path})"
+
+
+class StrictUndefined(Undefined):
+    def _error(self) -> Never:
+        raise UndefinedVariableError(
+            f"{self.path} is undefined",
+            token=self.token,
+            source=self.source,
+            name=self.template_name,
+        )
+
+    def __iter__(self) -> Iterator[str]:
+        self._error()
+
+    def __liquid_getattr__(self, name: str, context: RenderContext) -> object:
+        self._error()
+
+    def __liquid_hasattr__(self, name: str, context: RenderContext) -> bool:
+        self._error()
+
+    def __liquid__(self, hint: ContextHint, context: RenderContext) -> object:
+        self._error()
+
+    def __liquid_iter__(
+        self, start: int, end: int | None, reversed_: bool
+    ) -> IterableDrop[object]:
+        self._error()
+
+    def __len__(self) -> int:  # noqa: PLE0303
+        self._error()
+
+    def __getitem__(self, key: object) -> object:
+        self._error()
+
+    def __eq__(self, other: object) -> bool:
+        self._error()
+
+    def __lt__(self, other: object) -> bool:
+        self._error()
+
+    def __le__(self, other: object) -> bool:
+        self._error()
+
+    def __gt__(self, other: object) -> bool:
+        self._error()
+
+    def __ge__(self, other: object) -> bool:
+        self._error()
+
+    def __contains__(self, item: object) -> bool:
+        self._error()
+
+    def __str__(self) -> str:  # noqa: PLE0307
+        self._error()
+
+    def __bool__(self) -> bool:  # noqa: PLE0304
+        self._error()
+
+    def __int__(self) -> int:
+        self._error()
+
+    def __hash__(self) -> int:  # noqa: PLE0309
+        self._error()
+
+    def __reversed__(self) -> Iterable[object]:
+        self._error()
+
+    def poke(self) -> None:
+        self._error()
+
+
+class FalsyStrictUndefined(StrictUndefined):
+    def __liquid__(self, hint: ContextHint, context: RenderContext) -> object:
+        if hint == "boolean":
+            return False
+        self._error()
+
+    def __liquid_hasattr__(self, name: str, context: RenderContext) -> bool:
+        return name in ("first", "last", "size")
+
+    def __eq__(self, other: object) -> bool:
+        return other is None or isinstance(other, (Undefined, Nothing, Blank))
+
+    def __bool__(self) -> bool:
+        return False