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

liquid/loaders/package_loader.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import asyncio
+import importlib.resources
+from pathlib import Path, PurePath
+from typing import TYPE_CHECKING
+
+from .._loader import Loader, TemplateSource
+from ..exceptions import TemplateNotFoundError
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from types import ModuleType
+
+    from .._context import RenderContext
+    from ..environment import Environment
+
+
+class PackageLoader(Loader):
+    """A template loader that reads templates from Python packages.
+
+    Parameters
+    ----------
+    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: str | ModuleType,
+        *,
+        package_path: 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, name: str) -> Path:
+        template_path = PurePath(name)
+        if template_path.anchor:
+            template_path = PurePath(*template_path.parts[1:])
+
+        # 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)
+
+        for path in self.paths:
+            with importlib.resources.as_file(path) as base:
+                base_resolved = base.resolve()
+                source_path: Path = (base_resolved / template_path).resolve()
+
+                if not source_path.is_relative_to(base_resolved):
+                    continue
+
+                if not source_path.is_file():
+                    continue
+
+                # We don't want to expose a fully qualified path in error messages.
+                return base / template_path
+
+        raise TemplateNotFoundError(name)
+
+    def get_source(
+        self,
+        env: Environment,
+        name: str,
+        context: RenderContext | None = None,
+        **kwargs: object,
+    ) -> TemplateSource:
+        source_path = self._resolve_path(name)
+        return TemplateSource(
+            text=source_path.read_text(self.encoding),
+            name=source_path.name,
+            path=str(source_path),
+        )
+
+    async def get_source_async(
+        self,
+        env: Environment,
+        name: str,
+        context: RenderContext | None = None,
+        **kwargs: object,
+    ) -> TemplateSource:
+        loop = asyncio.get_running_loop()
+
+        source_path = await loop.run_in_executor(None, self._resolve_path, name)
+
+        source_text = await loop.run_in_executor(
+            None, source_path.read_text, self.encoding
+        )
+
+        return TemplateSource(
+            text=source_text,
+            name=source_path.name,
+            path=str(source_path),
+        )

liquid/tags/__init__.py

@@ -0,0 +1,61 @@
+from .assign import AssignTag
+from .capture import CaptureTag
+from .case import CaseTag
+from .comment import CommentTag
+from .cycle import CycleTag
+from .decrement import DecrementTag
+from .doc import DocTag
+from .echo import EchoTag
+from .else_ import ElseBlock
+from .error import ErrorNode
+from .extends import BlockTag, ExtendsTag
+from .for_ import BreakTag, ContinueTag, ForTag
+from .if_ import IfTag
+from .ifchanged import IfChangedTag
+from .include import IncludeTag
+from .increment import IncrementTag
+from .inline_comment import InlineCommentTag
+from .liquid import LiquidTag
+from .macro import CallTag, MacroTag
+from .output import OutputStatement
+from .raw import RawTag
+from .render import RenderTag
+from .tablerow import TableRowTag
+from .template_comment import TemplateComment
+from .translate import TranslateTag
+from .unless import UnlessTag
+from .with_ import WithTag
+
+__all__ = (
+    "AssignTag",
+    "BlockTag",
+    "BreakTag",
+    "CallTag",
+    "CaptureTag",
+    "CaseTag",
+    "CommentTag",
+    "ContinueTag",
+    "CycleTag",
+    "DecrementTag",
+    "DocTag",
+    "EchoTag",
+    "ElseBlock",
+    "ErrorNode",
+    "ExtendsTag",
+    "ForTag",
+    "IfChangedTag",
+    "IfTag",
+    "IncludeTag",
+    "IncrementTag",
+    "InlineCommentTag",
+    "LiquidTag",
+    "MacroTag",
+    "OutputStatement",
+    "RawTag",
+    "RenderTag",
+    "TableRowTag",
+    "TemplateComment",
+    "TranslateTag",
+    "UnlessTag",
+    "WithTag",
+)

liquid/tags/assign.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..exceptions import LiquidSyntaxError
+from ..tokens import TOKEN_ASSIGN, TOKEN_TAG_END
+
+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 AssignTag:
+    blank = True
+    tag = "assign"
+
+    __slots__ = ("expression", "name", "token")
+
+    def __init__(self, token: Token, name: Name, expression: Expression) -> None:
+        self.token = token
+        self.name = name
+        self.expression = expression
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        name = parser.parse_identifier()
+
+        if name.value.endswith("?"):
+            raise LiquidSyntaxError(
+                "invalid variable name",
+                token=name.span,
+                source=parser.source,
+                name=parser.template_name,
+            )
+
+        parser.eat(TOKEN_ASSIGN, "bad identifier or missing '='")
+        expression = parser.parse_filtered_expression()
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        return AssignTag(token, name, expression)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        context.assign(self.name.value, self.expression.evaluate(context))
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        context.assign(self.name.value, await self.expression.evaluate_async(context))
+
+    def children(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 [self.name]
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []

liquid/tags/capture.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import markupsafe
+
+from .._markup import render_block, render_block_async
+from ..exceptions import LiquidSyntaxError
+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 CaptureTag:
+    blank = True
+    tag = "capture"
+
+    __slots__ = ("block", "name", "token")
+
+    def __init__(self, token: Token, name: Name, block: Block) -> None:
+        self.token = token
+        self.name = name
+        self.block = block
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        name = parser.parse_identifier()
+
+        if name.value.endswith("?"):
+            raise LiquidSyntaxError(
+                "invalid variable name",
+                token=name.span,
+                source=parser.source,
+                name=parser.template_name,
+            )
+
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        block = parser.parse_block(end=("endcapture",))
+        parser.eat_empty_tag("endcapture")
+        return CaptureTag(token, name, block)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buf = context.env.buffer_factory()
+        render_block(self.block, context, buf)
+
+        if context.env.autoescape:
+            context.assign(self.name.value, markupsafe.Markup(buf.getvalue()))
+        else:
+            context.assign(self.name.value, buf.getvalue())
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buf = context.env.buffer_factory()
+        await render_block_async(self.block, context, buf)
+        if context.env.autoescape:
+            context.assign(self.name.value, markupsafe.Markup(buf.getvalue()))
+        else:
+            context.assign(self.name.value, buf.getvalue())
+
+    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 [self.name]
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []

liquid/tags/case.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._markup import is_blank_block, render_block, render_block_async
+from ..tokens import (
+    TOKEN_COMMA,
+    TOKEN_OR,
+    TOKEN_TAG_END,
+    TOKEN_TAG_NAME,
+    TOKEN_TAG_START,
+    TOKEN_TEXT,
+)
+from .else_ import ElseBlock
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    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 CaseTag:
+    tag = "case"
+
+    __slots__ = ("blank", "blocks", "expression", "token")
+
+    def __init__(
+        self,
+        token: Token,
+        expression: Expression,
+        blocks: Sequence[WhenBlock | ElseBlock],
+    ) -> None:
+        self.token = token
+        self.expression = expression
+        self.blocks = blocks
+
+        self.blank = all(block.blank for block in blocks)
+
+        if self.blank:
+            # Discard blank strings from all blocks.
+            for block in blocks:
+                block.filter_strings()
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        parser.expect_expression()
+        expression = parser.parse_expression(expect_end_of_expression=True)
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        if parser.kind() == TOKEN_TEXT:
+            # Junk between `{% case %}` and first `{% when %}`.
+            parser.eat(TOKEN_TEXT)
+
+        blocks: list[WhenBlock | ElseBlock] = []
+
+        while 1:
+            tag_name = parser.tags(("when", "else"))
+
+            if tag_name == "when":
+                blocks.append(CaseTag.parse_when(parser))
+            elif tag_name == "else":
+                name_token = parser.eat_tag("else")
+                blocks.append(
+                    ElseBlock(
+                        name_token, parser.parse_block(("endcase", "when", "else"))
+                    )
+                )
+            else:
+                break
+
+        parser.eat_empty_tag("endcase")
+        return CaseTag(token, expression, blocks)
+
+    @staticmethod
+    def parse_when(parser: Parser) -> WhenBlock:
+        parser.eat(TOKEN_TAG_START)
+        parser.skip_whitespace_control()
+        token = parser.eat(TOKEN_TAG_NAME)
+
+        if parser.kind() == TOKEN_COMMA:
+            parser.next()
+
+        right: list[Expression] = []
+
+        while 1:
+            right.append(parser.parse_expression())
+
+            if parser.kind() not in (TOKEN_COMMA, TOKEN_OR):
+                break
+
+            parser.next()
+
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        block = parser.parse_block(("endcase", "when", "else"))
+        return WhenBlock(token, right, block)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        left = self.expression.evaluate(context)
+        alt = True
+
+        # NOTE: This does not stop at the first truthy expression, nor does it stop
+        # at the first `else` block.
+
+        for block in self.blocks:
+            if isinstance(block, ElseBlock):
+                if alt:
+                    block.render(context, buffer)
+                continue
+
+            for expr in block.right:
+                if context.env.eq(left, expr.evaluate(context), context, expr.span):
+                    alt = False
+                    block.render(context, buffer)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        left = await self.expression.evaluate_async(context)
+        alt = True
+
+        # NOTE: This does not stop at the first truthy expression, nor does it stop
+        # at the first `else` block.
+
+        for block in self.blocks:
+            if isinstance(block, ElseBlock):
+                if alt:
+                    await block.render_async(context, buffer)
+                continue
+
+            for expr in block.right:
+                if context.env.eq(
+                    left, await expr.evaluate_async(context), context, expr.span
+                ):
+                    alt = False
+                    await block.render_async(context, buffer)
+
+    def children(self) -> list[Markup]:
+        return list(self.blocks)
+
+    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 []
+
+
+class WhenBlock:
+    tag = "when"
+
+    def __init__(self, token: Token, right: list[Expression], block: Block) -> None:
+        self.token = token
+        self.right = right
+        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.right
+
+    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

liquid/tags/comment.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..tokens import TOKEN_COMMENT, TOKEN_TAG_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 CommentTag:
+    blank = True
+    tag = "comment"
+
+    __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)
+        comment = parser.eat(TOKEN_COMMENT)
+        parser.eat_empty_tag("endcomment")
+        return CommentTag(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 []

liquid/tags/cycle.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING
+
+from ..expressions import Variable
+from ..tokens import TOKEN_COLON, TOKEN_COMMA, TOKEN_TAG_END
+
+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 CycleTag:
+    blank = False
+    tag = "cycle"
+
+    __slots__ = ("group", "items", "static_key", "token")
+
+    def __init__(
+        self, token: Token, group: Expression | None, items: list[Expression]
+    ) -> None:
+        self.token = token
+        self.group = group
+        self.items = items
+        self.static_key = ""
+
+        if group is None:
+            # This mimics Shopify/liquid by giving every Variable a unique ID.
+            self.static_key = str(
+                [f"{i}:{id(i)}" if isinstance(i, Variable) else str(i) for i in items]
+            )
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        group: Expression | None = None
+        items: list[Expression] = []
+
+        first = parser.parse_expression()
+
+        if parser.kind() == TOKEN_COLON:
+            group = first
+            parser.next()
+        else:
+            items.append(first)
+
+        if parser.kind() == TOKEN_COMMA:
+            parser.next()
+
+        items.extend(parser.parse_positional_arguments())
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        return CycleTag(token, group, items)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        cycles = context.get_register("cycle", default=register_factory)
+        key = self.static_key
+
+        if self.group:
+            key = context.env.to_str(
+                self.group.evaluate(context),
+                context,
+                self.group.span,
+            )
+
+        index = cycles[key]
+
+        if index < len(self.items):
+            expr = self.items[index]
+            buffer.write(context.env.to_str(expr.evaluate(context), context, expr.span))
+
+        index += 1
+        if index >= len(self.items):
+            index = 0
+
+        cycles[key] = index
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        cycles = context.get_register("cycle", default=register_factory)
+        key = self.static_key
+
+        if self.group:
+            key = context.env.to_str(
+                await self.group.evaluate_async(context),
+                context,
+                self.group.span,
+            )
+
+        index = cycles[key]
+
+        if index < len(self.items):
+            expr = self.items[index]
+
+            buffer.write(
+                context.env.to_str(
+                    await expr.evaluate_async(context), context, expr.span
+                )
+            )
+
+        index += 1
+        if index >= len(self.items):
+            index = 0
+
+        cycles[key] = index
+
+    def children(self) -> list[Markup]:
+        return []
+
+    def expressions(self) -> list[Expression]:
+        return [self.group, *self.items] if self.group else self.items
+
+    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)