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

liquid/builtin/content.py

@@ -1,41 +0,0 @@
-"""Pseudo tag and node definition for template content."""
-
-from typing import TextIO
-
-from liquid.ast import Node
-from liquid.context import RenderContext
-from liquid.stream import TokenStream
-from liquid.tag import Tag
-from liquid.token import TOKEN_CONTENT
-from liquid.token import Token
-
-
-class ContentNode(Node):
-    """Parse tree node for template content."""
-
-    __slots__ = ("text",)
-
-    def __init__(self, token: Token, text: str):
-        super().__init__(token)
-        self.blank = not text or text.isspace()
-        self.text = text
-
-    def __str__(self) -> str:
-        return self.text
-
-    def render_to_output(self, _: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        return buffer.write(self.text)
-
-
-class Literal(Tag):
-    """Pseudo "tag" for template content."""
-
-    name = TOKEN_CONTENT
-    block = False
-    node_class = ContentNode
-
-    def parse(self, stream: TokenStream) -> ContentNode:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.expect(TOKEN_CONTENT)
-        return self.node_class(token, token.value)

liquid/builtin/drops/__init__.py

@@ -1,3 +0,0 @@
-from .drops import IterableDrop  # noqa: D104
-
-__all__ = ("IterableDrop",)

liquid/builtin/drops/drops.py

@@ -1,13 +0,0 @@
-"""Legacy iterable drop base class."""
-from abc import ABC
-from abc import abstractmethod
-from typing import Any
-from typing import Collection
-
-
-class IterableDrop(ABC, Collection[Any]):
-    """Base class for drops that can be iterated with `include` and `render` tags."""
-
-    @abstractmethod
-    def step(self, item: Any) -> None:
-        """Step the iterator."""

liquid/builtin/expressions/__init__.py

@@ -1,47 +0,0 @@
-from ._tokenize import tokenize  # noqa: D104
-from .arguments import KeywordArgument  # noqa: D104
-from .arguments import Parameter
-from .arguments import PositionalArgument
-from .arguments import parse_arguments
-from .filtered import Filter
-from .filtered import FilteredExpression
-from .filtered import TernaryFilteredExpression
-from .logical import BooleanExpression
-from .loop import LoopExpression
-from .path import Location
-from .path import Path
-from .path import Segments
-from .primitive import Identifier
-from .primitive import Literal
-from .primitive import Nil
-from .primitive import StringLiteral
-from .primitive import is_empty
-from .primitive import parse_identifier
-from .primitive import parse_name
-from .primitive import parse_primitive
-from .primitive import parse_string_or_path
-
-__all__ = (
-    "BooleanExpression",
-    "FilteredExpression",
-    "Identifier",
-    "is_empty",
-    "KeywordArgument",
-    "Literal",
-    "Location",
-    "LoopExpression",
-    "Nil",
-    "parse_arguments",
-    "parse_identifier",
-    "parse_primitive",
-    "parse_string_or_path",
-    "Path",
-    "PositionalArgument",
-    "Segments",
-    "StringLiteral",
-    "TernaryFilteredExpression",
-    "tokenize",
-    "parse_name",
-    "Parameter",
-    "Filter",
-)

liquid/builtin/expressions/_tokenize.py

@@ -1,186 +0,0 @@
-"""Tokenize a liquid expression."""
-
-import re
-import sys
-from typing import Iterator
-
-from liquid.exceptions import LiquidSyntaxError
-from liquid.token import TOKEN_AND
-from liquid.token import TOKEN_AS
-from liquid.token import TOKEN_BLANK
-from liquid.token import TOKEN_COLON
-from liquid.token import TOKEN_COLS
-from liquid.token import TOKEN_COMMA
-from liquid.token import TOKEN_CONTAINS
-from liquid.token import TOKEN_CONTINUE
-from liquid.token import TOKEN_DOT
-from liquid.token import TOKEN_DPIPE
-from liquid.token import TOKEN_ELSE
-from liquid.token import TOKEN_EMPTY
-from liquid.token import TOKEN_FALSE
-from liquid.token import TOKEN_FLOAT
-from liquid.token import TOKEN_FOR
-from liquid.token import TOKEN_IDENTINDEX
-from liquid.token import TOKEN_IDENTSTRING
-from liquid.token import TOKEN_IF
-from liquid.token import TOKEN_ILLEGAL
-from liquid.token import TOKEN_IN
-from liquid.token import TOKEN_INTEGER
-from liquid.token import TOKEN_LBRACKET
-from liquid.token import TOKEN_LIMIT
-from liquid.token import TOKEN_LPAREN
-from liquid.token import TOKEN_NIL
-from liquid.token import TOKEN_NOT
-from liquid.token import TOKEN_NULL
-from liquid.token import TOKEN_OFFSET
-from liquid.token import TOKEN_OR
-from liquid.token import TOKEN_PIPE
-from liquid.token import TOKEN_RANGE
-from liquid.token import TOKEN_RANGE_LITERAL
-from liquid.token import TOKEN_RBRACKET
-from liquid.token import TOKEN_REQUIRED
-from liquid.token import TOKEN_REVERSED
-from liquid.token import TOKEN_RPAREN
-from liquid.token import TOKEN_SKIP
-from liquid.token import TOKEN_STRING
-from liquid.token import TOKEN_TRUE
-from liquid.token import TOKEN_WITH
-from liquid.token import TOKEN_WORD
-from liquid.token import Token
-from liquid.token import operators
-
-GROUP_QUOTE = sys.intern("quote")
-GROUP_QUOTED = sys.intern("quoted")
-GROUP_IDENTINDEX = sys.intern("path_index")
-GROUP_IDENTQUOTE = sys.intern("identquote")
-GROUP_IDENTQUOTED = sys.intern("identquoted")
-
-# The reference implementation will accept identifiers that start with an integer or
-# hyphen when in lax mode, but will raise a syntax error in strict mode. For historic
-# reasons we'll stick the following pattern until at least version 2 of Python Liquid.
-IDENTIFIER_PATTERN = r"\w[\w\-]*\??"
-
-# Trailing ? is not allowed in assignment names
-ASSIGN_IDENTIFIER_PATTERN = r"\w[\w\-]*"
-
-# ["ident"] or ['ident']
-IDENTSTRING_PATTERN = (
-    rf"\[\s*(?P<{GROUP_IDENTQUOTE}>[\"'])"
-    rf"(?P<{GROUP_IDENTQUOTED}>.*?)"
-    rf"(?P={GROUP_IDENTQUOTE})\s*]"
-)
-
-# [0] or [-1]
-IDENTINDEX_PATTERN = rf"\[\s*(?P<{GROUP_IDENTINDEX}>\-?\d+)\s*]"
-
-# 'something' or "something"
-STRING_PATTERN = rf"(?P<{GROUP_QUOTE}>[\"'])(?P<{GROUP_QUOTED}>.*?)(?P={GROUP_QUOTE})"
-
-# Rules for the standard boolean expression.
-# Does not support grouping with parentheses.
-_rules = (
-    (TOKEN_RANGE_LITERAL, r"\((?=.+?\.\.)"),
-    (TOKEN_IDENTINDEX, IDENTINDEX_PATTERN),
-    (TOKEN_IDENTSTRING, IDENTSTRING_PATTERN),
-    (TOKEN_STRING, STRING_PATTERN),
-    (TOKEN_RANGE, r"\.\."),
-    (TOKEN_FLOAT, r"-?\d+\.(?!\.)\d*"),
-    (TOKEN_INTEGER, r"-?\d+\b"),
-    (TOKEN_DOT, r"\."),
-    (TOKEN_WORD, IDENTIFIER_PATTERN),
-    (TOKEN_LPAREN, r"\("),
-    (TOKEN_RPAREN, r"\)"),
-    (TOKEN_LBRACKET, r"\["),
-    (TOKEN_RBRACKET, r"]"),
-    (TOKEN_COLON, r":"),
-    (TOKEN_COMMA, r","),
-    (TOKEN_DPIPE, r"\|\|"),
-    (TOKEN_PIPE, r"\|"),
-    ("OP", r"[!=<>]{1,2}"),
-    (TOKEN_SKIP, r"[ \n\t\r]+"),
-    (TOKEN_ILLEGAL, r"."),
-)
-
-# Keywords for the standard boolean expression.
-# Excludes `not`.
-_keywords = frozenset(
-    [
-        TOKEN_TRUE,
-        TOKEN_FALSE,
-        TOKEN_NIL,
-        TOKEN_NULL,
-        TOKEN_EMPTY,
-        TOKEN_BLANK,
-        TOKEN_AND,
-        TOKEN_OR,
-        TOKEN_CONTAINS,
-        TOKEN_NOT,
-        TOKEN_IN,
-        TOKEN_OFFSET,
-        TOKEN_LIMIT,
-        TOKEN_REVERSED,
-        TOKEN_COLS,
-        TOKEN_CONTINUE,
-        TOKEN_WITH,
-        TOKEN_FOR,
-        TOKEN_AS,
-        TOKEN_IF,
-        TOKEN_ELSE,
-        TOKEN_REQUIRED,
-    ]
-)
-
-_RE = re.compile(
-    "|".join(f"(?P<{name}>{pattern})" for name, pattern in _rules),
-    re.DOTALL,
-)
-
-
-def tokenize(source: str, parent_token: Token) -> Iterator[Token]:
-    """Tokenize a liquid expression."""
-    for match in _RE.finditer(source):
-        kind = match.lastgroup
-        assert kind is not None
-
-        value = match.group()
-
-        if kind == TOKEN_WORD and value in _keywords:
-            kind = value
-        elif kind == TOKEN_IDENTINDEX:
-            value = match.group(GROUP_IDENTINDEX)
-        elif kind == TOKEN_IDENTSTRING:
-            value = match.group(GROUP_IDENTQUOTED)
-        elif kind == TOKEN_STRING:
-            value = match.group(GROUP_QUOTED)
-        elif kind == "OP":
-            try:
-                kind = operators[value]
-            except KeyError as err:
-                raise LiquidSyntaxError(
-                    f"unknown operator {value!r}",
-                    token=Token(
-                        kind,
-                        value,
-                        start_index=parent_token.start_index + match.start(),
-                        source=parent_token.source,
-                    ),
-                ) from err
-        elif kind == TOKEN_SKIP:
-            continue
-        elif kind == TOKEN_ILLEGAL:
-            raise LiquidSyntaxError(
-                f"unexpected {value!r}",
-                token=Token(
-                    kind,
-                    value,
-                    start_index=parent_token.start_index + match.start(),
-                    source=parent_token.source,
-                ),
-            )
-
-        yield Token(
-            kind,
-            value,
-            start_index=parent_token.start_index + match.start(),
-            source=parent_token.source,
-        )

liquid/builtin/expressions/arguments.py

@@ -1,207 +0,0 @@
-"""Tag expression argument helpers."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from liquid import Mode
-from liquid.exceptions import LiquidSyntaxError
-from liquid.token import TOKEN_ASSIGN
-from liquid.token import TOKEN_COLON
-from liquid.token import TOKEN_COMMA
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_WORD
-
-from .primitive import parse_primitive
-
-if TYPE_CHECKING:
-    from liquid import Environment
-    from liquid import RenderContext
-    from liquid import Token
-    from liquid import TokenStream
-    from liquid.expression import Expression
-
-
-class KeywordArgument:
-    """A name/value pair."""
-
-    __slots__ = ("token", "name", "value")
-
-    def __init__(self, token: Token, name: str, value: Expression) -> None:
-        self.token = token
-        self.name = name
-        self.value = value
-
-    def __str__(self) -> str:
-        return f"{self.name}:{self.value}"
-
-    def evaluate(self, context: RenderContext) -> tuple[str, object]:
-        return (self.name, self.value.evaluate(context))
-
-    async def evaluate_async(self, context: RenderContext) -> tuple[str, object]:
-        return (self.name, await self.value.evaluate_async(context))
-
-    @staticmethod
-    def parse(env: Environment, tokens: TokenStream) -> list[KeywordArgument]:
-        """Parse a keyword arguments from _tokens_."""
-        argument_separators = (
-            (TOKEN_COLON, TOKEN_ASSIGN) if env.keyword_assignment else (TOKEN_COLON,)
-        )
-
-        args: list[KeywordArgument] = []
-
-        # Leading commas are OK
-        if tokens.current.kind == TOKEN_COMMA:
-            next(tokens)
-
-        while True:
-            token = next(tokens)
-
-            if token.kind == TOKEN_COMMA:
-                token = next(tokens)
-
-            if token.kind == TOKEN_EOF:
-                break
-
-            if token.kind == TOKEN_WORD:
-                tokens.eat_one_of(*argument_separators)
-                value = parse_primitive(env, tokens)
-                args.append(KeywordArgument(token, token.value, value))
-                if env.mode == Mode.STRICT and tokens.current.kind == TOKEN_WORD:
-                    raise LiquidSyntaxError(
-                        "expected a comma separated list of arguments, "
-                        f"found {tokens.current.kind}",
-                        token=tokens.current,
-                    )
-            else:
-                raise LiquidSyntaxError(
-                    f"expected an argument name, found {token.kind}", token=token
-                )
-
-        return args
-
-
-class PositionalArgument:
-    """Just a value."""
-
-    __slots__ = (
-        "token",
-        "value",
-    )
-
-    def __init__(self, value: Expression) -> None:
-        self.token = value.token
-        self.value = value
-
-    def __str__(self) -> str:
-        return str(self.value)
-
-    def evaluate(self, context: RenderContext) -> tuple[None, object]:
-        return (None, self.value.evaluate(context))
-
-    async def evaluate_async(self, context: RenderContext) -> tuple[None, object]:
-        return (None, await self.value.evaluate_async(context))
-
-    @staticmethod
-    def parse(env: Environment, tokens: TokenStream) -> list[PositionalArgument]:
-        """Parse a positional arguments from _tokens_."""
-        args: list[PositionalArgument] = []
-
-        while True:
-            if tokens.current.kind == TOKEN_COMMA:
-                next(tokens)
-
-            if tokens.current.kind == TOKEN_EOF:
-                break
-
-            args.append(PositionalArgument(parse_primitive(env, tokens)))
-
-        return args
-
-
-class Parameter:
-    """A name, possibly with a default value."""
-
-    __slots__ = ("token", "name", "value")
-
-    def __init__(self, token: Token, name: str, value: Expression | None) -> None:
-        self.token = token
-        self.name = name
-        self.value = value
-
-    def __str__(self) -> str:
-        return f"{self.name}:{self.value}" if self.value else self.name
-
-    @staticmethod
-    def parse(env: Environment, tokens: TokenStream) -> dict[str, Parameter]:
-        """Parse macro tag parameters from _tokens_."""
-        params: dict[str, Parameter] = {}
-        argument_separators = (
-            (TOKEN_COLON, TOKEN_ASSIGN) if env.keyword_assignment else (TOKEN_COLON,)
-        )
-
-        while True:
-            token = next(tokens)
-
-            if token.kind == TOKEN_COMMA:
-                # Leading and/or trailing commas are OK.
-                token = next(tokens)
-
-            if token.kind == TOKEN_EOF:
-                break
-
-            if token.kind == TOKEN_WORD:
-                if tokens.current.kind in argument_separators:
-                    # A parameter with a default value
-                    next(tokens)  # Move past ":" or "="
-                    value = parse_primitive(env, tokens)
-                    params[token.value] = Parameter(token, token.value, value)
-                else:
-                    params[token.value] = Parameter(token, token.value, None)
-            else:
-                raise LiquidSyntaxError(
-                    f"expected a parameter list, found {token.kind}",
-                    token=token,
-                )
-
-        return params
-
-
-def parse_arguments(
-    env: Environment, tokens: TokenStream
-) -> tuple[list[PositionalArgument], list[KeywordArgument]]:
-    """Parse arguments from _tokens_ until end of input."""
-    args: list[PositionalArgument] = []
-    kwargs: list[KeywordArgument] = []
-    argument_separators = (
-        (TOKEN_COLON, TOKEN_ASSIGN) if env.keyword_assignment else (TOKEN_COLON,)
-    )
-
-    # Leading commas are OK
-    if tokens.current.kind == TOKEN_COMMA:
-        next(tokens)
-
-    while True:
-        token = tokens.current
-
-        if token.kind == TOKEN_EOF:
-            break
-
-        if token.kind == TOKEN_WORD:
-            if tokens.peek.kind in argument_separators:
-                name_token = next(tokens)
-                next(tokens)  # = or :
-                value = parse_primitive(env, tokens)
-                kwargs.append(KeywordArgument(name_token, token.value, value))
-            else:
-                args.append(PositionalArgument(parse_primitive(env, tokens)))
-        else:
-            # A primitive as a positional argument
-            args.append(PositionalArgument(parse_primitive(env, tokens)))
-
-        if tokens.current.kind != TOKEN_COMMA:
-            break
-
-        tokens.eat(TOKEN_COMMA)
-
-    return args, kwargs