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

liquid/analyze_tags.py

@@ -1,214 +0,0 @@
-"""Analyze template tags from tokenized source text."""
-
-from __future__ import annotations
-
-from collections import defaultdict
-from typing import TYPE_CHECKING
-from typing import DefaultDict
-from typing import Iterable
-from typing import Mapping
-from typing import Optional
-
-from .span import Span
-from .token import TOKEN_TAG
-
-if TYPE_CHECKING:
-    from .environment import Environment
-    from .token import Token
-
-
-DEFAULT_INNER_TAG_MAP = {
-    "for": ["break", "continue"],
-    "if": ["else", "elsif"],
-    "case": ["when"],
-    "unless": ["else", "elsif"],
-}
-
-
-InnerTagMap = Mapping[str, Iterable[str]]
-TagMap = dict[str, list[Span]]
-
-
-class TagAnalysis:
-    """The result of analyzing a template's tags with `Environment.analyze_tags()`.
-
-    Each of the following properties maps tag names to a list of their locations.
-    Locations are (template_name, start_index) tuples.
-
-    Note that `raw` tags are not included at all. The lexer converts them to text
-    tokens before we get a chance to analyze them.
-
-    Also be aware that reported `unexpected_tags` don't handle the possibility of an
-    "inner" tag appearing in a partial template (using `{% include %}`), where
-    appropriate enclosing block tags are in the parent template.
-
-    Attributes:
-        all_tags: A mapping of all tags to their locations. Includes "end", "inner"
-            and unknown tags.
-        tags: A mapping of tag names to their locations. Excludes "end" and "inner"
-            tags.
-        unclosed_tags: Block tags that don't have a matching "end" tag.
-        unexpected_tags: Inner tags that are not properly enclosed by appropriate
-            block tags. For example, an `{% else %}` that is not enclosed by a
-            `{% for %}` or `{% unless %}` block.
-        unknown_tags: Tags that are unknown to the environment.
-    """
-
-    def __init__(
-        self,
-        *,
-        env: Environment,
-        name: str,
-        tokens: list[Token],
-        inner_tags: Optional[InnerTagMap] = None,
-    ) -> None:
-        self.template_name = name
-
-        # A mapping of all tags to their locations. Includes "end" and inner tags.
-        self.all_tags = self._all_tags(tokens)
-
-        # Reverse map of inner tags to possible enclosing block tags.
-        inner_tags = inner_tags or DEFAULT_INNER_TAG_MAP
-        self._inner_tags = defaultdict(set)
-        for tag, inner in inner_tags.items():
-            for inner_tag in inner:
-                self._inner_tags[inner_tag].add(tag)
-
-        # A mapping of tag names to their locations. Excludes inner tags and "end" tags.
-        self.tags = {
-            tag: loc
-            for tag, loc in self.all_tags.items()
-            if not tag.startswith("end") and tag not in self._inner_tags
-        }
-
-        (
-            self.unclosed_tags,
-            self.unexpected_tags,
-            self.unknown_tags,
-        ) = self._audit_tags(env, tokens)
-
-    def _all_tags(self, tokens: list[Token]) -> TagMap:
-        """Map tag names to their locations, similar to `Template.analyze` etc."""
-        tags: DefaultDict[str, list[Span]] = defaultdict(list)
-        for token in tokens:
-            if token.kind == TOKEN_TAG:
-                tags[token.value].append(Span(self.template_name, token.start_index))
-        return dict(tags)
-
-    def _audit_tags(  # noqa: PLR0912
-        self,
-        env: Environment,
-        tokens: list[Token],
-    ) -> tuple[TagMap, TagMap, TagMap]:
-        block_stack: list[_BlockStackItem] = []
-        unclosed_tags: TagMap = defaultdict(list)
-        unexpected_tags: TagMap = defaultdict(list)
-        unknown_tags: TagMap = defaultdict(list)
-
-        # Relies on the "end" closing block tag convention.
-        end_tags = {
-            token.value
-            for token in tokens
-            if token.kind == TOKEN_TAG and token.value.startswith("end")
-        }
-
-        # Infer which tags are block tags. This may or may not match what the
-        # environment's tag register believes are block tags.
-        block_tags = {tag[3:] for tag in end_tags} | {
-            tag.name for tag in env.tags.values() if tag.block
-        }
-
-        # Registered tags. "break" and "continue" are a special case.
-        registered_tags = {
-            name for name in env.tags if name not in ("break", "continue")
-        }
-
-        # Registered inline tags. We use this to find erroneous "end" tags.
-        inline_tags = {tag.name for tag in env.tags.values() if not tag.block}
-
-        # We use this to find unknown "end" tags.
-        registered_end_blocks = {
-            tag.end for tag in env.tags.values() if tag.block and tag.end
-        }
-
-        for token in tokens:
-            if token.kind != TOKEN_TAG:
-                continue
-
-            tag_name = token.value
-
-            if tag_name in block_tags:
-                block_stack.append(_BlockStackItem(token))
-            elif tag_name in end_tags:
-                start_block_tag = block_stack.pop()
-                if start_block_tag != tag_name[3:]:
-                    # if start_block_tag.name not in inline_tags:
-                    unclosed_tags[start_block_tag.name].append(
-                        Span(self.template_name, start_block_tag.token.start_index)
-                    )
-                continue
-
-            if tag_name not in registered_tags:
-                # Possible enclosing tags for an inner tag.
-                enclosing_tags: Iterable[str] = self._inner_tags.get(tag_name, [])
-                if not enclosing_tags:
-                    # Not an inner tag for any block.
-                    unknown_tags[tag_name].append(
-                        Span(self.template_name, token.start_index)
-                    )
-                elif not self._valid_inner_tag(
-                    self._inner_tags.get(tag_name, []), block_stack
-                ):
-                    # An inner tag, but not valid for any blocks currently on the stack.
-                    unexpected_tags[tag_name].append(
-                        Span(self.template_name, token.start_index)
-                    )
-
-        # Catch any unclosed tags.
-        for block in block_stack:
-            unclosed_tags[block.name].append(
-                Span(self.template_name, block.token.start_index)
-            )
-
-        # Catch bad "end" tags.
-        for tag_name, locations in self.all_tags.items():
-            if tag_name.startswith("end"):
-                start_tag_name = tag_name[3:]
-                if (
-                    start_tag_name in inline_tags
-                    and start_tag_name not in unknown_tags
-                    or (
-                        tag_name not in registered_end_blocks
-                        and start_tag_name not in unknown_tags
-                    )
-                ):
-                    unknown_tags[tag_name].extend(locations)
-
-        return dict(unclosed_tags), dict(unexpected_tags), dict(unknown_tags)
-
-    def _valid_inner_tag(
-        self,
-        tag_names: Iterable[str],
-        block_stack: list[_BlockStackItem],
-    ) -> bool:
-        return any(tag_name in block_stack for tag_name in tag_names)
-
-
-class _BlockStackItem:
-    def __init__(self, token: Token) -> None:
-        self.token = token
-        self.name = token.value
-
-    def __eq__(self, __o: object) -> bool:
-        return __o == self.name or (
-            isinstance(__o, _BlockStackItem) and self.name == __o.name
-        )
-
-    def __hash__(self) -> int:  # pragma: no cover
-        return hash(self.name)
-
-    def __str__(self) -> str:
-        return self.name
-
-    def __repr__(self) -> str:
-        return f"_BlockStackItem({self.name})"

liquid/ast.py

@@ -1,252 +0,0 @@
-"""Base class for all template nodes."""
-
-from __future__ import annotations
-
-from abc import ABC
-from abc import abstractmethod
-from enum import Enum
-from enum import auto
-from typing import TYPE_CHECKING
-from typing import Collection
-from typing import Iterable
-from typing import Optional
-from typing import TextIO
-from typing import Union
-
-from .exceptions import DisabledTagError
-from .output import NullIO
-from .token import TOKEN_TAG
-from .token import Token
-
-if TYPE_CHECKING:
-    from .builtin.expressions import Identifier
-    from .context import RenderContext
-    from .expression import Expression
-
-
-class Node(ABC):
-    """Base class for all nodes in a parse tree."""
-
-    __slots__ = ("token", "blank")
-
-    def __init__(self, token: Token) -> None:
-        self.token = token
-
-        self.blank = True
-        """If True, indicates that the node, when rendered, produces no output text
-        or only whitespace.
-        
-        The output node (`{{ something }}`) and echo tag are exception. Even if they
-        evaluate to an empty or blank string, they are not considered "blank".
-        """
-
-    def raise_for_disabled(self, disabled_tags: Collection[str]) -> None:
-        """Raise a DisabledTagError if this node's type is in the given list."""
-        if self.token.kind == TOKEN_TAG and self.token.value in disabled_tags:
-            raise DisabledTagError(
-                f"{self.token.value} usage is not allowed in this context",
-                token=self.token,
-            )
-
-    def render(self, context: RenderContext, buffer: TextIO) -> int:
-        """Check disabled tags before delegating to `render_to_output`."""
-        if context.disabled_tags:
-            self.raise_for_disabled(context.disabled_tags)
-        return self.render_to_output(context, buffer)
-
-    async def render_async(self, context: RenderContext, buffer: TextIO) -> int:
-        """An async version of `liquid.ast.Node.render`."""
-        if context.disabled_tags:
-            self.raise_for_disabled(context.disabled_tags)
-        return await self.render_to_output_async(context, buffer)
-
-    @abstractmethod
-    def render_to_output(
-        self,
-        context: RenderContext,
-        buffer: TextIO,
-    ) -> int:
-        """Render this node to the output buffer."""
-
-    async def render_to_output_async(
-        self,
-        context: RenderContext,
-        buffer: TextIO,
-    ) -> int:
-        """An async version of `liquid.ast.Node.render_to_output`."""
-        return self.render_to_output(context, buffer)
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        return []
-
-    async def children_async(
-        self,
-        static_context: RenderContext,
-        *,
-        include_partials: bool = True,
-    ) -> Iterable[Node]:
-        """An async version of `children()`."""
-        return self.children(static_context, include_partials=include_partials)
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        return []
-
-    def template_scope(self) -> Iterable[Identifier]:
-        """Return variables this node adds to the template local scope."""
-        return []
-
-    def block_scope(self) -> Iterable[Identifier]:
-        """Return variables this node adds to the node's block scope."""
-        return []
-
-    def partial_scope(self) -> Optional[Partial]:
-        """Return information about a partial template loaded by this node."""
-        return None
-
-
-class PartialScope(Enum):
-    """The kind of scope a partial template should have when loaded."""
-
-    SHARED = auto()
-    ISOLATED = auto()
-    INHERITED = auto()
-
-
-class Partial:
-    """Partial template meta data.
-
-    Args:
-        name: The name of the partial or an expression resolving to the name
-            associated with the partial template.
-        scope: The kind of scope the partial template should have when loaded.
-        in_scope: Names that will be added to the partial template scope.
-        key: A hash of the partial template name and any arguments the partial
-            template will be rendered with that might affect its scope. If a
-            key is provided, static analysis helpers will visit a partial
-            template once for each distinct key.
-    """
-
-    __slots__ = ("name", "scope", "in_scope", "key")
-
-    def __init__(
-        self,
-        name: Union[Expression, str],
-        scope: PartialScope,
-        in_scope: Iterable[Identifier],
-        *,
-        key: Optional[int] = None,
-    ) -> None:
-        self.name = name
-        self.scope = scope
-        self.in_scope = in_scope
-        self.key = key
-
-
-class IllegalNode(Node):
-    """Parse tree node representing an illegal or unregistered tag.
-
-    Illegal nodes are necessary when running in "warn" or "lax" mode. In
-    strict mode, an exception should be raised as soon as an illegal token
-    is found.
-    """
-
-    __slots__ = ()
-
-    def __str__(self) -> str:
-        return ""
-
-    def render_to_output(self, _context: RenderContext, _buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        return 0
-
-
-class BlockNode(Node):
-    """A parse tree node representing a sequence of statements."""
-
-    __slots__ = ("nodes", "blank")
-
-    def __init__(self, token: Token, nodes: list[Node]):
-        super().__init__(token)
-        self.nodes = nodes
-        self.blank = all(node.blank for node in nodes)
-
-    def __str__(self) -> str:
-        return "".join(str(s) for s in self.nodes)
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        if context.env.suppress_blank_control_flow_blocks and self.blank:
-            buf = NullIO()
-            for node in self.nodes:
-                node.render(context, buf)
-            return 0
-        return sum(node.render(context, buffer) for node in self.nodes)
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        if context.env.suppress_blank_control_flow_blocks and self.blank:
-            buf = NullIO()
-            for node in self.nodes:
-                await node.render_async(context, buf)
-            return 0
-        return sum([await node.render_async(context, buffer) for node in self.nodes])
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        return self.nodes
-
-
-class ConditionalBlockNode(Node):
-    """A node containing a sequence of statements and a conditional expression."""
-
-    __slots__ = ("expression", "block")
-
-    def __init__(self, token: Token, expression: Expression, block: BlockNode):
-        super().__init__(token)
-        self.expression = expression
-        self.block = block
-        self.blank = block.blank
-
-    def __str__(self) -> str:
-        return f"{{% elsif {self.expression} %}}{self.block}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        if self.expression.evaluate(context):
-            return self.block.render(context, buffer)
-        return 0
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        if await self.expression.evaluate_async(context):
-            return await self.block.render_async(context, buffer)
-        return 0
-
-    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

liquid/builtin/__init__.py

@@ -1,203 +0,0 @@
-from __future__ import annotations  # noqa: D104
-
-from typing import TYPE_CHECKING
-
-from . import content
-from . import illegal
-from . import output
-from .filters.array import compact
-from .filters.array import concat
-from .filters.array import find
-from .filters.array import find_index
-from .filters.array import first
-from .filters.array import has
-from .filters.array import join
-from .filters.array import last
-from .filters.array import map_
-from .filters.array import reject
-from .filters.array import reverse
-from .filters.array import sort
-from .filters.array import sort_natural
-from .filters.array import sum_
-from .filters.array import uniq
-from .filters.array import where
-from .filters.extra import escapejs
-from .filters.extra import safe
-from .filters.math import abs_
-from .filters.math import at_least
-from .filters.math import at_most
-from .filters.math import ceil
-from .filters.math import divided_by
-from .filters.math import floor
-from .filters.math import minus
-from .filters.math import modulo
-from .filters.math import plus
-from .filters.math import round_
-from .filters.math import times
-from .filters.misc import date
-from .filters.misc import default
-from .filters.misc import size
-from .filters.string import append
-from .filters.string import base64_decode
-from .filters.string import base64_encode
-from .filters.string import base64_url_safe_decode
-from .filters.string import base64_url_safe_encode
-from .filters.string import capitalize
-from .filters.string import downcase
-from .filters.string import escape
-from .filters.string import escape_once
-from .filters.string import lstrip
-from .filters.string import newline_to_br
-from .filters.string import prepend
-from .filters.string import remove
-from .filters.string import remove_first
-from .filters.string import remove_last
-from .filters.string import replace
-from .filters.string import replace_first
-from .filters.string import replace_last
-from .filters.string import rstrip
-from .filters.string import slice_
-from .filters.string import split
-from .filters.string import squish
-from .filters.string import strip
-from .filters.string import strip_html
-from .filters.string import strip_newlines
-from .filters.string import truncate
-from .filters.string import truncatewords
-from .filters.string import upcase
-from .filters.string import url_decode
-from .filters.string import url_encode
-from .loaders.caching_file_system_loader import CachingFileSystemLoader
-from .loaders.choice_loader import CachingChoiceLoader
-from .loaders.choice_loader import ChoiceLoader
-from .loaders.dict_loader import CachingDictLoader
-from .loaders.dict_loader import DictLoader
-from .loaders.file_system_loader import FileSystemLoader
-from .loaders.mixins import CachingLoaderMixin
-from .loaders.package_loader import PackageLoader
-from .tags import assign_tag
-from .tags import capture_tag
-from .tags import case_tag
-from .tags import comment_tag
-from .tags import cycle_tag
-from .tags import decrement_tag
-from .tags import doc_tag
-from .tags import echo_tag
-from .tags import for_tag
-from .tags import if_tag
-from .tags import ifchanged_tag
-from .tags import include_tag
-from .tags import increment_tag
-from .tags import inline_comment_tag
-from .tags import liquid_tag
-from .tags import render_tag
-from .tags import tablerow_tag
-from .tags import unless_tag
-
-if TYPE_CHECKING:
-    from liquid import Environment
-
-__all__ = (
-    "CachingFileSystemLoader",
-    "CachingChoiceLoader",
-    "ChoiceLoader",
-    "CachingDictLoader",
-    "DictLoader",
-    "FileSystemLoader",
-    "CachingLoaderMixin",
-    "PackageLoader",
-)
-
-
-def register(env: Environment) -> None:  # noqa: PLR0915
-    """Register all built-in tags and filters with an environment."""
-    env.add_tag(content.Literal)
-    env.add_tag(output.Output)
-    env.add_tag(illegal.Illegal)
-    env.add_tag(if_tag.IfTag)
-    env.add_tag(comment_tag.CommentTag)
-    env.add_tag(unless_tag.UnlessTag)
-    env.add_tag(case_tag.CaseTag)
-    env.add_tag(for_tag.ForTag)
-    env.add_tag(for_tag.BreakTag)
-    env.add_tag(for_tag.ContinueTag)
-    env.add_tag(tablerow_tag.TablerowTag)
-    env.add_tag(capture_tag.CaptureTag)
-    env.add_tag(cycle_tag.CycleTag)
-    env.add_tag(assign_tag.AssignTag)
-    env.add_tag(increment_tag.IncrementTag)
-    env.add_tag(decrement_tag.DecrementTag)
-    env.add_tag(echo_tag.EchoTag)
-    env.add_tag(liquid_tag.LiquidTag)
-    env.add_tag(include_tag.IncludeTag)
-    env.add_tag(render_tag.RenderTag)
-    env.add_tag(ifchanged_tag.IfChangedTag)
-    env.add_tag(inline_comment_tag.InlineCommentTag)
-    env.add_tag(doc_tag.DocTag)
-
-    env.add_filter("abs", abs_)
-    env.add_filter("at_most", at_most)
-    env.add_filter("at_least", at_least)
-    env.add_filter("ceil", ceil)
-    env.add_filter("divided_by", divided_by)
-    env.add_filter("floor", floor)
-    env.add_filter("minus", minus)
-    env.add_filter("plus", plus)
-    env.add_filter("round", round_)
-    env.add_filter("times", times)
-    env.add_filter("modulo", modulo)
-
-    env.add_filter("capitalize", capitalize)
-    env.add_filter("append", append)
-    env.add_filter("downcase", downcase)
-    env.add_filter("escape", escape)
-    env.add_filter("escape_once", escape_once)
-    env.add_filter("lstrip", lstrip)
-    env.add_filter("newline_to_br", newline_to_br)
-    env.add_filter("prepend", prepend)
-    env.add_filter("remove", remove)
-    env.add_filter("remove_first", remove_first)
-    env.add_filter("remove_last", remove_last)
-    env.add_filter("replace", replace)
-    env.add_filter("replace_first", replace_first)
-    env.add_filter("replace_last", replace_last)
-    env.add_filter("slice", slice_)
-    env.add_filter("split", split)
-    env.add_filter("upcase", upcase)
-    env.add_filter("strip", strip)
-    env.add_filter("rstrip", rstrip)
-    env.add_filter("strip_html", strip_html)
-    env.add_filter("strip_newlines", strip_newlines)
-    env.add_filter("truncate", truncate)
-    env.add_filter("truncatewords", truncatewords)
-    env.add_filter("url_encode", url_encode)
-    env.add_filter("url_decode", url_decode)
-    env.add_filter("base64_encode", base64_encode)
-    env.add_filter("base64_decode", base64_decode)
-    env.add_filter("base64_url_safe_encode", base64_url_safe_encode)
-    env.add_filter("base64_url_safe_decode", base64_url_safe_decode)
-    env.add_filter("squish", squish)
-
-    env.add_filter("find", find)
-    env.add_filter("find_index", find_index)
-    env.add_filter("join", join)
-    env.add_filter("first", first)
-    env.add_filter("has", has)
-    env.add_filter("last", last)
-    env.add_filter("concat", concat)
-    env.add_filter("map", map_)
-    env.add_filter("reject", reject)
-    env.add_filter("reverse", reverse)
-    env.add_filter("sort", sort)
-    env.add_filter("sort_natural", sort_natural)
-    env.add_filter("sum", sum_)
-    env.add_filter("where", where)
-    env.add_filter("uniq", uniq)
-    env.add_filter("compact", compact)
-
-    env.add_filter("size", size)
-    env.add_filter("default", default)
-    env.add_filter("date", date)
-
-    env.add_filter("safe", safe)
-    env.add_filter("escapejs", escapejs)