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

liquid/tags/for_.py

@@ -0,0 +1,421 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING
+
+from .._drop import liquid_async_iterable, liquid_iterable
+from .._markup import is_blank_block, render_block, render_block_async
+from .._slice import slice_sequence
+from ..drops import AsyncIterableDrop, ForLoop, Undefined
+from ..exceptions import LiquidSyntaxError
+from ..expressions import KeywordArgument, Name, Variable
+from ..tokens import TOKEN_COMMA, TOKEN_IN, TOKEN_TAG_END
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Block, Expression, Markup, Partial
+    from .._parser import Parser
+    from ..tokens import Token
+
+
+class ForTag:
+    tag = "for"
+
+    __slots__ = (
+        "blank",
+        "block",
+        "default",
+        "expression",
+        "limit",
+        "name",
+        "offset",
+        "offset_key",
+        "reversed",
+        "token",
+    )
+
+    def __init__(
+        self,
+        token: Token,
+        name: Name,
+        expression: Expression,
+        block: Block,
+        *,
+        offset: Expression | None,
+        limit: Expression | None,
+        reversed: bool,
+        default: Block | None,
+    ) -> None:
+        self.token = token
+        self.name = name
+        self.expression = expression
+        self.block: Block = block
+        self.offset = offset
+        self.limit = limit
+        self.reversed = reversed
+        self.default: Block | None = default
+
+        self.blank = is_blank_block(self.block) and (
+            not default or is_blank_block(default)
+        )
+
+        if self.blank:
+            self.block = [node for node in self.block if not isinstance(node, str)]
+            if self.default:
+                self.default = [
+                    node for node in self.default if not isinstance(node, str)
+                ]
+
+        self.offset_key = f"{self.name.value}-{self.expression}"
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        ident = parser.parse_identifier()
+        parser.eat(TOKEN_IN, message="missing 'in'")
+        parser.expect_expression()
+        expr = parser.parse_expression()
+
+        if parser.kind() == TOKEN_COMMA:
+            parser.next()
+
+        reversed_, offset, limit = ForTag.unpack_args(
+            parser, parser.parse_arguments(require_commas=False)
+        )
+
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        block = parser.parse_block(("else", "endfor"))
+        default: Block | None = None
+
+        if parser.tag("else"):
+            parser.eat_empty_tag("else")
+            default = parser.parse_block(("else", "endfor"))
+
+        parser.eat_empty_tag("endfor")
+
+        return ForTag(
+            token,
+            ident,
+            expr,
+            block,
+            offset=offset,
+            limit=limit,
+            reversed=reversed_,
+            default=default,
+        )
+
+    @staticmethod
+    def unpack_args(
+        parser: Parser, args: list[Expression | KeywordArgument]
+    ) -> tuple[bool, Expression | None, Expression | None]:
+        reversed_: bool = False
+        offset: Expression | None = None
+        limit: Expression | None = None
+
+        for arg in args:
+            if isinstance(arg, KeywordArgument):
+                if arg.name.value == "offset":
+                    offset = arg.expr
+                elif arg.name.value == "limit":
+                    limit = arg.expr
+                else:
+                    raise LiquidSyntaxError(
+                        f"unknown argument {arg.name.value!r}",
+                        token=arg.name.token,
+                        source=parser.source,
+                        name=parser.template_name,
+                    )
+
+            elif (
+                isinstance(arg, Variable)
+                and isinstance(arg.root, Name)
+                and arg.root.value == "reversed"
+                and not arg.selectors
+            ):
+                reversed_ = True
+
+            else:
+                raise LiquidSyntaxError(
+                    "unexpected argument",
+                    token=arg.token,
+                    source=parser.source,
+                    name=parser.template_name,
+                )
+
+        return reversed_, offset, limit
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        target = self.expression.evaluate(context)
+
+        offsets = context.get_register("loop_offset", default=register_factory)
+
+        if self.offset:
+            offset_ = self.offset.evaluate(context)
+
+            if isinstance(offset_, Undefined) and offset_.path == "continue":
+                offset = offsets[self.offset_key]
+            else:
+                offset = context.env.to_int(offset_, context, self.offset.span)
+
+        else:
+            offset = 0
+
+        if self.limit:
+            limit = context.env.to_int(
+                self.limit.evaluate(context), context, self.limit.span
+            )
+        else:
+            limit = None
+
+        it: Iterable[object]
+
+        if liquid_iterable(target):
+            it = target.__liquid_iter__(offset, limit, self.reversed)
+            length = len(it)
+
+        else:
+            a = context.env.to_array(target, context, self.expression.span)
+            if not offset and not limit:
+                it = a if not self.reversed else reversed(a)
+                length = len(a)
+
+            else:
+                it, length = slice_sequence(a, offset, limit, self.reversed)
+
+        offsets[self.offset_key] = offset + length
+
+        if not length:
+            if self.default:
+                render_block(self.default, context, buffer)
+            return
+
+        name = self.name.value
+        parent_loop = context.parent_loop()
+
+        forloop = ForLoop(f"{name}-{self.expression}", length, parent_loop)
+        namespace: dict[str, object] = {"forloop": forloop}
+
+        with context.loop(namespace, forloop):
+            for obj in it:
+                namespace[name] = obj
+                forloop.step()
+                render_block(self.block, context, buffer)
+
+                if context.interrupts:
+                    interrupt = context.interrupts.pop()
+                    if interrupt == "break":
+                        break
+
+                    if interrupt == "continue":
+                        continue
+
+                    context.interrupts.append(interrupt)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        target = await self.expression.evaluate_async(context)
+
+        offsets = context.get_register("loop_offset", default=register_factory)
+
+        if self.offset:
+            offset_ = await self.offset.evaluate_async(context)
+
+            if isinstance(offset_, Undefined) and offset_.path == "continue":
+                offset = offsets[self.offset_key]
+            else:
+                offset = context.env.to_int(offset_, context, self.offset.span)
+        else:
+            offset = 0
+
+        if self.limit:
+            limit = context.env.to_int(
+                await self.limit.evaluate_async(context), context, self.limit.span
+            )
+        else:
+            limit = None
+
+        it: Iterable[object] | AsyncIterableDrop[object]
+
+        if liquid_async_iterable(target):
+            it = await target.__liquid_iter_async__(offset, limit, self.reversed)
+            length = len(it)
+
+        elif liquid_iterable(target):
+            it = target.__liquid_iter__(offset, limit, self.reversed)
+            length = len(it)
+
+        else:
+            a = context.env.to_array(target, context, self.expression.span)
+            if not offset and not limit:
+                it = a if not self.reversed else reversed(a)
+                length = len(a)
+            else:
+                it, length = slice_sequence(a, offset, limit, self.reversed)
+
+        offsets[self.offset_key] = offset + length
+
+        if not length:
+            if self.default:
+                await render_block_async(self.default, context, buffer)
+            return
+
+        name = self.name.value
+        parent_loop = context.parent_loop()
+
+        forloop = ForLoop(f"{name}-{self.expression}", length, parent_loop)
+        namespace: dict[str, object] = {"forloop": forloop}
+
+        with context.loop(namespace, forloop):
+            if isinstance(it, AsyncIterableDrop):
+                async for obj in it:
+                    namespace[name] = obj
+                    forloop.step()
+                    await render_block_async(self.block, context, buffer)
+
+                    if context.interrupts:
+                        interrupt = context.interrupts.pop()
+                        if interrupt == "break":
+                            break
+
+                        if interrupt == "continue":
+                            continue
+
+                        context.interrupts.append(interrupt)
+
+            else:
+                for obj in it:
+                    namespace[name] = obj
+                    forloop.step()
+                    await render_block_async(self.block, context, buffer)
+
+                    if context.interrupts:
+                        interrupt = context.interrupts.pop()
+                        if interrupt == "break":
+                            break
+
+                        if interrupt == "continue":
+                            continue
+
+                        context.interrupts.append(interrupt)
+
+    def children(self) -> list[Markup]:
+        result: list[Markup] = [
+            node for node in self.block if not isinstance(node, str)
+        ]
+
+        if self.default:
+            for node in self.default:
+                if not isinstance(node, str):
+                    result.append(node)
+
+        return result
+
+    def expressions(self) -> list[Expression]:
+        result = [self.expression]
+
+        if self.offset:
+            result.append(self.offset)
+
+        if self.limit:
+            result.append(self.limit)
+
+        return result
+
+    def block_scope(self) -> list[Name]:
+        return [self.name]
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []
+
+
+class BreakTag:
+    blank = True
+    tag = "break"
+
+    __slots__ = ("token",)
+
+    def __init__(self, token: Token) -> None:
+        self.token = token
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        return BreakTag(token)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        context.interrupts.append("break")
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        context.interrupts.append("break")
+
+    def children(self) -> list[Markup]:
+        return []
+
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []
+
+
+class ContinueTag:
+    blank = True
+    tag = "continue"
+
+    __slots__ = ("token",)
+
+    def __init__(self, token: Token) -> None:
+        self.token = token
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        return ContinueTag(token)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        context.interrupts.append("continue")
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        context.interrupts.append("continue")
+
+    def children(self) -> list[Markup]:
+        return []
+
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []
+
+
+def register_factory() -> defaultdict[str, int]:
+    return defaultdict(int)

liquid/tags/if_.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._markup import is_blank_block, render_block, render_block_async
+from ..tokens import (
+    TOKEN_TAG_END,
+    TOKEN_TAG_NAME,
+    TOKEN_TAG_START,
+)
+from .else_ import ElseBlock
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Block, Expression, Markup, Partial
+    from .._parser import Parser
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class IfTag:
+    tag = ""
+
+    __slots__ = ("blank", "blocks", "token")
+
+    def __init__(
+        self, token: Token, blocks: list[IfBlock | ElsIfBlock | ElseBlock]
+    ) -> None:
+        self.token = token
+        self.blocks = blocks
+        self.blank = all(block.blank for block in self.blocks)
+
+        if self.blank:
+            for block in self.blocks:
+                block.filter_strings()
+
+    @classmethod
+    def parse(cls, token: Token, parser: Parser) -> Markup:
+        blocks: list[IfBlock | ElsIfBlock | ElseBlock] = []
+
+        parser.expect_expression()
+        expression = parser.parse_expression(infix=True, expect_end_of_expression=True)
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        block = parser.parse_block(("else", "elsif", "endif"))
+        blocks.append(IfBlock(token, expression, block))
+
+        while 1:
+            tag_name = parser.tags(("else", "elsif"))
+
+            if tag_name == "elsif":
+                blocks.append(cls.parse_else_if(parser))
+            elif tag_name == "else":
+                name_token = parser.eat_tag("else")
+                blocks.append(
+                    ElseBlock(
+                        name_token, parser.parse_block(("else", "elsif", "endif"))
+                    )
+                )
+            else:
+                break
+
+        parser.eat_empty_tag("endif")
+        return IfTag(token, blocks)
+
+    @classmethod
+    def parse_else_if(cls, parser: Parser) -> ElsIfBlock:
+        parser.eat(TOKEN_TAG_START)
+        parser.skip_whitespace_control()
+        token = parser.eat(TOKEN_TAG_NAME)
+        parser.expect_expression()
+        expression = parser.parse_expression(infix=True, expect_end_of_expression=True)
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        return ElsIfBlock(
+            token, expression, parser.parse_block(("else", "elsif", "endif"))
+        )
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        for block in self.blocks:
+            if context.env.truthy(block.expression.evaluate(context), context):
+                return block.render(context, buffer)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        for block in self.blocks:
+            if context.env.truthy(
+                await block.expression.evaluate_async(context), context
+            ):
+                return await block.render_async(context, buffer)
+
+    def children(self) -> list[Markup]:
+        return list(self.blocks)
+
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []
+
+
+class IfBlock:
+    tag = "if"
+
+    __slots__ = ("blank", "block", "expression", "token")
+
+    def __init__(self, token: Token, expression: Expression, block: Block) -> None:
+        self.token = token
+        self.expression = expression
+        self.block = block
+        self.blank = is_blank_block(block)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        render_block(self.block, context, buffer)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        await render_block_async(self.block, context, buffer)
+
+    def children(self) -> list[Markup]:
+        return [node for node in self.block if not isinstance(node, str)]
+
+    async def children_async(self) -> list[Markup]:
+        return self.children()
+
+    def expressions(self) -> list[Expression]:
+        return [self.expression]
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    def filter_strings(self) -> None:
+        markup: Block = [node for node in self.block if not isinstance(node, str)]
+        self.block = markup
+
+
+class ElsIfBlock(IfBlock):
+    tag = "elsif"

liquid/tags/ifchanged.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._markup import render_block, render_block_async
+from ..tokens import TOKEN_TAG_END
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Block, Expression, Markup, Partial
+    from .._parser import Parser
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class IfChangedTag:
+    blank = False
+    tag = "ifchanged"
+
+    __slots__ = ("block", "token")
+
+    def __init__(self, token: Token, block: Block) -> None:
+        self.token = token
+        self.block = block
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        block = parser.parse_block(end=("endifchanged",))
+        parser.eat_empty_tag("endifchanged")
+        return IfChangedTag(token, block)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buf = context.env.buffer_factory()
+        render_block(self.block, context, buf)
+        buffered = buf.getvalue()
+
+        if buffered != context.get_register("ifchanged", str):
+            buffer.write(buffered)
+            context.registers["ifchanged"] = buffered
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buf = context.env.buffer_factory()
+        await render_block_async(self.block, context, buf)
+        buffered = buf.getvalue()
+
+        if buffered != context.get_register("ifchanged", str):
+            buffer.write(buffered)
+            context.registers["ifchanged"] = buffered
+
+    def children(self) -> list[Markup]:
+        return [node for node in self.block if not isinstance(node, str)]
+
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []