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

liquid/tags/output.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Expression, Markup, Partial
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class OutputStatement:
+    blank = False
+    tag = ""
+
+    __slots__ = ("expression", "token")
+
+    def __init__(self, token: Token, expression: Expression) -> None:
+        self.token = token
+        self.expression = expression
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buffer.write(
+            context.env.serialize(
+                self.expression.evaluate(context), context, self.expression.span
+            )
+        )
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buffer.write(
+            context.env.serialize(
+                await self.expression.evaluate_async(context),
+                context,
+                self.expression.span,
+            )
+        )
+
+    def children(self) -> list[Markup]:
+        return []
+
+    async def children_async(self) -> list[Markup]:
+        return []
+
+    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 []

liquid/tags/raw.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..tokens import TOKEN_TAG_END, TOKEN_TEXT, token_value
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Expression, Markup, Partial
+    from .._parser import Parser
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class RawTag:
+    blank = False
+    tag = "raw"
+
+    __slots__ = ("text", "token")
+
+    def __init__(self, token: Token, text: str) -> None:
+        self.token = token
+        self.text = text
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        text = (
+            token_value(parser.eat(TOKEN_TEXT), parser.source)
+            if parser.kind() == TOKEN_TEXT
+            else ""
+        )
+        parser.eat_empty_tag("endraw")
+        return RawTag(token, text)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buffer.write(self.text)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buffer.write(self.text)
+
+    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 []

liquid/tags/render.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._markup import SCOPE_ISOLATED, Partial
+from .._nothing import NOTHING
+from ..drops import ForLoop
+from ..exceptions import NoSuchTemplateError, TemplateNotFoundError
+from ..expressions import Name, StringLiteral
+from ..tokens import TOKEN_COMMA, TOKEN_TAG_END
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Expression, Markup
+    from .._parser import Parser
+    from ..expressions import KeywordArgument
+    from ..tokens import Token
+
+
+class RenderTag:
+    blank = False
+    tag = "render"
+
+    __slots__ = ("alias", "args", "loop", "name", "token", "variable")
+
+    def __init__(
+        self,
+        token: Token,
+        *,
+        name: StringLiteral,
+        loop: bool,
+        variable: Expression | None,
+        alias: Name | None,
+        args: list[KeywordArgument],
+    ) -> None:
+        self.token = token
+        self.name = name
+        self.loop = loop
+        self.variable = variable
+        self.alias = alias
+        self.args = args
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        name_expr = parser.parse_string_literal()
+
+        loop = False
+        variable: Expression | None = None
+        alias: Name | None = None
+
+        # `for`, `with` and `as` don't have their own tokens kinds.
+        ident = parser.value()
+        if ident in ("for", "with"):
+            loop = ident == "for"
+            parser.next()
+            variable = parser.parse_expression()
+
+        if parser.value() == "as":
+            parser.next()
+            alias = parser.parse_identifier()
+
+        if parser.kind() == TOKEN_COMMA:
+            parser.next()
+
+        args = parser.parse_keyword_arguments(require_commas=False)
+
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        return RenderTag(
+            token,
+            name=name_expr,
+            loop=loop,
+            variable=variable,
+            alias=alias,
+            args=args,
+        )
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        template_name = self.name.value
+
+        try:
+            template = context.env.get_template(
+                template_name, context=context, tag="render"
+            )
+        except TemplateNotFoundError as err:
+            # Promote TemplateNotFoundError to NoSuchTemplateError
+            raise NoSuchTemplateError(
+                str(err),
+                token=self.name.span,
+                source=context.template.source,
+                name=context.template.name,
+            ) from None
+
+        bind_key = self.alias.value if self.alias else template.name.split(".", 1)[0]
+        bind_value: object
+
+        if self.variable:
+            bind_value = self.variable.evaluate(context)
+        else:
+            bind_value = context.resolve(template_name)
+            if bind_value == NOTHING:
+                bind_value = None
+
+        scope = {arg.name.value: arg.expr.evaluate(context) for arg in self.args}
+
+        ctx = context.copy(
+            scope,
+            disabled_tags=("include",),
+            block_scope=False,
+            carry_loop_iterations=True,
+            template=template,
+        )
+
+        if self.loop and isinstance(bind_value, list):
+            ctx.raise_for_loop_limit(len(bind_value))  # pyright: ignore[reportUnknownArgumentType]
+
+            forloop = ForLoop(bind_key, len(bind_value), None)  # pyright: ignore[reportUnknownArgumentType]
+            scope["forloop"] = forloop
+
+            for item in bind_value:  # pyright: ignore[reportUnknownVariableType]
+                scope[bind_key] = item
+                forloop.step()
+                template.render_with_context(ctx, buffer)
+        else:
+            scope[bind_key] = bind_value
+            template.render_with_context(ctx, buffer)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        template_name = self.name.value
+
+        try:
+            template = await context.env.get_template_async(
+                template_name, context=context, tag="render"
+            )
+        except TemplateNotFoundError as err:
+            # Promote TemplateNotFoundError to NoSuchTemplateError
+            raise NoSuchTemplateError(
+                str(err),
+                token=self.name.span,
+                source=context.template.source,
+                name=context.template.name,
+            ) from None
+
+        bind_key = self.alias.value if self.alias else template.name.split(".", 1)[0]
+        bind_value: object
+
+        if self.variable:
+            bind_value = await self.variable.evaluate_async(context)
+        else:
+            bind_value = context.resolve(template_name)
+            if bind_value == NOTHING:
+                bind_value = None
+
+        scope = {
+            arg.name.value: await arg.expr.evaluate_async(context) for arg in self.args
+        }
+
+        ctx = context.copy(
+            scope,
+            disabled_tags=("include",),
+            block_scope=False,
+            carry_loop_iterations=True,
+            template=template,
+        )
+
+        if self.loop and isinstance(bind_value, list):
+            ctx.raise_for_loop_limit(len(bind_value))  # pyright: ignore[reportUnknownArgumentType]
+
+            forloop = ForLoop(bind_key, len(bind_value), None)  # pyright: ignore[reportUnknownArgumentType]
+            scope["forloop"] = forloop
+            for item in bind_value:  # pyright: ignore[reportUnknownVariableType]
+                scope[bind_key] = item
+                forloop.step()
+                await template.render_with_context_async(ctx, buffer)
+        else:
+            scope[bind_key] = bind_value
+            await template.render_with_context_async(ctx, buffer)
+
+    def children(self) -> list[Markup]:
+        return []
+
+    def expressions(self) -> list[Expression]:
+        result: list[Expression] = []
+
+        if self.variable:
+            result.append(self.variable)
+
+        result.extend(arg.expr for arg in self.args)
+        return result
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        template = context.env.get_template(
+            self.name.value,
+            context=context,
+            tag="render",
+        )
+
+        scope: list[Name] = [arg.name for arg in self.args]
+
+        if self.variable:
+            if self.alias:
+                scope.append(self.alias)
+            else:
+                scope.append(Name(self.name.token, self.name.value))
+
+        return [
+            Partial(
+                template=template,
+                scope=SCOPE_ISOLATED,
+                in_scope=scope,
+                key=hash((self.name.value, ":".join(n.value for n in scope))),
+            )
+        ]
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        template = await context.env.get_template_async(
+            self.name.value,
+            context=context,
+            tag="render",
+        )
+
+        scope: list[Name] = [arg.name for arg in self.args]
+
+        if self.variable:
+            if self.alias:
+                scope.append(self.alias)
+            else:
+                scope.append(Name(self.name.token, self.name.value))
+
+        return [
+            Partial(
+                template=template,
+                scope=SCOPE_ISOLATED,
+                in_scope=scope,
+                key=hash((self.name.value, ":".join(n.value for n in scope))),
+            )
+        ]

liquid/tags/tablerow.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._drop import liquid_iterable
+from .._markup import render_block, render_block_async
+from .._slice import slice_sequence
+from ..drops import TableRowLoop
+from ..exceptions import LiquidSyntaxError
+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 ..expressions import Name
+    from ..tokens import Token
+
+
+class TableRowTag:
+    blank = False
+    tag = "tablerow"
+
+    __slots__ = (
+        "block",
+        "cols",
+        "expression",
+        "limit",
+        "name",
+        "offset",
+        "token",
+    )
+
+    def __init__(
+        self,
+        token: Token,
+        name: Name,
+        expression: Expression,
+        block: Block,
+        *,
+        cols: Expression | None,
+        offset: Expression | None,
+        limit: Expression | None,
+    ) -> None:
+        self.token = token
+        self.name = name
+        self.expression = expression
+        self.block: Block = block
+        self.offset = offset
+        self.limit = limit
+        self.cols = cols
+
+    @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()
+
+        args = parser.parse_keyword_arguments(require_commas=False)
+
+        cols: Expression | None = None
+        offset: Expression | None = None
+        limit: Expression | None = None
+
+        for arg in args:
+            if arg.name.value == "offset":
+                offset = arg.expr
+            elif arg.name.value == "limit":
+                limit = arg.expr
+            elif arg.name.value == "cols":
+                cols = arg.expr
+            elif arg.name.value == "range":
+                pass
+            else:
+                raise LiquidSyntaxError(
+                    f"unknown argument {arg.name.value!r}",
+                    token=arg.name.token,
+                    source=parser.source,
+                    name=parser.template_name,
+                )
+
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        block = parser.parse_block(("endtablerow",))
+        parser.eat_empty_tag("endtablerow")
+
+        return TableRowTag(
+            token,
+            ident,
+            expr,
+            block,
+            cols=cols,
+            offset=offset,
+            limit=limit,
+        )
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        offset = _to_int(self.offset, context, 0, 0)
+        limit = _to_int(self.limit, context, None, 0)
+
+        target = self.expression.evaluate(context)
+        it: Iterable[object]
+
+        if context.env.is_nil(target):
+            return
+
+        if liquid_iterable(target):
+            it = target.__liquid_iter__(offset, limit, False)
+            length = len(it)
+        else:
+            a = context.env.to_array(target, context, self.expression.span)
+            it, length = slice_sequence(a, offset, limit, False)
+
+        cols = _to_int(self.cols, context, length, 0)
+        tablerowloop = TableRowLoop(length, cols)
+
+        name = self.name.value
+        namespace: dict[str, object] = {"tablerowloop": tablerowloop}
+
+        with context.loop(namespace, tablerowloop):
+            buffer.write('<tr class="row1">\n')
+
+            for item in it:
+                namespace[name] = item
+                buffer.write(f'<td class="col{tablerowloop["col"]}">')
+                render_block(self.block, context, buffer)
+                buffer.write("</td>")
+
+                if context.interrupts and context.interrupts.pop() == "break":
+                    break
+
+                if tablerowloop["col_last"] and not tablerowloop["last"]:
+                    buffer.write(f'</tr>\n<tr class="row{tablerowloop["row"] + 1}">')
+
+                tablerowloop.step()
+
+            buffer.write("</tr>\n")
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        offset = await _to_int_async(self.offset, context, 0, 0)
+        limit = await _to_int_async(self.limit, context, None, 0)
+
+        target = await self.expression.evaluate_async(context)
+        it: Iterable[object]
+
+        if context.env.is_nil(target):
+            return
+
+        if liquid_iterable(target):
+            it = target.__liquid_iter__(offset, limit, False)
+            length = len(it)
+        else:
+            a = context.env.to_array(target, context, self.expression.span)
+            it, length = slice_sequence(a, offset, limit, False)
+
+        cols = await _to_int_async(self.cols, context, length, 0)
+        tablerowloop = TableRowLoop(length, cols)
+
+        name = self.name.value
+        namespace: dict[str, object] = {"tablerowloop": tablerowloop}
+
+        with context.loop(namespace, tablerowloop):
+            buffer.write('<tr class="row1">\n')
+
+            for item in it:
+                namespace[name] = item
+                buffer.write(f'<td class="col{tablerowloop["col"]}">')
+                await render_block_async(self.block, context, buffer)
+                buffer.write("</td>")
+
+                if context.interrupts and context.interrupts.pop() == "break":
+                    break
+
+                if tablerowloop["col_last"] and not tablerowloop["last"]:
+                    buffer.write(f'</tr>\n<tr class="row{tablerowloop["row"] + 1}">')
+
+                tablerowloop.step()
+
+            buffer.write("</tr>\n")
+
+    def children(self) -> list[Markup]:
+        result: list[Markup] = [
+            node for node in self.block if not isinstance(node, str)
+        ]
+
+        return result
+
+    def expressions(self) -> list[Expression]:
+        result = [self.expression]
+
+        if self.cols:
+            result.append(self.cols)
+
+        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 []
+
+
+def _to_int[T](
+    expression: Expression | None,
+    context: RenderContext,
+    default: T,
+    null: T,
+) -> int | T:
+    if expression is None:
+        return default
+
+    value = expression.evaluate(context)
+
+    if context.env.is_nil(value):
+        return null
+
+    return context.env.to_int(value, context, expression.span)
+
+
+async def _to_int_async[T](
+    expression: Expression | None,
+    context: RenderContext,
+    default: T,
+    null: T,
+) -> int | T:
+    if expression is None:
+        return default
+
+    value = await expression.evaluate_async(context)
+
+    if context.env.is_nil(value):
+        return null
+
+    return context.env.to_int(value, context, expression.span)

liquid/tags/template_comment.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..tokens import TOKEN_COMMENT, TOKEN_COMMENT_END, token_value
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Expression, Markup, Partial
+    from .._parser import Parser
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class TemplateComment:
+    blank = True
+    tag = ""
+
+    __slots__ = ("text", "token")
+
+    def __init__(self, token: Token, text: str) -> None:
+        self.token = token
+        self.text = text
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        parser.carry_whitespace_control()
+        comment = parser.eat(TOKEN_COMMENT)
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_COMMENT_END)
+        return TemplateComment(token, token_value(comment, parser.source))
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        return None
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        return None
+
+    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 []