GJDutils 0.2.2__py3-none-any.whl

gjdutils/lists.py

@@ -0,0 +1,13 @@
+def get_list_from_str_or_list(str_or_list: str | list[str]) -> list[str]:
+    """
+    e.g.
+      - get_list_from_str_or_list("asdf") -> ["asdf"]
+      - get_list_from_str_or_list(["asdf"]) -> ["asdf"]
+    """
+    if isinstance(str_or_list, str):
+        aliases = [str_or_list]
+    elif isinstance(str_or_list, list):
+        aliases = str_or_list
+    else:
+        raise Exception(f"Unknown typ: {type(str_or_list)}")
+    return aliases

gjdutils/llm_utils.py

@@ -0,0 +1,167 @@
+import base64
+import io
+import json
+from typing import Any, Literal, Optional
+
+from anthropic import Anthropic
+from openai import OpenAI
+
+from gjdutils.llms_claude import call_claude_gpt
+from gjdutils.llms_openai import call_openai_gpt
+from gjdutils.strings import jinja_render
+
+
+MODEL_TYPE = Literal["openai", "claude"]
+
+
+def proc_llm_out_json(s: str):
+    # TODO probably we don't need this function any more, because OpenAI will guarantee JSON output
+    """
+    If GPT-4 returns json output like this:
+
+    ```json
+    ...
+    ```
+
+    This strips away that markdown wrapping.
+
+    Alternatively, consider using llm_prompt_json()
+    """
+    s = s.strip()
+    # remove the markdown code wrapping
+    if s.startswith("```json") and s.endswith("```"):
+        s = s[7:-3]
+    try:
+        j = json.loads(s)
+    except:
+        print(s)
+        raise Exception("Could not parse JSON from LLM output")
+    return j
+
+
+def image_to_base64_resized(image_full_filen: str, resize_target_size_kb: int = 100):
+    from PIL import Image
+
+    # based on https://claude.ai/chat/d0eb1f39-3f42-4cb5-a2ec-5aa102c60ea0
+    assert resize_target_size_kb > 0
+    with Image.open(image_full_filen) as img_orig:
+        width_orig, height_orig = img_orig.size
+        # Calculate initial file size
+        temp_buffer = io.BytesIO()
+        img_orig.save(temp_buffer, format=img_orig.format)
+        img_resized = img_orig.copy()
+        current_size_kb = len(temp_buffer.getvalue()) / 1024
+
+        # Iteratively resize until file size is below target
+        resize_factor = 0.9
+        while current_size_kb > resize_target_size_kb:
+            resize_factor *= resize_factor
+            width = int(width_orig * resize_factor)
+            height = int(height_orig * resize_factor)
+            img_resized = img_orig.resize(
+                (width, height), Image.LANCZOS  # type: ignore
+            )  #  type: ignore
+            # Check new file size
+            temp_buffer = io.BytesIO()
+            img_resized.save(temp_buffer, format=img_orig.format)
+            current_size_kb = len(temp_buffer.getvalue()) / 1024
+
+        # Convert final resized image to base64
+        img_bytes = io.BytesIO()
+        img_resized.save(img_bytes, format=img_orig.format)
+        img_buffer = img_bytes.getvalue()
+
+    return img_buffer
+
+
+def image_to_base64(img_full_filen: str, resize_target_size_kb: Optional[int] = None):
+    # from https://chat.openai.com/c/35f15af9-b947-4fa6-acbe-2a5ed26e7547
+    if resize_target_size_kb is None:
+        with open(img_full_filen, "rb") as image_file:
+            img_bytes = image_file.read()
+    else:
+        img_bytes = image_to_base64_resized(img_full_filen, resize_target_size_kb)
+    img_b64 = base64.b64encode(img_bytes).decode("utf-8")
+    return img_b64
+
+
+def image_to_base64_basic(image_filen: str) -> str:
+    with open(image_filen, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode("ascii")
+
+
+def contents_for_images(image_filens: list[str], resize_target_size_kb: int):
+    # assert (
+    #     1 <= len(image_filens) <= 10
+    # ), "You can only provide between 1 and 10 images"
+    base64_images = []
+    new_contents = []
+    for image_filen in image_filens:
+        base64_image = image_to_base64(
+            image_filen, resize_target_size_kb=resize_target_size_kb
+        )
+        filen_content = {
+            "type": "text",
+            "text": f"Filename: {image_filen}",
+        }
+        img_content = {
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},
+        }
+        base64_images.append(base64_image)
+        new_contents.extend([filen_content, img_content])
+    return new_contents, base64_images
+
+
+def generate_gpt_from_template(
+    client: Anthropic | OpenAI,
+    prompt_template_var: str,
+    context_d: dict,
+    response_json: bool,
+    image_filens: list[str] | str | None = None,
+    model_type: MODEL_TYPE = "claude",
+    max_tokens: Optional[int] = None,
+    prompt_template_filen: str = "prompt_templates",  # i.e. prompt_templates.py
+    verbose: int = 0,
+) -> tuple[str | dict[str, Any], dict[str, Any]]:
+    """
+    e.g.
+        generate_gpt_from_template("quick_search_for_word", {"word_tgt": word}, True, verbose)
+    """
+    # dynamically import `template_var` from prompt_templates as `prompt_template`
+    prompt_template = getattr(__import__(prompt_template_filen), prompt_template_var)
+    prompt = jinja_render(prompt_template, context_d)
+    if model_type == "openai":
+        assert isinstance(client, OpenAI), "Expected OpenAI client"
+        out, _, extra = call_openai_gpt(
+            prompt,
+            client=client,
+            image_filens=image_filens,
+            response_json=response_json,
+            max_tokens=max_tokens,
+        )
+    else:
+        assert isinstance(client, Anthropic), "Expected Anthropic client"
+        out, extra = call_claude_gpt(
+            prompt,
+            client=client,
+            image_filens=image_filens,
+            response_json=response_json,
+            max_tokens=max_tokens if max_tokens is not None else 4096,
+        )
+    if response_json:
+        assert isinstance(out, dict), f"Expected dict, got {type(out)}"
+    else:
+        assert isinstance(out, str), f"Expected str, got {type(out)}"
+    if verbose >= 1:
+        print(
+            f"Called GPT on '{prompt_template_var}', context keys {list(context_d.keys())}"
+        )
+    extra.update(
+        {
+            "model_type": model_type,
+            "prompt_template": prompt_template_var,
+            "prompt_context_d": context_d,
+        }
+    )
+    return out, extra  # type: ignore

gjdutils/llms_claude.py

@@ -0,0 +1,131 @@
+import json
+from pathlib import Path
+from anthropic import Anthropic, NOT_GIVEN
+import os
+from typing import Optional
+
+from gjdutils.rand import DEFAULT_RANDOM_SEED
+from gjdutils.llm_utils import image_to_base64_basic
+
+CLAUDE_API_KEY = os.environ.get("CLAUDE_API_KEY")
+# https://docs.anthropic.com/en/docs/about-claude/models
+MODEL_NAME_CLAUDE_SONNET_GOOD_PINNED = "claude-3-5-sonnet-20240620"
+MODEL_NAME_CLAUDE_SONNET_GOOD_LATEST = "claude-3-5-sonnet-latest"
+MODEL_NAME_CLAUDE_SONNET_CHEAP_LATEST = "claude-3-5-haiku-latest"
+
+
+def img_as_content_dict(img_filen: str):
+    media_type_from_extension = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".webp": "image/webp",
+        ".gif": "image/gif",
+        ".bmp": "image/bmp",
+        ".tiff": "image/tiff",
+        ".ico": "image/vnd.microsoft.icon",
+        ".svg": "image/svg+xml",
+        ".heic": "image/heic",
+        ".heif": "image/heif",
+    }
+
+    ext = Path(img_filen).suffix
+    if ext not in media_type_from_extension:
+        raise ValueError(f"Unknown image file extension: {img_filen}")
+    media_type = media_type_from_extension[ext]
+
+    img_base64 = image_to_base64_basic(img_filen)
+    return {
+        "type": "image",
+        "source": {
+            "type": "base64",
+            "media_type": media_type,
+            "data": img_base64,
+        },
+    }
+
+
+def call_claude_gpt(
+    prompt: str,
+    tools: Optional[list[dict]] = None,
+    image_filens: str | list[str] | None = None,
+    image_resize_target_size_kb: Optional[int] = 100,
+    client: Optional[Anthropic] = None,
+    model: str = MODEL_NAME_CLAUDE_SONNET_GOOD_LATEST,
+    temperature: Optional[float] = 0.001,
+    response_json: bool = False,
+    # seed: Optional[int] = DEFAULT_RANDOM_SEED,
+    max_tokens: int = 4096,
+    verbose: int = 0,
+):
+    """Call Claude API with support for text, images, and function calling"""
+    extra = locals()
+    extra.pop("client")
+
+    if tools is not None:
+        raise NotImplementedError(
+            "I think tools are supported, but not implemented in this function"
+        )
+
+    if client is None:
+        client = Anthropic(api_key=CLAUDE_API_KEY)
+
+    # Prepare image contents if provided
+    contents = []
+    if image_filens:
+        if isinstance(image_filens, str):
+            image_filens = [image_filens]
+        assert image_resize_target_size_kb is not None
+        for i, img_filen in enumerate(image_filens):
+            contents.extend(
+                [
+                    {"type": "text", "text": f"Image {i+1}:"},
+                    img_as_content_dict(image_filens[i]),
+                    # {
+                    #     "type": "image",
+                    #     "source": {
+                    #         "type": "base64",
+                    #         "media_type": "image/jpeg",  # Adjust based on actual image type
+                    #         "data": b64,
+                    #     },
+                    # },
+                ]
+            )
+
+    # Add text prompt
+    contents.append({"type": "text", "text": prompt})
+
+    # Prepare response format
+    response_format = {"type": "json_object"} if response_json else None
+
+    # Make API call
+    response = client.messages.create(
+        model=model,
+        max_tokens=max_tokens,
+        messages=[{"role": "user", "content": contents}],
+        temperature=temperature if temperature is not None else NOT_GIVEN,
+        # seed=seed,
+        # response_format=response_format,
+    )
+
+    msg = response.content[0].text  # type: ignore
+    if response_json:
+        msg = json.loads(msg)
+    extra.update(
+        {
+            "response": response.model_dump(),
+            "msg": msg,
+            # "tool_calls": tool_calls,
+            "model": model,
+            "contents": contents,
+        }
+    )
+
+    if verbose >= 2:
+        print(f"PROMPT:\n{prompt}")
+    if verbose >= 1:
+        print(f"LLM MESSAGE:\n{msg}")
+    if verbose >= 2:
+        # print(f"TOOL CALLS:\n{tool_calls}")
+        print(f"LLM RESPONSE:\n{json.dumps(response.model_dump(), indent=2)}")
+    return msg, extra

gjdutils/llms_openai.py

@@ -0,0 +1,299 @@
+import json
+from openai import OpenAI, NOT_GIVEN
+import os
+from pprint import pprint
+from typing import Any, Literal, Optional
+
+from .prompt_templates import summarise_list_of_texts_as_one, summarise_text
+from .rand import DEFAULT_RANDOM_SEED
+from .strings import jinja_render
+from gjdutils.llm_utils import contents_for_images
+
+
+# openai.api_key = OPENAI_API_KEY
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+MODEL_NAME_GPT4 = "gpt-4"
+MODEL_NAME_GPT35 = "gpt-3.5-turbo"
+MODEL_NAME_GPT4_TURBO = "gpt-4-turbo"  # -1106-preview"
+MODEL_NAME_GPT4O = "gpt-4o"
+MODEL_NAME_GPT4O_MINI = "gpt-4o-mini"
+MODEL_NAME_O1 = "o1-preview"
+MODEL_NAME_O1_MINI = "o1-mini"
+DEFAULT_MODEL_NAME = MODEL_NAME_GPT4O
+
+MODELS_NO_TOOLS = [MODEL_NAME_O1, MODEL_NAME_O1_MINI]
+
+# from https://github.com/openai/openai-python
+ToolChoiceTyps = Literal["auto", "required", "none"]
+
+GranularityTyps = Literal[
+    "short phrase of just a few words",
+    "short title",
+    "short sentence",
+    "at most a sentence",
+    "sentence or two",
+    "few sentences",
+    "single short paragraph",
+    "couple of paragraphs",
+    "page",
+]
+
+
+def call_openai_gpt(
+    prompt: str,
+    tools: Optional[list[dict]] = None,
+    tool_choice: Optional[ToolChoiceTyps] = None,
+    image_filens: str | list[str] | None = None,
+    image_resize_target_size_kb: Optional[int] = 100,
+    client: Optional[OpenAI] = None,
+    model: Optional[str] = None,
+    temperature: Optional[float] = 0.001,
+    max_tokens: int | None = None,
+    # stop: Optional[list[str]] = None,
+    response_json: bool = False,
+    seed: Optional[int] = DEFAULT_RANDOM_SEED,
+    verbose: int = 0,
+):
+    """
+    Usage:
+
+        client = OpenAI(
+            api_key=OPENAI_API_KEY,
+        )
+        msg, tools, extra = call_gpt_uncached(client, "What is the capital of France?")
+
+        @cachier()
+        def call_gpt_cached(
+            inp: str, tools: Optional[list[dict]] = None, tool_choice: ToolChoiceTyps = "auto"
+        ):
+            return call_gpt(client=client, inp=inp, tools=tools, tool_choice=tool_choice)
+
+    https://platform.openai.com/docs/api-reference/chat/create?lang=python
+    SAMPLE_TOOLS = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_weather",
+                "description": "Get the current weather in a given location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city and state, e.g. San Francisco, CA",
+                        },
+                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                    },
+                    "required": ["location"],
+                },
+            },
+        }
+    ]
+
+    The messages for images could look like this:
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Filename: cat.jpg"
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAA..."
+                    }
+                },
+                {
+                    "type": "text",
+                    "text": "Filename: dog.png"
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJA..."
+                    }
+                },
+                {
+                    "type": "text",
+                    "text": "Describe each of these images, referring to them by their filenames:"
+                },
+            ]
+        }
+    ]
+    """
+
+    extra = locals()
+    extra.pop("client")  # to avoid caching issues, and because it includes the API key
+    if client is None:
+        client = OpenAI(api_key=OPENAI_API_KEY)
+    if not tools:
+        # otherwise you get a 400
+        tool_choice = None
+    if model is None:
+        model = DEFAULT_MODEL_NAME
+    if image_filens is None:
+        base64_images = None
+        image_contents = []
+    else:
+        if isinstance(image_filens, str):
+            image_filens = [image_filens]
+        assert (
+            image_resize_target_size_kb is not None
+        ), "You must provide a resize_target_size_kb"
+        image_contents, base64_images = contents_for_images(
+            image_filens, resize_target_size_kb=image_resize_target_size_kb
+        )
+
+    prompt_content = {"type": "text", "text": prompt}
+    contents = image_contents + [prompt_content]
+    messages = [{"role": "user", "content": contents}]
+    response_format = {"type": "json_object"} if response_json else None
+    if model in MODELS_NO_TOOLS:
+        assert (
+            tools is None
+        ), "You cannot provide tools for models that don't support them"
+        assert (
+            tool_choice is None
+        ), "You cannot provide tool_choice for models that don't support them"
+        tools, tool_choice = NOT_GIVEN, NOT_GIVEN  # type: ignore
+        # assert temperature is None, f"Temperature can't be set for {model}"
+        temperature = NOT_GIVEN  # type: ignore
+    response = client.chat.completions.create(
+        model=model,
+        messages=messages,  # type: ignore
+        tools=tools,  # type: ignore
+        tool_choice=tool_choice,  # type: ignore
+        temperature=temperature,
+        max_tokens=max_tokens if max_tokens is not None else NOT_GIVEN,
+        # stop=stop,  # for some reason, setting this to None causes an error
+        seed=seed,
+        response_format=response_format,  # type: ignore
+    )
+    msg = response.choices[0].message.content  # could be empty
+    if response_json:
+        msg = json.loads(msg)  # type: ignore
+    tool_calls = response.choices[0].message.tool_calls  # could be None or a list
+    extra.update(
+        {
+            "response": response.model_dump(),
+            "msg": msg,
+            "tool_calls": tool_calls,
+            "model": model,
+            "base64_images": base64_images,
+            "contents": contents,
+            # "client": client,
+        }
+    )
+    if verbose >= 2:
+        print(f"PROMPT:\n{prompt}")
+    if verbose >= 1:
+        print(f"LLM MESSAGE:\n{msg}")
+    if verbose >= 2:
+        print(f"TOOL CALLS:\n{tool_calls}")
+        print(f"LLM RESPONSE:\n{json.dumps(response.model_dump(), indent=2)}")
+    return msg, tool_calls, extra
+
+
+def llm_generate_summary(
+    txt_or_txts: str | list[str],
+    granularity: Optional[GranularityTyps] = None,
+    full_txt_or_html: Optional[str] = None,
+    n_truncate_words=None,
+    model_name: Optional[str] = None,
+    max_tokens: Optional[int] = None,
+    verbose: int = 0,
+):
+    """
+    TXT_OR_TXTS can either be a single string,
+    or a list of strings (in which case it tries to find the summary that unifies them).
+
+    FULL_TXT_OR_HTML is the full text or HTML that the text is a part of.
+    It is used to provide context to the summarisation.
+
+    TODO: I combined summarisation of text and list into one, but I'm not convinced
+    it was such a good idea. It has made things unwieldy. I'm mostly focused on the
+    summarisation of a single text for now.
+
+    TODO maybe we don't need both MAX_TOKENS and N_TRUNCATE_WORDS. Maybe we can just
+    use MAX_TOKENS and calculate N_TRUNCATE_WORDS from that.
+    """
+
+    def do_summarise_text(txt: str):
+        if n_truncate_words:
+            txt = txt[:n_truncate_words]
+        context["txt"] = txt
+        prompt = jinja_render(summarise_text, context)
+        extra.update(
+            {
+                "txt": txt,  # type: ignore
+            }
+        )  # type: ignore
+        return prompt
+
+    def do_summarise_list(txts: list[str]):
+        # UNTESTED
+        txts = [txt.replace("\n", " ").replace("  ", " ").strip() for txt in txts]
+        if max_tokens is not None:
+            if n_truncate_words is None:  # type: ignore
+                # assume a word is <1.5 tokens. so 3500 / 10 / 1.5 = 233
+                n_truncate_words = int(max_tokens / len(txts) / 1.5)
+        if n_truncate_words is not None:  # type: ignore
+            txts = [txt[:n_truncate_words] for txt in txts if txt]  # type: ignore
+        context["txts"] = txts  # type: ignore
+        prompt = jinja_render(summarise_list_of_texts_as_one, context)
+        extra.update(
+            {
+                "txts": txts,
+                "max_tokens": max_tokens,
+                "n_truncate_words": n_truncate_words,  # type: ignore
+            }
+        )  # type: ignore
+        return prompt
+
+    extra = {"input": locals()}
+    if full_txt_or_html is not None:
+        raise NotImplementedError("full_txt_or_html is not yet implemented")
+    context = {
+        "granularity": (
+            "Adjust the length of your summary appropriately, based on the length and complexity of the text. For example, if the text is a paragraph, write a sentence or two. If it's a page, write a paragraph or so. If it's a book, write a page."
+            if granularity is None
+            else f"Write at most a {granularity}."
+        )
+    }
+    assert txt_or_txts, "txt_or_txts must be non-empty"
+    if isinstance(txt_or_txts, str):
+        prompt = do_summarise_text(txt=txt_or_txts)
+    elif isinstance(txt_or_txts, list):
+        prompt = do_summarise_list(txts=txt_or_txts)
+    else:
+        raise TypeError("txt_or_txts must be str or list[str]: %s" % type(txt_or_txts))
+
+    assert max_tokens is None, "max_tokens is not yet implemented"
+    msg, tools, extra = call_openai_gpt(
+        prompt=prompt, model=model_name
+    )  # , max_tokens=max_tokens)
+    extra.update(
+        {
+            "context": context,
+            "prompt": prompt,
+            "llm_msg": msg,
+            "llm_tools": tools,
+            "llm_extra": extra,
+        }  # type: ignore
+    )
+    if verbose > 0:
+        print("Summary:", msg)
+    if verbose > 1:
+        print(f"PROMPT:\n{prompt}")
+    extra = {
+        "model_name": model_name,
+        "prompt": prompt,
+    }
+    return msg, extra
+
+
+if __name__ == "__main__":
+    # txt = prompt('What is the capital of France?')
+    msg, _, _ = call_openai_gpt("What is the capital of France?")
+    print(msg)

gjdutils/misc.py

@@ -0,0 +1,30 @@
+from .dicts import print_dict
+from .typ import isfunction
+
+
+def print_locals(
+    d: dict, ignore_functions: bool = True, ignore_underscores: bool = True
+):
+    """
+    e.g. print_locals(locals())
+    """
+
+    def del_robust(k):
+        if k in d:
+            del d[k]
+
+    assert isinstance(d, dict)
+    for k in d.keys():
+        if ignore_functions and isfunction(d[k]):
+            del_robust(k)
+        if ignore_underscores and k.startswith("_"):
+            del_robust(k)
+    return print_dict(d)
+
+
+def identity_func(x):
+    return x
+
+
+def empty_func(*args, **kwargs):
+    return None