python-liquid 2.3.5__tar.gz → 3.0.0__tar.gz

{python_liquid-2.3.5 → python_liquid-3.0.0}/.gitignore

@@ -52,6 +52,7 @@ coverage.xml
 # Sphinx documentation
 docs/_build/
 site/
+.doctrees
 
 # PyBuilder
 target/
@@ -81,4 +82,6 @@ ENV/
 
 # Dev utils
 dev.py
-dump_golden.py
+dump_golden.py
+pr.md
+pr.rst

{python_liquid-2.3.5 → python_liquid-3.0.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 - 2023 James Prior
+Copyright (c) 2020 - 2026 James Prior
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{python_liquid-2.3.5 → python_liquid-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-liquid
-Version: 2.3.5
+Version: 3.0.0
 Summary: A Python engine for the Liquid template language.
 Project-URL: Change Log, https://github.com/jg-rp/liquid/blob/main/CHANGES.md
 Project-URL: Documentation, https://jg-rp.github.io/liquid/
@@ -13,22 +13,18 @@ License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.9
+Requires-Python: >=3.12
 Requires-Dist: babel>=2
-Requires-Dist: importlib-resources>=5.12
 Requires-Dist: markupsafe>=3
-Requires-Dist: python-dateutil>=2.8.1
-Requires-Dist: pytz
+Requires-Dist: python-dateutil
+Requires-Dist: tzdata
 Description-Content-Type: text/markdown
 
 <h1 align="center">Python Liquid</h1>
@@ -77,28 +73,37 @@ We follow <a href="https://github.com/Shopify/liquid">Shopify/Liquid</a> closely
 
 ## Install
 
-Install Python Liquid using [Pipenv](https://pipenv.pypa.io/en/latest/):
+Install `python-liquid` from [PyPi](https://pypi.org/project/python-liquid) using your favorite package manager.
+
+**pip**
+
+```shell
+pip install python-liquid
+```
+
+**uv**
 
 ```shell
-$ pipenv install -u python-liquid
+uv add python-liquid
 ```
 
-Or [pip](https://pip.pypa.io/en/stable/getting-started/):
+**pipenv**
 
 ```shell
-$ pip install python-liquid
+pipenv install -u python-liquid
 ```
 
-Or from [conda-forge](https://anaconda.org/conda-forge/python-liquid):
+**conda**
 
 ```shell
-$ conda install -c conda-forge python-liquid
+conda install -c conda-forge python-liquid
 ```
 
 ## Links
 
 - Documentation: https://jg-rp.github.io/liquid/
 - Documentation for Python Liquid version 1.x: https://jg-rp.github.io/python-liquid-docs-archive/
+- Documentation for Python Liquid version 2.x: https://github.com/jg-rp/liquid/blob/v2.3.6/docs/index.md
 - Change Log: https://github.com/jg-rp/liquid/blob/main/CHANGES.md
 - PyPi: https://pypi.org/project/python-liquid/
 - Source Code: https://github.com/jg-rp/liquid
@@ -115,18 +120,17 @@ $ conda install -c conda-forge python-liquid
 
 ### `render()`
 
-This example renders a template from a string of text with the package-level `render()` function. The template has just one placeholder variable `you`, which we've given the value `"World"`.
+Use the package-level `liquid.render()` function to render a template with Liquid's default configuration. The first argument is template source code and the second is a dictionary of template variables.
 
 ```python
-from liquid import render
+import liquid
 
-print(render("Hello, {{ you }}!", you="World"))
-# Hello, World!
+print(liquid.render("Hello, {{ you }}!", {"you": "World"}))  # Hello, World!
 ```
 
 ### `parse()`
 
-Often you'll want to render the same template several times with different variables. We can parse source text without immediately rendering it using the `parse()` function. `parse()` returns a `BoundTemplate` instance with a `render()` method.
+Use `liquid.parse()` to get an instance of `liquid.Template`, which can be rendered multiple times with different data.
 
 ```python
 from liquid import parse
@@ -138,33 +142,22 @@ print(template.render(you="Liquid"))  # Hello, Liquid!
 
 ### Configure
 
-Both `parse()` and `render()` are convenience functions that use the default Liquid environment. For all but the simplest cases, you'll want to configure an instance of `Environment`, then load and render templates from that.
+You'll need to create an instance of `liquid.Environment` to configure Liquid, then load and render templates from that.
 
 ```python
-from liquid import CachingFileSystemLoader
-from liquid import Environment
+from liquid import Environment, CachingFileSystemLoader
 
 env = Environment(
-    autoescape=True,
-    loader=CachingFileSystemLoader("./templates"),
+  autoescape=True,
+  loader=CachingFileSystemLoader("./templates")
 )
-```
-
-Then, using `env.parse()` or `env.get_template()`, we can create a `BoundTemplate` from a string or read from the file system, respectively.
-
-```python
-# ... continued from above
-template = env.parse("Hello, {{ you }}!")
-print(template.render(you="World"))  # Hello, World!
 
-# Try to load "./templates/index.html"
-another_template = env.get_template("index.html")
-data = {"some": {"thing": [1, 2, 3]}}
-result = another_template.render(**data)
+template = env.get_template("index.liquid")
+another_template = env.parse("{% render 'greeting' %}, World!")
 ```
 
-Unless you happen to have a relative folder called `templates` with a file called `index.html` within it, we would expect a `TemplateNotFoundError` to be raised when running the example above.
+See [docs](https://jg-rp.github.io/liquid/).
 
 ## Contributing
 
-Please see [Contributing to Python Liquid](https://github.com/jg-rp/liquid/blob/main/contributing.md).
+Please see [Contributing to Python Liquid](https://github.com/jg-rp/liquid/blob/main/CONTRIBUTING.md).

{python_liquid-2.3.5 → python_liquid-3.0.0}/README.md

@@ -44,28 +44,37 @@ We follow <a href="https://github.com/Shopify/liquid">Shopify/Liquid</a> closely
 
 ## Install
 
-Install Python Liquid using [Pipenv](https://pipenv.pypa.io/en/latest/):
+Install `python-liquid` from [PyPi](https://pypi.org/project/python-liquid) using your favorite package manager.
+
+**pip**
+
+```shell
+pip install python-liquid
+```
+
+**uv**
 
 ```shell
-$ pipenv install -u python-liquid
+uv add python-liquid
 ```
 
-Or [pip](https://pip.pypa.io/en/stable/getting-started/):
+**pipenv**
 
 ```shell
-$ pip install python-liquid
+pipenv install -u python-liquid
 ```
 
-Or from [conda-forge](https://anaconda.org/conda-forge/python-liquid):
+**conda**
 
 ```shell
-$ conda install -c conda-forge python-liquid
+conda install -c conda-forge python-liquid
 ```
 
 ## Links
 
 - Documentation: https://jg-rp.github.io/liquid/
 - Documentation for Python Liquid version 1.x: https://jg-rp.github.io/python-liquid-docs-archive/
+- Documentation for Python Liquid version 2.x: https://github.com/jg-rp/liquid/blob/v2.3.6/docs/index.md
 - Change Log: https://github.com/jg-rp/liquid/blob/main/CHANGES.md
 - PyPi: https://pypi.org/project/python-liquid/
 - Source Code: https://github.com/jg-rp/liquid
@@ -82,18 +91,17 @@ $ conda install -c conda-forge python-liquid
 
 ### `render()`
 
-This example renders a template from a string of text with the package-level `render()` function. The template has just one placeholder variable `you`, which we've given the value `"World"`.
+Use the package-level `liquid.render()` function to render a template with Liquid's default configuration. The first argument is template source code and the second is a dictionary of template variables.
 
 ```python
-from liquid import render
+import liquid
 
-print(render("Hello, {{ you }}!", you="World"))
-# Hello, World!
+print(liquid.render("Hello, {{ you }}!", {"you": "World"}))  # Hello, World!
 ```
 
 ### `parse()`
 
-Often you'll want to render the same template several times with different variables. We can parse source text without immediately rendering it using the `parse()` function. `parse()` returns a `BoundTemplate` instance with a `render()` method.
+Use `liquid.parse()` to get an instance of `liquid.Template`, which can be rendered multiple times with different data.
 
 ```python
 from liquid import parse
@@ -105,33 +113,22 @@ print(template.render(you="Liquid"))  # Hello, Liquid!
 
 ### Configure
 
-Both `parse()` and `render()` are convenience functions that use the default Liquid environment. For all but the simplest cases, you'll want to configure an instance of `Environment`, then load and render templates from that.
+You'll need to create an instance of `liquid.Environment` to configure Liquid, then load and render templates from that.
 
 ```python
-from liquid import CachingFileSystemLoader
-from liquid import Environment
+from liquid import Environment, CachingFileSystemLoader
 
 env = Environment(
-    autoescape=True,
-    loader=CachingFileSystemLoader("./templates"),
+  autoescape=True,
+  loader=CachingFileSystemLoader("./templates")
 )
-```
-
-Then, using `env.parse()` or `env.get_template()`, we can create a `BoundTemplate` from a string or read from the file system, respectively.
-
-```python
-# ... continued from above
-template = env.parse("Hello, {{ you }}!")
-print(template.render(you="World"))  # Hello, World!
 
-# Try to load "./templates/index.html"
-another_template = env.get_template("index.html")
-data = {"some": {"thing": [1, 2, 3]}}
-result = another_template.render(**data)
+template = env.get_template("index.liquid")
+another_template = env.parse("{% render 'greeting' %}, World!")
 ```
 
-Unless you happen to have a relative folder called `templates` with a file called `index.html` within it, we would expect a `TemplateNotFoundError` to be raised when running the example above.
+See [docs](https://jg-rp.github.io/liquid/).
 
 ## Contributing
 
-Please see [Contributing to Python Liquid](https://github.com/jg-rp/liquid/blob/main/contributing.md).
+Please see [Contributing to Python Liquid](https://github.com/jg-rp/liquid/blob/main/CONTRIBUTING.md).

python_liquid-3.0.0/liquid/__about__.py

@@ -0,0 +1 @@
+__version__ = "3.0.0"

python_liquid-3.0.0/liquid/__init__.py

@@ -0,0 +1,220 @@
+from collections.abc import Iterator, Mapping
+from typing import Any, TextIO
+
+from ._base_tag import AbstractTag
+from ._context import RenderContext
+from ._drop import (
+    ContextHint,
+    LiquidAsyncIterable,
+    LiquidAsyncObject,
+    LiquidIterable,
+    LiquidObject,
+    LiquidPrimitive,
+)
+from ._filter import Filter, FilterContext
+from ._io import StringBuffer
+from ._lax_parser_mixin import LaxParserMixin
+from ._lexer import Lexer
+from ._lexer_extended import ExtendedLexer
+from ._lexer_legacy import LegacyLexer
+from ._loader import Loader, TemplateSource
+from ._markup import (
+    Block,
+    Expression,
+    Markup,
+    Node,
+    Partial,
+    Scope,
+    Tag,
+    render_block,
+    render_block_async,
+)
+from ._messages import (
+    MessageTuple,
+    Translations,
+    extract_from_template,
+    extract_from_templates,
+)
+from ._nothing import NOTHING
+from ._parser import Parser
+from ._parser_extended import ExtendedParser
+from ._parser_legacy import LegacyParser
+from ._resource_limits import ResourceLimits
+from ._slice import slice_range, slice_sequence
+from ._static_analysis import Segments, TemplateAnalysis
+from ._template import Template
+from .drops import (
+    AsyncIterableDrop,
+    FalsyStrictUndefined,
+    IterableDrop,
+    StrictUndefined,
+    Undefined,
+)
+from .environment import Environment
+from .loaders import (
+    CachingChoiceLoader,
+    CachingDictLoader,
+    CachingFileSystemLoader,
+    CachingLoaderMixin,
+    ChoiceLoader,
+    DictLoader,
+    FileSystemLoader,
+    PackageLoader,
+)
+from .tokens import TOKEN_NAMES, Token, TokenKind, span, token_value
+
+__all__ = (
+    "NOTHING",
+    "TOKEN_NAMES",
+    "AbstractTag",
+    "AsyncIterableDrop",
+    "Block",
+    "CachingChoiceLoader",
+    "CachingDictLoader",
+    "CachingFileSystemLoader",
+    "CachingLoaderMixin",
+    "ChoiceLoader",
+    "ContextHint",
+    "DictLoader",
+    "Environment",
+    "Expression",
+    "ExtendedLexer",
+    "ExtendedParser",
+    "FalsyStrictUndefined",
+    "FileSystemLoader",
+    "Filter",
+    "FilterContext",
+    "IterableDrop",
+    "LaxExtendedParser",
+    "LaxLegacyParser",
+    "LaxParserMixin",
+    "LegacyLexer",
+    "LegacyParser",
+    "Lexer",
+    "LiquidAsyncIterable",
+    "LiquidAsyncObject",
+    "LiquidIterable",
+    "LiquidObject",
+    "LiquidPrimitive",
+    "Loader",
+    "Markup",
+    "Node",
+    "PackageLoader",
+    "Parser",
+    "Partial",
+    "RenderContext",
+    "ResourceLimits",
+    "Scope",
+    "Segments",
+    "StrictUndefined",
+    "StringBuffer",
+    "Tag",
+    "Template",
+    "TemplateAnalysis",
+    "TemplateSource",
+    "Token",
+    "TokenKind",
+    "Translations",
+    "Undefined",
+    "extract_from_templates",
+    "render_block",
+    "render_block_async",
+    "slice_range",
+    "slice_sequence",
+    "span",
+    "token_value",
+)
+
+
+DEFAULT_ENVIRONMENT = Environment()
+
+
+def parse(
+    source: str,
+    *,
+    name: str = "",
+    globals: Mapping[str, Any] | None = None,
+) -> Template:
+    """Parse template source code `source` using the default Liquid environment.
+
+    Parameters
+    ----------
+    source
+        Template source code.
+    name
+        A name for the template that will appear in error messages.
+    globals
+        Variables to pin to the resulting template.
+    """
+    return DEFAULT_ENVIRONMENT.parse(source, name=name, globals=globals)
+
+
+def render(source: str, data: Mapping[str, Any] | None = None) -> str:
+    """Parse and render `source` with variables from `data` using the default environment.
+
+    Parameters
+    ----------
+    source
+        Template source code.
+    data
+        Template variables.
+    """
+    return DEFAULT_ENVIRONMENT.render(source, data)
+
+
+async def render_async(source: str, data: Mapping[str, Any] | None = None) -> str:
+    """Parse and render `source` asynchronously with variables from `data` using the
+    default environment.
+
+    Parameters
+    ----------
+    source
+        Template source code.
+    data
+        Template variables.
+    """
+    return await DEFAULT_ENVIRONMENT.render_async(source, data)
+
+
+class LaxLegacyParser(LaxParserMixin, LegacyParser):
+    """A legacy parser that suppresses Liquid syntax errors.
+
+    Use ``Template.errors()`` to get a list of available ``LiquidSyntaxError`` instances.
+    """
+
+
+class LaxExtendedParser(LaxParserMixin, ExtendedParser):
+    """An extended parser that suppresses Liquid syntax errors.
+
+    Use ``Template.errors()`` to get a list of available ``LiquidSyntaxError`` instances.
+    """
+
+
+def extract_liquid(
+    fileobj: TextIO,
+    keywords: list[str],
+    comment_tags: list[str] | None = None,
+    options: Mapping[str, Any] | None = None,
+) -> Iterator[MessageTuple]:
+    """A babel compatible translation message extraction method for Liquid templates.
+
+    See https://babel.pocoo.org/en/latest/messages.html
+
+    Keywords are the names of Liquid filters or tags operating on translatable strings.
+    For a filter to contribute to message extraction, it must also appear as a child of
+    a `FilteredExpression` and be a `TranslatableFilter`. Similarly, tags must produce a
+    node that is a `TranslatableTag`.
+
+    Where a Liquid comment contains a prefix in `comment_tags`, the comment will be
+    attached to the translatable filter or tag immediately following the comment. Python
+    Liquid's non-standard shorthand comments are not supported.
+
+    Use ``extract_from_template`` to extract messages from an existing template bound to
+    an existing environment.
+    """
+    template = Environment(extra=True).parse(fileobj.read())
+    return extract_from_template(
+        template=template,
+        keywords=keywords,
+        comment_tags=comment_tags,
+    )

python_liquid-3.0.0/liquid/_base_tag.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+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 AbstractTag(ABC):
+    """An abstract class for implementing custom tags.
+
+    It is not necessary to inherit from `AbstractTag` when implementing custom tags, but
+    it can be convenient if you're not interested in methods supporting static template
+    analysis, saving you from writing several empty methods.
+
+    Internally we use the `Markup` and `Tag` protocols, without a required base class.
+    """
+
+    @classmethod
+    @abstractmethod
+    def parse(cls, token: Token, parser: Parser) -> Markup:
+        """Parse tokens or text from `parser` into a markup node."""
+
+    @abstractmethod
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        """Render this node to `buffer` using data from `context`."""
+
+    @abstractmethod
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        """Render this node to `buffer` asynchronously using data from `context`."""
+
+    def children(self) -> list[Markup]:
+        """Returns markup nodes that are direct children of this node in the syntax tree.
+
+        This is used to traverse template syntax trees during static analysis.
+        """
+        return []
+
+    def expressions(self) -> list[Expression]:
+        """Return expression owned by this node."""
+        return []
+
+    def block_scope(self) -> list[Name]:
+        """Return variable names that are in scope for the duration of this node's block.
+
+        This is used during static analysis to isolate and report global variables.
+        """
+        return []
+
+    def template_scope(self) -> list[Name]:
+        """Return variable names that this tag adds to the template scope."""
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        """Return meta data about partial templates rendered from this node."""
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        """Return meta data about partial templates rendered from this node."""
+        return []

python_liquid-2.3.5/liquid/utils/chain_map.py → python_liquid-3.0.0/liquid/_chain_map.py

@@ -3,26 +3,29 @@
 Based on "A greatly simplified read-only version of Chainmap" by Raymond Hettinger.
 https://code.activestate.com/recipes/305268/
 """
+
 from collections import deque
+from collections.abc import Iterator, Mapping
 from itertools import chain
-from typing import Any
-from typing import Iterator
-from typing import Mapping
+
+from ._missing import MISSING
 
 
 class ReadOnlyChainMap(Mapping[str, object]):
-    """Combine multiple mappings for sequential lookup."""
+    """Combine multiple mappings for sequential lookup.
+
+    This chain map never raises a KeyError. It returns the MISSING sentinel
+    if a key does not exist in the chain.
+    """
 
     def __init__(self, *maps: Mapping[str, object]):
         self._maps = deque(maps)
 
     def __getitem__(self, key: str) -> object:
         for mapping in self._maps:
-            try:
+            if key in mapping:
                 return mapping[key]
-            except KeyError:
-                pass
-        raise KeyError(key)
+        return MISSING
 
     def __iter__(self) -> Iterator[str]:
         return chain(*self._maps)
@@ -30,21 +33,17 @@ class ReadOnlyChainMap(Mapping[str, object]):
     def __len__(self) -> int:
         return sum(len(_map) for _map in self._maps)
 
+    def __contains__(self, key: object) -> bool:
+        return any(key in mapping for mapping in self._maps)
+
     def size(self) -> int:
-        """Return the number of maps in the chain."""
         return len(self._maps)
 
-    def get(self, key: str, default: object = None) -> object:
-        """Return the value for key if key is in the dictionary, else default."""
-        try:
-            return self[key]
-        except KeyError:
-            return default
+    def get(self, key: str, default: object = MISSING) -> object:
+        return self[key]
 
-    def push(self, namespace: Mapping[Any, Any]) -> None:
-        """Add a mapping to the front of the chain map."""
+    def push(self, namespace: Mapping[str, object]) -> None:
         self._maps.appendleft(namespace)
 
-    def pop(self) -> Mapping[Any, Any]:
-        """Remove a mapping from the front of the chain map."""
+    def pop(self) -> Mapping[str, object]:
         return self._maps.popleft()