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

liquid/builtin/loaders/package_loader.py

@@ -1,132 +0,0 @@
-"""A template loader that reads templates from Python packages."""
-
-from __future__ import annotations
-
-import asyncio
-import os
-from pathlib import Path
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import Optional
-from typing import Union
-
-import importlib_resources
-
-from liquid.exceptions import TemplateNotFoundError
-from liquid.loader import BaseLoader
-from liquid.loader import TemplateSource
-
-if TYPE_CHECKING:
-    from types import ModuleType
-
-    from liquid import Environment
-    from liquid import RenderContext
-
-
-class PackageLoader(BaseLoader):
-    """A template loader that reads templates from Python packages.
-
-    Args:
-        package: Import name of a package containing Liquid templates.
-        package_path: One or more directories in the package containing Liquid
-            templates.
-        encoding: Encoding of template files.
-        ext: A default file extension to use if one is not provided. Should
-            include a leading period.
-    """
-
-    def __init__(
-        self,
-        package: Union[str, ModuleType],
-        *,
-        package_path: Union[str, Iterable[str]] = "templates",
-        encoding: str = "utf-8",
-        ext: str = ".liquid",
-    ) -> None:
-        if isinstance(package_path, str):
-            self.paths = [importlib_resources.files(package).joinpath(package_path)]
-        else:
-            _package = importlib_resources.files(package)
-            self.paths = [_package.joinpath(path) for path in package_path]
-
-        self.encoding = encoding
-        self.ext = ext
-
-    def _resolve_path(self, template_name: str) -> Path:
-        template_path = Path(template_name)
-
-        if not template_path.name:
-            raise TemplateNotFoundError(template_name)
-
-        # Add suffix self.ext if template name does not have a suffix.
-        if not template_path.suffix:
-            template_path = template_path.with_suffix(self.ext)
-
-        if os.path.pardir in template_path.parts or template_path.is_absolute():
-            raise TemplateNotFoundError(template_name)
-
-        for path in self.paths:
-            with importlib_resources.as_file(path) as base:
-                source_path: Path = base.joinpath(template_path)
-
-                try:
-                    if not source_path.exists() or not source_path.is_file():
-                        continue
-                except OSError:
-                    # "File name too long", for example
-                    continue
-
-                resolved = source_path.resolve(strict=False)
-                base_resolved = base.resolve(strict=False)
-
-                if not resolved.is_relative_to(base_resolved):
-                    continue
-
-                return source_path
-
-        raise TemplateNotFoundError(template_name)
-
-    def get_source(
-        self,
-        env: Environment,  # noqa: ARG002
-        template_name: str,
-        *,
-        context: Optional[RenderContext] = None,  # noqa: ARG002
-        **kwargs: object,  # noqa: ARG002
-    ) -> TemplateSource:
-        """Get source information for a template."""
-        source_path = self._resolve_path(template_name)
-        return TemplateSource(
-            text=source_path.read_text(self.encoding),
-            name=str(source_path),
-            uptodate=None,
-        )
-
-    async def get_source_async(
-        self,
-        env: Environment,  # noqa: ARG002
-        template_name: str,
-        *,
-        context: Optional[RenderContext] = None,  # noqa: ARG002
-        **kwargs: object,  # noqa: ARG002
-    ) -> TemplateSource:
-        """Get source information for a template."""
-        loop = asyncio.get_running_loop()
-
-        source_path = await loop.run_in_executor(
-            None,
-            self._resolve_path,
-            template_name,
-        )
-
-        source_text = await loop.run_in_executor(
-            None,
-            source_path.read_text,
-            self.encoding,
-        )
-
-        return TemplateSource(
-            text=source_text,
-            name=str(source_path),
-            uptodate=None,
-        )

liquid/builtin/output.py

@@ -1,74 +0,0 @@
-"""Parse tree node and pseudo "tag" for output statements."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import TextIO
-
-from liquid.ast import Node
-from liquid.builtin.expressions import FilteredExpression
-from liquid.builtin.expressions import tokenize
-from liquid.stream import TokenStream
-from liquid.stringify import to_liquid_string
-from liquid.tag import Tag
-from liquid.token import TOKEN_EXPRESSION
-from liquid.token import TOKEN_OUTPUT
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid.context import RenderContext
-    from liquid.expression import Expression
-
-
-class OutputNode(Node):
-    """Parse tree node representing an output statement."""
-
-    __slots__ = ("expression",)
-
-    def __init__(self, token: Token, expression: Expression):
-        super().__init__(token)
-        self.expression = expression
-        self.blank = False
-
-    def __str__(self) -> str:
-        return f"{{{{ {self.expression} }}}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        return buffer.write(
-            to_liquid_string(self.expression.evaluate(context), context.autoescape)
-        )
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        return buffer.write(
-            to_liquid_string(
-                await self.expression.evaluate_async(context), context.autoescape
-            )
-        )
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's children."""
-        yield self.expression
-
-
-class Output(Tag):
-    """Pseudo "tag" to register output statements with the environment."""
-
-    name = TOKEN_OUTPUT
-    block = False
-    node_class = OutputNode
-
-    def parse(self, stream: TokenStream) -> OutputNode:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_OUTPUT)
-        expr_token = stream.expect(TOKEN_EXPRESSION)
-        return self.node_class(
-            token,
-            FilteredExpression.parse(
-                self.env, TokenStream(tokenize(expr_token.value, expr_token))
-            ),
-        )

liquid/builtin/tags/assign_tag.py

@@ -1,75 +0,0 @@
-"""The built-in _assign_ 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 FilteredExpression
-from liquid.builtin.expressions import Identifier
-from liquid.builtin.expressions import parse_identifier
-from liquid.tag import Tag
-from liquid.token import TOKEN_ASSIGN
-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_ASSIGN = sys.intern("assign")
-
-
-class AssignNode(Node):
-    """The built-in _assign_ tag."""
-
-    __slots__ = ("name", "expression")
-
-    def __init__(self, token: Token, *, name: Identifier, expression: Expression):
-        super().__init__(token)
-        self.name = name
-        self.expression = expression
-
-    def __str__(self) -> str:
-        return f"{{% assign {self.name} = {self.expression} %}}"
-
-    def render_to_output(self, context: RenderContext, _: TextIO) -> int:
-        """Render the node to the output buffer."""
-        context.assign(self.name, self.expression.evaluate(context))
-        return 0
-
-    async def render_to_output_async(self, context: RenderContext, _: TextIO) -> int:
-        """Render the node to the output buffer."""
-        context.assign(self.name, await self.expression.evaluate_async(context))
-        return 0
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        yield self.expression
-
-    def template_scope(self) -> Iterable[Identifier]:
-        """Return variables this node adds to the template local scope."""
-        yield self.name
-
-
-class AssignTag(Tag):
-    """The built-in _assign_ tag."""
-
-    name = TAG_ASSIGN
-    block = False
-    node_class = AssignNode
-
-    def parse(self, stream: TokenStream) -> AssignNode:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        tokens = stream.into_inner(tag=token, eat=False)
-        name = parse_identifier(self.env, tokens, allow_trailing_question_mark=False)
-        tokens.eat(TOKEN_ASSIGN)
-        return self.node_class(
-            token, name=name, expression=FilteredExpression.parse(self.env, tokens)
-        )

liquid/builtin/tags/capture_tag.py

@@ -1,98 +0,0 @@
-"""Parse tree node and tag definition for the built-in "capture" tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import TextIO
-
-from liquid import Markup
-from liquid.ast import BlockNode
-from liquid.ast import Node
-from liquid.builtin.expressions import parse_identifier
-from liquid.parser import get_parser
-from liquid.tag import Tag
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from io import StringIO
-
-    from liquid.builtin.expressions import Identifier
-    from liquid.context import RenderContext
-    from liquid.stream import TokenStream
-
-
-TAG_CAPTURE = sys.intern("capture")
-TAG_ENDCAPTURE = sys.intern("endcapture")
-
-ENDCAPTUREBLOCK = frozenset((TAG_ENDCAPTURE, TOKEN_EOF))
-
-
-class CaptureNode(Node):
-    """Parse tree node for the built-in "capture" tag."""
-
-    __slots__ = ("name", "block")
-
-    def __init__(self, token: Token, name: Identifier, block: BlockNode):
-        super().__init__(token)
-        self.name = name
-        self.block = block
-
-    def __str__(self) -> str:
-        return f"{{% capture {self.name} %}}{self.block}{{% endcapture %}}"
-
-    def _assign(self, context: RenderContext, buf: StringIO) -> None:
-        if context.autoescape:
-            context.assign(self.name, Markup(buf.getvalue()))
-        else:
-            context.assign(self.name, buf.getvalue())
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        buf = context.get_buffer(buffer)
-        self.block.render(context, buf)
-        self._assign(context, buf)
-        return False
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        buf = context.get_buffer(buffer)
-        await self.block.render_async(context, buf)
-        self._assign(context, buf)
-        return False
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        yield self.block
-
-    def template_scope(self) -> Iterable[Identifier]:
-        """Return variables this node adds to the template local scope."""
-        yield self.name
-
-
-class CaptureTag(Tag):
-    """The built-in capture tag."""
-
-    name = TAG_CAPTURE
-    end = TAG_ENDCAPTURE
-    node_class = CaptureNode
-
-    def parse(self, stream: TokenStream) -> CaptureNode:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        tokens = stream.into_inner(tag=token)
-        name = parse_identifier(self.env, tokens)
-        tokens.expect_eos()
-        block = get_parser(self.env).parse_block(stream, ENDCAPTUREBLOCK)
-        stream.expect(TOKEN_TAG, value=TAG_ENDCAPTURE)
-        return self.node_class(token, name, block)

liquid/builtin/tags/case_tag.py

@@ -1,287 +0,0 @@
-"""The built-in _case_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import TextIO
-from typing import Union
-
-from liquid.ast import BlockNode
-from liquid.ast import Node
-from liquid.builtin.expressions import parse_primitive
-from liquid.builtin.expressions.logical import _eq  # type: ignore
-from liquid.exceptions import LiquidSyntaxError
-from liquid.expression import Expression
-from liquid.parser import get_parser
-from liquid.tag import Tag
-from liquid.token import TOKEN_COMMA
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_OR
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid import Environment
-    from liquid import TokenStream
-    from liquid.context import RenderContext
-
-
-TAG_CASE = sys.intern("case")
-TAG_ENDCASE = sys.intern("endcase")
-TAG_WHEN = sys.intern("when")
-TAG_ELSE = sys.intern("else")
-
-ENDWHENBLOCK = frozenset((TAG_ENDCASE, TAG_WHEN, TAG_ELSE, TOKEN_EOF))
-ENDCASEBLOCK = frozenset((TAG_ENDCASE, TAG_ELSE))
-
-
-class CaseNode(Node):
-    """The built-in _case_ tag."""
-
-    __slots__ = ("blocks", "expression")
-
-    def __init__(
-        self,
-        token: Token,
-        expression: Expression,
-        blocks: list[Union[MultiExpressionBlockNode, BlockNode]],
-    ):
-        super().__init__(token)
-        self.expression = expression
-        self.blocks = blocks
-
-        self.blank = all(node.blank for node in self.blocks)
-
-        for node in self.blocks:
-            node.blank = self.blank
-            if isinstance(node, MultiExpressionBlockNode):
-                node.block.blank = self.blank
-
-    def __str__(self) -> str:
-        blocks: list[str] = []
-        for block in self.blocks:
-            if isinstance(block, BlockNode):
-                blocks.append(f"{{% else %}}{block}")
-            else:
-                blocks.append(str(block))
-
-        blocks_ = "".join(blocks)
-
-        return f"{{% case {self.expression} %}}\n{blocks_}{{% endcase %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        count = 0
-        default = True
-
-        for block in self.blocks:
-            # Always render truthy `when` blocks, no matter the order.
-            if isinstance(block, MultiExpressionBlockNode):
-                count_ = block.render(context, buffer)
-                if count_ >= 0:
-                    default = False
-                    count += count_
-            # Only render `else` blocks if all preceding `when` blocks are falsy.
-            # Multiple `else` blocks are OK.
-            elif default:
-                count += block.render(context, buffer)
-
-        return count
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        count = 0
-        default = True
-
-        for block in self.blocks:
-            # Always render truthy `when` blocks, no matter the order.
-            if isinstance(block, MultiExpressionBlockNode):
-                count_ = await block.render_async(context, buffer)
-                if count_ >= 0:
-                    default = False
-                    count += count_
-            # Only render `else` blocks if all preceding `when` blocks are falsy.
-            # Multiple `else` blocks are OK.
-            elif default:
-                count += await block.render_async(context, buffer)
-
-        return count
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        yield from self.blocks
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        yield self.expression
-
-
-class CaseTag(Tag):
-    """The built-in _case_ tag."""
-
-    name = TAG_CASE
-    end = TAG_ENDCASE
-    node_class = CaseNode
-
-    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)
-        tokens = stream.into_inner(tag=token)
-        left = parse_primitive(self.env, tokens)
-        tokens.expect_eos()
-
-        # Eat whitespace or junk between `case` and when/else/endcase
-        while (
-            stream.current.kind not in (TOKEN_TAG, TOKEN_EOF)
-            and stream.current.value not in ENDWHENBLOCK
-        ):
-            next(stream)
-
-        parse_block = get_parser(self.env).parse_block
-        blocks: list[Union[MultiExpressionBlockNode, BlockNode]] = []
-
-        while not stream.current.is_tag(TAG_ENDCASE):
-            if stream.current.is_tag(TAG_ELSE):
-                next(stream)
-                blocks.append(parse_block(stream, ENDWHENBLOCK))
-            elif stream.current.is_tag(TAG_WHEN):
-                alternative_token = next(stream)
-                expressions = self._parse_when_expression(
-                    stream.into_inner(tag=alternative_token)
-                )
-                alternative_block = parse_block(stream, ENDWHENBLOCK)
-
-                blocks.append(
-                    MultiExpressionBlockNode(
-                        alternative_token,
-                        alternative_block,
-                        _AnyExpression(alternative_token, left, expressions),
-                    )
-                )
-            else:
-                raise LiquidSyntaxError(
-                    f"unexpected tag {stream.current.value!r}", token=stream.current
-                )
-
-        stream.expect(TOKEN_TAG, TAG_ENDCASE)
-
-        return self.node_class(
-            token,
-            left,
-            blocks,
-        )
-
-    def _parse_when_expression(self, stream: TokenStream) -> list[Expression]:
-        expressions: list[Expression] = [parse_primitive(self.env, stream)]
-        while stream.current.kind in (TOKEN_COMMA, TOKEN_OR):
-            next(stream)
-            try:
-                expressions.append(parse_primitive(self.env, stream))
-            except LiquidSyntaxError:
-                # Use expressions we have so far an discard the rest.
-                return expressions
-
-        return expressions
-
-
-class _AnyExpression(Expression):
-    __slots__ = (
-        "left",
-        "expressions",
-    )
-
-    def __init__(
-        self, token: Token, left: Expression, expressions: list[Expression]
-    ) -> None:
-        super().__init__(token)
-        self.left = left
-        self.expressions = expressions
-
-    def __str__(self) -> str:
-        return ", ".join(str(expr) for expr in self.expressions)
-
-    def evaluate(self, context: RenderContext) -> list[bool]:
-        left = self.left.evaluate(context)
-        return [_eq(left, right.evaluate(context)) for right in self.expressions]
-
-    async def evaluate_async(self, context: RenderContext) -> list[bool]:
-        left = await self.left.evaluate_async(context)
-        return [
-            _eq(left, await right.evaluate_async(context)) for right in self.expressions
-        ]
-
-    def children(self) -> list[Expression]:
-        return self.expressions
-
-
-class MultiExpressionBlockNode(Node):
-    """A node containing a sequence of nodes guarded by a choice of expressions."""
-
-    __slots__ = ("block", "expression")
-
-    def __init__(
-        self,
-        token: Token,
-        block: BlockNode,
-        expression: _AnyExpression,
-    ) -> None:
-        super().__init__(token)
-        self.block = block
-        self.expression = expression
-        self.blank = self.block.blank
-
-    def __str__(self) -> str:
-        return f"{{% when {self.expression} %}}{self.block}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        matches = self.expression.evaluate(context)
-
-        if any(matches):
-            return sum(
-                [self.block.render(context, buffer) for _ in range(matches.count(True))]
-            )
-
-        return -1
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        matches = await self.expression.evaluate_async(context)
-
-        if any(matches):
-            return sum(
-                [
-                    await self.block.render_async(context, buffer)
-                    for _ in range(matches.count(True))
-                ]
-            )
-
-        return -1
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        yield self.block
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        yield self.expression