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

liquid/messages.py

@@ -1,357 +0,0 @@
-"""Translation related objects and message extraction."""
-
-from __future__ import annotations
-
-import os
-from abc import ABC
-from abc import abstractmethod
-from pathlib import Path
-from typing import TYPE_CHECKING
-from typing import Any
-from typing import Callable
-from typing import Iterable
-from typing import Iterator
-from typing import NamedTuple
-from typing import Protocol
-from typing import Union
-
-from babel.messages import Catalog
-
-from .builtin.expressions import Filter
-from .builtin.expressions import FilteredExpression
-from .builtin.expressions import TernaryFilteredExpression
-from .builtin.tags.comment_tag import CommentNode
-from .context import RenderContext
-from .token import TOKEN_TAG
-from .token import Token
-
-if TYPE_CHECKING:
-    from .ast import Node
-    from .environment import Environment
-    from .expression import Expression
-    from .template import BoundTemplate
-
-
-DEFAULT_KEYWORDS = {
-    "t": None,
-    "trans": None,
-    "translate": None,
-    "gettext": None,
-    "ngettext": (1, 2),
-    "pgettext": ((1, "c"), 2),
-    "npgettext": ((1, "c"), 2, 3),
-}
-
-DEFAULT_COMMENT_TAGS = [
-    "Translators:",
-]
-
-
-class Translations(Protocol):
-    """Message catalog interface.
-
-    An object implementing this protocol is expected to be available in
-    a render context.
-
-    Could be a `GNUTranslations` instance from the `gettext` module,
-    a Babel `Translations` object, or any object implementing `gettext`,
-    `ngettext`, `pgettext` and `npgettext` methods.
-    """
-
-    def gettext(self, message: str) -> str:
-        """Lookup the message in the catalog."""
-
-    def ngettext(self, singular: str, plural: str, n: int) -> str:
-        """Do plural-forms message lookup."""
-
-    def pgettext(self, context: str, message: str) -> str:
-        """Lookup the context and message in the catalog."""
-
-    def npgettext(self, context: str, singular: str, plural: str, n: int) -> str:
-        """Do plural-forms context and message lookup."""
-
-
-MESSAGES = Union[
-    str,
-    tuple[str, ...],
-    tuple[tuple[str, str], str],
-    tuple[tuple[str, str], str, str],
-]
-
-SPEC = Union[
-    tuple[int, ...],
-    tuple[tuple[int, str], int],
-    tuple[tuple[int, str], int, int],
-]
-
-
-class MessageTuple(NamedTuple):
-    """The tuple expected to be returned from babel extraction methods."""
-
-    lineno: int
-    funcname: str
-    message: MESSAGES
-    comments: list[str]
-
-
-class MessageText(NamedTuple):
-    """Partial message tuple returned from translatable tags."""
-
-    lineno: int
-    funcname: str
-    message: MESSAGES
-
-
-class TranslatableTag(ABC):
-    """Base class for translatable tags."""
-
-    @abstractmethod
-    def messages(self) -> Iterable[MessageText]:
-        """Generate a sequence of translation messages."""
-
-
-class TranslatableFilter(ABC):
-    """Base class for translatable filters."""
-
-    @abstractmethod
-    def message(
-        self,
-        left: Expression,
-        _filter: Filter,
-        lineno: int,
-    ) -> MessageText | None:
-        """Return a translation message."""
-
-
-def extract_from_templates(
-    *templates: BoundTemplate,
-    keywords: dict[str, Any] | None = None,
-    comment_tags: list[str] | None = None,
-    strip_comment_tags: bool = False,
-) -> Catalog:
-    """Extract messages from one or more templates.
-
-    This function returns a single `babel.messages.Catalog` containing
-    messages from all the given templates.
-
-    Args:
-        templates: templates to extract messages from.
-        keywords: a Babel compatible mapping of translatable "function"
-            names to argument specs. The included translation filters and tag
-            transform their messages into typical *gettext format, regardless
-            of their names.
-        comment_tags: a list of translator tags to search for and
-            include in extracted messages.
-        strip_comment_tags: if `True`, remove comment tags from collected
-            message comments.
-    """
-    keywords = keywords or DEFAULT_KEYWORDS
-    comment_tags = comment_tags or DEFAULT_COMMENT_TAGS
-    catalog = Catalog()
-    for template in templates:
-        for lineno, funcname, messages, comments in extract_from_template(
-            template, keywords, comment_tags
-        ):
-            # A partial reimplementation of Babel's messages.extract function.
-            # See https://github.com/python-babel/babel/blob/master/babel/messages/extract.py#L262
-            spec: SPEC = keywords[funcname] or (1,)
-            if not isinstance(messages, (list, tuple)):
-                messages = (messages,)  # noqa: PLW2901
-            if not messages:
-                continue
-            if len(spec) != len(messages):
-                continue
-
-            # Assumes context is the first item in the spec
-            if isinstance(spec[0], tuple):
-                # context aware message
-                context = messages[spec[0][0] - 1][0]
-                message = [messages[i - 1] for i in spec[1:]]
-            else:
-                context = None
-                message = [messages[i - 1] for i in spec if isinstance(i, int)]
-
-            if not message[0]:
-                # Empty message
-                continue
-
-            if strip_comment_tags:
-                comments = _strip_comment_tags(comments, comment_tags)  # noqa: PLW2901
-
-            # Use the template's path if it has one
-            template_name = template.name
-            if isinstance(template.path, Path):
-                template_name = str(template.path.joinpath(template_name))
-            elif isinstance(template.path, str):
-                template_name = os.path.join(template.path, template_name)
-
-            catalog.add(
-                message[0] if len(message) == 1 else message,  # type: ignore
-                "",
-                [(template_name, lineno)],
-                auto_comments=comments,
-                context=context,
-            )
-
-    return catalog
-
-
-def extract_from_template(
-    template: BoundTemplate,
-    keywords: Union[list[str], dict[str, Any], None] = None,
-    comment_tags: list[str] | None = None,
-) -> Iterator[MessageTuple]:
-    """Extract translation messages from a Liquid template."""
-    _comment_tags = comment_tags or DEFAULT_COMMENT_TAGS
-    _comments: list[tuple[int, str]] = []
-    _keywords = keywords or DEFAULT_KEYWORDS
-    ctx = RenderContext(template)
-
-    _line_number = line_number_factory(template.nodes[0].token.source)
-
-    def visit_expression(expr: Expression, lineno: int) -> Iterator[MessageTuple]:
-        if isinstance(expr, (FilteredExpression, TernaryFilteredExpression)):
-            for _lineno, funcname, message in _extract_from_filters(
-                template.env, expr, lineno, _keywords
-            ):
-                if _comments and _comments[-1][0] < lineno - 1:
-                    _comments.clear()
-
-                yield MessageTuple(
-                    lineno=_lineno,
-                    funcname=funcname,
-                    message=message,
-                    comments=[text for _, text in _comments],
-                )
-                _comments.clear()
-
-        for expression in expr.children():
-            yield from visit_expression(expression, lineno)
-
-    def visit(node: Node) -> Iterator[MessageTuple]:
-        token = node.token
-        lineno = _line_number(token)
-        if isinstance(node, CommentNode) and node.text is not None:
-            comment_text = node.text.strip()
-            for comment_tag in _comment_tags:
-                if comment_text.startswith(comment_tag):
-                    # Our multi-line comments are wrapped in a tag, so we're
-                    # only ever going to have one comment text object to deal
-                    # with.
-                    _comments.clear()
-                    _comments.append((lineno, comment_text))
-                    break
-        elif (
-            token.kind == TOKEN_TAG
-            and token.value in _keywords
-            and isinstance(node, TranslatableTag)
-        ):
-            for lineno, funcname, message in node.messages():
-                if _comments and _comments[-1][0] < lineno - 1:
-                    _comments.clear()
-
-                yield MessageTuple(
-                    lineno=lineno,
-                    funcname=funcname,
-                    message=message,
-                    comments=[text for _, text in _comments],
-                )
-                _comments.clear()
-
-        for child in node.children(ctx, include_partials=False):
-            for expr in child.expressions():
-                yield from visit_expression(expr, _line_number(expr.token))
-            yield from visit(child)
-
-    for node in template.nodes:
-        for expr in node.expressions():
-            yield from visit_expression(expr, _line_number(expr.token))
-        yield from visit(node)
-
-
-def _extract_from_filters(
-    environment: Environment,
-    expression: FilteredExpression | TernaryFilteredExpression,
-    lineno: int,
-    keywords: Union[list[str], dict[str, Any]],
-) -> Iterable[MessageText]:
-    if isinstance(expression, FilteredExpression) and expression.filters:
-        first_filter = expression.filters[0]
-        if first_filter.name in keywords:
-            filter_callable = environment.filters.get(first_filter.name)
-            if isinstance(filter_callable, TranslatableFilter):  # noqa: SIM102
-                if message := filter_callable.message(  # type: ignore
-                    expression.left,
-                    first_filter,
-                    lineno,
-                ):
-                    yield message
-
-    if isinstance(expression, TernaryFilteredExpression):
-        yield from _extract_from_filters(environment, expression.left, lineno, keywords)
-
-        if expression.filters and expression.alternative:
-            first_filter = expression.filters[0]
-            if first_filter.name in keywords:
-                filter_callable = environment.filters.get(first_filter.name)
-                if isinstance(filter_callable, TranslatableFilter):  # noqa: SIM102
-                    if message := filter_callable.message(  # type: ignore
-                        expression.alternative,
-                        first_filter,
-                        lineno,
-                    ):
-                        yield message
-
-
-def _strip_comment_tags(comments: list[str], tags: list[str]) -> list[str]:
-    """Similar to Babel's messages.extract._strip_comment_tags."""
-
-    def _strip(line: str) -> str:
-        for tag in tags:
-            if line.startswith(tag):
-                return line[len(tag) :].strip()
-        return line
-
-    return [_strip(comment) for comment in comments]
-
-
-def line_number(token: Token) -> int:
-    """Return _token_'s line number."""
-    lines = token.source.splitlines(keepends=True)
-    cumulative_length = 0
-    target_line_index = -1
-
-    for i, line in enumerate(lines):
-        cumulative_length += len(line)
-        if token.start_index < cumulative_length:
-            target_line_index = i
-            break
-
-    if target_line_index == -1:
-        raise ValueError("index is out of bounds for the given string")
-
-    # Line number (1-based)
-    return target_line_index + 1
-
-
-def line_number_factory(source: str) -> Callable[[Token], int]:
-    """Return a function for looking up token line numbers in _source_."""
-    lines = source.splitlines(keepends=True)
-
-    def _line_number(token: Token) -> int:
-        cumulative_length = 0
-        target_line_index = -1
-
-        for i, line in enumerate(lines):
-            cumulative_length += len(line)
-            if token.start_index < cumulative_length:
-                target_line_index = i
-                break
-
-        if target_line_index == -1:
-            raise ValueError("index is out of bounds for the given string")
-
-        # Line number (1-based)
-        return target_line_index + 1
-
-    return _line_number

liquid/mode.py

@@ -1,12 +0,0 @@
-"""Template error tolerance modes."""
-
-from enum import IntEnum
-from enum import auto
-
-
-class Mode(IntEnum):
-    """Template error tolerance mode."""
-
-    LAX = auto()
-    WARN = auto()
-    STRICT = auto()

liquid/output.py

@@ -1,35 +0,0 @@
-"""Template output streams."""
-
-from io import StringIO
-from typing import Optional
-
-from liquid.exceptions import OutputStreamLimitError
-
-
-class LimitedStringIO(StringIO):
-    """A StringIO subclass that limits the number of bytes that can be written."""
-
-    def __init__(
-        self,
-        limit: int,
-        initial_value: Optional[str] = None,
-        newline: Optional[str] = None,
-    ) -> None:
-        super().__init__(initial_value, newline)
-        self.limit = limit
-        self.size = 0
-
-    def write(self, __s: str) -> int:  # noqa: D102
-        if __s:
-            self.size += len(__s.encode("utf-8"))
-            if self.size > self.limit:
-                raise OutputStreamLimitError("output stream limit reached", token=None)
-        return super().write(__s)
-
-
-class NullIO(StringIO):
-    """A StringIO subclass that is a null op. It doesn't write anything."""
-
-    def write(self, _s: str) -> int:
-        """Pretend to write the string to the stream."""
-        return 0

liquid/parser.py

@@ -1,119 +0,0 @@
-"""Liquid template parser."""
-
-from __future__ import annotations
-
-from functools import lru_cache
-from typing import TYPE_CHECKING
-from typing import Container
-from typing import Iterator
-
-from .ast import BlockNode
-from .ast import Node
-from .exceptions import BlockNestingError
-from .exceptions import LiquidError
-from .token import TOKEN_COMMENT
-from .token import TOKEN_CONTENT
-from .token import TOKEN_DOC
-from .token import TOKEN_EOF
-from .token import TOKEN_ILLEGAL
-from .token import TOKEN_OUTPUT
-from .token import TOKEN_TAG
-
-if TYPE_CHECKING:
-    from .environment import Environment
-    from .stream import TokenStream
-
-
-class Parser:
-    """A Liquid template parser. Create a parse tree from a stream of tokens."""
-
-    __slots__ = ("env",)
-
-    def __init__(self, env: Environment):
-        self.env = env
-
-    def parse(self, stream: TokenStream) -> list[Node]:
-        """Parse tokens from _stream_ into a list of nodes."""
-        return list(self._parse(stream))
-
-    def _parse(self, stream: TokenStream) -> Iterator[Node]:
-        tags = self.env.tags
-        illegal = tags[TOKEN_ILLEGAL]
-        content = tags[TOKEN_CONTENT]
-        output = tags[TOKEN_OUTPUT]
-
-        while stream.current.kind != TOKEN_EOF:
-            token = stream.current
-            kind = token.kind
-
-            try:
-                if kind == TOKEN_OUTPUT:
-                    yield output.get_node(stream)
-                elif kind == TOKEN_DOC:
-                    yield tags.get(TOKEN_DOC, illegal).get_node(stream)
-                elif stream.current.kind == TOKEN_TAG:
-                    yield tags.get(token.value, illegal).get_node(stream)
-                elif kind == "COMMENT":
-                    yield tags.get(TOKEN_COMMENT, illegal).get_node(stream)
-                else:
-                    yield content.get_node(stream)
-            except LiquidError as err:
-                self.env.error(err, token=stream.current)
-
-            next(stream)
-
-    def parse_block(self, stream: TokenStream, end: Container[str]) -> BlockNode:
-        """Parse tokens from _stream_ until we reach a token in _end_."""
-        tags = self.env.tags
-        illegal = tags[TOKEN_ILLEGAL]
-        content = tags[TOKEN_CONTENT]
-        output = tags[TOKEN_OUTPUT]
-
-        nodes: list[Node] = []
-        stream.block_depth += 1
-
-        if stream.block_depth > self.env.block_nesting_limit:
-            raise BlockNestingError("block nesting limit reached", token=None)
-
-        while stream.current.kind != TOKEN_EOF:
-            if stream.current.kind == TOKEN_TAG and stream.current.value in end:
-                break
-            token = stream.current
-            kind = token.kind
-
-            try:
-                if kind == TOKEN_OUTPUT:
-                    nodes.append(output.get_node(stream))
-                elif kind == TOKEN_DOC:
-                    nodes.append(tags.get(TOKEN_DOC, illegal).get_node(stream))
-                elif stream.current.kind == TOKEN_TAG:
-                    nodes.append(tags.get(token.value, illegal).get_node(stream))
-                elif kind == "COMMENT":
-                    nodes.append(tags.get(TOKEN_COMMENT, illegal).get_node(stream))
-                else:
-                    nodes.append(content.get_node(stream))
-            except LiquidError as err:
-                self.env.error(err, token=stream.current)
-
-            next(stream)
-
-        stream.block_depth -= 1
-        return BlockNode(stream.current, nodes)
-
-
-def eat_block(stream: TokenStream, end: Container[str]) -> None:
-    """Advance the stream until we reach a token in _end_.
-
-    This is used to discard blocks after a syntax error is found, in the hope
-    that we can continue to parse more of the stream after the offending block.
-    """
-    while stream.current.kind != TOKEN_EOF:
-        if stream.current.kind == TOKEN_TAG and stream.current.value in end:
-            break
-        next(stream)
-
-
-@lru_cache(maxsize=128)
-def get_parser(env: Environment) -> Parser:
-    """Return a template parser for the given environment."""
-    return Parser(env)

liquid/span.py

@@ -1,35 +0,0 @@
-"""The location of a variable, tag or filter in a template."""
-
-from dataclasses import dataclass
-
-
-@dataclass
-class Span:
-    """The location of a variable, tag or filter in a template."""
-
-    template_name: str
-    """The template name."""
-
-    index: int
-    """A start index into the template source text."""
-
-    def line_col(self, source: str) -> tuple[int, int]:
-        """Return a tuple of (line number, column number) for this span in _source_."""
-        lines = source.splitlines(keepends=True)
-        cumulative_length = 0
-        target_line_index = -1
-
-        for i, line in enumerate(lines):
-            cumulative_length += len(line)
-            if self.index < cumulative_length:
-                target_line_index = i
-                break
-
-        if target_line_index == -1:
-            raise ValueError("index is out of bounds for the given string")
-
-        # Line number (1-based)
-        line_number = target_line_index + 1
-        # Column number within the line
-        column_number = self.index - (cumulative_length - len(lines[target_line_index]))
-        return line_number, column_number