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

liquid/filters/uniq.py

@@ -0,0 +1,11 @@
+from .._filter import FilterContext
+
+
+def uniq(context: FilterContext, left: object, prop: object = None) -> list[object]:
+    left = context.input_array(left)
+
+    if context.is_nil(prop):
+        return [obj for i, obj in enumerate(left) if left.index(obj) == i]
+
+    keys = [context.get_item(obj, prop) for obj in left]
+    return [left[i] for i, key in enumerate(keys) if keys.index(key) == i]

liquid/filters/upcase.py

@@ -0,0 +1,5 @@
+from .._filter import FilterContext
+
+
+def upcase(context: FilterContext, left: object) -> str:
+    return context.to_str(left, "").upper()

liquid/filters/url.py

@@ -0,0 +1,18 @@
+import urllib.parse
+
+import markupsafe
+
+from .._filter import FilterContext
+
+
+def url_encode(context: FilterContext, left: object) -> str:
+    left_ = context.to_str(left, "")
+
+    if context.env.autoescape:
+        return markupsafe.Markup(urllib.parse.quote_plus(left_))
+
+    return urllib.parse.quote_plus(left_)
+
+
+def url_decode(context: FilterContext, left: object) -> str:
+    return urllib.parse.unquote_plus(context.to_str(left, ""), errors="strict")

liquid/filters/where.py

@@ -0,0 +1,18 @@
+from .._filter import FilterContext
+
+
+def where(
+    context: FilterContext, left: object, prop: object, value: object = None
+) -> list[object]:
+    left = context.input_array(left)
+
+    if context.is_nil(prop):
+        return []
+
+    def _filter(obj: object) -> bool:
+        return context.truthy(context.get_item(obj, prop))
+
+    if context.is_nil(value):
+        return list(filter(_filter, left))
+
+    return [obj for obj in left if context.get_item(obj, prop) == value]

liquid/loaders/__init__.py

@@ -0,0 +1,17 @@
+from .caching_file_system_loader import CachingFileSystemLoader
+from .choice_loader import CachingChoiceLoader, ChoiceLoader
+from .dict_loader import CachingDictLoader, DictLoader
+from .file_system_loader import FileSystemLoader
+from .mixins import CachingLoaderMixin
+from .package_loader import PackageLoader
+
+__all__ = (
+    "CachingChoiceLoader",
+    "CachingDictLoader",
+    "CachingFileSystemLoader",
+    "CachingLoaderMixin",
+    "ChoiceLoader",
+    "DictLoader",
+    "FileSystemLoader",
+    "PackageLoader",
+)

liquid/loaders/caching_file_system_loader.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .file_system_loader import FileSystemLoader
+from .mixins import CachingLoaderMixin
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from pathlib import Path
+
+
+class CachingFileSystemLoader(CachingLoaderMixin, FileSystemLoader):
+    """A file system loader that caches parsed templates in memory.
+
+    Parameters
+    ----------
+    search_path
+        One or more paths to search.
+    encoding
+        Open template files with the given encoding.
+    ext
+        A default file extension. Should include a leading period.
+    reject_symlinks
+        When `True`, reject paths to symlinks that resolve to files outside the
+        search path. Defaults to `False`.
+    auto_reload
+        If `True`, automatically reload a cached template if it has been updated.
+    namespace_key
+        The name of a global render context variable or loader keyword argument
+        that resolves to the current loader "namespace" or "scope".
+
+        If you're developing a multi-user application, a good namespace might be
+        `uid`, where `uid` is a unique identifier for a user and templates are
+        arranged in folders named for each `uid` inside the search path.
+    capacity
+        The maximum number of templates to hold in the cache before removing the
+        least recently used template.
+    """
+
+    def __init__(
+        self,
+        search_path: str | Path | Iterable[str | Path],
+        encoding: str = "utf-8",
+        ext: str | None = None,
+        *,
+        reject_symlinks: bool = False,
+        auto_reload: bool = True,
+        namespace_key: str = "",
+        capacity: int = 300,
+    ):
+        super().__init__(
+            auto_reload=auto_reload,
+            namespace_key=namespace_key,
+            capacity=capacity,
+        )
+
+        FileSystemLoader.__init__(
+            self,
+            search_path=search_path,
+            encoding=encoding,
+            ext=ext,
+            reject_symlinks=reject_symlinks,
+        )

liquid/loaders/choice_loader.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._loader import Loader, TemplateSource
+from ..exceptions import TemplateNotFoundError
+from .mixins import CachingLoaderMixin
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from ..environment import Environment
+
+
+class ChoiceLoader(Loader):
+    """A template loader that delegates to other template loaders.
+
+    Parameters
+    ----------
+    loaders
+        A list of loaders implementing `liquid.Loader`.
+    """
+
+    def __init__(self, loaders: list[Loader]):
+        super().__init__()
+        self.loaders = loaders
+
+    def get_source(
+        self,
+        env: Environment,
+        name: str,
+        context: RenderContext | None = None,
+        **kwargs: object,
+    ) -> TemplateSource:
+        """Get source information for a template."""
+        for loader in self.loaders:
+            try:
+                return loader.get_source(env, name, context=context, **kwargs)
+            except TemplateNotFoundError:
+                pass
+
+        raise TemplateNotFoundError(name)
+
+    async def get_source_async(
+        self,
+        env: Environment,
+        name: str,
+        context: RenderContext | None = None,
+        **kwargs: object,
+    ) -> TemplateSource:
+        """Get source information for a template."""
+        for loader in self.loaders:
+            try:
+                return await loader.get_source_async(
+                    env, name, context=context, **kwargs
+                )
+            except TemplateNotFoundError:
+                pass
+
+        raise TemplateNotFoundError(name)
+
+
+class CachingChoiceLoader(CachingLoaderMixin, ChoiceLoader):
+    """A `ChoiceLoader` that caches parsed templates in memory.
+
+    Parameters
+    ----------
+    loaders
+        A list of loaders implementing `liquid.Loader`.
+    auto_reload
+        If ``True``, automatically reload a cached template if it has been updated.
+    namespace_key
+        The name of a global render context variable or loader keyword argument
+        that resolves to the current loader "namespace" or "scope".
+    capacity
+        The maximum number of templates to hold in the cache before removing the
+        least recently used template.
+    """
+
+    def __init__(
+        self,
+        loaders: list[Loader],
+        *,
+        auto_reload: bool = True,
+        namespace_key: str = "",
+        capacity: int = 300,
+    ):
+        super().__init__(
+            auto_reload=auto_reload,
+            namespace_key=namespace_key,
+            capacity=capacity,
+        )
+
+        ChoiceLoader.__init__(self, loaders)

liquid/loaders/dict_loader.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._loader import Loader, TemplateSource
+from ..exceptions import TemplateNotFoundError
+from .mixins import CachingLoaderMixin
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from ..environment import Environment
+
+
+class DictLoader(Loader):
+    """A template loader that reads source text from a dictionary.
+
+    Parameters
+    ----------
+    templates
+        A mapping of template names to template source code.
+    """
+
+    def __init__(self, templates: dict[str, str]) -> None:
+        super().__init__()
+        self.templates = templates
+
+    def get_source(
+        self,
+        env: Environment,
+        name: str,
+        context: RenderContext | None = None,
+        **kwargs: object,
+    ) -> TemplateSource:
+        if name not in self.templates:
+            raise TemplateNotFoundError(name)
+        return TemplateSource(name=name, text=self.templates[name])
+
+
+class CachingDictLoader(CachingLoaderMixin, DictLoader):
+    """A ``DictLoader`` that caches parsed templates in memory."""
+
+    def __init__(
+        self,
+        templates: dict[str, str],
+        *,
+        auto_reload: bool = True,
+        namespace_key: str = "",
+        capacity: int = 300,
+    ):
+        super().__init__(
+            auto_reload=auto_reload,
+            namespace_key=namespace_key,
+            capacity=capacity,
+        )
+
+        DictLoader.__init__(self, templates)

liquid/{builtin/loaders → loaders}/file_system_loader.py

@@ -1,46 +1,46 @@
-"""Built-in file system loader."""
-
 from __future__ import annotations
 
 import asyncio
 import os
+from collections.abc import Iterable
 from functools import partial
-from pathlib import Path
-from pathlib import PurePath
+from pathlib import Path, PurePath
 from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import Optional
-from typing import Union
 
-from liquid.exceptions import TemplateNotFoundError
-from liquid.loader import BaseLoader
-from liquid.loader import TemplateSource
+from .._loader import Loader, TemplateSource
+from ..exceptions import TemplateNotFoundError
 
 if TYPE_CHECKING:
-    from liquid import Environment
-    from liquid import RenderContext
-
-
-class FileSystemLoader(BaseLoader):
-    """A loader that loads templates from one or more directories on the file system.
-
-    Args:
-        search_path: One or more paths to search.
-        encoding: Encoding to use when opening files.
-        ext: A default file extension. Should include a leading period.
-        reject_symlinks: When `True`, reject paths to symlinks that resolve to files
-            outside the search path. Defaults to `False`.
-
-    Raise:
-        ValueError if `ext` is not a valid suffix.
+    from liquid import Environment, RenderContext
+
+
+class FileSystemLoader(Loader):
+    """A loader that loads templates from one or more directories on a file system.
+
+    Parameters
+    ----------
+    search_path
+        One or more paths to search.
+    encoding
+        Encoding to use when opening files.
+    ext
+        A default file extension. Should include a leading period.
+    reject_symlinks
+        When ``True``, reject paths to symlinks that resolve to files outside the
+        search path. Defaults to `False`.
+
+    Raises
+    ------
+    ValueError
+        If `ext` is not a valid suffix.
     """
 
     def __init__(
         self,
-        search_path: Union[str, Path, Iterable[Union[str, Path]]],
+        search_path: str | Path | Iterable[str | Path],
         *,
         encoding: str = "utf-8",
-        ext: Optional[str] = None,
+        ext: str | None = None,
         reject_symlinks: bool = False,
     ):
         super().__init__()
@@ -56,25 +56,19 @@ class FileSystemLoader(BaseLoader):
         if ext:
             Path("x").with_suffix(ext)
 
-    def resolve_path(self, template_name: str) -> Path:
-        """Return a path to the template identified by _template_name_.
-
-        If the search path is a list of paths, returns the first path where
-        _template_name_ exists. If none of the search paths contain _template_name_, a
-        _TemplateNotFound_ exception is raised.
-        """
-        template_path = PurePath(template_name)
+    def resolve_path(self, name: str) -> Path:
+        template_path = PurePath(name)
         if template_path.anchor:
             template_path = PurePath(*template_path.parts[1:])
 
         if not template_path.name:
-            raise TemplateNotFoundError(template_name)
+            raise TemplateNotFoundError(name)
 
         if self.ext and not template_path.suffix:
             template_path = template_path.with_suffix(self.ext)
 
         if os.path.pardir in template_path.parts or template_path.is_absolute():
-            raise TemplateNotFoundError(template_name)
+            raise TemplateNotFoundError(name)
 
         for base in self.search_path:
             base_resolved = base.resolve()
@@ -96,7 +90,7 @@ class FileSystemLoader(BaseLoader):
             # We don't want to expose a fully qualified path in error messages.
             return base / template_path
 
-        raise TemplateNotFoundError(template_name)
+        raise TemplateNotFoundError(name)
 
     def _read(self, source_path: Path) -> tuple[str, float]:
         with source_path.open(encoding=self.encoding) as fd:
@@ -105,19 +99,19 @@ class FileSystemLoader(BaseLoader):
 
     def get_source(
         self,
-        env: Environment,  # noqa: ARG002
-        template_name: str,
-        *,
-        context: Optional[RenderContext] = None,  # noqa: ARG002
-        **kwargs: object,  # noqa: ARG002
+        env: Environment,
+        name: str,
+        context: RenderContext | None = None,
+        **kwargs: object,
     ) -> TemplateSource:
         """Get source information for a template."""
-        source_path = self.resolve_path(template_name)
+        source_path = self.resolve_path(name)
         source, mtime = self._read(source_path)
         return TemplateSource(
-            source,
-            str(source_path),
-            partial(self._uptodate, source_path, mtime),
+            text=source,
+            name=source_path.name,
+            path=str(source_path),
+            up_to_date=partial(self._uptodate, source_path, mtime),
         )
 
     @staticmethod
@@ -132,16 +126,18 @@ class FileSystemLoader(BaseLoader):
 
     async def get_source_async(
         self,
-        env: Environment,  # noqa: ARG002
-        template_name: str,
-        *,
-        context: Optional[RenderContext] = None,  # noqa: ARG002
-        **kwargs: object,  # noqa: ARG002
+        env: Environment,
+        name: str,
+        context: RenderContext | None = None,
+        **kwargs: object,
     ) -> TemplateSource:
         """Get source information for a template."""
         loop = asyncio.get_running_loop()
-        source_path = await loop.run_in_executor(None, self.resolve_path, template_name)
+        source_path = await loop.run_in_executor(None, self.resolve_path, name)
         source, mtime = await loop.run_in_executor(None, self._read, source_path)
         return TemplateSource(
-            source, str(source_path), partial(self._uptodate_async, source_path, mtime)
+            text=source,
+            name=source_path.name,
+            path=str(source_path),
+            up_to_date=partial(self._uptodate_async, source_path, mtime),
         )

liquid/{builtin/loaders → loaders}/mixins.py

@@ -1,28 +1,18 @@
-"""Mixin classes that can be used to add common functions to a template loader."""
-
 from __future__ import annotations
 
 from abc import ABC
 from contextlib import suppress
 from functools import partial
-from typing import TYPE_CHECKING
-from typing import Awaitable
-from typing import Callable
-from typing import Mapping
-from typing import Optional
-from typing import Protocol
+from typing import TYPE_CHECKING, Protocol
 
-from liquid.utils import LRUCache
-from liquid.utils import ThreadSafeLRUCache
+from .._lru_cache import LRUCache, ThreadSafeLRUCache
 
 if TYPE_CHECKING:
-    from liquid import BoundTemplate
-    from liquid import Environment
-    from liquid import RenderContext
-
-# ruff: noqa: D102
+    from collections.abc import Awaitable, Callable, Mapping
 
-# ignoring "safe-super" type errors due to https://github.com/python/mypy/issues/14757
+    from .._context import RenderContext
+    from .._template import Template
+    from ..environment import Environment
 
 
 class _CachingLoaderProtocol(Protocol):
@@ -30,21 +20,19 @@ class _CachingLoaderProtocol(Protocol):
         self,
         env: Environment,
         name: str,
-        *,
-        globals: Optional[Mapping[str, object]] = None,  # noqa: A002
-        context: Optional[RenderContext] = None,
+        globals: Mapping[str, object] | None = None,
+        context: RenderContext | None = None,
         **kwargs: object,
-    ) -> BoundTemplate: ...
+    ) -> Template: ...
 
     async def load_async(  # pragma: no cover
         self,
         env: Environment,
         name: str,
-        *,
-        globals: Optional[Mapping[str, object]] = None,  # noqa: A002
-        context: Optional[RenderContext] = None,
+        globals: Mapping[str, object] | None = None,
+        context: RenderContext | None = None,
         **kwargs: object,
-    ) -> BoundTemplate: ...
+    ) -> Template: ...
 
 
 class CachingLoaderMixin(ABC, _CachingLoaderProtocol):
@@ -62,19 +50,20 @@ class CachingLoaderMixin(ABC, _CachingLoaderProtocol):
     ):
         self.auto_reload = auto_reload
         self.cache = (
-            ThreadSafeLRUCache[str, "BoundTemplate"](capacity=capacity)
+            ThreadSafeLRUCache[str, "Template"](capacity=capacity)
             if thread_safe
-            else LRUCache[str, "BoundTemplate"](capacity=capacity)
+            else LRUCache[str, "Template"](capacity=capacity)
         )
         self.namespace_key = namespace_key
 
     def _check_cache(
         self,
-        env: Environment,  # noqa: ARG002
+        *,
+        env: Environment,
         cache_key: str,
-        globals: Optional[Mapping[str, object]],  # noqa: A002
-        load_func: Callable[[], BoundTemplate],
-    ) -> BoundTemplate:
+        globals: Mapping[str, object] | None,
+        load_func: Callable[[], Template],
+    ) -> Template:
         try:
             cached_template = self.cache[cache_key]
         except KeyError:
@@ -93,11 +82,12 @@ class CachingLoaderMixin(ABC, _CachingLoaderProtocol):
 
     async def _check_cache_async(
         self,
-        env: Environment,  # noqa: ARG002
+        *,
+        env: Environment,
         cache_key: str,
-        globals: Optional[Mapping[str, object]],  # noqa: A002
-        load_func: Callable[[], Awaitable[BoundTemplate]],
-    ) -> BoundTemplate:
+        globals: Mapping[str, object] | None,
+        load_func: Callable[[], Awaitable[Template]],
+    ) -> Template:
         try:
             cached_template = self.cache[cache_key]
         except KeyError:
@@ -118,17 +108,16 @@ class CachingLoaderMixin(ABC, _CachingLoaderProtocol):
         self,
         env: Environment,
         name: str,
-        *,
-        globals: Optional[Mapping[str, object]] = None,  # noqa: A002
-        context: Optional[RenderContext] = None,
+        globals: Mapping[str, object] | None = None,
+        context: RenderContext | None = None,
         **kwargs: object,
-    ) -> BoundTemplate:
+    ) -> Template:
         cache_key = self.cache_key(name, context, kwargs)
         return self._check_cache(
-            env,
-            cache_key,
-            globals,
-            partial(
+            env=env,
+            cache_key=cache_key,
+            globals=globals,
+            load_func=partial(
                 super().load,  # type: ignore
                 env,
                 name,
@@ -142,17 +131,16 @@ class CachingLoaderMixin(ABC, _CachingLoaderProtocol):
         self,
         env: Environment,
         name: str,
-        *,
-        globals: Optional[Mapping[str, object]] = None,  # noqa: A002
-        context: Optional[RenderContext] = None,
+        globals: Mapping[str, object] | None = None,
+        context: RenderContext | None = None,
         **kwargs: object,
-    ) -> BoundTemplate:
+    ) -> Template:
         cache_key = self.cache_key(name, context, kwargs)
         return await self._check_cache_async(
-            env,
-            cache_key,
-            globals,
-            partial(
+            env=env,
+            cache_key=cache_key,
+            globals=globals,
+            load_func=partial(
                 super().load_async,  # type: ignore
                 env,
                 name,
@@ -165,7 +153,7 @@ class CachingLoaderMixin(ABC, _CachingLoaderProtocol):
     def cache_key(
         self,
         name: str,
-        context: Optional[RenderContext],
+        context: RenderContext | None,
         args: Mapping[str, object],
     ) -> str:
         if not self.namespace_key: