banks 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

banks/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2023-present Massimiliano Pippi <mpippi@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "2.2.0"
+__version__ = "2.4.0"

banks/config.py

@@ -28,9 +28,12 @@ class _BanksConfig:
             return original_value
 
         # Convert string from env var to the actual type
-        t = super().__getattribute__("__annotations__")[name]
+        annotations = getattr(type(self), "__annotations__", {})
+        t = annotations.get(name, type(original_value))
         if t is bool:
             return strtobool(read_value)
+        if t is Any:
+            return read_value
 
         return t(read_value)
 

banks/env.py

@@ -4,7 +4,7 @@
 from jinja2 import Environment, select_autoescape
 
 from .config import config
-from .filters import audio, cache_control, image, lemmatize, tool, xml
+from .filters import audio, cache_control, document, image, lemmatize, tool, video, xml
 
 
 def _add_extensions(_env):
@@ -38,6 +38,8 @@ env.filters["image"] = image
 env.filters["lemmatize"] = lemmatize
 env.filters["tool"] = tool
 env.filters["audio"] = audio
+env.filters["video"] = video
+env.filters["document"] = document
 env.filters["to_xml"] = xml
 
 _add_extensions(env)

banks/errors.py

@@ -14,7 +14,7 @@ class CanaryWordError(Exception):
 
 
 class PromptNotFoundError(Exception):
-    """The prompt was now found in the registry."""
+    """The prompt was not found in the registry."""
 
 
 class InvalidPromptError(Exception):

banks/extensions/completion.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: MIT
 import importlib
 import json
-from typing import cast
+from typing import TYPE_CHECKING, Any, Callable, cast
 
 from jinja2 import TemplateSyntaxError, nodes
 from jinja2.ext import Extension
@@ -12,6 +12,8 @@ from pydantic import ValidationError
 from banks.errors import InvalidPromptError, LLMError
 from banks.types import ChatMessage, Tool
 
+if TYPE_CHECKING:
+    from litellm.types.utils import ChatCompletionMessageToolCall
 SUPPORTED_KWARGS = ("model",)
 LITELLM_INSTALL_MSG = "litellm is not installed. Please install it with `pip install litellm`."
 
@@ -74,7 +76,19 @@ class CompletionExtension(Extension):
             return nodes.CallBlock(self.call_method("_do_completion_async", args), [], [], body).set_lineno(lineno)
         return nodes.CallBlock(self.call_method("_do_completion", args), [], [], body).set_lineno(lineno)
 
-    def _get_tool_callable(self, tools, tool_call):
+    def _get_tool_callable(self, tools: list[Tool], tool_call: "ChatCompletionMessageToolCall") -> Callable[..., Any]:
+        """Get the callable function for a tool call.
+
+        Args:
+            tools: List of available tools
+            tool_call: The tool call from the LLM response
+
+        Returns:
+            The callable function
+
+        Raises:
+            ValueError: If the function is not found in available tools
+        """
         for tool in tools:
             if tool.function.name == tool_call.function.name:
                 module_name, func_name = tool.import_path.rsplit(".", maxsplit=1)

banks/filters/__init__.py

@@ -3,9 +3,11 @@
 # SPDX-License-Identifier: MIT
 from .audio import audio
 from .cache_control import cache_control
+from .document import document
 from .image import image
 from .lemmatize import lemmatize
 from .tool import tool
+from .video import video
 from .xml import xml
 
-__all__ = ("cache_control", "image", "lemmatize", "tool", "audio", "xml")
+__all__ = ("cache_control", "image", "lemmatize", "tool", "audio", "video", "document", "xml")

banks/filters/audio.py

@@ -1,23 +1,76 @@
 # SPDX-FileCopyrightText: 2023-present Massimiliano Pippi <mpippi@gmail.com>
 #
 # SPDX-License-Identifier: MIT
+import re
 from pathlib import Path
+from typing import cast
+from urllib.parse import urlparse
 
-from banks.types import ContentBlock, InputAudio
+import filetype  # type: ignore[import-untyped]
 
+from banks.types import AudioFormat, ContentBlock, InputAudio, resolve_binary
 
-def audio(value: str) -> str:
+BASE64_AUDIO_REGEX = re.compile(r"audio\/.*;base64,.*")
+
+
+def _is_url(string: str) -> bool:
+    """Check if a string is a URL."""
+    result = urlparse(string)
+    if not result.scheme:
+        return False
+
+    if not result.netloc:
+        # The only valid format when netloc is empty is base64 data urls
+        return all([result.scheme == "data", BASE64_AUDIO_REGEX.match(result.path)])
+
+    return True
+
+
+def _get_audio_format_from_url(url: str) -> AudioFormat:
+    """Extract audio format from URL.
+
+    Tries to determine format from URL path or defaults to mp3.
+    """
+    parsed = urlparse(url)
+    path = parsed.path.lower()
+    for fmt in ("mp3", "wav", "m4a", "webm", "ogg", "flac"):
+        if path.endswith(f".{fmt}"):
+            return cast(AudioFormat, fmt)
+    # Default to mp3 if format cannot be determined
+    return "mp3"
+
+
+def _get_audio_format_from_bytes(data: bytes) -> AudioFormat:
+    """Extract audio format from bytes data using filetype library."""
+    kind = filetype.guess(data)
+    if kind is not None:
+        fmt = kind.extension
+        if fmt in ("mp3", "wav", "m4a", "webm", "ogg", "flac"):
+            return cast(AudioFormat, fmt)
+    # Default to mp3 if format cannot be determined
+    return "mp3"
+
+
+def audio(value: str | bytes) -> str:
     """Wrap the filtered value into a ContentBlock of type audio.
 
     The resulting ChatMessage will have the field `content` populated with a list of ContentBlock objects.
 
+    Supports both file paths and URLs (including data URLs).
+
     Example:
         ```jinja
-        Describe what you see
-
-        {{ "path/to/audio/file" | audio }}
+        {{ "path/to/audio/file.mp3" | audio }}
+        {{ "https://example.com/audio.mp3" | audio }}
         ```
     """
-    input_audio = InputAudio.from_path(Path(value))
+    if isinstance(value, bytes):
+        audio_format = _get_audio_format_from_bytes(resolve_binary(value, as_base64=False))
+        input_audio = InputAudio.from_bytes(value, audio_format=audio_format)
+    elif _is_url(value):
+        audio_format = _get_audio_format_from_url(value)
+        input_audio = InputAudio.from_url(value, audio_format)
+    else:
+        input_audio = InputAudio.from_path(Path(value))
     block = ContentBlock.model_validate({"type": "audio", "input_audio": input_audio})
     return f"<content_block>{block.model_dump_json()}</content_block>"

banks/filters/document.py

@@ -0,0 +1,135 @@
+# SPDX-FileCopyrightText: 2023-present Massimiliano Pippi <mpippi@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+import mimetypes
+import re
+from pathlib import Path
+from typing import cast
+from urllib.parse import urlparse
+
+import filetype  # type: ignore[import-untyped]
+
+from banks.types import ContentBlock, DocumentFormat, InputDocument, resolve_binary
+
+BASE64_DOCUMENT_REGEX = re.compile(r"(text|application)\/.*;base64,.*")
+
+
+def _is_url(string: str) -> bool:
+    """Check if a string is a URL."""
+    result = urlparse(string)
+    if not result.scheme:
+        return False
+
+    if not result.netloc:
+        # The only valid format when netloc is empty is base64 data urls
+        return all([result.scheme == "data", BASE64_DOCUMENT_REGEX.match(result.path)])
+
+    return True
+
+
+def _get_document_format_from_url(url: str) -> DocumentFormat:
+    """Extract document format from URL.
+
+    Tries to determine format from URL path or defaults to pdf.
+    """
+    parsed = urlparse(url)
+    path = parsed.path.lower()
+    # Gemini supported file types https://ai.google.dev/gemini-api/docs/file-input-methods
+    # text/html
+    # text/css
+    # text/plain
+    # text/xml
+    # text/csv
+    # text/rtf
+    # text/javascript
+    # application/json
+    # application/pdf
+
+    # Claude supported file types
+    # application/pdf
+    # text/plain
+
+    # OpenAI supported file types
+    # application/pdf
+
+    for fmt in (
+        "pdf",
+        "html",
+        "htm",
+        "xhtml",
+        "css",
+        "txt",
+        "md",
+        "markdown",
+        "rst",
+        "xml",
+        "csv",
+        "rtf",
+        "js",
+        "mjs",
+        "cjs",
+        "javascript",
+        "json",
+    ):
+        # Because Claude only supports pdf and text, and Gemini only supports a small subset of text formats,
+        # we can default to 'txt' for any text-based format that is not pdf. This allows the data to be sent to the llm
+        # in an acceptable format, but the LLM should still be able to understand the content: e.g., html, markdown,
+        # xml, etc.
+        if path.endswith(f".{fmt}"):
+            if fmt == "pdf":
+                return cast(DocumentFormat, "pdf")
+            return "txt"
+    mime = mimetypes.guess_type(path)[0]
+    if mime is not None and mime.startswith("text/"):
+        return "txt"
+    # With urls, the likelihood seems sufficiently high that it's probably a pdf if not otherwise indicated
+    if mime is None:
+        return "pdf"
+    # Document type indicated to be other than pdf or text type
+    raise ValueError("Unsupported document format: " + path)
+
+
+def _get_document_format_from_bytes(data: bytes) -> DocumentFormat:
+    """Extract document format from bytes data using filetype library."""
+    # First check for pdf (only non text based format) and RTF formats (can be detected by file header)
+    kind = filetype.guess(data)
+    if kind is not None:
+        fmt = kind.extension
+        if fmt == "pdf":
+            return cast(DocumentFormat, fmt)
+
+    # filetype is good at detecting binary formats, but not text-based ones.
+    # So, this is a good indicator that it's text-based.
+    # Because Claude only supports pdf and text, and Gemini only supports a small subset of text formats,
+    # we can default to 'txt' for any text-based format that is not pdf. This allows the data to be sent to the llm in
+    # an acceptable format, but the LLM should still be able to understand the content: e.g., html, markdown, xml, etc.
+    # If detecting text types should become desirable, I recommend using something like Google magicka
+    if kind is None or kind.extension == "rtf":
+        return "txt"
+    # There are many common document types (like word, excel, powerpoint, etc.) that are not supported.
+    raise ValueError("Unsupported document format: " + kind.extension)
+
+
+def document(value: str | bytes) -> str:
+    """Wrap the filtered value into a ContentBlock of type document.
+
+    The resulting ChatMessage will have the field `content` populated with a list of ContentBlock objects.
+
+    Supports both file paths and URLs (including data URLs).
+
+    Example:
+        ```jinja
+        {{ "path/to/document/file.pdf" | document }}
+        {{ "https://example.com/document.pdf" | document }}
+        ```
+    """
+    if isinstance(value, bytes):
+        document_format = _get_document_format_from_bytes(resolve_binary(value, as_base64=False))
+        input_document = InputDocument.from_bytes(value, document_format=document_format)
+    elif _is_url(value):
+        document_format = _get_document_format_from_url(value)
+        input_document = InputDocument.from_url(value, document_format)
+    else:
+        input_document = InputDocument.from_path(Path(value))
+    block = ContentBlock.model_validate({"type": "document", "input_document": input_document})
+    return f"<content_block>{block.model_dump_json()}</content_block>"

banks/filters/image.py

@@ -22,7 +22,7 @@ def _is_url(string: str) -> bool:
     return True
 
 
-def image(value: str) -> str:
+def image(value: str | bytes) -> str:
     """Wrap the filtered value into a ContentBlock of type image.
 
     The resulting ChatMessage will have the field `content` populated with a list of ContentBlock objects.
@@ -38,7 +38,9 @@ def image(value: str) -> str:
         this filter marks the content to cache by surrounding it with `<content_block>` and
         `</content_block>`, so it's only useful when used within a `{% chat %}` block.
     """
-    if _is_url(value):
+    if isinstance(value, bytes):
+        image_url = ImageUrl.from_bytes(bytes_str=value)
+    elif _is_url(value):
         image_url = ImageUrl(url=value)
     else:
         image_url = ImageUrl.from_path(Path(value))

banks/filters/video.py

@@ -0,0 +1,108 @@
+# SPDX-FileCopyrightText: 2023-present Massimiliano Pippi <mpippi@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+import re
+from pathlib import Path
+from typing import cast
+from urllib.parse import urlparse
+
+import filetype  # type: ignore[import-untyped]
+from filetype.types.video import IsoBmff  # type: ignore[import-untyped]
+
+from banks.types import ContentBlock, InputVideo, VideoFormat, resolve_binary
+
+BASE64_VIDEO_REGEX = re.compile(r"video\/.*;base64,.*")
+
+
+class M3gp(IsoBmff):
+    """
+    Implements the 3gp video type matcher.
+
+    The type matcher in the filetype lib does not work correctly for 3gp files,
+    so implement our own here.
+    """
+
+    MIME = "video/3gpp"
+    EXTENSION = "3gp"
+
+    def __init__(self):
+        super().__init__(mime=M3gp.MIME, extension=M3gp.EXTENSION)
+
+    def match(self, buf):
+        if not self._is_isobmff(buf):
+            return False
+
+        major_brand, _, compatible_brands = self._get_ftyp(buf)
+        for brand in compatible_brands:
+            if brand in ["3gp4", "3gp5", "3gpp"]:
+                return True
+        return major_brand in ["3gp4", "3gp5", "3gpp"]
+
+
+def _is_url(string: str) -> bool:
+    """Check if a string is a URL."""
+    result = urlparse(string)
+    if not result.scheme:
+        return False
+
+    if not result.netloc:
+        # The only valid format when netloc is empty is base64 data urls
+        return all([result.scheme == "data", BASE64_VIDEO_REGEX.match(result.path)])
+
+    return True
+
+
+def _get_video_format_from_url(url: str) -> VideoFormat:
+    """Extract video format from URL.
+
+    Tries to determine format from URL path or defaults to mp4.
+    """
+    parsed = urlparse(url)
+    path = parsed.path.lower()
+
+    # Based on formats supported by Gemini https://ai.google.dev/gemini-api/docs/video-understanding
+    for fmt in ("mp4", "mpeg", "mov", "avi", "flv", "mpg", "webm", "wmv", "3gpp"):
+        if path.endswith(f".{fmt}"):
+            return cast(VideoFormat, fmt)
+    # Default to mp4 if format cannot be determined
+    return "mp4"
+
+
+def _get_video_format_from_bytes(data: bytes) -> VideoFormat:
+    """Extract video format from bytes data using filetype library."""
+    m3gp = M3gp()
+    if m3gp not in filetype.types:
+        filetype.add_type(m3gp)
+
+    kind = filetype.guess(data)
+    if kind is not None:
+        fmt = kind.extension
+        if fmt in ("mp4", "mpg", "mov", "avi", "flv", "webm", "wmv", "3gp"):
+            return cast(VideoFormat, fmt)
+    # Default to mp4 if format cannot be determined
+    return "mp4"
+
+
+def video(value: str | bytes) -> str:
+    """Wrap the filtered value into a ContentBlock of type video.
+
+    The resulting ChatMessage will have the field `content` populated with a list of ContentBlock objects.
+
+    Supports both file paths and URLs (including data URLs).
+
+    Example:
+        ```jinja
+        {{ "path/to/video/file.mp4" | video }}
+        {{ "https://example.com/video.mp4" | video }}
+        ```
+    """
+    if isinstance(value, bytes):
+        video_format = _get_video_format_from_bytes(resolve_binary(value, as_base64=False))
+        input_video = InputVideo.from_bytes(value, video_format=video_format)
+    elif _is_url(value):
+        video_format = _get_video_format_from_url(value)
+        input_video = InputVideo.from_url(value, video_format)
+    else:
+        input_video = InputVideo.from_path(Path(value))
+    block = ContentBlock.model_validate({"type": "video", "input_video": input_video})
+    return f"<content_block>{block.model_dump_json()}</content_block>"

banks/prompt.py

@@ -81,8 +81,17 @@ class BasePrompt:
 
     @property
     def variables(self) -> set[str]:
-        ast = env.parse(self.raw)
-        return meta.find_undeclared_variables(ast)
+        try:
+            ast = env.parse(self.raw)
+            return meta.find_undeclared_variables(ast)
+        except Exception as e:
+            from jinja2 import TemplateSyntaxError
+
+            if isinstance(e, TemplateSyntaxError):
+                raise
+            # Re-raise as TemplateSyntaxError for consistency
+            msg = f"Failed to parse template: {e}"
+            raise TemplateSyntaxError(msg, 0) from e
 
     def canary_leaked(self, text: str) -> bool:
         """Returns whether the canary word is present in `text`, signalling the prompt might have leaked."""

banks/types.py

@@ -5,11 +5,14 @@ from __future__ import annotations
 
 import base64
 import re
+from base64 import b64decode, b64encode
+from binascii import Error as BinasciiError
 from enum import Enum
 from inspect import Parameter, getdoc, signature
 from pathlib import Path
 from typing import Callable, Literal, Union, cast
 
+import filetype  # type: ignore[import-untyped]
 from pydantic import BaseModel
 from typing_extensions import Self
 
@@ -19,10 +22,37 @@ from .utils import parse_params_from_docstring, python_type_to_jsonschema
 CONTENT_BLOCK_REGEX = re.compile(r"(<content_block>\{.*?\}<\/content_block>)|([^<](?:(?!<content_block>)[\s\S])*)")
 
 
+def resolve_binary(bytes_str: bytes, *, as_base64: bool = True) -> bytes:
+    """
+    Resolve binary data between base64 and raw bytes.
+
+    Args:
+        bytes_str: Bytes data
+        as_base64: Whether to return base64 encoded bytes or raw bytes
+
+    Returns:
+        b64 encoded bytes if input is not base64 encoded, else returns input as is.
+    """
+    # check if bytes_str is base64 encoded
+    try:
+        # Check if raw_bytes is already base64 encoded.
+        # b64decode() can succeed on random binary data, so we
+        # pass verify=True to make sure it's not a false positive
+        raw_bytes = base64.b64decode(bytes_str, validate=True)
+        b64_bytes = bytes_str
+    except BinasciiError:
+        # b64decode failed, leave as is
+        raw_bytes = bytes_str
+        b64_bytes = b64encode(bytes_str)
+    return b64_bytes if as_base64 else raw_bytes
+
+
 class ContentBlockType(str, Enum):
     text = "text"
     image_url = "image_url"
     audio = "audio"
+    video = "video"
+    document = "document"
 
 
 class CacheControl(BaseModel):
@@ -32,6 +62,14 @@ class CacheControl(BaseModel):
 class ImageUrl(BaseModel):
     url: str
 
+    @staticmethod
+    def _mimetype_from_bytes(raw_bytes: bytes) -> str:
+        kind = filetype.guess(raw_bytes)
+        if kind is not None:
+            return kind.mime
+        # Default to jpeg if format cannot be determined
+        return "image/jpeg"
+
     @classmethod
     def from_base64(cls, media_type: str, base64_str: str) -> Self:
         return cls(url=f"data:{media_type};base64,{base64_str}")
@@ -39,10 +77,31 @@ class ImageUrl(BaseModel):
     @classmethod
     def from_path(cls, file_path: Path) -> Self:
         with open(file_path, "rb") as image_file:
-            return cls.from_base64("image/jpeg", base64.b64encode(image_file.read()).decode("utf-8"))
+            raw_bytes = image_file.read()
+            mimetype = cls._mimetype_from_bytes(raw_bytes)
+            return cls.from_base64(mimetype, base64.b64encode(raw_bytes).decode("utf-8"))
+
+    @classmethod
+    def from_bytes(cls, bytes_str: bytes) -> Self:
+        """Create ImageUrl from bytes
+        Args:
+            bytes_str: Bytes data
+        Returns:
+            ImageUrl instance with base64 encoded bytes as URL
+        """
+        b64_bytes = resolve_binary(bytes_str)
+        mimetype = cls._mimetype_from_bytes(b64decode(b64_bytes))
+        return cls.from_base64(mimetype, b64_bytes.decode("utf-8"))
 
 
 AudioFormat = Literal["mp3", "wav", "m4a", "webm", "ogg", "flac"]
+VideoFormat = Literal["mp4", "mpg", "mov", "avi", "flv", "webm", "wmv", "3gp", "3gpp"]
+# Because Claude only supports pdf and text, and Gemini only supports a small subset of text formats,
+# we can default to 'txt' for any text-based format that is not pdf. This allows the data to be sent to the llm
+# in an acceptable format, but the LLM should still be able to understand the content: e.g., html, markdown,
+# xml, etc.
+# If detecting text types should become desirable, I recommend using something like Google magicka
+DocumentFormat = Literal["pdf", "txt"]
 
 
 class InputAudio(BaseModel):
@@ -56,6 +115,114 @@ class InputAudio(BaseModel):
             file_format = cast(AudioFormat, file_path.suffix[1:])
             return cls(data=encoded_str, format=file_format)
 
+    @classmethod
+    def from_url(cls, url: str, audio_format: AudioFormat) -> Self:
+        """Create InputAudio from a URL.
+
+        Args:
+            url: The URL to the audio file
+            audio_format: The audio format
+
+        Returns:
+            InputAudio instance with the URL as data
+        """
+        return cls(data=url, format=audio_format)
+
+    @classmethod
+    def from_bytes(cls, bytes_str: bytes, audio_format: AudioFormat) -> Self:
+        """Create InputAudio from bytes
+
+        Args:
+            bytes_str: Bytes data
+            audio_format: The audio format
+
+        Returns:
+            InputAudio instance with base64 encoded bytes as data
+        """
+        b64_bytes = resolve_binary(bytes_str)
+        encoded_str = b64_bytes.decode("utf-8")
+        return cls(data=encoded_str, format=audio_format)
+
+
+class InputVideo(BaseModel):
+    data: str
+    format: VideoFormat
+
+    @classmethod
+    def from_path(cls, file_path: Path) -> Self:
+        with open(file_path, "rb") as video_file:
+            encoded_str = base64.b64encode(video_file.read()).decode("utf-8")
+            file_format = cast(VideoFormat, file_path.suffix[1:])
+            return cls(data=encoded_str, format=file_format)
+
+    @classmethod
+    def from_url(cls, url: str, video_format: VideoFormat) -> Self:
+        """Create InputVideo from a URL.
+
+        Args:
+            url: The URL to the audio file
+            video_format: The audio format
+
+        Returns:
+            InputVideo instance with the URL as data
+        """
+        return cls(data=url, format=video_format)
+
+    @classmethod
+    def from_bytes(cls, bytes_str: bytes, video_format: VideoFormat) -> Self:
+        """Create InputVideo from bytes
+
+        Args:
+            bytes_str: Bytes data
+            video_format: The video format
+
+        Returns:
+            InputVideo instance with base64 encoded bytes as data
+        """
+        b64_bytes = resolve_binary(bytes_str)
+        encoded_str = b64_bytes.decode("utf-8")
+        return cls(data=encoded_str, format=video_format)
+
+
+class InputDocument(BaseModel):
+    data: str
+    format: DocumentFormat
+
+    @classmethod
+    def from_path(cls, file_path: Path) -> Self:
+        with open(file_path, "rb") as document_file:
+            encoded_str = base64.b64encode(document_file.read()).decode("utf-8")
+            file_format = cast(DocumentFormat, file_path.suffix[1:])
+            return cls(data=encoded_str, format=file_format)
+
+    @classmethod
+    def from_url(cls, url: str, document_format: DocumentFormat) -> Self:
+        """Create InputDocument from a URL.
+
+        Args:
+            url: The URL to the document file
+            document_format: The document format
+
+        Returns:
+            InputDocument instance with the URL as data
+        """
+        return cls(data=url, format=document_format)
+
+    @classmethod
+    def from_bytes(cls, bytes_str: bytes, document_format: DocumentFormat) -> Self:
+        """Create InputDocument from bytes
+
+        Args:
+            bytes_str: Bytes data
+            document_format: The document format
+
+        Returns:
+            InputDocument instance with base64 encoded bytes as data
+        """
+        b64_bytes = resolve_binary(bytes_str)
+        encoded_str = b64_bytes.decode("utf-8")
+        return cls(data=encoded_str, format=document_format)
+
 
 class ContentBlock(BaseModel):
     type: ContentBlockType
@@ -63,6 +230,8 @@ class ContentBlock(BaseModel):
     text: str | None = None
     image_url: ImageUrl | None = None
     input_audio: InputAudio | None = None
+    input_video: InputVideo | None = None
+    input_document: InputDocument | None = None
 
 
 ChatMessageContent = Union[list[ContentBlock], str]

{banks-2.2.0.dist-info → banks-2.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: banks
-Version: 2.2.0
+Version: 2.4.0
 Summary: A prompt programming language
 Project-URL: Documentation, https://github.com/masci/banks#readme
 Project-URL: Issues, https://github.com/masci/banks/issues
@@ -15,11 +15,13 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9
 Requires-Dist: deprecated
 Requires-Dist: eval-type-backport; python_version < '3.10'
+Requires-Dist: filetype>=1.2.0
 Requires-Dist: griffe
 Requires-Dist: jinja2
 Requires-Dist: platformdirs
@@ -125,11 +127,11 @@ print(p.chat_messages({"persona": "helpful assistant"}))
 # [
 #   ChatMessage(role='system', content=[
 #      ContentBlock(type=<ContentBlockType.text: 'text'>, cache_control=None, text='You are a helpful assistant.', 
-#                  image_url=None, input_audio=None)
+#                  image_url=None, input_audio=None, input_video=None, input_document=None)
 #   ], tool_call_id=None, name=None), 
 #   ChatMessage(role='user', content=[
 #      ContentBlock(type=<ContentBlockType.text: 'text'>, cache_control=None, text='Hello, how are you?', 
-#                  image_url=None, input_audio=None)
+#                  image_url=None, input_audio=None, input_video=None, input_document=None)
 #   ], tool_call_id=None, name=None)
 # ]
 ```

banks-2.4.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+banks/__about__.py,sha256=Kbqara7VPF_4Txd0QVMWDNL5EqtjtYKEQFgzvx2Dqgc,132
+banks/__init__.py,sha256=4IBopxXstFZliCvSjOuTurSQb32Vy26EXOPhmNZ4Hus,334
+banks/cache.py,sha256=uUGAu82-mfrscc2q24x19ZMZBkoQzf3hh7_V300J-Ik,1069
+banks/config.py,sha256=Ry2pdba1pgepsfmj41hxMdfQCT9pMjdV6TRWySpMiSY,1192
+banks/env.py,sha256=oGC4wjmF0-NTwoi49NooCLqqT44htn6EWDnHsDl2n0I,1347
+banks/errors.py,sha256=EnKRBhHmo8KEcSg3YoDBtVEaooJj9uSqRV1wnzUtrJU,580
+banks/prompt.py,sha256=LXaDGHBywFkD_JmWPQOXqyuQKZgozzDIb5lSZ12xf5A,8505
+banks/types.py,sha256=p74ZUJfH0vZnneOEsAmiHoDGfsbjNLO-VDHYPuov2Yo,11347
+banks/utils.py,sha256=ZetGG3qhXMYOitDZQCWbE33wHEqR0ih2ZEg_dIW8OeI,1827
+banks/extensions/__init__.py,sha256=Lx4UrOzywYQY7a8qvIqvc3ql54nwK0lNP7x3jYdbREY,110
+banks/extensions/chat.py,sha256=VV6UV1wQZcJ0KbIFHSFmDeptWtww4o2IXF5pXB6TpTM,2478
+banks/extensions/completion.py,sha256=p6NdzA5kOuWZ0BIcGQH86Ji4Z4PFz0-h_G2cHgKdYvw,7861
+banks/extensions/docs.py,sha256=vWOZvu2JoS4LwUG-BR3jPqThirYvu3Fdba331UxooYM,1098
+banks/filters/__init__.py,sha256=fcAlKqgDSX19JDQHfTTOtpotxbdC84QbcFF3dKTtEog,430
+banks/filters/audio.py,sha256=x1mWEpzSN2mc_HAUEaNEOUgS_Vh7Wa1VPwRFkRy4oG0,2574
+banks/filters/cache_control.py,sha256=aOGOIzuqasV_TcuFaaXbaoGhA2W9YTFuz7wkatyjXRU,962
+banks/filters/document.py,sha256=hs2IO6d-xcLyTHH50bpzA3848bJLpQYjUkEgjOBYGqE,4893
+banks/filters/image.py,sha256=0t4u2El2Gi92C1qlY_0ji5OpPnjJfTn67SXb2mCIOl8,1507
+banks/filters/lemmatize.py,sha256=Yvp8M4HCx6C0nrcu3UEMtjJUwsyVYI6GQDYOG4S6EEw,887
+banks/filters/tool.py,sha256=i8ukSDYw54ksShVJ2abfRQAiKzKrqUtmgBB1H04cig0,475
+banks/filters/video.py,sha256=MFni5um9Xnq8Sxf6ZBTN5GsKAC6f73CLrqFAGaE2pkk,3531
+banks/filters/xml.py,sha256=uQ_2zfCf8NhpdbF8F5HS7URXvDzsxfg-TEIVGufZbM0,1991
+banks/registries/__init__.py,sha256=iRK-8420cKBckOTd5KcIFQyV66EsF0Mc7UHCkzf8qZU,255
+banks/registries/directory.py,sha256=gRFO7fl9yXHt2NJ1pDA2wPSQtlORhSw1GKWxSTyFzE8,6055
+banks/registries/file.py,sha256=8ayvFrcM8Tk0DWgGXmKD2DRBfGXr5CmgtdQaQ5cXhow,4054
+banks/registries/redis.py,sha256=eBL92URJa-NegOxRLS4b2xrDRDxz6iiaz_7Ddi32Rtc,2756
+banks-2.4.0.dist-info/METADATA,sha256=D94dNSjkJj9vXMecMp7lTiGS_7sM4ipxyRvtbkn8aYs,12258
+banks-2.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+banks-2.4.0.dist-info/licenses/LICENSE.txt,sha256=NZJne_JTwMFwq_g-kq-sm4PuaeVOgu1l3NUGOgBHX-g,1102
+banks-2.4.0.dist-info/RECORD,,

{banks-2.2.0.dist-info → banks-2.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

banks-2.2.0.dist-info/RECORD

@@ -1,28 +0,0 @@
-banks/__about__.py,sha256=77xoXWQ484-a4X30IBRswGGTfRx8t_BwItzAm7NTXwI,132
-banks/__init__.py,sha256=4IBopxXstFZliCvSjOuTurSQb32Vy26EXOPhmNZ4Hus,334
-banks/cache.py,sha256=uUGAu82-mfrscc2q24x19ZMZBkoQzf3hh7_V300J-Ik,1069
-banks/config.py,sha256=c6B1cXUZ-NN0XmJvfezXeHPXHP7knk8TfbmcZL7gCzk,1082
-banks/env.py,sha256=XOSz6QGNSRaqnIdKWhH5U-ci8Tfi1mDyJHit_aE27Ro,1266
-banks/errors.py,sha256=I5cgsa7wtolRVKBSq_aH5xs27yVcErBlMyUswCnM-es,580
-banks/prompt.py,sha256=RhPq3wpE-AiCfCftZpPFj2HXGdazwYD502Pr1e-j7FY,8162
-banks/types.py,sha256=03x7E7FPVfuN39xY--c0fKumnyVUVzNrq9pgG5R-pAU,5520
-banks/utils.py,sha256=ZetGG3qhXMYOitDZQCWbE33wHEqR0ih2ZEg_dIW8OeI,1827
-banks/extensions/__init__.py,sha256=Lx4UrOzywYQY7a8qvIqvc3ql54nwK0lNP7x3jYdbREY,110
-banks/extensions/chat.py,sha256=VV6UV1wQZcJ0KbIFHSFmDeptWtww4o2IXF5pXB6TpTM,2478
-banks/extensions/completion.py,sha256=kF55PiNxjqpslUTAd46H4jOy0eFiLLm5hEcwxS4_oxs,7356
-banks/extensions/docs.py,sha256=vWOZvu2JoS4LwUG-BR3jPqThirYvu3Fdba331UxooYM,1098
-banks/filters/__init__.py,sha256=MMNxopwecFHW4LA76NwL2JQkdddIAGbKOaHUHG1JQs8,353
-banks/filters/audio.py,sha256=2vTPdpDo8FVQsl0WiPlXskwMCGnF8zKwWXfq1fYQzws,726
-banks/filters/cache_control.py,sha256=aOGOIzuqasV_TcuFaaXbaoGhA2W9YTFuz7wkatyjXRU,962
-banks/filters/image.py,sha256=Ls1fWCgRx0YLGIFx7hdKtR1skY575jDWlCESP0zV1Bs,1407
-banks/filters/lemmatize.py,sha256=Yvp8M4HCx6C0nrcu3UEMtjJUwsyVYI6GQDYOG4S6EEw,887
-banks/filters/tool.py,sha256=i8ukSDYw54ksShVJ2abfRQAiKzKrqUtmgBB1H04cig0,475
-banks/filters/xml.py,sha256=uQ_2zfCf8NhpdbF8F5HS7URXvDzsxfg-TEIVGufZbM0,1991
-banks/registries/__init__.py,sha256=iRK-8420cKBckOTd5KcIFQyV66EsF0Mc7UHCkzf8qZU,255
-banks/registries/directory.py,sha256=gRFO7fl9yXHt2NJ1pDA2wPSQtlORhSw1GKWxSTyFzE8,6055
-banks/registries/file.py,sha256=8ayvFrcM8Tk0DWgGXmKD2DRBfGXr5CmgtdQaQ5cXhow,4054
-banks/registries/redis.py,sha256=eBL92URJa-NegOxRLS4b2xrDRDxz6iiaz_7Ddi32Rtc,2756
-banks-2.2.0.dist-info/METADATA,sha256=m2W5swzWGUFGr0uNCFAgOqFtxv4A7fMyjsC34GDBTsk,12098
-banks-2.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-banks-2.2.0.dist-info/licenses/LICENSE.txt,sha256=NZJne_JTwMFwq_g-kq-sm4PuaeVOgu1l3NUGOgBHX-g,1102
-banks-2.2.0.dist-info/RECORD,,