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

liquid/builtin/tags/include_tag.py

@@ -1,251 +0,0 @@
-"""The built-in _include_ 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 Node
-from liquid.ast import Partial
-from liquid.ast import PartialScope
-from liquid.builtin.drops import IterableDrop
-from liquid.builtin.expressions import Identifier
-from liquid.builtin.expressions import KeywordArgument
-from liquid.builtin.expressions import Literal
-from liquid.builtin.expressions import Path
-from liquid.builtin.expressions import parse_identifier
-from liquid.builtin.expressions import parse_string_or_path
-from liquid.exceptions import TemplateNotFoundError
-from liquid.tag import Tag
-from liquid.token import TOKEN_AS
-from liquid.token import TOKEN_FOR
-from liquid.token import TOKEN_TAG
-from liquid.token import TOKEN_WITH
-from liquid.token import TOKEN_WORD
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid.context import RenderContext
-    from liquid.expression import Expression
-    from liquid.stream import TokenStream
-
-TAG_INCLUDE = sys.intern("include")
-
-
-class IncludeNode(Node):
-    """The built-in _include_ tag."""
-
-    __slots__ = ("name", "var", "alias", "args")
-    tag = TAG_INCLUDE
-
-    def __init__(
-        self,
-        token: Token,
-        name: Expression,
-        var: Optional[Expression] = None,
-        alias: Optional[Identifier] = None,
-        args: Optional[list[KeywordArgument]] = None,
-    ):
-        super().__init__(token)
-        self.name = name
-        self.var = var
-        self.alias = alias
-        self.args = args or []
-        self.blank = False
-
-    def __str__(self) -> str:
-        var = f" with {self.var}" if self.var else ""
-        if self.alias:
-            var += f" as {self.alias}"
-        if self.args:
-            var += ","
-        args = " " + ", ".join(str(arg) for arg in self.args) if self.args else ""
-        return f"{{% include {self.name}{var}{args} %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        name = self.name.evaluate(context)
-
-        try:
-            template = context.env.get_template(
-                str(name), context=context, tag=self.tag
-            )
-        except TemplateNotFoundError as err:
-            err.token = self.name.token
-            err.template_name = context.template.full_name()
-            raise
-
-        namespace: dict[str, object] = {
-            arg.name: arg.value.evaluate(context) for arg in self.args
-        }
-
-        with context.extend(namespace, template=template):
-            # Bind a variable to the included template.
-            if self.var is not None:
-                val = self.var.evaluate(context)
-                key = self.alias or template.name.split(".")[0]
-
-                # If the variable is array-like, render the template once for each
-                # item in the array.
-                #
-                # The reference implementation does not seem to distinguish between
-                # "for" and "with". Just checks for array-like-ness.
-                if isinstance(val, (tuple, list, IterableDrop)):
-                    # NOTE: What if an included template with a bound array updates
-                    # a keyword argument value? Do we need to update namespace
-                    # arguments after each loop?
-                    #
-                    # The reference implementation seems to evaluate arguments once,
-                    # before the loop.
-                    context.raise_for_loop_limit(len(val))
-                    for itm in val:
-                        namespace[key] = itm
-                        template.render_with_context(context, buffer, partial=True)
-                else:
-                    namespace[key] = val
-                    template.render_with_context(context, buffer, partial=True)
-            else:
-                template.render_with_context(context, buffer, partial=True)
-
-        return True
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        name = await self.name.evaluate_async(context)
-
-        try:
-            template = await context.env.get_template_async(
-                str(name), context=context, tag=self.tag
-            )
-        except TemplateNotFoundError as err:
-            err.token = self.name.token
-            err.template_name = context.template.full_name()
-            raise
-
-        namespace: dict[str, object] = {
-            arg.name: await arg.value.evaluate_async(context) for arg in self.args
-        }
-
-        with context.extend(namespace, template=template):
-            if self.var is not None:
-                val = await self.var.evaluate_async(context)
-                key = self.alias or template.name.split(".")[0]
-
-                if isinstance(val, (tuple, list, IterableDrop)):
-                    context.raise_for_loop_limit(len(val))
-                    for itm in val:
-                        namespace[key] = itm
-                        await template.render_with_context_async(
-                            context, buffer, partial=True
-                        )
-                else:
-                    namespace[key] = val
-                    await template.render_with_context_async(
-                        context, buffer, partial=True
-                    )
-            else:
-                await template.render_with_context_async(context, buffer, partial=True)
-
-        return True
-
-    def children(
-        self, static_context: RenderContext, *, include_partials: bool = True
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        if include_partials:
-            name = self.name.evaluate(static_context)
-            try:
-                template = static_context.env.get_template(
-                    str(name), context=static_context, tag=self.tag
-                )
-                yield from template.nodes
-            except TemplateNotFoundError as err:
-                err.token = self.name.token
-                err.template_name = static_context.template.full_name()
-                raise
-
-    async def children_async(
-        self, static_context: RenderContext, *, include_partials: bool = True
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        if include_partials:
-            name = await self.name.evaluate_async(static_context)
-            try:
-                template = await static_context.env.get_template_async(
-                    str(name), context=static_context, tag=self.tag
-                )
-                return template.nodes
-            except TemplateNotFoundError as err:
-                err.token = self.name.token
-                err.template_name = static_context.template.full_name()
-                raise
-        return []
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        yield self.name
-        if self.var:
-            yield self.var
-        yield from (arg.value for arg in self.args)
-
-    def partial_scope(self) -> Partial | None:
-        """Return information about a partial template loaded by this node."""
-        scope: list[Identifier] = [
-            Identifier(arg.name, token=arg.token) for arg in self.args
-        ]
-
-        if self.var:
-            if self.alias:
-                scope.append(self.alias)
-            elif isinstance(self.name, Literal):
-                scope.append(
-                    Identifier(
-                        str(self.name.value).split(".", 1)[0], token=self.name.token
-                    )
-                )
-
-        return Partial(name=self.name, scope=PartialScope.SHARED, in_scope=scope)
-
-
-BIND_TOKENS = frozenset((TOKEN_WITH, TOKEN_FOR))
-
-
-class IncludeTag(Tag):
-    """The built-in _include_ tag."""
-
-    name = TAG_INCLUDE
-    block = False
-    node_class = IncludeNode
-
-    def parse(self, stream: TokenStream) -> Node:
-        """Read an IncludeNode from the given stream of tokens."""
-        token = stream.eat(TOKEN_TAG)
-        tokens = stream.into_inner(tag=token, eat=False)
-
-        # Need a string or identifier that resolves to a string. This is the name
-        # of the template to be included.
-        name = parse_string_or_path(self.env, tokens)
-        var: Optional[Path] = None
-        alias: Optional[Identifier] = None
-
-        # Optionally bind a variable to the included template context
-        if tokens.current.kind in BIND_TOKENS:
-            next(tokens)  # Eat 'with' or 'for'
-            tokens.expect(TOKEN_WORD)
-            var = Path.parse(self.env, tokens)
-
-            # The bound variable will take the name of the template by default,
-            # or an alias if an identifier follows the "as" keyword.
-            if tokens.current.kind == TOKEN_AS:
-                next(tokens)  # Eat 'as'
-                tokens.expect(TOKEN_WORD)
-                alias = parse_identifier(self.env, tokens)
-
-        # Zero or more keyword arguments
-        args = KeywordArgument.parse(self.env, tokens)
-        return self.node_class(token, name, var, alias, args)

liquid/builtin/tags/increment_tag.py

@@ -1,60 +0,0 @@
-"""The built-in _increment_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import TextIO
-
-from liquid.ast import Node
-from liquid.builtin.expressions import parse_identifier
-from liquid.tag import Tag
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid.builtin.expressions import Identifier
-    from liquid.context import RenderContext
-    from liquid.stream import TokenStream
-
-
-TAG_INCREMENT = sys.intern("increment")
-
-
-class IncrementNode(Node):
-    """The built-in _increment_ tag."""
-
-    __slots__ = ("name",)
-
-    def __init__(self, token: Token, name: Identifier):
-        super().__init__(token)
-        self.name = name
-        self.blank = False
-
-    def __str__(self) -> str:
-        return f"{{% increment {self.name} %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        return buffer.write(str(context.increment(self.name)))
-
-    def template_scope(self) -> Iterable[Identifier]:
-        """Return variables this node adds to the template local scope."""
-        yield self.name
-
-
-class IncrementTag(Tag):
-    """The built-in _increment_ tag."""
-
-    name = TAG_INCREMENT
-    block = False
-    node_class = IncrementNode
-
-    def parse(self, stream: TokenStream) -> IncrementNode:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        return self.node_class(
-            token,
-            name=parse_identifier(self.env, stream.into_inner(tag=token, eat=False)),
-        )

liquid/builtin/tags/inline_comment_tag.py

@@ -1,47 +0,0 @@
-"""The built-in inline comment tag."""
-
-from __future__ import annotations
-
-import re
-import sys
-from typing import TYPE_CHECKING
-
-from liquid.builtin.tags.comment_tag import CommentNode
-from liquid.exceptions import LiquidSyntaxError
-from liquid.tag import Tag
-from liquid.token import TOKEN_EXPRESSION
-from liquid.token import TOKEN_TAG
-
-if TYPE_CHECKING:
-    from liquid.stream import TokenStream
-
-
-RE_INVALID_INLINE_COMMENT = re.compile(r"\n\s*[^#\s]")
-
-
-class InlineCommentNode(CommentNode):
-    """The built-in inline comment tag."""
-
-    def __str__(self) -> str:
-        return f"{{% # {self.text} %}}"
-
-
-class InlineCommentTag(Tag):
-    """The built-in inline comment tag."""
-
-    block = False
-    name = sys.intern("#")
-    node_class = InlineCommentNode
-
-    def parse(self, stream: TokenStream) -> InlineCommentNode:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.expect(TOKEN_TAG)
-        # Empty comment tag?
-        if stream.peek.kind == TOKEN_EXPRESSION:
-            next(stream)
-            if RE_INVALID_INLINE_COMMENT.search(stream.current.value):
-                raise LiquidSyntaxError(
-                    "every line of an inline comment must start with a '#' character",
-                    token=stream.current,
-                )
-        return self.node_class(token, text=stream.current.value)

liquid/builtin/tags/liquid_tag.py

@@ -1,183 +0,0 @@
-"""The built-in _liquid_ tag."""
-
-from __future__ import annotations
-
-import re
-import sys
-from functools import partial
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import Iterator
-from typing import Optional
-from typing import Pattern
-from typing import TextIO
-
-from liquid.ast import BlockNode
-from liquid.ast import Node
-from liquid.exceptions import LiquidSyntaxError
-from liquid.parser import get_parser
-from liquid.stream import TokenStream
-from liquid.tag import Tag
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_EXPRESSION
-from liquid.token import TOKEN_ILLEGAL
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid import Environment
-    from liquid import RenderContext
-
-TAG_LIQUID = sys.intern("liquid")
-
-
-class LiquidNode(Node):
-    """The built-in _liquid_ tag."""
-
-    __slots__ = (
-        "liquid_token",
-        "block",
-    )
-
-    def __init__(self, token: Token, liquid_token: Optional[Token], block: BlockNode):
-        super().__init__(token)
-        self.liquid_token = liquid_token
-        self.block = block
-        self.blank = block.blank
-
-    def __str__(self) -> str:
-        # NOTE: We're using a string representation of the token, not the node.
-        # Which might cause issues later.
-        expr = self.liquid_token.value if self.liquid_token else ""
-        return f"{{% liquid {expr} %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        return self.block.render(context, buffer)
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        return await self.block.render_async(context, buffer)
-
-    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 LiquidTag(Tag):
-    """The built-in "liquid" tag."""
-
-    name = TAG_LIQUID
-    block = False
-    node_class = LiquidNode
-
-    def __init__(self, env: Environment):
-        super().__init__(env)
-
-        comment_start_string = env.comment_start_string.replace("{", "")
-
-        if comment_start_string:
-            seq = re.escape(comment_start_string)
-            rules = (
-                (
-                    "LIQUID_EXPR",
-                    rf"[ \t]*(?P<name>(\w+|{seq}))[ \t]*(?P<expr>.*?)[ \t\r]*?(\n+|$)",
-                ),
-                ("SKIP", r"[\r\n]+"),
-                (TOKEN_ILLEGAL, r"."),
-            )
-        else:
-            rules = (
-                (
-                    "LIQUID_EXPR",
-                    r"[ \t]*(?P<name>#|\w+)[ \t]*(?P<expr>.*?)[ \t\r]*?(\n+|$)",
-                ),
-                ("SKIP", r"[\r\n]+"),
-                (TOKEN_ILLEGAL, r"."),
-            )
-
-        self._tokenize = partial(
-            _tokenize_liquid_expression,
-            rules=_compile_rules(rules),
-            comment_start_string=comment_start_string,
-        )
-
-    def parse(self, stream: TokenStream) -> Node:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        token_: Optional[Token] = None
-
-        if stream.current.kind == TOKEN_EOF:
-            # Empty liquid tag. Empty block.
-            block = BlockNode(token, [])
-        elif stream.current.kind == TOKEN_TAG:
-            parser = get_parser(self.env)
-            block = parser.parse_block(stream, end=())
-        else:
-            token_ = stream.expect(TOKEN_EXPRESSION)
-            block = get_parser(self.env).parse_block(
-                TokenStream(
-                    self._tokenize(
-                        token_.value,
-                        token=token_,
-                    ),
-                    block_depth_carry=stream.block_depth,
-                ),
-                end=(),
-            )
-
-        return self.node_class(token, token_, block=block)
-
-
-def _tokenize_liquid_expression(
-    source: str,
-    rules: Pattern[str],
-    token: Token,
-    comment_start_string: str,
-) -> Iterator[Token]:
-    """Tokenize a "{% liquid %}" tag."""
-    for match in rules.finditer(source):
-        kind = match.lastgroup
-        assert kind is not None
-
-        value = match.group()
-
-        if kind == "LIQUID_EXPR":
-            name = match.group("name")
-            if name == comment_start_string:
-                continue
-
-            yield Token(
-                TOKEN_TAG,
-                value=name,
-                start_index=token.start_index + match.start("name"),
-                source=token.source,
-            )
-
-            if match.group("expr"):
-                yield Token(
-                    TOKEN_EXPRESSION,
-                    value=match.group("expr"),
-                    start_index=token.start_index + match.start("expr"),
-                    source=token.source,
-                )
-        elif kind == "SKIP":
-            continue
-        else:
-            raise LiquidSyntaxError(
-                f"expected newline delimited tag expressions, found {value!r}",
-                token=token,
-            )
-
-
-def _compile_rules(rules: Iterable[tuple[str, str]]) -> Pattern[str]:
-    """Compile the given rules into a single regular expression."""
-    pattern = "|".join(f"(?P<{name}>{pattern})" for name, pattern in rules)
-    return re.compile(pattern, re.DOTALL)