GJDutils 0.2.2__py3-none-any.whl

gjdutils/num.py

@@ -0,0 +1,77 @@
+from typing import Union
+
+# this doesn't support numpy's numeric types, but it's a good stopgap for now.
+# there doesn't appear to be a perfect, agreed solution
+#
+# https://stackoverflow.com/questions/60616802/how-to-type-hint-a-generic-numeric-type-in-python
+Numeric = Union[int, float]
+
+
+def percent(num, denom):
+    return (100 * (num / float(denom))) if denom else 0
+
+
+def percent_str(num, denom):
+    return str(percent) + "%"
+
+
+def discretise(
+    val,
+    increment: Union[int, float] = 0.1,
+    lower: Union[int, float] = 0.0,
+    upper: Union[int, float] = 1.0,
+    enforce_range: bool = False,
+):
+    """
+    You will probably want to cache this.
+    """
+    import numpy as np
+    import pandas as pd
+
+    def calc_increments(increment, lower, upper):
+        assert (
+            lower <= increment <= upper
+        ), f"Required: {lower:.2f} < {increment:.2f} <= {upper:.2f}"
+        # e.g. for lower=0, upper=1, increment_size=0.05, nincrements=21
+        nincrements = int((upper - lower) / increment) + 1
+        # e.g. for lower=0, upper=1, increment_size=0.05, increments = [0., 0.05, 0.1, ..., 0.95, 1. ]
+        increments = np.linspace(lower, upper, nincrements)
+        return increments
+
+    if pd.isnull(val):
+        return upper
+    if enforce_range:
+        assert (
+            lower <= val <= upper
+        ), f"Required: {lower:.2f} < {val:.2f} <= {upper:.2f}"
+    increments = calc_increments(increment, lower, upper)
+    if val < lower:
+        return increments[0]
+    if val > upper:
+        return increments[-1]
+    idx = np.digitize(val, increments)
+    # e.g.
+    #   0.00 -> 0.0
+    #   0.01 -> 0.0
+    #   0.06 -> 0.05
+    #   0.99 -> 0.95
+    #   1.00 -> 1.0
+    discretised = increments[idx - 1]
+    return discretised
+
+
+def ordinal(n: int):
+    """
+    e.g 1 -> "1st", 103 -> "103rd"
+    """
+    # from https://claude.ai/chat/87fad336-e0fa-4074-aed4-f4e57ed20bb7
+
+    # TESTED:
+    # for i in [0, 1, 2, 3, 4, 10, 11, 12, 13, 22, 78, 103, 103231, 103235]:
+    #     print(i, ordinal(i))
+    assert n >= 0
+    if 10 <= n % 100 <= 20:
+        suffix = "th"
+    else:
+        suffix = {1: "st", 2: "nd", 3: "rd"}.get(n % 10, "th")
+    return f"{n}{suffix}"

gjdutils/obsolete/google_text_to_speech.py

@@ -0,0 +1,46 @@
+"""
+Synthesizes speech from the input string of text or ssml.
+Make sure to be working in a virtual environment.
+https://cloud.google.com/text-to-speech/docs/libraries
+"""
+
+from google.cloud import texttospeech
+
+
+def outloud(text: str, language_code: str = "en-GB", bot_gender=None):
+    bot_gender = bot_gender.lower() if bot_gender else None
+    # not all genders supported for all languages. see https://cloud.google.com/text-to-speech/docs/voices
+    if bot_gender is None or bot_gender == "neutral":
+        bot_gender = texttospeech.SsmlVoiceGender.NEUTRAL
+    elif bot_gender in ["female", texttospeech.SsmlVoiceGender.FEMALE]:
+        bot_gender = texttospeech.SsmlVoiceGender.FEMALE
+    elif bot_gender in ["male", texttospeech.SsmlVoiceGender.MALE]:
+        bot_gender = texttospeech.SsmlVoiceGender.MALE
+    else:
+        # gender = texttospeech.SsmlVoiceGender.SSML_VOICE_GENDER_UNSPECIFIED
+        raise Exception(f"Unknown gender: {bot_gender}")
+    # Instantiates a client
+    client = texttospeech.TextToSpeechClient()
+
+    # Set the text input to be synthesized
+    synthesis_input = texttospeech.SynthesisInput(text=text)
+    # synthesis_input = texttospeech.SynthesisInput(text="Bonjour, Monsieur Natterbot!")
+    # synthesis_input = texttospeech.SynthesisInput(text="Γεια σου, Natterbot!")
+
+    # Build the voice request, select the language code ("en-US") and the ssml
+    # voice gender ("neutral")
+    voice = texttospeech.VoiceSelectionParams(
+        language_code=language_code, ssml_gender=bot_gender
+    )  # e.g. 'en-GB'
+
+    # Select the type of audio file you want returned
+    audio_config = texttospeech.AudioConfig(
+        audio_encoding=texttospeech.AudioEncoding.MP3
+    )
+
+    # Perform the text-to-speech request on the text input with the selected
+    # voice parameters and audio file type
+    response = client.synthesize_speech(
+        input=synthesis_input, voice=voice, audio_config=audio_config
+    )
+    return response

gjdutils/obsolete/llms_obsolete.py

@@ -0,0 +1,298 @@
+import llm
+import json
+import openai
+import os
+from pprint import pprint
+from typing import Any, Optional
+
+from gjdutils.llm_utils import proc_llm_out_json
+from gjdutils.llms_openai import (
+    DEFAULT_MODEL_NAME,
+    MODEL_NAME_GPT4_TURBO,
+    OPENAI_API_KEY,
+    GranularityTyps,
+    call_openai_gpt,
+    call_openai_gpt_with_retry,
+    call_openai_gpt_with_retry_and_backoff,
+)
+from gjdutils.prompt_templates import summarise_list_of_texts_as_one, summarise_text
+from gjdutils.rand import DEFAULT_RANDOM_SEED
+from gjdutils.strings import jinja_render
+
+
+DEFAULT_MODEL = llm.get_model(DEFAULT_MODEL_NAME)
+DEFAULT_MODEL.key = os.environ.get("OPENAI_API_KEY")
+
+
+def model_from_model_name(model_name: Optional[str] = None, verbose: int = 0):
+    if model_name is None:
+        model = DEFAULT_MODEL
+    else:
+        if verbose > 0:
+            print("MODEL:", model_name)
+        model = llm.get_model(model_name)
+        model.key = OPENAI_API_KEY
+    return model, model_name
+
+
+def llm_prompt(
+    prompt: str,
+    model_name: Optional[str] = None,
+    temperature: Optional[float] = 0.01,
+    max_tokens: Optional[int] = None,
+    to_json: bool = False,
+    verbose: int = 1,
+):
+    model, _ = model_from_model_name(model_name)
+    response = model.prompt(prompt, temperature=temperature, max_tokens=max_tokens)
+    if verbose > 0:
+        for chunk in response:
+            print(chunk, end="")
+        print()
+    llm_out = response.text()
+    llm_json = proc_llm_out_json(llm_out) if to_json else None
+    extra = {
+        "prompt": prompt,
+        "model_name": model_name,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "response": response,
+        "llm_out": llm_out,
+        "llm_json": llm_json,
+    }
+    return llm_json if to_json else llm_out, extra
+
+
+def llm_prompt_json(
+    prompt: str,
+    functions: list[dict],
+    model_name: str = MODEL_NAME_GPT4_TURBO,
+    temperature: Optional[float] = 0.01,
+    verbose: int = 1,
+):
+    """
+    Based on https://platform.openai.com/docs/guides/gpt/function-calling
+
+    Simon Willison's LLM library doesn't seem to support function calling,
+    so we're using the OpenAI Python API directly.
+
+    Doesn't actually call the function - we're just using the function-calling
+    API to ensure we get back json that matches our defined schema.
+
+    e.g. functions = [
+        {
+            "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"],
+            },
+        }
+    ]
+    """
+    # model, model_name = model_from_model_name(model_name)
+    assert functions, "PROMPT_JSON requires at least one function"
+    messages = [{"role": "user", "content": prompt}]
+
+    response = openai.ChatCompletion.create(  # type: ignore
+        model=model_name,
+        messages=messages,
+        # if you try and set this to None or [] you get an error, so we'll require at least one actual function (see assert above)
+        functions=functions,
+        temperature=temperature,
+        seed=DEFAULT_RANDOM_SEED,
+    )
+    response_message = response["choices"][0]["message"]  # type: ignore
+
+    if response_message.get("function_call"):
+        function_name = response_message["function_call"]["name"]
+        function_args = json.loads(response_message["function_call"]["arguments"])
+        llm_out = {
+            "role": "function",
+            "name": function_name,
+            "args": function_args,
+            # "content": function_response,
+        }
+
+        # if call_function:
+        #     Step 3: call the function
+        #     # Note: the JSON response may not always be valid; be sure to handle errors
+        #     available_functions = {
+        #         "get_current_weather": get_current_weather,
+        #     }  # only one function in this example, but you can have multiple
+        #     function_to_call = available_functions[function_name]
+        #     function_response = function_to_call(
+        #         location=function_args.get("location"),
+        #         unit=function_args.get("unit"),
+        #     )
+
+        # Step 4: send the info on the function call and function response to GPT
+        messages.append(response_message)  # extend conversation with assistant's reply
+        messages.append(
+            {
+                "role": "function",
+                "name": function_name,
+                # "content": function_response,
+            }
+        )
+        # if call_function:
+        #     )  # extend conversation with function response
+        #     second_response = openai.ChatCompletion.create(
+        #         model="gpt-3.5-turbo-0613",
+        #         messages=messages,
+        #         seed=DEFAULT_RANDOM_SEED,
+        #     )  # get a new response from GPT where it can see the function response
+        #     return second_response
+    else:
+        function_name = None
+        function_args = None
+        llm_out = response_message["content"]
+
+    extra = {
+        "prompt": prompt,
+        "model_name": model_name,
+        "functions": functions,
+        "temperature": temperature,
+        "messages": messages,
+        "response": response,
+        "response_message": response_message,
+        "function_name": function_name,
+        "function_args": function_args,
+    }
+    if verbose > 0:
+        if isinstance(llm_out, str):
+            print(llm_out)
+        else:
+            pprint(llm_out)
+    return llm_out, extra
+
+
+def llm_generate_summary(
+    txt_or_txts: str | list[str],
+    granularity: Optional[GranularityTyps] = None,
+    n_truncate_words=None,
+    model_name: Optional[str] = None,
+    max_tokens: Optional[int] = None,
+    verbose: int = 1,
+):
+    """
+    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).
+
+    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
+
+    if model_name is None:
+        model_name = "gpt-3.5-turbo"
+    extra = {"input": locals()}
+    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))
+
+    llm_out, llm_extra = llm_prompt(
+        prompt, model_name=model_name, max_tokens=max_tokens, verbose=0
+    )
+    extra.update(
+        {
+            "context": context,
+            "prompt": prompt,
+            "llm_out": llm_out,
+            "llm_extra": llm_extra,
+        }  # type: ignore
+    )
+    if verbose > 0:
+        print("Summary:", llm_out)
+    if verbose > 1:
+        print(f"PROMPT:\n{prompt}")
+    extra = {
+        "model_name": model_name,
+        "prompt": prompt,
+    }
+    return llm_out, extra
+
+
+def llm_fix_json(broken_j: str, model_name: str = "gpt-3.5-turbo"):
+    broken_j = broken_j.strip()
+    prompt = (
+        """
+Here is some output from an LLM that is supposed to be pure, valid JSON, but it is broken. Return valid JSON, stripping away any extraneous commentary or prose, but maintaining the structure and meaning of the original data as closely as possible.
+
+If the json is already valid, return it unchanged.
+
+Err on the side of caution: if you're confused about what to do with the input, or if it's ambiguous how best to fix the json, or it is not possible to fix the json, or any other error or uncertainty, return 'ERROR'.
+
+----
+
+%s
+"""
+        % broken_j
+    )
+    prompt = prompt.strip()
+    fixed_j, extra = llm_prompt(prompt, model_name=model_name, temperature=0.001)
+    fixed_j = fixed_j.strip()  # type: ignore
+    try:
+        json.loads(fixed_j)
+        # TODO check that the before and after are similar lengths and substantially similar strings
+        return fixed_j
+    except:
+        raise
+
+
+if __name__ == "__main__":
+    # txt = prompt('What is the capital of France?')
+    txt = llm_prompt("What is the capital of France?")

gjdutils/outloud_text_to_speech.py

@@ -0,0 +1,230 @@
+import os
+from typing import Optional
+
+
+def outloud(
+    text: str,
+    mp3_filen: str,
+    prog: str,
+    language_code: Optional[str] = None,
+    bot_gender: Optional[str] = None,
+    bot_name: Optional[str] = None,
+    speed: Optional[str] = None,  # or 'slow'
+    play: bool = False,
+    verbose: int = 0,
+):
+    if prog == "google":
+        response = outloud_google(
+            text=text,
+            mp3_filen=mp3_filen,  # type: ignore
+            language_code=language_code,  # type: ignore
+            bot_gender=bot_gender,
+            speed=speed,
+            verbose=verbose,
+        )
+    elif prog == "azure":
+        response = outloud_azure(
+            text=text,
+            mp3_filen=mp3_filen,
+            language_code=language_code,
+            bot_gender=bot_gender,
+            bot_name=bot_name,
+            speed=speed,
+            verbose=verbose,
+        )
+    elif prog == "elevenlabs":
+        response = outloud_elevenlabs(
+            text=text,
+            mp3_filen=mp3_filen,
+            bot_name=bot_name,
+            speed=speed,
+            verbose=verbose,
+        )
+    else:
+        raise Exception(f"Unknown PROG '{prog}'")
+    if play:
+        from .audios import play_mp3
+
+        play_mp3(mp3_filen, prog="cli")
+    return response
+
+
+def outloud_azure(
+    text: str,
+    mp3_filen: str,
+    language_code: Optional[str] = "en-GB",
+    bot_gender: Optional[str] = None,
+    bot_name: Optional[str] = None,
+    speed: Optional[str] = None,  # or 'slow'
+    verbose: int = 0,
+):
+    """
+    from https://learn.microsoft.com/en-us/azure/cognitive-services/speech-service/get-started-text-to-speech?pivots=programming-language-python&tabs=macos%2Cterminal
+    """
+    import azure.cognitiveservices.speech as speechsdk
+
+    # This example requires environment variables named "SPEECH_KEY" and "SPEECH_REGION"
+    speech_config = speechsdk.SpeechConfig(
+        subscription=os.environ.get("SPEECH_KEY"),
+        region=os.environ.get("SPEECH_REGION"),
+    )
+    # https://learn.microsoft.com/en-us/answers/questions/693848/can-azure-text-to-speech-support-more-audio-files.html
+    speech_config.set_speech_synthesis_output_format(
+        speechsdk.SpeechSynthesisOutputFormat.Audio16Khz32KBitRateMonoMp3
+    )
+    audio_config = speechsdk.audio.AudioOutputConfig(
+        use_default_speaker=True, filename=mp3_filen
+    )
+
+    # The language of the voice that speaks.
+    # speech_config.speech_synthesis_voice_name = "en-US-JennyNeural"
+    speech_config.speech_synthesis_voice_name = bot_name
+
+    speech_synthesizer = speechsdk.SpeechSynthesizer(
+        speech_config=speech_config, audio_config=audio_config
+    )
+
+    # ssml = f'<speak><prosody rate="30%">{text}</prosody></speak>'
+    ssml = f"""
+<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="en-US">
+    <voice name="{bot_name}">
+        <prosody rate="slow">
+            {text}
+        </prosody>
+    </voice>
+</speak>
+    """.strip()
+    # print(ssml)
+
+    # speech_synthesis_result = speech_synthesizer.speak_text_async(text).get()
+    speech_synthesis_result = speech_synthesizer.speak_ssml_async(ssml).get()
+
+    if (
+        speech_synthesis_result.reason
+        == speechsdk.ResultReason.SynthesizingAudioCompleted
+    ):
+        if verbose > 0:
+            print("Speech synthesized for text [{}]".format(text))
+    elif speech_synthesis_result.reason == speechsdk.ResultReason.Canceled:
+        cancellation_details = speech_synthesis_result.cancellation_details
+        print("Speech synthesis canceled: {}".format(cancellation_details.reason))
+        if cancellation_details.reason == speechsdk.CancellationReason.Error:
+            if cancellation_details.error_details:
+                print("Error details: {}".format(cancellation_details.error_details))
+                print("Did you set the speech resource key and region values?")
+
+    return speech_synthesis_result
+
+
+def outloud_google(
+    text: str,
+    mp3_filen: str,
+    language_code: str = "en-GB",
+    bot_gender=None,
+    speed=None,  # or 'slow'
+    verbose: int = 0,
+):
+    from google.cloud import texttospeech
+
+    bot_gender = bot_gender.lower() if bot_gender else None
+    # not all genders supported for all languages. see https://cloud.google.com/text-to-speech/docs/voices
+    if bot_gender is None or bot_gender == "neutral":
+        bot_gender = texttospeech.SsmlVoiceGender.NEUTRAL
+    elif bot_gender in ["female", texttospeech.SsmlVoiceGender.FEMALE]:
+        bot_gender = texttospeech.SsmlVoiceGender.FEMALE
+    elif bot_gender in ["male", texttospeech.SsmlVoiceGender.MALE]:
+        bot_gender = texttospeech.SsmlVoiceGender.MALE
+    else:
+        # gender = texttospeech.SsmlVoiceGender.SSML_VOICE_GENDER_UNSPECIFIED
+        raise Exception("Unknown gender: %s" % bot_gender)
+    # Instantiates a client
+    client = texttospeech.TextToSpeechClient()
+
+    # Set the text input to be synthesized
+    if speed is None:
+        synthesis_input = texttospeech.SynthesisInput(text=text)
+    elif speed == "slow":
+        # https://stackoverflow.com/questions/68742170/google-clouds-rate-and-pitch-prosody-attributes
+        # ssml = f'<speak><prosody rate="slow">{text}</prosody></speak>'
+        ssml = f'<speak><prosody rate="100%">{text}</prosody></speak>'
+        synthesis_input = texttospeech.SynthesisInput(ssml=ssml)
+    else:
+        raise Exception(f"Unknown SPEED '{speed}'")
+    # synthesis_input = texttospeech.SynthesisInput(text="Bonjour, Monsieur Natterbot!")
+    # synthesis_input = texttospeech.SynthesisInput(text="Γεια σου, Natterbot!")
+
+    # Build the voice request, select the language code ("en-US") and the ssml
+    # voice gender ("neutral")
+    voice = texttospeech.VoiceSelectionParams(
+        language_code=language_code,  # e.g. 'en-GB'
+        ssml_gender=bot_gender,
+    )
+
+    # Select the type of audio file you want returned
+    audio_config = texttospeech.AudioConfig(
+        audio_encoding=texttospeech.AudioEncoding.MP3
+    )
+
+    # Perform the text-to-speech request on the text input with the selected
+    # voice parameters and audio file type
+    response = client.synthesize_speech(
+        input=synthesis_input, voice=voice, audio_config=audio_config
+    )
+    with open(mp3_filen, "wb") as out:
+        # Write the response to the output file.
+        out.write(response.audio_content)  # type: ignore
+        if verbose > 0:
+            print(f"Audio content written to {mp3_filen}")
+
+    return response
+
+
+def outloud_elevenlabs(
+    text: str,
+    api_key: Optional[str] = None,
+    mp3_filen: Optional[str] = None,
+    bot_name: Optional[str] = None,
+    model: str = "eleven_multilingual_v2",
+    # speed=None,
+    should_play: bool = False,
+    verbose: int = 0,
+):
+    from elevenlabs import play, save
+    from elevenlabs.client import ElevenLabs
+
+    if api_key is None:
+        api_key = os.environ.get("ELEVENLABS_API_KEY")
+    # i should figure out a better way to handle playing an mp3 file
+    # assert (
+    #     not mp3_filen and should_play
+    # ), "Writing out uses up the bytes, so you can't then play"
+    assert model in ["eleven_multilingual_v2", "eleven_turbo_v2_5"]
+    # if speed is not None:
+    #     raise Exception(f"Unknown SPEED '{speed}'")
+    if bot_name is None:
+        bot_name = "Charlotte"  # slower
+
+    client = ElevenLabs(
+        api_key=api_key,
+    )
+    audio = client.generate(
+        text=text,
+        voice=bot_name,
+        model=model,
+    )
+    if mp3_filen is not None:
+        save(audio, mp3_filen)  # type: ignore
+    if should_play:
+        if mp3_filen is None:
+            play(audio)
+        else:
+            # if you've already saved, it will consume the bytes
+            from .audios import play_mp3
+
+            play_mp3(mp3_filen, prog="cli")
+    return audio
+
+
+# mp3_filen = TEMP_MP3_FILEN
+# # response = outloud(text="Hello Natterbot!", mp3_filen=mp3_filen, language_code='en-GB')
+# response = outloud(text="γεια σου", mp3_filen=mp3_filen, language_code='el')

gjdutils/prompt_templates.py

@@ -0,0 +1,20 @@
+# each of these is a Jinja template. see gjdutils.strings.jinja_render()
+
+summarise_text = """
+Summarise the following. Be as concise, concrete, and easy to understand as you can. Provide only the summary itself, without any superfluous conversation, commentary, markup, etc. {{ granularity }}
+
+----
+{{ txt }}
+"""
+
+
+# UNTESTED
+summarise_list_of_texts_as_one = """
+Summarise the whole of the following list. Be as concise, concrete, and easy to understand as you can. Provide only the summary itself, without any superfluous conversation or commentary etc. {{ granularity }}
+
+----
+{% for txt in txts %}
+- {{txt}}
+{% endfor %}
+----
+"""