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

liquid/builtin/tags/for_tag.py

@@ -1,337 +0,0 @@
-"""The built-in _for_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Any
-from typing import Iterable
-from typing import Iterator
-from typing import Mapping
-from typing import Optional
-from typing import TextIO
-
-from liquid.ast import BlockNode
-from liquid.ast import Node
-from liquid.builtin.expressions import Identifier
-from liquid.builtin.expressions import LoopExpression
-from liquid.exceptions import BreakLoop
-from liquid.exceptions import ContinueLoop
-from liquid.parser import get_parser
-from liquid.tag import Tag
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid.context import RenderContext
-    from liquid.expression import Expression
-    from liquid.stream import TokenStream
-
-
-TAG_FOR = sys.intern("for")
-TAG_ENDFOR = sys.intern("endfor")
-TAG_ELSE = sys.intern("else")
-
-TAG_BREAK = sys.intern("break")
-TAG_CONTINUE = sys.intern("continue")
-
-ENDFORBLOCK = frozenset((TAG_ENDFOR, TAG_ELSE))
-ENDFORELSEBLOCK = frozenset((TAG_ENDFOR,))
-
-
-class ForNode(Node):
-    """The built-in _for_ tag."""
-
-    __slots__ = ("expression", "block", "default")
-
-    def __init__(
-        self,
-        token: Token,
-        expression: LoopExpression,
-        block: BlockNode,
-        default: Optional[BlockNode] = None,
-    ):
-        super().__init__(token)
-        self.expression = expression
-        self.block = block
-        self.default = default
-        self.blank = block.blank and (not default or default.blank)
-
-    def __str__(self) -> str:
-        default = ""
-
-        if self.default:
-            default = f"{{% else %}}{self.default}"
-
-        return f"{{% for {self.expression} %}}{self.block}{default}{{% endfor %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        it, length = self.expression.evaluate(context)
-
-        if length:
-            character_count = 0
-            name = self.expression.identifier
-
-            forloop = ForLoop(
-                name=f"{name}-{self.expression.iterable}",
-                it=it,
-                length=length,
-                parentloop=context.parentloop(),
-            )
-
-            namespace = {
-                "forloop": forloop,
-                name: None,
-            }
-
-            # Extend the context. Essentially giving priority to `ForLoopDrop`, then
-            # delegating `get` and `assign` to the outer context.
-            with context.loop(namespace, forloop):
-                for itm in forloop:
-                    namespace[name] = itm
-                    try:
-                        character_count += self.block.render(context, buffer)
-                    except ContinueLoop:
-                        continue
-                    except BreakLoop:
-                        break
-
-            return character_count
-
-        return self.default.render(context, buffer) if self.default else 0
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        it, length = await self.expression.evaluate_async(context)
-
-        if length:
-            character_count = 0
-            name = self.expression.identifier
-
-            forloop = ForLoop(
-                name=f"{name}-{self.expression.iterable}",
-                it=it,
-                length=length,
-                parentloop=context.parentloop(),
-            )
-
-            namespace = {
-                "forloop": forloop,
-                name: None,
-            }
-
-            # Extend the context. Essentially giving priority to `ForLoopDrop`, then
-            # delegating `get` and `assign` to the outer context.
-            with context.loop(namespace, forloop):
-                for itm in forloop:
-                    namespace[name] = itm
-                    try:
-                        character_count += await self.block.render_async(
-                            context, buffer
-                        )
-                    except ContinueLoop:
-                        continue
-                    except BreakLoop:
-                        break
-
-            return character_count
-
-        return await self.default.render_async(context, buffer) if self.default else 0
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        yield self.block
-        if self.default:
-            yield self.default
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        yield self.expression
-
-    def block_scope(self) -> Iterable[Identifier]:
-        """Return variables this node adds to the node's block scope."""
-        yield Identifier(self.expression.identifier, token=self.expression.token)
-        yield Identifier("forloop", token=self.token)
-
-
-class BreakNode(Node):
-    """Parse tree node for the built-in "break" tag."""
-
-    def __str__(self) -> str:
-        return "{% break %}"
-
-    def render_to_output(
-        self,
-        _: RenderContext,
-        __: TextIO,
-    ) -> int:
-        """Render the node to the output buffer."""
-        raise BreakLoop("break")
-
-
-class ContinueNode(Node):
-    """Parse tree node for the built-in "continue" tag."""
-
-    def __str__(self) -> str:
-        return "{% continue %}"
-
-    def render_to_output(
-        self,
-        _: RenderContext,
-        __: TextIO,
-    ) -> int:
-        """Render the node to the output buffer."""
-        raise ContinueLoop("continue")
-
-
-class ForTag(Tag):
-    """The built-in _for_ tag."""
-
-    name = TAG_FOR
-    end = TAG_ENDFOR
-    node_class = ForNode
-
-    def parse(self, stream: TokenStream) -> Node:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        expr = LoopExpression.parse(self.env, stream.into_inner(tag=token))
-
-        parse_block = get_parser(self.env).parse_block
-        block = parse_block(stream, ENDFORBLOCK)
-        default: Optional[BlockNode] = None
-
-        if stream.current.is_tag(TAG_ELSE):
-            next(stream)
-            default = parse_block(stream, ENDFORELSEBLOCK)
-
-        stream.expect(TOKEN_TAG, value=TAG_ENDFOR)
-        return self.node_class(token, expression=expr, block=block, default=default)
-
-
-class BreakTag(Tag):
-    """The built-in _break_ tag."""
-
-    name = TAG_BREAK
-    block = False
-
-    def parse(self, stream: TokenStream) -> BreakNode:
-        """Parse tokens from _stream_ into an AST node."""
-        stream.expect(TOKEN_TAG, value=TAG_BREAK)
-        return BreakNode(stream.current)
-
-
-class ContinueTag(Tag):
-    """The built-in _continue_ tag."""
-
-    name = TAG_CONTINUE
-    block = False
-
-    def parse(self, stream: TokenStream) -> ContinueNode:
-        """Parse tokens from _stream_ into an AST node."""
-        stream.expect(TOKEN_TAG, value=TAG_CONTINUE)
-        return ContinueNode(stream.current)
-
-
-class ForLoop(Mapping[str, object]):
-    """Loop helper variables."""
-
-    __slots__ = (
-        "name",
-        "it",
-        "length",
-        "item",
-        "_index",
-        "parentloop",
-    )
-
-    _keys = frozenset(
-        [
-            "name",
-            "length",
-            "index",
-            "index0",
-            "rindex",
-            "rindex0",
-            "first",
-            "last",
-            "parentloop",
-        ]
-    )
-
-    def __init__(
-        self,
-        name: str,
-        it: Iterator[Any],
-        length: int,
-        parentloop: object,
-    ):
-        self.name = name
-        self.it = it
-        self.length = length
-
-        self.item = None
-        self._index = -1  # Step is called before `next(it)`
-        self.parentloop = parentloop
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"ForLoop(name='{self.name}', length={self.length})"
-
-    def __getitem__(self, key: str) -> object:
-        if key in self._keys:
-            return getattr(self, key)
-        raise KeyError(key)
-
-    def __len__(self) -> int:
-        return len(self._keys)
-
-    def __next__(self) -> object:
-        self.step()
-        return next(self.it)
-
-    def __iter__(self) -> Iterator[Any]:
-        return self
-
-    def __str__(self) -> str:
-        return "ForLoop"
-
-    @property
-    def index(self) -> int:
-        """The 1-based index of the current loop iteration."""
-        return self._index + 1
-
-    @property
-    def index0(self) -> int:
-        """The 0-based index of the current loop iteration."""
-        return self._index
-
-    @property
-    def rindex(self) -> int:
-        """The 1-based index, counting from the right, of the current loop iteration."""
-        return self.length - self._index
-
-    @property
-    def rindex0(self) -> int:
-        """The 0-based index, counting from the right, of the current loop iteration."""
-        return self.length - self._index - 1
-
-    @property
-    def first(self) -> bool:
-        """True if this is the first iteration, false otherwise."""
-        return self._index == 0
-
-    @property
-    def last(self) -> bool:
-        """True if this is the last iteration, false otherwise."""
-        return self._index == self.length - 1
-
-    def step(self) -> None:
-        """Move the for loop helper forward to the next iteration."""
-        self._index += 1

liquid/builtin/tags/if_tag.py

@@ -1,209 +0,0 @@
-"""The built-in _if_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import Optional
-from typing import TextIO
-
-from liquid.ast import BlockNode
-from liquid.ast import ConditionalBlockNode
-from liquid.ast import IllegalNode
-from liquid.ast import Node
-from liquid.builtin.expressions import BooleanExpression
-from liquid.exceptions import LiquidSyntaxError
-from liquid.mode import Mode
-from liquid.parser import eat_block
-from liquid.parser import get_parser
-from liquid.tag import Tag
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_EXPRESSION
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid.context import RenderContext
-    from liquid.expression import Expression
-    from liquid.stream import TokenStream
-
-
-TAG_IF = sys.intern("if")
-TAG_ENDIF = sys.intern("endif")
-TAG_ELSIF = sys.intern("elsif")
-TAG_ELSE = sys.intern("else")
-
-ENDIFBLOCK = frozenset((TAG_ENDIF, TAG_ELSIF, TAG_ELSE, TOKEN_EOF))
-ENDELSIFBLOCK = frozenset((TAG_ENDIF, TAG_ELSIF, TAG_ELSE))
-ENDIFELSEBLOCK = frozenset((TAG_ENDIF, TAG_ELSE, TAG_ELSIF))
-
-
-class IfNode(Node):
-    """The built-in _if_ tag."""
-
-    __slots__ = (
-        "condition",
-        "consequence",
-        "alternatives",
-        "default",
-    )
-
-    def __init__(
-        self,
-        token: Token,
-        condition: Expression,
-        consequence: BlockNode,
-        alternatives: list[ConditionalBlockNode],
-        default: Optional[BlockNode],
-    ):
-        super().__init__(token)
-        self.condition = condition
-        self.consequence = consequence
-        self.alternatives = alternatives
-        self.default = default
-
-        self.blank = (
-            consequence.blank
-            and all(node.blank for node in alternatives)
-            and (not default or default.blank)
-        )
-
-        self.consequence.blank = self.blank
-
-        for node in self.alternatives:
-            node.blank = self.blank
-
-        if self.default:
-            self.default.blank = self.blank
-
-    def __str__(self) -> str:
-        alts = "".join(str(alt) for alt in self.alternatives)
-        default = ""
-
-        if self.default:
-            default = f"{{% else %}}{self.default}"
-
-        return (
-            f"{{% if {self.condition} %}}{self.consequence}{alts}{default}{{% endif %}}"
-        )
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        if self.condition.evaluate(context):
-            return self.consequence.render(context, buffer)
-
-        for alternative in self.alternatives:
-            if alternative.expression.evaluate(context):
-                return alternative.block.render(context, buffer)
-
-        if self.default:
-            return self.default.render(context, buffer)
-
-        return 0
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        if await self.condition.evaluate_async(context):
-            return await self.consequence.render_async(context, buffer)
-
-        for alternative in self.alternatives:
-            if await alternative.expression.evaluate_async(context):
-                return await alternative.render_async(context, buffer)
-
-        if self.default:
-            return await self.default.render_async(context, buffer)
-
-        return 0
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        yield self.consequence
-        yield from self.alternatives
-        if self.default:
-            yield self.default
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        yield self.condition
-
-
-class IfTag(Tag):
-    """The built-in _if_ tag."""
-
-    name = TAG_IF
-    end = TAG_ENDIF
-    node_class = IfNode
-
-    mode = Mode.LAX
-    """Tag specific parsing mode, independent from environment tolerance mode."""
-
-    def parse(self, stream: TokenStream) -> Node:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        tokens = stream.into_inner(tag=token)
-        condition = BooleanExpression.parse(self.env, tokens)
-        parse_block = get_parser(self.env).parse_block
-        consequence = parse_block(stream, ENDIFBLOCK)
-        alternatives: list[ConditionalBlockNode] = []
-
-        while stream.current.is_tag(TAG_ELSIF):
-            # If the expression can't be parsed, eat the "elsif" block and
-            # continue to parse more "elsif" expression, if any.
-            try:
-                expr = BooleanExpression.parse(
-                    self.env, stream.into_inner(tag=next(stream))
-                )
-            except LiquidSyntaxError as err:
-                self.env.error(err)
-                eat_block(stream, ENDELSIFBLOCK)
-                return IllegalNode(token)
-
-            alt_tok = stream.current
-            alt_block = parse_block(stream, ENDELSIFBLOCK)
-
-            alternatives.append(
-                ConditionalBlockNode(alt_tok, expression=expr, block=alt_block)
-            )
-
-        default: Optional[BlockNode] = None
-
-        if stream.current.is_tag(TAG_ELSE):
-            next(stream)
-            if stream.current.kind == TOKEN_EXPRESSION:
-                if self.mode == Mode.LAX:
-                    # Superfluous expressions inside an `else` tag are ignored.
-                    next(stream)
-                else:
-                    raise LiquidSyntaxError(
-                        "found an 'else' tag expression, did you mean 'elsif'?",
-                        token=stream.current,
-                    )
-            default = parse_block(stream, ENDIFELSEBLOCK)
-
-        # Extraneous `else` and `elsif` blocks are ignored.
-        if not stream.current.is_tag(TAG_ENDIF) and self.mode == Mode.LAX:
-            while stream.current.kind != TOKEN_EOF:
-                if (
-                    stream.current.kind == TOKEN_TAG
-                    and stream.current.value == TAG_ENDIF
-                ):
-                    break
-                next(stream)
-
-        stream.expect(TOKEN_TAG, value=TAG_ENDIF)
-
-        return self.node_class(
-            token=token,
-            condition=condition,
-            consequence=consequence,
-            alternatives=alternatives,
-            default=default,
-        )

liquid/builtin/tags/ifchanged_tag.py

@@ -1,94 +0,0 @@
-"""The built-in _ifchanged_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import TextIO
-
-from liquid.ast import BlockNode
-from liquid.ast import Node
-from liquid.parser import get_parser
-from liquid.tag import Tag
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid import Environment
-    from liquid.context import RenderContext
-    from liquid.stream import TokenStream
-
-
-TAG_IFCHANGED = sys.intern("ifchanged")
-TAG_ENDIFCHANGED = sys.intern("endifchanged")
-
-ENDIFCHANGEDBLOCK = frozenset((TAG_ENDIFCHANGED,))
-
-
-class IfChangedNode(Node):
-    """The built-in _ifchanged_ tag."""
-
-    __slots__ = ("block",)
-
-    def __init__(self, token: Token, block: BlockNode):
-        super().__init__(token)
-        self.block = block
-        self.blank = block.blank
-
-    def __str__(self) -> str:
-        return f"{{% ifchanged %}}{{ {self.block} }}{{% endifchanged %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        # Render to an intermediate buffer.
-        buf = context.get_buffer(buffer)
-        self.block.render(context, buf)
-        val = buf.getvalue()
-
-        # The context will update its namespace if needed.
-        if context.ifchanged(val):
-            return buffer.write(val)
-        return 0
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        # Render to an intermediate buffer.
-        buf = context.get_buffer(buffer)
-        await self.block.render_async(context, buf)
-        val = buf.getvalue()
-
-        # The context will update its namespace if needed.
-        if context.ifchanged(val):
-            return buffer.write(val)
-        return 0
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        yield self.block
-
-
-class IfChangedTag(Tag):
-    """The built-in _ifchanged_ tag."""
-
-    name = TAG_IFCHANGED
-    end = TAG_ENDIFCHANGED
-    node_class = IfChangedNode
-
-    def __init__(self, env: Environment):
-        super().__init__(env)
-        self.parser = get_parser(self.env)
-
-    def parse(self, stream: TokenStream) -> Node:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        block = self.parser.parse_block(stream, ENDIFCHANGEDBLOCK)
-        stream.expect(TOKEN_TAG, value=TAG_ENDIFCHANGED)
-        return self.node_class(token, block)