lm-deluge 0.0.3__py3-none-any.whl

lm_deluge/util/xml.py

@@ -0,0 +1,291 @@
+import re
+from bs4 import BeautifulSoup, Tag
+
+# import xml.etree.ElementTree as ET
+from lxml import etree  # type: ignore
+
+
+def get_tag(
+    html_string: str, tag: str, return_attributes: bool = False
+) -> dict | str | None:
+    # Try to use regular expressions first
+    if html_string is None:
+        return None
+    try:
+        # Regex pattern to extract tag content and attributes
+        pattern = re.compile(rf"<{tag}([^>]*)>(.*?)</{tag}>", re.DOTALL)
+        match = pattern.search(html_string)
+        if match:
+            tag_attributes = match.group(1)  # Attributes string from the opening tag
+            tag_contents = match.group(2)  # Contents inside the tag
+
+            # If return_attributes is False, just return the tag contents
+            if not return_attributes:
+                return tag_contents
+
+            # Parse attributes into a dictionary
+            attributes_pattern = re.compile(
+                r'(\w+)\s*=\s*"([^"]*)"'
+            )  # Matches key="value"
+            attributes = dict(attributes_pattern.findall(tag_attributes))
+
+            return {"content": tag_contents, "attributes": attributes}
+    except re.error:
+        print(f"Failed to compile regular expression for HTML tag '{tag}'")
+
+    # If regexp fails, use BeautifulSoup
+    try:
+        soup = BeautifulSoup(html_string, "html.parser")
+        tag_content = soup.find(tag)
+        assert tag_content is None or isinstance(
+            tag_content, Tag
+        ), f"Unexpected type for tag_content: {type(tag_content)}"
+        if tag_content is not None:
+            tag_contents = tag_content.decode_contents()
+
+            # If return_attributes is False, return just the content
+            if not return_attributes:
+                return tag_contents
+
+            # Extract attributes from the tag
+            attributes = tag_content.attrs
+
+            return {"content": tag_contents, "attributes": attributes}
+    except Exception as e:
+        print(f"Failed to extract content from HTML tag '{tag}': {e}. Returning None.")
+
+    return None
+
+
+def get_tags(html_string: str, tag: str, return_attributes: bool = False) -> list:
+    """
+    Extract all instances of the <tag></tag> in the string, not just the first.
+    If return_attributes is True, also return the tag's attributes.
+    """
+    if html_string is None:
+        return []
+
+    try:
+        # Regex pattern to match all instances of the tag and capture attributes and content
+        pattern = re.compile(rf"<{tag}([^>]*)>(.*?)</{tag}>", re.DOTALL)
+        matches = pattern.findall(html_string)
+
+        if not return_attributes:
+            return [
+                match[1] for match in matches
+            ]  # Return just the content inside the tags
+
+        # Parse attributes if return_attributes is True
+        attributes_pattern = re.compile(r'(\w+)\s*=\s*"([^"]*)"')  # Matches key="value"
+
+        results = []
+        for match in matches:
+            tag_attributes = match[0]  # The attributes portion of the tag
+            tag_contents = match[1]  # The content portion of the tag
+
+            # Parse attributes into a dictionary
+            attributes = dict(attributes_pattern.findall(tag_attributes))
+            results.append({"content": tag_contents, "attributes": attributes})
+        return results
+    except re.error:
+        print(f"Failed to compile regular expression for HTML tag '{tag}'")
+
+    # Fallback to BeautifulSoup if regex fails
+    try:
+        soup = BeautifulSoup(html_string, "html.parser")
+        tag_contents = soup.find_all(tag)
+
+        if not return_attributes:
+            return [tag_content.decode_contents() for tag_content in tag_contents]  # type: ignore
+
+        # Collect content and attributes when return_attributes is True
+        results = []
+        for tag_content in tag_contents:
+            if isinstance(tag_content, Tag):
+                results.append(
+                    {
+                        "content": tag_content.decode_contents(),
+                        "attributes": tag_content.attrs,
+                    }
+                )
+        return results
+    except Exception as e:
+        print(
+            f"Failed to extract content from HTML tag '{tag}': {e}. Returning no matches."
+        )
+
+    return []
+
+
+def strip_xml(xml_string: str) -> str:
+    """
+    Trim any text before the first '<' and after the last '>'.
+    """
+    if not xml_string:
+        return ""
+    start = xml_string.find("<")
+    end = xml_string.rfind(">") + 1
+    return xml_string[start:end] if start != -1 and end != 0 else xml_string
+
+
+def remove_namespace_prefixes(xml_string):
+    """
+    Remove namespace prefixes from XML tags in the provided XML string.
+    """
+    # Remove namespace prefixes in opening and closing tags
+    xml_string = re.sub(r"<(/?)(\w+:)", r"<\1", xml_string)
+    # Remove namespace declarations in root element
+    xml_string = re.sub(r'xmlns(:\w+)?="[^"]+"', "", xml_string)
+    return xml_string
+
+
+def object_to_xml(
+    obj: dict | list | str | int | float,
+    root_tag: str,
+    ignore_dict_nulls: bool = True,
+    list_item_tag: str = "li",  # could also be "option", "item", etc.
+    include_list_index: bool = True,
+    index_attr: str = "key",  # could be index, id, name, etc.
+    indent_level: int = 0,
+    indent_str: str = "  ",
+    index=None,
+):
+    """
+    Convert a Python object to an XML string.
+    """
+    xml = indent_str * indent_level
+    xml += f"<{root_tag}"
+    if include_list_index and index is not None:
+        xml += f' {index_attr}="{index}"'
+    xml += ">\n"
+    # base case
+    if isinstance(obj, str) or isinstance(obj, int) or isinstance(obj, float):
+        xml += indent_str * (indent_level + 1)
+        xml += f"{obj}\n"
+    elif isinstance(obj, dict):
+        for key, value in obj.items():
+            if ignore_dict_nulls and value is None:
+                continue
+            xml += object_to_xml(
+                value,
+                root_tag=key,
+                list_item_tag=list_item_tag,
+                include_list_index=include_list_index,
+                index_attr=index_attr,
+                indent_level=indent_level + 1,
+            )
+    elif isinstance(obj, list):
+        for index, item in enumerate(obj):
+            xml += object_to_xml(
+                item,
+                root_tag=list_item_tag,
+                list_item_tag=list_item_tag,
+                include_list_index=include_list_index,
+                index_attr=index_attr,
+                indent_level=indent_level + 1,
+                index=index,
+            )
+    else:
+        raise ValueError("Unsupported object type.")
+
+    xml += indent_str * indent_level
+    xml += f"</{root_tag}>\n"
+    return xml
+
+
+def parse_base_element(
+    elem_text: str | None, parse_empty_tags_as_none: bool, parse_null_text_as_none: bool
+):
+    if elem_text is None or elem_text.strip() == "":
+        return None if parse_empty_tags_as_none else ""
+    elem_text = elem_text.strip()
+    if parse_null_text_as_none and elem_text.lower() == "null":
+        return None
+    # Try int first, then float
+    try:
+        return int(elem_text)
+    except ValueError:
+        try:
+            return float(elem_text)
+        except ValueError:
+            return elem_text
+
+
+def xml_to_object(
+    xml_string: str, parse_null_text_as_none=True, parse_empty_tags_as_none=False
+):
+    """
+    Intended to be the reverse of object_to_xml.
+    Written by ChatGPT so unclear if this will work as intended.
+    """
+    xml_string = strip_xml(xml_string)
+    xml_string = remove_namespace_prefixes(xml_string)
+    parser = etree.XMLParser(recover=True, ns_clean=True)
+    root = etree.fromstring(xml_string.encode("utf-8"), parser=parser)
+
+    def parse_element(element):
+        # Base case: element has no child elements
+        if len(element) == 0:
+            text = element.text
+            return parse_base_element(
+                text, parse_empty_tags_as_none, parse_null_text_as_none
+            )
+        else:
+            is_list = False
+            index_attrs = ["key", "index"]
+            # Get child tag names without namespace prefixes
+            child_tags = [etree.QName(child).localname for child in element]
+            # Treat it as a list if there are any repeated children
+            if (
+                len(set(child_tags)) == 1
+                and len(child_tags) == len(element)
+                and len(child_tags) > 1
+            ):
+                is_list = True
+            # Treat as list if it has one child, but the child has a "key" or "index" attribute
+            elif len(child_tags) == 1 and any(
+                attr in element[0].attrib for attr in index_attrs
+            ):
+                is_list = True
+            # If multiple child tag types, but has repeats, error
+            elif len(set(child_tags)) > 1 and len(set(child_tags)) < len(element):
+                raise ValueError(
+                    "Cannot parse XML with multiple child tags and repeats."
+                )
+
+            if is_list:
+                items_with_index = []
+                for child in element:
+                    # look for either  <li key="…">  or  <li index="…">
+                    index_value = None
+                    for attr in ("key", "index"):
+                        if attr in child.attrib:
+                            index_value = child.attrib[attr]
+                            break
+                    # normalise to int when possible
+                    try:
+                        if index_value is not None:
+                            index_value = int(index_value)
+                    except ValueError:
+                        pass
+
+                    items_with_index.append((index_value, parse_element(child)))
+
+                # Sort only when *all* items have an integer index
+                if all(idx is not None for idx, _ in items_with_index):
+                    items_with_index.sort(key=lambda x: x[0])
+                return [item for _, item in items_with_index]
+            else:
+                # Treat as a dictionary
+                obj = {}
+                for child in element:
+                    key = etree.QName(child).localname  # Get tag name without namespace
+                    value = parse_element(child)
+                    if key in obj:
+                        raise ValueError(
+                            f"Duplicate key '{key}' found in XML when not expecting a list."
+                        )
+                    obj[key] = value
+                return obj
+
+    return parse_element(root)

lm_deluge-0.0.3.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: lm_deluge
+Version: 0.0.3
+Summary: Python utility for using LLM API models.
+Author-email: Benjamin Anderson <ben@trytaylor.ai>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv
+Requires-Dist: json5
+Requires-Dist: PyYAML
+Requires-Dist: pandas
+Requires-Dist: aiohttp
+Requires-Dist: tiktoken
+Requires-Dist: xxhash
+Requires-Dist: tqdm
+Requires-Dist: google-auth
+Requires-Dist: requests-aws4auth
+Requires-Dist: pydantic
+Requires-Dist: bs4
+Requires-Dist: lxml
+Provides-Extra: image
+Requires-Dist: pdf2image; extra == "image"
+Requires-Dist: pillow; extra == "image"
+Provides-Extra: pdf
+Requires-Dist: pdf2image; extra == "pdf"
+Requires-Dist: pymupdf; extra == "pdf"
+Provides-Extra: translate
+Requires-Dist: fasttext-wheel; extra == "translate"
+Requires-Dist: fasttext-langdetect; extra == "translate"
+Provides-Extra: full
+Requires-Dist: pillow; extra == "full"
+Requires-Dist: pdf2image; extra == "full"
+Requires-Dist: pymupdf; extra == "full"
+Requires-Dist: fasttext-wheel; extra == "full"
+Requires-Dist: fasttext-langdetect; extra == "full"
+
+# lm_deluge
+
+`lm_deluge` is a lightweight helper library for talking to large language model APIs.  It wraps several providers under a single interface, handles rate limiting, and exposes a few useful utilities for common NLP tasks.
+
+## Features
+
+- **Unified client** – send prompts to OpenAI‑compatible models, Anthropic, Cohere and Vertex hosted Claude models using the same API.
+- **Async or sync** – process prompts concurrently with `process_prompts_async` or run them synchronously with `process_prompts_sync`.
+- **Spray across providers** – configure multiple model names with weighting so requests are distributed across different providers.
+- **Caching** – optional LevelDB, SQLite or custom caches to avoid duplicate calls.
+- **Embeddings and reranking** – helper functions for embedding text and reranking documents via Cohere/OpenAI endpoints.
+- **Built‑in tools** – simple `extract`, `translate` and `score_llm` helpers for common patterns.
+
+## Installation
+
+```bash
+pip install lm_deluge
+```
+
+The package relies on environment variables for API keys.  Typical variables include `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `COHERE_API_KEY`, `META_API_KEY` (for Llama) and `GOOGLE_APPLICATION_CREDENTIALS` for Vertex.
+
+## Quickstart
+
+```python
+from lm_deluge import LLMClient
+
+client = LLMClient.basic(
+    model=["gpt-4o-mini"],    # any model id from lm_deluge.models.registry
+    temperature=0.2,
+    max_new_tokens=256,
+)
+
+resp = client.process_prompts_sync(["Hello, world!"])  # returns list[APIResponse]
+print(resp[0].completion)
+```
+
+### Asynchronous usage
+
+```python
+import asyncio
+
+async def main():
+    responses = await client.process_prompts_async(
+        ["an async call"],
+        return_completions_only=True,
+    )
+    print(responses[0])
+
+asyncio.run(main())
+```
+
+### Distributing requests across models
+
+You can provide multiple `model_names` and optional `model_weights` when creating an `LLMClient`.  Each prompt will be sent to one of the models based on those weights.
+
+```python
+client = LLMClient(
+    model_names=["gpt-4o-mini", "claude-haiku-anthropic"],
+    model_weights="rate_limit",        # or a list like [0.7, 0.3]
+    max_requests_per_minute=5000,
+    max_tokens_per_minute=1_000_000,
+    max_concurrent_requests=100,
+)
+```
+
+### Provider specific notes
+
+- **OpenAI and compatible providers** – set `OPENAI_API_KEY`.  Model ids in the registry include OpenAI models as well as Meta Llama, Grok and many others that expose OpenAI style APIs.
+- **Anthropic** – set `ANTHROPIC_API_KEY`.  Use model ids such as `claude-haiku-anthropic` or `claude-sonnet-anthropic`.
+- **Cohere** – set `COHERE_API_KEY`.  Models like `command-r` are available.
+- **Vertex Claude** – set `GOOGLE_APPLICATION_CREDENTIALS` and `PROJECT_ID`.  Use a model id such as `claude-sonnet-vertex`.
+
+The [models.py](src/lm_deluge/models.py) file lists every supported model and the required environment variable.
+
+## Built‑in tools
+
+The `lm_deluge.llm_tools` package exposes a few helper functions:
+
+- `extract` – structure text or images into a Pydantic model based on a schema.
+- `translate` – translate a list of strings to English if needed.
+- `score_llm` – simple yes/no style scoring with optional log probability output.
+
+Embeddings (`embed.embed_parallel_async`) and document reranking (`rerank.rerank_parallel_async`) are also provided.
+
+## Caching results
+
+`lm_deluge.cache` includes LevelDB, SQLite and custom dictionary based caches.  Pass an instance via `LLMClient(..., cache=my_cache)` and previously seen prompts will not be re‑sent.
+
+## Development notes
+
+Models and costs are defined in [src/lm_deluge/models.py](src/lm_deluge/models.py).  Conversations are built using the `Conversation` and `Message` helpers in [src/lm_deluge/prompt.py](src/lm_deluge/prompt.py), which also support images.

lm_deluge-0.0.3.dist-info/RECORD

@@ -0,0 +1,37 @@
+lm_deluge/__init__.py,sha256=r3Erra7aT5i2Mu5B9lcY8ll1T6q8_xF-xgnataKgKPg,153
+lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
+lm_deluge/client.py,sha256=oUtzZEbKwlW1s6bjSikMvliRXTpT6dIj5GRNL6ZZBh8,29327
+lm_deluge/embed.py,sha256=3hpGD_ljMsaQ_KV74a9ejNobPbEiQfTRSVFD97KQdHc,14017
+lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
+lm_deluge/gemini_limits.py,sha256=V9mpS9JtXYz7AY6OuKyQp5TuIMRH1BVv9YrSNmGmHNA,1569
+lm_deluge/image.py,sha256=8tIPMZ5-R_JUVHXH8SpPGrmxBMSiU1XU3oFv4AkVr1c,7028
+lm_deluge/models.py,sha256=jrD8CYKZIQ46VYvXL0ffFKqU6V3_aQrTv9i3hxqge5I,40364
+lm_deluge/prompt.py,sha256=AVTvm2n-NV9PqFWJaKGeGYQbXpzTcKQGicBEIW8jfxQ,12710
+lm_deluge/rerank.py,sha256=M5NbzDisUfxb7d_Jm7uio7zM4GkK0B5YzKQvpBmqepI,12082
+lm_deluge/sampling_params.py,sha256=E2kewh1vz-1Qcy5xNBCzihfGgT_GcHYMfzaWb3FLiXs,739
+lm_deluge/tool.py,sha256=RVUW3E3FW11jCM-R7pIL1GpRs1YKCOjvTkL1D5xPetk,3196
+lm_deluge/tracker.py,sha256=iTA8yN6tslqjiqUPz-bWkyModjlWNoygM9twlvtg7WY,306
+lm_deluge/api_requests/__init__.py,sha256=_aSpD6CJL9g6OpLPoChXiHjl4MH_OlGcKgfZaW8cgLM,71
+lm_deluge/api_requests/anthropic.py,sha256=lsugNe3mbtnkvLjX_kqRbqrJJoMOjHtaoq2FPlgB408,6887
+lm_deluge/api_requests/base.py,sha256=CuRqnP7r5flnF8JlYq2B_w5YZSiXhlED3aYxdqUp5UQ,15080
+lm_deluge/api_requests/cohere.py,sha256=eC-MWMWYMkYD5Q8oe7H6TbB2lYOekaJ8ta0SISv-i1o,5202
+lm_deluge/api_requests/common.py,sha256=ZtUirAlYNE4CJOQPbNip-mWKOMXCJi2_malwYsUcqsg,642
+lm_deluge/api_requests/google.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lm_deluge/api_requests/openai.py,sha256=HP5ra8tpz9Ojbh3tL4LZZa2HIQ41OoBTZl205sU1MPU,5779
+lm_deluge/api_requests/vertex.py,sha256=XNFAVte_DuHUWGSNCQY0kmNgHwEmIg8Otg6FGDdq8AQ,14857
+lm_deluge/api_requests/deprecated/bedrock.py,sha256=Wtjt8DFb3Fy1JNl2jAH-t5dmZfEerGUpddmLo241Ri8,11332
+lm_deluge/api_requests/deprecated/deepseek.py,sha256=VVyaSgs9VQp5SzTqrWE8yD9VNBiGKONbm_hoa2rBqLo,4588
+lm_deluge/api_requests/deprecated/mistral.py,sha256=20XP0tHYDIfx_C7-lyc9dXV1k3YwbCIQo2iqmO-zFPo,4715
+lm_deluge/llm_tools/__init__.py,sha256=TbZTETq9i_9yYskFWQKOG4pGh5ZiyE_D-h3RArfhGp4,231
+lm_deluge/llm_tools/extract.py,sha256=exoLGxUf8uKDZZ9SY1rC4O3gPTwa0vbVeOXi9RjzJjs,3671
+lm_deluge/llm_tools/score.py,sha256=9oGA3-k2U5buHQXkXaEI9M4Wb5yysNhTLsPbGeghAlQ,2580
+lm_deluge/llm_tools/translate.py,sha256=iXyYvQZ8bC44FWhBk4qpdqjKM1WFF7Shq-H2PxhPgg4,1452
+lm_deluge/util/json.py,sha256=KuzyXvBCwoW2PLc6durR0aNA0MjlEcQprA1NTZmqh_g,5326
+lm_deluge/util/logprobs.py,sha256=Fs0It0G9hTnZ1TkmRn45TEFOoIp9iv-__roYItLOs18,11781
+lm_deluge/util/pdf.py,sha256=zBcuh2IJxRfro6JPzQkAqdc6hUcrduFwb9aEoacNG9U,1590
+lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
+lm_deluge/util/xml.py,sha256=-yUKOZwsAY009w4ppQ8FI4hb5gDvLzMwcSgv88aEnaE,10578
+lm_deluge-0.0.3.dist-info/METADATA,sha256=xZTdJ-Tx7kRArPZiKqoohO1G8v0Wg6Bp3b8td6HXtWo,4956
+lm_deluge-0.0.3.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+lm_deluge-0.0.3.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.3.dist-info/RECORD,,

lm_deluge-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lm_deluge-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+lm_deluge