py-isaac 0.1.0__py3-none-any.whl

isaac/__init__.py

@@ -0,0 +1,38 @@
+import json
+import os
+
+from yapper import PiperVoiceUS
+
+import isaac.constants as c
+
+if not os.path.isdir(c.APP_DIR):
+    os.mkdir(c.APP_DIR)
+
+if not os.path.isfile(c.FILE_SETTINGS):
+    with open(c.FILE_SETTINGS, "w", encoding="utf-8") as f:
+        json.dump(
+            {
+                c.STNG_FLD_GROQ: {
+                    c.STNG_FLD_KEY: None,
+                    c.STNG_FLD_MODEL: None,
+                },
+                c.STNG_FLD_GEMINI: {
+                    c.STNG_FLD_KEY: None,
+                    c.STNG_FLD_MODEL: None,
+                },
+                c.STNG_FLD_SPEECH: {
+                    c.STNG_FLD_IS_ENABLED: False,
+                    c.STNG_FLD_PIPER_VOICE: PiperVoiceUS.HFC_FEMALE.value,
+                },
+                c.STNG_FLD_HEARING: {
+                    c.STNG_FLD_IS_ENABLED: False,
+                    c.STNG_FLD_WHISPER_SIZE: "auto",
+                },
+                c.STNG_FLD_RSPNS_GENERATOR: None,
+                c.STNG_FLD_SYS_MESSAGE: None,
+                c.STNG_FLD_CONTEXT_ENABLED: True,
+                c.STNG_FLD_SHELL: c.FILE_SHELL,
+            },
+            f,
+            indent=2,
+        )

isaac/cli.py

@@ -0,0 +1,4 @@
+def main():
+    from isaac.command import run_loop
+
+    run_loop()

isaac/command.py

@@ -0,0 +1,336 @@
+try:
+    import readline
+except ImportError:
+    import pyreadline3 as readline
+import shlex
+from typing import Optional
+
+import platform
+import subprocess
+import isaac.constants as c
+import isaac.globals as glb
+import psutil
+import os
+import isaac.lang_models as lang_models
+import isaac.speech as speech
+from isaac.settings import Settings
+from isaac.theme import BOLD_BRIGHT, BRIGHT, RESET
+from isaac.utils import clear, handle_lm_response, write, label_switch
+from difflib import SequenceMatcher
+
+CMD_SELECT = ":select"
+CMD_TOGGLE = ":toggle"
+CMD_KEY = ":key"
+CMD_INSTRUCT = ":instruct"
+CMD_STATUS = ":status"
+CMD_MUTE = ":mute"
+CMD_CMD = ":cmd"
+CMD_COMMANDS = ":commands"
+CMD_CLEAR = ":clear"
+CMD_EXIT = ":exit"
+
+SELECTABLE_LM_PROVIDER = "lm_provider"
+SELECTABLE_VOICE = "voice"
+SELECTABLE_LANG_MODEL = "lm"
+SELECTABLE_WHISPER_MODEL = "whisper"
+
+TOGGLABLE_SPEECH = "speech"
+TOGGLABLE_HEARING = "hearing"
+TOGGLABLE_CONTEXT = "context"
+
+commands = {
+    CMD_SELECT,
+    CMD_TOGGLE,
+    CMD_KEY,
+    CMD_INSTRUCT,
+    CMD_STATUS,
+    CMD_MUTE,
+    CMD_CMD,
+    CMD_COMMANDS,
+    CMD_CLEAR,
+    CMD_EXIT,
+}
+selectables = [
+    SELECTABLE_LM_PROVIDER,
+    SELECTABLE_LANG_MODEL,
+    SELECTABLE_VOICE,
+    SELECTABLE_WHISPER_MODEL,
+]
+togglables = [TOGGLABLE_SPEECH, TOGGLABLE_HEARING, TOGGLABLE_CONTEXT]
+command_args = {CMD_SELECT: selectables, CMD_TOGGLE: togglables}
+
+
+def print_welcome():
+    """Prints the welcome message on the screen."""
+    banner = """
+%s ___   ____      _         _      ____
+|_ _| / ___|    / \       / \    / ___|
+ | |  \___ \   / _ \     / _ \  | |
+ | | _ ___) | / ___ \ _ / ___ \ | |___
+|___(_)____(_)_/   \_(_)_/   \_(_)____|%s"""
+    message = banner + "   type %s%s%s to see commands.\n"
+    message = message % (BRIGHT, RESET, BOLD_BRIGHT, CMD_COMMANDS, RESET)
+    print(message)
+
+
+def is_command(text: str) -> bool:
+    """
+    prints if the given text is a command, i.e. if it starts with a colon(:).
+    """
+    return text.startswith(":")
+
+
+def command_exists(word: str) -> bool:
+    """
+    checks if the given word is one of the valid commands defined in the file.
+    """
+    return word in commands
+
+
+def handle_misspell(word: str) -> str:
+    """prints the most similar command to word."""
+
+    # penalizes command matches that don't share the first letter
+    def key(c: str):
+        return SequenceMatcher(None, word, c).ratio() * (
+            0.8 if c[:2] != word[:2] else 1
+        )
+
+    similar = max(commands, key=key)
+    write(f"command not found, did you mean '{similar}'?")
+
+
+def command_completer(text: str, state: int) -> Optional[str]:
+    """handles auto-completion of commands and their arguments."""
+    text = readline.get_line_buffer().lstrip()
+    if not is_command(text):
+        return
+    words = shlex.split(text)
+    if len(words) > 2:
+        return
+    command = words[0]
+    if not command_exists(command):
+        if len(words) == 1:
+            options = [cmd for cmd in commands if cmd.startswith(command)]
+            return options[state] if state < len(options) else None
+        return None
+    if command not in command_args:
+        return
+    arg = words[1] if len(words) == 2 else ""
+    options = [option for option in command_args[command] if option.startswith(arg)]
+    return options[state] if state < len(options) else None
+
+
+def handle_select(args: list[str]):
+    """handles the ':select' command."""
+    if len(args) > 1:
+        write(":select only takes one argument")
+        return
+    elif len(args) == 0:
+        write(":select needs an argument")
+        return
+
+    arg = args[0]
+    if arg not in selectables:
+        write(f"invalid argument {arg}, must be one of {selectables}")
+        return
+
+    if arg == SELECTABLE_LM_PROVIDER:
+        glb.settings.select_lm_provider()
+    elif arg == SELECTABLE_LANG_MODEL:
+        glb.settings.select_lm()
+    elif arg == SELECTABLE_VOICE:
+        glb.settings.select_voice()
+    else:
+        glb.settings.select_whisper_size()
+
+
+def handle_toggle(args: list[str]):
+    """handles the ':toggle' command."""
+    if len(args) > 1:
+        write(":toggle only takes one argument")
+        return
+    elif len(args) == 0:
+        write(":toggle needs an argument")
+        return
+
+    arg = args[0]
+    if arg not in togglables:
+        write(f"invalid argument {arg}, argument must be one of {togglables}")
+        return
+
+    if arg == TOGGLABLE_SPEECH:
+        glb.settings.toggle_speech()
+    elif arg == TOGGLABLE_CONTEXT:
+        glb.settings.toggle_context()
+    else:
+        glb.settings.toggle_hearing()
+
+
+def set_sys_msg(args: list[str]):
+    """sets the system message if it is valid."""
+    if len(args) == 0:
+        write(f"{CMD_INSTRUCT} needs an argument")
+        return
+    if len(args) > 1:
+        write(f"{CMD_INSTRUCT} only takes one argument")
+        return
+    message = args[0]
+    if len(message.strip()) == 0:
+        write("instruction must not be empty")
+        return
+    glb.settings.set_sys_msg(message)
+
+
+def handle_cmd():
+    """handles the `:cmd` command, i.e. launches the appropriate shell."""
+    try:
+        if glb.listener is not None:
+            glb.listener.pause()
+        if platform.system() == "Windows":
+            subprocess.run(["powershell.exe"])
+        else:
+            subprocess.run(["/bin/sh"])
+    finally:
+        if glb.listener is not None:
+            glb.listener.resume()
+
+
+def display_status():
+    """Displays the user's preferences, token cost, and memory consumption."""
+    settings = glb.settings
+    lang_model = (
+        glb.settings.groq_model
+        if settings.response_generator == c.RSPNS_GNRTR_GROQ
+        else glb.settings.gemini_model
+    )
+    total_mem = psutil.virtual_memory().total
+    parent = psutil.Process(os.getpid())
+    consumed_mem = parent.memory_info().rss
+    for child in parent.children(recursive=True):
+        consumed_mem += child.memory_info().rss
+    mem_per = consumed_mem / total_mem * 100
+
+    lines = [
+        "%slanguage model:%s" % (BOLD_BRIGHT, RESET),
+        "  %sprovider%s: %s" % (BRIGHT, RESET, settings.response_generator),
+        "  %smodel:%s %s" % (BRIGHT, RESET, lang_model),
+        "  %sinstruction:%s %s" % (BRIGHT, RESET, settings.system_message or "null"),
+        "  %scontext:%s %s" % (BRIGHT, RESET, label_switch(settings.context_enabled)),
+        "%sspeech:%s" % (BOLD_BRIGHT, RESET),
+        "  %sstatus:%s %s" % (BRIGHT, RESET, label_switch(settings.speech_enabled)),
+        "  %svoice:%s %s" % (BRIGHT, RESET, glb.settings.piper_voice),
+        "%shearing:%s" % (BOLD_BRIGHT, RESET),
+        "  %sstatus:%s %s" % (BRIGHT, RESET, label_switch(settings.hearing_enabled)),
+        "  %smodel:%s %s" % (BRIGHT, RESET, settings.whisper_size or "null"),
+        "%sconsumption:%s" % (BOLD_BRIGHT, RESET),
+        "  %sprompt tokens:%s %s" % (BRIGHT, RESET, settings.prompt_tokens),
+        "  %scompletion tokens:%s %s" % (BRIGHT, RESET, settings.completion_tokens),
+        "  %smemory:%s %.2f%%" % (BRIGHT, RESET, mem_per),
+    ]
+    write("\n".join(lines))
+
+
+def display_commands():
+    """Displays the available commands."""
+    lines = [
+        "%s%s%s to turn features on or off" % (BOLD_BRIGHT, CMD_TOGGLE, RESET),
+        "  %s%s %s%s to toggle the assistant's speech"
+        % (BRIGHT, CMD_TOGGLE, TOGGLABLE_SPEECH, RESET),
+        (
+            "  %s%s %s%s to toggle the use of conversation"
+            " history for coherent responses"
+        )
+        % (BRIGHT, CMD_TOGGLE, TOGGLABLE_CONTEXT, RESET),
+        "  %s%s %s%s to toggle the assistant's ability to hear you"
+        % (BRIGHT, CMD_TOGGLE, TOGGLABLE_HEARING, RESET),
+        "%s%s%s for selecting from available models and voices"
+        % (BOLD_BRIGHT, CMD_SELECT, RESET),
+        "  %s%s %s%s to select the language model provider"
+        % (BRIGHT, CMD_SELECT, SELECTABLE_LM_PROVIDER, RESET),
+        "  %s%s %s%s to select the model for generating responses"
+        % (BRIGHT, CMD_SELECT, SELECTABLE_LANG_MODEL, RESET),
+        "  %s%s %s%s to select the assistant's voice"
+        % (BRIGHT, CMD_SELECT, SELECTABLE_VOICE, RESET),
+        "  %s%s %s%s to select the model interpreting speech"
+        % (BRIGHT, CMD_SELECT, SELECTABLE_WHISPER_MODEL, RESET),
+        "%s%s%s to set the LLM API key for the selected provider"
+        % (BOLD_BRIGHT, CMD_KEY, RESET),
+        "%s%s%s to instruct the model to behave a certain way"
+        % (BOLD_BRIGHT, CMD_INSTRUCT, RESET),
+        "%s%s%s to display status and settings" % (BOLD_BRIGHT, CMD_STATUS, RESET),
+        "%s%s%s to mute the assistant" % (BOLD_BRIGHT, CMD_MUTE, RESET),
+        "%s%s%s to launch a shell session" % (BOLD_BRIGHT, CMD_CMD, RESET),
+        "%s%s%s to print this help message" % (BOLD_BRIGHT, CMD_COMMANDS, RESET),
+        "%s%s%s for clearing the console" % (BOLD_BRIGHT, CMD_CLEAR, RESET),
+        "%s%s%s to exit" % (BOLD_BRIGHT, CMD_EXIT, RESET),
+    ]
+    write("\n".join(lines))
+
+
+def handle_command(words: list[str]):
+    """handles words as command."""
+    command = words[0]
+
+    if command == CMD_SELECT:
+        handle_select(words[1:])
+    elif command == CMD_TOGGLE:
+        handle_toggle(words[1:])
+    elif command == CMD_KEY:
+        glb.settings.set_key()
+    elif command == CMD_INSTRUCT:
+        set_sys_msg(words[1:])
+    elif command == CMD_STATUS:
+        display_status()
+    elif command == CMD_MUTE:
+        speech.mute()
+    elif command == CMD_CMD:
+        handle_cmd()
+    elif command == CMD_COMMANDS:
+        display_commands()
+    elif command == CMD_CLEAR:
+        clear()
+    elif command == CMD_EXIT:
+        glb.settings.dump_to_cache()
+        if glb.listener is not None:
+            glb.settings.disable_hearing()
+
+
+def get_proc_count():
+    import psutil
+
+    return sum(1 for _ in psutil.Process(os.getpid()).children(recursive=True)) + 1
+
+
+def run_loop():
+    """starts the REPL loop."""
+    readline.set_completer(command_completer)
+    readline.parse_and_bind("tab: complete")
+
+    glb.settings = Settings()
+    glb.settings.enact()
+    clear()
+    print_welcome()
+
+    while True:
+        try:
+            query = input(">> ")
+            if len(query.strip()) == 0:
+                continue
+            if is_command(query):
+                try:
+                    words = shlex.split(query)
+                    if command_exists(words[0]):
+                        handle_command(words)
+                        if words[0] == CMD_EXIT:
+                            break
+                    elif words[0] == ":procs":
+                        print(get_proc_count())
+                    else:
+                        handle_misspell(words[0])
+                except ValueError:
+                    write("invalid command")
+            else:
+                handle_lm_response(lang_models.ask(query))
+        except KeyboardInterrupt:
+            write("\r", end="")

isaac/constants.py

@@ -0,0 +1,79 @@
+import os
+import sys
+import os.path as path
+
+import isaac.meta as meta
+
+# Gemini API fields
+GMNI_FLD_SYS_INST = "system_instruction"
+GMNI_FLD_CONTENT = "content"
+GMNI_FLD_ROLE = "role"
+GMNI_FLD_PARTS = "parts"
+GMNI_FLD_CONTENTS = "contents"
+GMNI_FLD_CANDIDATES = "candidates"
+GMNI_FLD_TEXT = "text"
+GMNI_FLD_USAGE = "usageMetadata"
+GMNI_FLD_ERROR = "error"
+
+GMNI_USG_PROMPT = "promptTokenCount"
+GMNI_USG_COMPLETION = "candidatesTokenCount"
+
+GMNI_ROLE_USER = "user"
+GMNI_ROLE_MODEL = "model"
+
+# Groq  API fields
+GROQ_FLD_ROLE = "role"
+GROQ_FLD_CHOICES = "choices"
+GROQ_FLD_MESSAGE = "message"
+GROQ_FLD_CONTENT = "content"
+GROQ_FLD_MESSAGES = "messages"
+GROQ_FLD_MODEL = "model"
+GROQ_FLD_USAGE = "usage"
+GROQ_FLD_ERROR = "error"
+GROQ_FLD_ERROR_CODE = "code"
+
+GROQ_USG_PROMPT = "prompt_tokens"
+GROQ_USG_COMPLETION = "completion_tokens"
+
+GROQ_ROLE_SYSTEM = "system"
+GROQ_ROLE_USER = "user"
+GROQ_ROLE_ASSISTANT = "assistant"
+
+# Settings fields
+STNG_FLD_GROQ = "groq"
+STNG_FLD_GEMINI = "gemini"
+STNG_FLD_KEY = "key"
+STNG_FLD_MODEL = "model"
+STNG_FLD_HEARING = "hearing"
+STNG_FLD_WHISPER_SIZE = "whisperSize"
+STNG_FLD_SPEECH = "speech"
+STNG_FLD_PIPER_VOICE = "piperVoice"
+STNG_FLD_IS_ENABLED = "isEnabled"
+STNG_FLD_RSPNS_GENERATOR = "responseGenerator"
+STNG_FLD_SYS_MESSAGE = "systemMessage"
+STNG_FLD_CONTEXT_ENABLED = "contextEnabled"
+STNG_FLD_SHELL = "shell"
+
+# Response generator APIs
+RSPNS_GNRTR_GROQ = "groq"
+RSPNS_GNRTR_GEMINI = "gemini"
+
+
+if os.name == "nt":
+    APP_DIR = path.join(os.getenv("APPDATA"), meta.name)
+elif os.name == "posix":
+    home = path.expanduser("~")
+    if os.uname().sysname == "Darwin":
+        APP_DIR = path.join(home, "Library/Application Support", meta.name)
+    else:
+        APP_DIR = path.join(home, ".config", meta.name)
+else:
+    print("your system is not supported")
+    sys.exit()
+
+# File names
+FILE_SETTINGS = path.join(APP_DIR, "settings.json")
+FILE_SHELL = "powershell.exe" if os.name == "nt" else "/bin/sh"
+
+# messages
+MSG_LANG_MODEL_ERROR = "could not process that query, something went wrong"

isaac/globals.py

@@ -0,0 +1,8 @@
+from isaac.types import SettingsInterface, SpeakerInteface, ListenerInterface
+from typing import Optional
+
+
+settings: Optional[SettingsInterface] = None
+speaker: Optional[SpeakerInteface] = None
+listener: Optional[ListenerInterface] = None
+past_exchanges = []

isaac/lang_models.py

@@ -0,0 +1,168 @@
+from typing import List, Optional, Tuple
+
+import requests
+
+import isaac.constants as c
+import isaac.globals as glb
+
+import re
+
+
+def append_history(query: str, answer: str):
+    glb.past_exchanges.append((query, answer))
+
+
+def ask_gemini(
+    model: str,
+    api_key: str,
+    query: str,
+    sys_msg: Optional[str] = None,
+    past_exchanges: Optional[List[Tuple[str, str]]] = None,
+) -> str:
+    """
+    queries the selected `Gemini` model and returns its repsonse as a string.
+    """
+    base = "https://generativelanguage.googleapis.com/v1beta/models"
+    url = f"{base}/{model}:generateContent?key={api_key}"
+    data = {}
+    if sys_msg is not None:
+        data[c.GMNI_FLD_SYS_INST] = {c.GMNI_FLD_PARTS: {c.GMNI_FLD_TEXT: sys_msg}}
+    contents = []
+    if past_exchanges is not None:
+        for exchange in past_exchanges:
+            contents.append(
+                {
+                    c.GMNI_FLD_ROLE: c.GMNI_ROLE_USER,
+                    c.GMNI_FLD_PARTS: [{c.GMNI_FLD_TEXT: exchange[0]}],
+                }
+            )
+            contents.append(
+                {
+                    c.GMNI_FLD_ROLE: c.GMNI_ROLE_MODEL,
+                    c.GMNI_FLD_PARTS: [{c.GMNI_FLD_TEXT: exchange[1]}],
+                }
+            )
+    contents.append(
+        {
+            c.GMNI_FLD_ROLE: c.GMNI_ROLE_USER,
+            c.GMNI_FLD_PARTS: [{c.GMNI_FLD_TEXT: query}],
+        }
+    )
+    data[c.GMNI_FLD_CONTENTS] = contents
+    response = requests.post(url, json=data).json()
+    if c.GMNI_FLD_ERROR in response:
+        return c.MSG_LANG_MODEL_ERROR
+    update_token_cost(
+        response[c.GMNI_FLD_USAGE][c.GMNI_USG_PROMPT],
+        response[c.GMNI_FLD_USAGE][c.GMNI_USG_COMPLETION],
+    )
+    content = response[c.GMNI_FLD_CANDIDATES][0][c.GMNI_FLD_CONTENT]
+    return content[c.GMNI_FLD_PARTS][0][c.GMNI_FLD_TEXT]
+
+
+def ask_groq(
+    model: str,
+    api_key: str,
+    query: str,
+    sys_msg: Optional[str] = None,
+    past_exhanges: Optional[List[Tuple[str, str]]] = None,
+) -> str:
+    """
+    queries the selected `Groq` model and returns its repsonse as a string.
+    """
+    url = "https://api.groq.com/openai/v1/chat/completions"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}",
+        "User-Agent": "curl/7.68.0",
+    }
+    messages = []
+    if sys_msg is not None:
+        messages.append(
+            {c.GROQ_FLD_ROLE: c.GROQ_ROLE_SYSTEM, c.GROQ_FLD_CONTENT: sys_msg}
+        )
+    if past_exhanges is not None:
+        for exchange in past_exhanges:
+            messages.append(
+                {
+                    c.GROQ_FLD_ROLE: c.GROQ_ROLE_USER,
+                    c.GROQ_FLD_CONTENT: exchange[0],
+                }
+            )
+            messages.append(
+                {
+                    c.GROQ_FLD_ROLE: c.GROQ_ROLE_ASSISTANT,
+                    c.GROQ_FLD_CONTENT: exchange[1],
+                }
+            )
+    messages.append({c.GROQ_FLD_ROLE: c.GROQ_ROLE_USER, c.GROQ_FLD_CONTENT: query})
+    data = {c.GROQ_FLD_MESSAGES: messages, c.GROQ_FLD_MODEL: model}
+    response = requests.post(url, json=data, headers=headers).json()
+    if c.GROQ_FLD_ERROR in response:
+        if response[c.GROQ_FLD_ERROR].get(c.GROQ_FLD_ERROR_CODE) == "model_decommissioned":
+            return (f"the model '{model}' has been decommissioned"
+                    ", please use another Groq model.")
+        return c.MSG_LANG_MODEL_ERROR
+    update_token_cost(
+        response[c.GROQ_FLD_USAGE][c.GROQ_USG_PROMPT],
+        response[c.GROQ_FLD_USAGE][c.GROQ_USG_COMPLETION],
+    )
+    return response[c.GROQ_FLD_CHOICES][0][c.GROQ_FLD_MESSAGE][c.GROQ_FLD_CONTENT]
+
+
+def ask(query: str) -> Tuple[bool, str]:
+    """
+    queries the selected language model and returns response as a string,
+    sends chat context if context is enabled.
+    """
+    if glb.settings.response_generator is None:
+        glb.settings.select_lm_provider()
+    if glb.settings.lang_model is None:
+        glb.settings.select_lm()
+
+    exchanges = glb.past_exchanges if glb.settings.context_enabled else None
+    if glb.settings.response_generator == c.RSPNS_GNRTR_GEMINI:
+        response = ask_gemini(
+            glb.settings.gemini_model,
+            glb.settings.gemini_key,
+            query,
+            glb.settings.system_message,
+            exchanges,
+        )
+    else:
+        response = ask_groq(
+            glb.settings.groq_model,
+            glb.settings.groq_key,
+            query,
+            glb.settings.system_message,
+            exchanges,
+        )
+    post_ask(query, response)
+    return response
+
+
+def post_ask(query: str, answer: str):
+    """
+    stores query-response exchange to send as context with later queries,
+    if the response contains code, only keeps code as response, if response
+    contains plain text, response is truncated.
+    """
+    max_answer_words = 30
+    max_exchanges = 5
+    code_blocks = re.findall(r"```.*?```", answer, re.DOTALL)
+
+    if len(code_blocks) > 0:
+        answer = "\n\n".join(code_blocks)
+    else:
+        parts = answer.split()
+        if len(parts) > max_answer_words:
+            answer = " ".join(parts[:max_answer_words]) + "..."
+    glb.past_exchanges.append((query, answer))
+    if len(glb.past_exchanges) > max_exchanges:
+        glb.past_exchanges = glb.past_exchanges[-max_exchanges:]
+
+
+def update_token_cost(prompt: int, completion: int):
+    """updates the token cost to keep track of token expenditure."""
+    glb.settings.prompt_tokens += prompt
+    glb.settings.completion_tokens += completion

isaac/meta.py

@@ -0,0 +1,3 @@
+name = "py-isaac"
+version = "0.1.0"
+github = "https://github.com/n1teshy/%s" % (name,)

isaac/settings.py

@@ -0,0 +1,275 @@
+import re
+import json
+
+from yapper import GeminiModel, GroqModel, PiperVoiceUK, PiperVoiceUS
+
+import isaac.constants as c
+from isaac.utils import (
+    select_from,
+    write,
+    get_piper_voice_enum,
+    handle_lm_response,
+    safe_input,
+)
+from isaac.types import SettingsInterface
+import isaac.speech as speech
+from yapper import PiperSpeaker
+import isaac.globals as glb
+import isaac.lang_models as lm
+
+
+whisper_options = [
+    "tiny",
+    "tiny.en",
+    "base",
+    "base.en",
+    "small",
+    "small.en",
+    "medium",
+    "medium",
+    "turbo",
+    "large",
+    "auto",
+]
+whisper_option_details = [
+    "~1GB",
+    "~1GB, english only",
+    "~1GB",
+    "~1GB, english only",
+    "~2GB",
+    "~2GB, english only",
+    "~5GB",
+    "~5GB, english only",
+    "~6GB",
+    "~10GB",
+    "select based on resource availability",
+]
+
+
+class Settings(SettingsInterface):
+    """
+    stores the user's preferences, loads settings from the default settings
+    file on initialization and can dump back to the same file.
+    """
+
+    def __init__(self):
+        cache = json.load(open(c.FILE_SETTINGS, encoding="utf-8"))
+        self.groq_key = cache[c.STNG_FLD_GROQ][c.STNG_FLD_KEY]
+        self.groq_model = cache[c.STNG_FLD_GROQ][c.STNG_FLD_MODEL]
+        self.gemini_key = cache[c.STNG_FLD_GEMINI][c.STNG_FLD_KEY]
+        self.gemini_model = cache[c.STNG_FLD_GEMINI][c.STNG_FLD_MODEL]
+        self.hearing_enabled = cache[c.STNG_FLD_HEARING][c.STNG_FLD_IS_ENABLED]
+        self.whisper_size = cache[c.STNG_FLD_HEARING][c.STNG_FLD_WHISPER_SIZE]
+        self.speech_enabled = cache[c.STNG_FLD_SPEECH][c.STNG_FLD_IS_ENABLED]
+        self.piper_voice = cache[c.STNG_FLD_SPEECH][c.STNG_FLD_PIPER_VOICE]
+        self.response_generator = cache[c.STNG_FLD_RSPNS_GENERATOR]
+        self.system_message = cache[c.STNG_FLD_SYS_MESSAGE]
+        self.context_enabled = cache[c.STNG_FLD_CONTEXT_ENABLED]
+        self.shell = cache[c.STNG_FLD_SHELL]
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        if self.response_generator is None:
+            self.select_lm_provider()
+
+    @property
+    def lang_model(self):
+        if self.response_generator == c.RSPNS_GNRTR_GEMINI:
+            return self.gemini_model
+        elif self.response_generator == c.RSPNS_GNRTR_GROQ:
+            return self.groq_model
+        return None
+
+    def dump_to_cache(self):
+        """dumps settings to the default settings file."""
+        cache = {}
+        cache[c.STNG_FLD_GROQ] = {
+            c.STNG_FLD_KEY: self.groq_key,
+            c.STNG_FLD_MODEL: self.groq_model,
+        }
+        cache[c.STNG_FLD_GEMINI] = {
+            c.STNG_FLD_KEY: self.gemini_key,
+            c.STNG_FLD_MODEL: self.gemini_model,
+        }
+        cache[c.STNG_FLD_SPEECH] = {
+            c.STNG_FLD_IS_ENABLED: self.speech_enabled,
+            c.STNG_FLD_PIPER_VOICE: self.piper_voice,
+        }
+        cache[c.STNG_FLD_HEARING] = {
+            c.STNG_FLD_IS_ENABLED: self.hearing_enabled,
+            c.STNG_FLD_WHISPER_SIZE: self.whisper_size,
+        }
+        cache[c.STNG_FLD_RSPNS_GENERATOR] = self.response_generator
+        cache[c.STNG_FLD_SYS_MESSAGE] = self.system_message
+        cache[c.STNG_FLD_CONTEXT_ENABLED] = self.context_enabled
+        cache[c.STNG_FLD_SHELL] = self.shell
+        json.dump(cache, open(c.FILE_SETTINGS, "w", encoding="utf-8"), indent=2)
+
+    def select_lm_provider(self):
+        """
+        lets the user select a language model provider,
+        currently from `Groq` and `Gemini`.
+        """
+        options = [c.RSPNS_GNRTR_GEMINI, c.RSPNS_GNRTR_GROQ]
+        idx = select_from(
+            options, prompt="select an LLM API provider", allow_none=False
+        )
+        if idx != -1:
+            self.response_generator = options[idx]
+        if self.lang_model is None:
+            self.select_lm()
+
+    def select_lm(self):
+        """
+        lets the user select a language model to be used for answering
+        queries.
+        """
+        if self.response_generator is None:
+            self.select_lm_provider()
+        provider = self.response_generator
+        if provider is None:
+            return
+        options = (
+            [model.value for model in GroqModel]
+            if self.response_generator == c.RSPNS_GNRTR_GROQ
+            else list(GeminiModel)
+        )
+        idx = select_from(
+            options, prompt="please select a language model", allow_none=False
+        )
+        if idx == -1:
+            return
+        if provider == c.RSPNS_GNRTR_GEMINI:
+            self.gemini_model = options[idx]
+        else:
+            self.groq_model = options[idx]
+
+        if (
+            self.response_generator == c.RSPNS_GNRTR_GROQ
+            and self.groq_key is None
+            or self.response_generator == c.RSPNS_GNRTR_GEMINI
+            and self.gemini_key is None
+        ):
+            self.set_key()
+
+    def set_key(self):
+        """sets the key for the currently selected language model provider."""
+        if self.response_generator is None:
+            self.select_lm()
+        key = safe_input(f"please enter your {self.response_generator} key: ").strip()
+        if self.response_generator == c.RSPNS_GNRTR_GROQ:
+            self.groq_key = key
+        else:
+            self.gemini_key = key
+        write()
+
+    def set_sys_msg(self, message: str):
+        """
+        sets the system message to be used for querying the language
+        model.
+        """
+        self.system_message = message
+
+    def toggle_context(self):
+        """
+        toggles the use of context to help the model come up with coherent
+        responses.
+        """
+        self.context_enabled = not self.context_enabled
+
+    def enable_speech(self):
+        """
+        enables speech for the assistant so it can both prints and speaks its
+        response.
+        """
+        glb.speaker = PiperSpeaker(
+            get_piper_voice_enum(self.piper_voice), show_progress=False
+        )
+        self.speech_enabled = True
+
+    def disable_speech(self):
+        """disables speech for the assistant."""
+        glb.speaker = None
+        self.speech_enabled = False
+
+    def select_voice(self):
+        """
+        lets the user select a piper voice for the assistant to speak with
+        """
+        voices = [voice.value for voice in PiperVoiceUS] + [
+            voice.value for voice in PiperVoiceUK
+        ]
+        idx = select_from(voices, prompt="select a voice")
+        if idx == -1:
+            return
+        if self.speech_enabled and self.piper_voice != voices[idx]:
+            glb.speaker = PiperSpeaker(
+                get_piper_voice_enum(voices[idx]), show_progress=False
+            )
+        self.piper_voice = voices[idx]
+
+    def toggle_speech(self):
+        """toggles the assistant's ability to speak."""
+        if self.speech_enabled:
+            self.disable_speech()
+        else:
+            self.enable_speech()
+
+    def select_whisper_size(self):
+        """
+        lets the user select the size of the whisper model used for converting
+        user's speech to text.
+        """
+        display_options = [
+            f"{whisper_options[idx]} ({whisper_option_details[idx]})"
+            for idx in range(len(whisper_options))
+        ]
+        idx = select_from(
+            display_options,
+            prompt="please select a whisper model, large model means better accuracy",
+        )
+        self.whisper_size = whisper_options[idx]
+
+    def enable_hearing(self):
+        """enables the assistant to hear user with py-listener."""
+        from listener import Listener
+
+        def handle_speech(query: list[str]):
+            # print voice transcription on the console so
+            # the user may know what the assistant interprets
+            query = " ".join(query).strip()
+            if re.search("\w+", query) is None:
+                return
+            write(re.sub(r"\n+", ";", query))
+            handle_lm_response(lm.ask(query))
+            write(">> ", end="")
+
+        glb.listener = Listener(
+            time_window=3,
+            speech_handler=handle_speech,
+            on_speech_start=speech.mute,
+            whisper_size=self.whisper_size,
+            en_only=True,
+            # show_download=False
+        )
+        glb.listener.listen()
+        self.hearing_enabled = True
+
+    def disable_hearing(self):
+        """stops listening to user."""
+        glb.listener.close()
+        glb.listener = None
+        self.hearing_enabled = False
+
+    def toggle_hearing(self):
+        """toggles assistant's ability to hear user's speech."""
+        if self.hearing_enabled:
+            self.disable_hearing()
+        else:
+            self.enable_hearing()
+
+    def enact(self):
+        """brings the settings into action."""
+        if self.speech_enabled:
+            self.enable_speech()
+        if self.hearing_enabled:
+            self.enable_hearing()

isaac/speech.py

@@ -0,0 +1,41 @@
+import os
+import tempfile
+import threading
+
+
+import isaac.globals as glb
+import isaac.sync as sync
+
+os.environ["PYGAME_HIDE_SUPPORT_PROMPT"] = "1"
+import pygame
+
+
+def mute():
+    """
+    sets the `event_mute` event that signals the speaker thread to stop
+    speaking.
+    """
+    sync.event_mute.set()
+
+
+def say(text: str):
+    """Speaks the given text in a separate thread."""
+
+    def say_in_thread(text: str):
+        sync.event_mute.clear()
+        with sync.speech_lock:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp:
+                file = temp.name
+            try:
+                glb.speaker.text_to_wave(text, file)
+                sound = pygame.mixer.Sound(file)
+                sound.play()
+                while pygame.mixer.get_busy():
+                    if sync.event_mute.is_set():
+                        sound.stop()
+                        break
+                    pygame.time.wait(100)
+            finally:
+                os.remove(file)
+
+    threading.Thread(target=say_in_thread, args=(text,)).start()

isaac/sync.py

@@ -0,0 +1,5 @@
+import threading
+
+event_mute = threading.Event()
+speech_lock = threading.Lock()
+stdout_lock = threading.Lock()

isaac/theme.py

@@ -0,0 +1,7 @@
+RED = "\033[31m"
+GREEN = "\033[32m"
+
+BRIGHT = "\033[97m"
+BOLD_BRIGHT = "\033[1;97m"
+
+RESET = "\033[0m"

isaac/types.py

@@ -0,0 +1,38 @@
+from typing import Optional, Literal
+from abc import ABC, abstractmethod
+
+
+class SettingsInterface(ABC):
+    groq_key: Optional[str]
+    groq_model: str
+    gemini_key: Optional[str]
+    gemini_model: str
+    hearing_enabled: bool
+    whisper_size: str
+    speech_enabled: bool
+    piper_voice: str
+    response_generator: Literal["gemini", "groq"]
+    system_message = Optional[str]
+    context_enabled: bool
+    shell: str
+    prompt_tokens: int
+    completion_tokens: int
+
+
+class SpeakerInteface(ABC):
+    @abstractmethod
+    def text_to_wave(self, text: str, file: str): ...
+
+
+class ListenerInterface(ABC):
+    @abstractmethod
+    def listen(self): ...
+
+    @abstractmethod
+    def close(self): ...
+
+    @abstractmethod
+    def pause(self): ...
+
+    @abstractmethod
+    def resume(self): ...

isaac/utils.py

@@ -0,0 +1,168 @@
+import os
+import platform
+import re
+from typing import Optional, Union
+
+from rich.console import Console, ConsoleOptions
+from rich.markdown import Markdown
+from rich.segment import Segment
+from yapper import PiperVoiceUK, PiperVoiceUS
+
+import isaac.globals as glb
+import isaac.speech as speech
+import isaac.sync as sync
+import isaac.theme as theme
+
+rich_console = Console()
+
+
+def clear():
+    """
+    clears the screen.
+    """
+    os.system("cls" if platform.system() == "Windows" else "clear")
+
+
+def write(*args, **kwargs):
+    """
+    prints the given text on the screen with a lock that prevents
+    the listener thread from interrupting it.
+    """
+    with sync.stdout_lock:
+        print(*args, **kwargs, flush=True)
+
+
+def label_switch(switch: bool):
+    """
+    return a string that prints the given boolean switch on the screen
+    in color.
+    """
+    label = "on" if switch else "off"
+    pre = theme.GREEN if switch else theme.RED
+    label = pre + label + theme.RESET
+    return label
+
+
+def get_piper_voice_enum(str_voice: str) -> Union[PiperVoiceUS, PiperVoiceUK]:
+    """
+    takes stringified name of a piper voice and return the matching attribute
+    from enum `PiperVoiceUS` or `PiperVoiceUK`.
+    """
+    for voice_enum in list(PiperVoiceUS) + list(PiperVoiceUK):
+        if voice_enum.value == str_voice:
+            return voice_enum
+
+
+def safe_input(message: str) -> str:
+    try:
+        if glb.listener is not None:
+            glb.listener.pause()
+        with sync.stdout_lock:
+            return input(message)
+    finally:
+        if glb.listener is not None:
+            glb.listener.resume()
+
+
+def select_from(
+    options: list[str],
+    prompt: Optional[str] = None,
+    allow_none: bool = True,
+    none_label: str = "none",
+) -> int:
+    """
+    Displays indexed options on the screen and lets the user select
+    one by typing its index.
+    """
+    if allow_none:
+        options += [none_label]
+    options = [f"{idx}: {option}" for idx, option in enumerate(options)]
+    if prompt is not None:
+        write(theme.BOLD_BRIGHT + prompt + theme.RESET)
+    write("\n".join(options))
+    while True:
+        idx = safe_input("select by typing the index: ").strip()
+        try:
+            idx = int(idx)
+            if idx >= len(options):
+                raise ValueError()
+        except ValueError:
+            write("invalid option")
+            continue
+        if allow_none and idx == len(options) - 1:
+            return -1
+        write()
+        return idx
+
+
+def normalize_md(text: str) -> str:
+    """
+    Detects code blocks in markdown text and replaces the code with
+    "you can see the code on the screen", replacs 'code' with specific
+    language if it can be detected.
+    """
+
+    def replacer(match):
+        match = re.search("```(\w+).*", text)
+        repl = match.group(1) if match else "the code"
+        return f"you can see {repl} on the screen. "
+
+    text = re.sub(r"```.*?```", replacer, text, flags=re.DOTALL)
+    text = re.sub(r"#+ ", "", text)
+    text = re.sub(r"\*\*(.*?)\*\*", r"\1", text)
+    text = re.sub(r"\*(.*?)\*", r"\1", text)
+    return text
+
+
+def handle_lm_response(response: str):
+    """
+    prints the response on the screen, normalizes and speaks it.
+    """
+    with sync.stdout_lock:
+        rich_console.print(CustomMarkdown(response))
+    if glb.settings.speech_enabled:
+        speech.say(normalize_md(response))
+
+
+class CustomMarkdown(Markdown):
+    """
+    rich.markdown.Markdown prepends a leading space character before lines of
+    code, that makes the code clearer to read but it becomes difficult to just
+    copy it from the console and paste because of the leading space, this
+    class detects those leading spaces, and moves them with sequence of spaces
+    or before the next newline character, makes code easy to copy and paste.
+    """
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions):
+        rows: list[list[Segment]] = [[]]
+        bg_style = None
+        for seg in super().__rich_console__(console, options):
+            rows[-1].append(seg)
+            if (
+                bg_style is None
+                and seg.style
+                and seg.style.bgcolor
+                and seg.text.strip(" ") == ""
+            ):
+                bg_style = seg.style
+            if seg.text.endswith("\n"):
+                rows.append([])
+
+        rows = rows[:-1] if len(rows[-1]) == 0 else rows
+
+        for row_idx in range(len(rows)):
+            row = rows[row_idx]
+            if (
+                not row[0].text.startswith(" ")
+                or row[0].text.count(" ") == options.max_width
+            ):
+                continue
+            if row[0].text == " ":
+                rows[row_idx] = row = row[1:]
+            else:
+                segment = Segment(row[0].text[1:], row[0].style, row[0].control)
+                rows[row_idx][0] = row[0] = segment
+            rows[row_idx] = row[:-1] + [Segment(" ", style=bg_style)] + [row[-1]]
+
+        for segment in [s for row in rows for s in row]:
+            yield segment

py_isaac-0.1.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: py-isaac
+Version: 0.1.0
+Summary: Cooles locally run AI assistant
+Home-page: https://github.com/n1teshy/py-isaac
+Author: Nitesh Yadav
+Author-email: nitesh.txt@gmail.com
+License: MIT
+Keywords: AI assistant,local assistant
+Platform: Posix; Windows
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: yapper-tts
+Requires-Dist: py-listener
+Requires-Dist: psutil
+Requires-Dist: rich
+Requires-Dist: pyreadline3; sys_platform == "win32"
+

py_isaac-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+isaac/__init__.py,sha256=SECpAtki4bUUcPSQGNlp4RRhGGObET-DY4lH0T7KA6g,1155
+isaac/cli.py,sha256=OtEzrGzURT3IOz5sVL1OmQG341XA12ubt3s0rrtLkpE,67
+isaac/command.py,sha256=Zj7n7yx_NfNidl50aabVU78h7Midg3cIL1Fmzjjtfow,10847
+isaac/constants.py,sha256=ay5FqBKKVtnPpns05EHaggTzyyFCqoHwX6GyL8OGkp4,2035
+isaac/globals.py,sha256=-mftYWEGP3iw-yOnTnPN6O9gR5LvMprJDDGA-TTa7kI,260
+isaac/lang_models.py,sha256=lFTR0qLKUO6cJifqs2NMTP46IH_yZsRniHvGTgzhtYo,5550
+isaac/meta.py,sha256=47Z714NbVkVnpKnxja4CGreFG2gVPM-hOwOxkva_4fM,86
+isaac/settings.py,sha256=-IBi62Q1kLG2icjuL1I_Fc1NIGfCRV3Gy4dtsmorWu4,8878
+isaac/speech.py,sha256=2Anjy2R9vqAeRIZQsYNutn1dFakk98C5Bp_z5rXaCr4,1065
+isaac/sync.py,sha256=GB1gCk5n5aGbZ4viavHLR5nzHR1FEAWQ5ZiCDZwW8gQ,111
+isaac/theme.py,sha256=c8V6sP0upZk2UVvyb54apJhCU3LIW304ReIYnWRXYPg,103
+isaac/types.py,sha256=lTGIIoZhm09RiuGZ4YJZ_lM8x0e2mB1OpyMw6SnzDcQ,796
+isaac/utils.py,sha256=_iJBEqzb0rmVK-IZ9SVst8iTbsYhJe-lmFH6g4L7PCA,5066
+py_isaac-0.1.0.dist-info/METADATA,sha256=51Ac6dLcdGgEhSy5pAHlsKWHpjQJ4fxfeFDfNmQl5dM,740
+py_isaac-0.1.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+py_isaac-0.1.0.dist-info/entry_points.txt,sha256=KgxpEWNAg3CorJxXXHMPytyJsVEIaXo9Cx_81471JwM,44
+py_isaac-0.1.0.dist-info/top_level.txt,sha256=8a8FgzwJHUaYkAYAYrDA4d8e2svPKRpmgy_nddysmzQ,6
+py_isaac-0.1.0.dist-info/RECORD,,

py_isaac-0.1.0.dist-info/WHEEL

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

py_isaac-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+py-isaac = isaac.cli:main

py_isaac-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+isaac