banks 2.1.3__tar.gz → 2.2.0__tar.gz

{banks-2.1.3 → banks-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: banks
-Version: 2.1.3
+Version: 2.2.0
 Summary: A prompt programming language
 Project-URL: Documentation, https://github.com/masci/banks#readme
 Project-URL: Issues, https://github.com/masci/banks/issues

{banks-2.1.3 → banks-2.2.0}/docs/examples.md

@@ -3,6 +3,7 @@
 - [Create a blog writing prompt](#create-a-blog-writing-prompt)
 - [Create a summarizer prompt](#create-a-summarizer-prompt)
 - [Lemmatize text while processing a template](#lemmatize-text-while-processing-a-template)
+- [Convert a JSON-like object into XML while processing the template](#convert-a-json-like-object-into-xml-while-processing-the-template)
 - [Use a LLM to generate a text while rendering a prompt](#use-a-llm-to-generate-a-text-while-rendering-a-prompt)
 - [Render a prompt template as chat messages](#render-a-prompt-template-as-chat-messages)
 - [Use prompt caching from Anthropic](#use-prompt-caching-from-anthropic)
@@ -135,6 +136,57 @@ the cat be run
 Summary:
 ```
 
+## Convert a JSON-like object into XML while processing the template
+
+Banks has built-in support for filtering JSON-like objects (Pydantic `BaseModel` subclasses, dictionaries, deserializable strings) and returning an XML string. 
+
+Here is an example of how you can use it:
+
+```python
+from banks import Prompt
+from pydantic import BaseModel
+from typing import Dict
+
+prompt_template = """
+Please extract the contact details from this user:
+
+{{ data | to_xml }}
+
+Contact details:
+"""
+
+class User(BaseModel):
+    username: str
+    account_id: str
+    registered_at: str
+    email: str
+    phone_number: str
+    social_media_accounts: Dict[str, str]
+
+user = User(username="example", account_id="0000", registered_at="10-25-2024", email="example@email.com", phone_number="0123456789", social_media_accounts={"BlueSky": "@example.com"})
+
+p = Prompt(prompt_template)
+print(p.text({"data": user}))
+```
+
+This will output:
+
+```text
+Please extract the contact details from this user:
+
+<user>
+	<username>example</username>
+	<account_id>0000</account_id>
+	<registered_at>10-25-2024</registered_at>
+	<email>example@email.com</email>
+	<phone_number>0123456789</phone_number>
+	<social_media_accounts>{'BlueSky': '@example.com'}</social_media_accounts>
+</user>
+
+
+Contact details:
+```
+
 ## Use a LLM to generate a text while rendering a prompt
 
 Sometimes it might be useful to ask another LLM to generate examples for you in a

{banks-2.1.3 → banks-2.2.0}/src/banks/__about__.py

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

{banks-2.1.3 → banks-2.2.0}/src/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
+from .filters import audio, cache_control, image, lemmatize, tool, xml
 
 
 def _add_extensions(_env):
@@ -38,5 +38,6 @@ env.filters["image"] = image
 env.filters["lemmatize"] = lemmatize
 env.filters["tool"] = tool
 env.filters["audio"] = audio
+env.filters["to_xml"] = xml
 
 _add_extensions(env)

{banks-2.1.3 → banks-2.2.0}/src/banks/filters/__init__.py

@@ -6,5 +6,6 @@ from .cache_control import cache_control
 from .image import image
 from .lemmatize import lemmatize
 from .tool import tool
+from .xml import xml
 
-__all__ = ("cache_control", "image", "lemmatize", "tool", "audio")
+__all__ = ("cache_control", "image", "lemmatize", "tool", "audio", "xml")

{banks-2.1.3 → banks-2.2.0}/src/banks/filters/image.py

@@ -1,15 +1,25 @@
 # SPDX-FileCopyrightText: 2023-present Massimiliano Pippi <mpippi@gmail.com>
 #
 # SPDX-License-Identifier: MIT
+import re
 from pathlib import Path
 from urllib.parse import urlparse
 
 from banks.types import ContentBlock, ImageUrl
 
+BASE64_PATH_REGEX = re.compile(r"image\/.*;base64,.*")
+
 
 def _is_url(string: str) -> bool:
     result = urlparse(string)
-    return all([result.scheme, result.netloc])
+    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_PATH_REGEX.match(result.path)])
+
+    return True
 
 
 def image(value: str) -> str:

banks-2.2.0/src/banks/filters/xml.py

@@ -0,0 +1,62 @@
+import json
+import xml.etree.ElementTree as ET
+from typing import Any, Optional, Union
+from xml.dom.minidom import parseString
+
+from pydantic import BaseModel
+
+
+def _deserialize(string: str) -> Optional[dict]:
+    try:
+        return json.loads(string)
+    except json.JSONDecodeError:
+        return None
+
+
+def _prepare_dictionary(value: Union[str, BaseModel, dict[str, Any]]):
+    root_tag = "input"
+    if isinstance(value, str):
+        model: Optional[dict[str, Any]] = _deserialize(value)
+        if model is None:
+            msg = f"{value} is not deserializable"
+            raise ValueError(msg)
+    elif isinstance(value, BaseModel):
+        model = value.model_dump()
+        root_tag = value.__class__.__name__.lower()
+    elif isinstance(value, dict):
+        model = value.copy()
+        for k in value.keys():
+            if not isinstance(k, str):
+                key = str(k)
+                if isinstance(k, (int, float)):
+                    key = "_" + key
+                v = model.pop(k)
+                model[key.lower()] = v
+    else:
+        msg = f"Input can only be of type BaseModel, dictionary or deserializable string. Got {type(value)}"
+        raise ValueError(msg)
+    return model, root_tag
+
+
+def xml(value: Union[str, BaseModel, dict[str, Any]]) -> str:
+    """
+    Convert a Pydantic model, a deserializable string or a dictionary into an XML string.
+
+    Example:
+        ```jinja
+        {{'{"username": "user", "email": "example@email.com"}' | to_xml}}
+        "
+        <input>
+            <username>user</username>
+            <email>example@email.com</email>
+        </input>
+        "
+        ```
+    """
+    model, root_tag = _prepare_dictionary(value)
+    xml_model = ET.Element(root_tag)
+    for k, v in model.items():
+        sub = ET.SubElement(xml_model, k)
+        sub.text = str(v)
+    xml_str = ET.tostring(xml_model, encoding="unicode")
+    return parseString(xml_str).toprettyxml().replace('<?xml version="1.0" ?>\n', "")  # noqa: S318

{banks-2.1.3 → banks-2.2.0}/tests/test_image.py

@@ -57,6 +57,23 @@ def test_image_with_file_path(tmp_path):
     assert content_block["image_url"]["url"].startswith("data:image/jpeg;base64,")
 
 
+def test_image_base64(tmp_path):
+    """Test image filter with a binary input"""
+    test_image = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABMgA"
+    result = image(test_image)
+
+    # Verify the content block wrapper
+    assert result.startswith("<content_block>")
+    assert result.endswith("</content_block>")
+
+    # Parse the JSON content
+    json_content = result[15:-16]  # Remove wrapper tags
+    content_block = json.loads(json_content)
+
+    assert content_block["type"] == "image_url"
+    assert content_block["image_url"]["url"].startswith("data:image/png;base64,")
+
+
 def test_image_with_nonexistent_file():
     """Test image filter with a nonexistent file path"""
     with pytest.raises(FileNotFoundError):

banks-2.2.0/tests/test_xml.py

@@ -0,0 +1,70 @@
+import xml.etree.ElementTree as ET
+from typing import Any
+from xml.dom.minidom import parseString
+
+import pytest
+from pydantic import BaseModel
+
+from banks.filters.xml import xml
+
+
+@pytest.fixture
+def xml_string_from_basemodel() -> str:
+    model = ET.Element("person")
+    age = ET.SubElement(model, "age")
+    age.text = "30"
+    name = ET.SubElement(model, "name")
+    name.text = "John Doe"
+    xml_str = ET.tostring(model, encoding="unicode")
+    return parseString(xml_str).toprettyxml().replace('<?xml version="1.0" ?>\n', "")  # noqa: S318
+
+
+@pytest.fixture
+def xml_string_from_other() -> str:
+    model = ET.Element("input")
+    age = ET.SubElement(model, "age")
+    age.text = "30"
+    name = ET.SubElement(model, "name")
+    name.text = "John Doe"
+    xml_str = ET.tostring(model, encoding="unicode")
+    return parseString(xml_str).toprettyxml().replace('<?xml version="1.0" ?>\n', "")  # noqa: S318
+
+
+@pytest.fixture
+def xml_string_from_edge_case() -> str:
+    model = ET.Element("input")
+    hello = ET.SubElement(model, "_1")
+    hello.text = "hello"
+    world = ET.SubElement(model, "_2.4")
+    world.text = "world"
+    xml_str = ET.tostring(model, encoding="unicode")
+    return parseString(xml_str).toprettyxml().replace('<?xml version="1.0" ?>\n', "")  # noqa: S318
+
+
+@pytest.fixture
+def starting_value() -> tuple[BaseModel, dict[str, Any], str]:
+    class Person(BaseModel):
+        age: int
+        name: str
+
+    p = Person(age=30, name="John Doe")
+    return p, p.model_dump(), p.model_dump_json()
+
+
+@pytest.fixture
+def dict_edge_case() -> tuple[dict, str]:
+    return {1: "hello", 2.4: "world"}
+
+
+def test_xml_filter(
+    xml_string_from_basemodel: str,
+    xml_string_from_other: str,
+    starting_value: tuple[BaseModel, dict[str, Any], str],
+    dict_edge_case: dict,
+    xml_string_from_edge_case: str,
+) -> None:
+    model, dictionary, string = starting_value
+    assert xml(model) == xml_string_from_basemodel
+    assert xml(dictionary) == xml_string_from_other
+    assert xml(string) == xml_string_from_other
+    assert xml(dict_edge_case) == xml_string_from_edge_case