python-liquid 2.2.2__tar.gz → 2.3.0__tar.gz

{python_liquid-2.2.2 → python_liquid-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-liquid
-Version: 2.2.2
+Version: 2.3.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/

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/__init__.py

@@ -56,7 +56,7 @@ from .tag import Tag
 
 from . import future
 
-__version__ = "2.2.2"
+__version__ = "2.3.0"
 
 __all__ = (
     "AwareBoundTemplate",

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/builtin/expressions/loop.py

@@ -123,29 +123,23 @@ class LoopExpression(Expression):
     ) -> tuple[Iterator[object], int]:
         offset_key = f"{self.identifier}-{self.iterable}"
 
-        if limit is None and offset is None:
-            context.stopindex(key=offset_key, index=length)
-            if self.reversed:
-                return reversed(list(it)), length
-            return it, length
-
         if offset == "continue":
-            offset = context.stopindex(key=offset_key)
-            length = max(length - offset, 0)
-        elif offset is not None:
-            assert isinstance(offset, int), f"found {offset!r}"
-            length = max(length - offset, 0)
+            start = context.stopindex(offset_key)
+        else:
+            start = int(offset or 0)
+
+        stop = None if limit is None else limit + start
 
-        if limit is not None:
-            length = min(length, limit)
+        start_ = min(max(start, 0), length)
+        stop_ = min(stop or length, length)
+        length_ = max(stop_ - start_, 0)
 
-        stop = offset + length if offset else length
-        context.stopindex(key=offset_key, index=stop)
-        it = islice(it, offset, stop)
+        context.stopindex(key=offset_key, index=stop_)
+        it = islice(it, start_, stop_)
 
         if self.reversed:
-            return reversed(list(it)), length
-        return it, length
+            return reversed(list(it)), length_
+        return it, length_
 
     def evaluate(self, context: RenderContext) -> tuple[Iterator[object], int]:
         it, length = self._to_iter(self.iterable.evaluate(context), context)

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/builtin/expressions/primitive.py

@@ -39,6 +39,12 @@ if TYPE_CHECKING:
     from liquid import TokenStream
 
 
+# MAX_RANGE = (2**53) - 1
+# MIN_RANGE = -(2**53) + 1
+MAX_RANGE = 1024
+MIN_RANGE = -1024
+
+
 class Nil(Expression):
     __slots__ = ()
 
@@ -249,7 +255,9 @@ class RangeLiteral(Expression):
         if start > stop:
             return range(0)
 
-        return range(start, stop + 1)
+        return range(
+            clamp(start, MIN_RANGE, MAX_RANGE), clamp(stop + 1, MIN_RANGE, MAX_RANGE)
+        )
 
     def evaluate(self, context: RenderContext) -> range:
         return self._make_range(
@@ -415,3 +423,8 @@ def parse_string_or_path(
 def is_empty(obj: object) -> bool:
     """Return True if _obj_ is considered empty."""
     return isinstance(obj, (list, dict, str)) and not obj
+
+
+def clamp(n: int, min_value: int, max_value: int) -> int:
+    """Clamp _n_ between _min_value_ and _max_value_."""
+    return max(min_value, min(n, max_value))

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/builtin/loaders/file_system_loader.py

@@ -76,7 +76,11 @@ class FileSystemLoader(BaseLoader):
         for base in self.search_path:
             source_path = base.joinpath(template_path)
 
-            if not source_path.exists() or not source_path.is_file():
+            try:
+                if not source_path.exists() or not source_path.is_file():
+                    continue
+            except OSError:
+                # "File name too long", for example
                 continue
 
             if self.reject_symlinks:

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/builtin/tags/liquid_tag.py

@@ -127,7 +127,8 @@ class LiquidTag(Tag):
                     self._tokenize(
                         token_.value,
                         token=token_,
-                    )
+                    ),
+                    block_depth_carry=stream.block_depth,
                 ),
                 end=(),
             )

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/environment.py

@@ -18,6 +18,7 @@ from . import builtin
 from .analyze_tags import InnerTagMap
 from .analyze_tags import TagAnalysis
 from .builtin import DictLoader
+from .exceptions import BlockNestingError
 from .exceptions import LiquidError
 from .exceptions import LiquidSyntaxError
 from .exceptions import TemplateInheritanceError
@@ -79,6 +80,10 @@ class Environment:
             template loaded from this environment.
     """
 
+    block_nesting_limit: ClassVar[int] = 30
+    """The maximum markup block nesting depth allowed before a `BlockNestingError`
+    exception is raised."""
+
     context_depth_limit: ClassVar[int] = 30
     """The maximum number of times a render context can be extended or wrapped before
     raising a `ContextDepthError`."""
@@ -275,7 +280,7 @@ class Environment:
         """
         try:
             nodes = self._parse(source)
-        except (LiquidSyntaxError, TemplateInheritanceError) as err:
+        except (LiquidSyntaxError, TemplateInheritanceError, BlockNestingError) as err:
             err.template_name = path
             raise err
         except Exception as err:  # noqa: BLE001

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/exceptions.py

@@ -191,6 +191,10 @@ class ResourceLimitError(LiquidError):
     """Base class for exceptions relating to resource limits."""
 
 
+class BlockNestingError(ResourceLimitError):
+    """The exception raised when block nesting limit is reached."""
+
+
 class ContextDepthError(ResourceLimitError):
     """Exception raised when the maximum context depth is reached.
 

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/parser.py

@@ -9,6 +9,7 @@ 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
@@ -69,6 +70,10 @@ class Parser:
         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:
@@ -92,6 +97,7 @@ class Parser:
 
             next(stream)
 
+        stream.block_depth -= 1
         return BlockNode(stream.current, nodes)
 
 

{python_liquid-2.2.2 → python_liquid-2.3.0}/liquid/stream.py

@@ -18,12 +18,10 @@ class TokenStream:
 
     eof = Token(TOKEN_EOF, TOKEN_EOF, -1, "")
 
-    def __init__(
-        self,
-        tokens: Iterator[Token],
-    ):
+    def __init__(self, tokens: Iterator[Token], block_depth_carry: int = 0):
         self.tokens = list(tokens)
         self.pos = 0
+        self.block_depth = block_depth_carry
 
     def __next__(self) -> Token:
         return self.next_token()

{python_liquid-2.2.2 → python_liquid-2.3.0}/pyproject.toml

@@ -160,6 +160,7 @@ convention = "google"
 "liquid/builtin/loaders/__init__.py" = ["D104", "I001"]
 "liquid/builtin/tags/__init__.py" = ["D104", "I001"]
 "tests/*" = ["D100", "D101", "D104", "D103", "D102", "D209", "D205", "SIM117"]
+"tests/test_compliance.py" = ["E501"]
 "performance/*" = ["D103", "PLR2004", "T201", "D100"]
 "liquid/builtin/expressions/primitive.py" = ["D101", "D102"]
 "liquid/builtin/expressions/path.py" = ["D101", "D102"]