autonomous-app 0.2.25__py3-none-any.whl → 0.3.1__py3-none-any.whl

autonomous/__init__.py

@@ -1,4 +1,7 @@
-__version__ = "0.2.25"
+__version__ = "0.3.01"
+
+from dotenv import load_dotenv
+
+load_dotenv()
 
 from .logger import log
-from .model.automodel import AutoModel

autonomous/ai/audioagent.py

@@ -0,0 +1,32 @@
+from autonomous import log
+from autonomous.model.autoattr import ReferenceAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+from .models.openai import OpenAIModel
+
+
+class AudioAgent(AutoModel):
+    client = ReferenceAttr(choices=[OpenAIModel])
+    name = StringAttr(default="audioagent")
+    instructions = StringAttr(
+        default="You are highly skilled AI trained to assist with generating audio files."
+    )
+    description = StringAttr(
+        default="A helpful AI assistant trained to assist with generating audio files."
+    )
+
+    _ai_model = OpenAIModel
+
+    def get_client(self):
+        if self.client is None:
+            self.client = self._ai_model(
+                name=self.name,
+                instructions=self.instructions,
+                description=self.description,
+            )
+            self.client.save()
+            self.save()
+        return self.client
+
+    def generate(self, prompt, file_path, **kwargs):
+        return self.get_client().generate_audio(prompt, file_path, **kwargs)

autonomous/ai/imageagent.py

@@ -0,0 +1,31 @@
+from autonomous.model.autoattr import ReferenceAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+from .models.openai import OpenAIModel
+
+
+class ImageAgent(AutoModel):
+    client = ReferenceAttr(choices=[OpenAIModel])
+    name = StringAttr(default="imageagent")
+    instructions = StringAttr(
+        default="You are highly skilled AI trained to assist with generating images."
+    )
+    description = StringAttr(
+        default="A helpful AI assistant trained to assist with generating images."
+    )
+
+    _ai_model = OpenAIModel
+
+    def get_client(self):
+        if self.client is None:
+            self.client = self._ai_model(
+                name=self.name,
+                instructions=self.instructions,
+                description=self.description,
+            )
+            self.client.save()
+            self.save()
+        return self.client
+
+    def generate(self, prompt, **kwargs):
+        return self.get_client().generate_image(prompt, **kwargs)

autonomous/ai/jsonagent.py

@@ -0,0 +1,40 @@
+import json
+
+from autonomous.model.autoattr import ReferenceAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+from .models.openai import OpenAIModel
+
+
+class JSONAgent(AutoModel):
+    client = ReferenceAttr(choices=[OpenAIModel])
+    name = StringAttr(default="jsonagent")
+    instructions = StringAttr(
+        default="You are highly skilled AI trained to assist with generating JSON formatted data."
+    )
+    description = StringAttr(
+        default="A helpful AI assistant trained to assist with generating JSON formatted data."
+    )
+
+    _ai_model = OpenAIModel
+
+    def get_client(self):
+        if self.client is None:
+            self.client = self._ai_model(
+                name=self.name,
+                instructions=self.instructions,
+                description=self.description,
+            )
+            self.client.save()
+            self.save()
+        return self.client
+
+    def generate(self, messages, function, additional_instructions=""):
+        result = self.get_client().generate_json(
+            messages, function, additional_instructions
+        )
+        if isinstance(result, str):
+            result = json.loads(result)
+        elif not isinstance(result, dict):
+            raise ValueError(f"Invalid JSON response from AI model.\n\n{result}")
+        return result

autonomous/ai/models/openai.py

@@ -0,0 +1,308 @@
+import json
+import os
+import random
+import time
+from base64 import b64decode
+
+import openai
+from openai import NotFoundError as openai_NotFoundError
+from openai import OpenAI
+
+from autonomous import log
+from autonomous.model.autoattr import DictAttr, ListAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+
+class OpenAIModel(AutoModel):
+    _client = None
+    _text_model = "gpt-4o-mini"
+    _image_model = "dall-e-3"
+    _json_model = "gpt-4o"
+    agent_id = StringAttr()
+    messages = ListAttr(StringAttr(default=[]))
+    tools = DictAttr()
+    vector_store = StringAttr()
+    name = StringAttr(default="agent")
+    instructions = StringAttr(
+        default="You are highly skilled AI trained to assist with various tasks."
+    )
+    description = StringAttr(
+        default="A helpful AI assistant trained to assist with various tasks."
+    )
+
+    @property
+    def client(self):
+        if not self._client:
+            self._client = OpenAI(api_key=os.environ.get("OPENAI_KEY"))
+        return self._client
+
+    def clear_agent(self):
+        if self.agent_id:
+            self.client.beta.assistants.delete(self.agent_id)
+            self.agent_id = ""
+            self.save()
+
+    def clear_agents(self):
+        assistants = self.client.beta.assistants.list().data
+        log(assistants)
+        for assistant in assistants:
+            log(f"==== Deleting Agent with ID: {assistant.id} ====")
+            try:
+                self.client.beta.assistants.delete(assistant.id)
+            except openai_NotFoundError:
+                log(f"==== Agent with ID: {assistant.id} not found ====")
+        self.agent_id = ""
+        self.save()
+
+    def _get_agent_id(self):
+        if not self.agent_id or not self.client.beta.assistants.retrieve(self.agent_id):
+            agent = self.client.beta.assistants.create(
+                instructions=self.instructions,
+                description=self.description,
+                name=self.name,
+                model=self._json_model,
+            )
+            self.agent_id = agent.id
+            log(f"==== Creating Agent with ID: {self.agent_id} ====")
+            self.save()
+        return self.agent_id
+
+    def clear_files(self, file_id=None, all=False):
+        if not file_id:
+            store_files = self.client.files.list().data
+
+            for vs in self.client.beta.vector_stores.list().data:
+                try:
+                    self.client.beta.vector_stores.delete(vs.id)
+                except openai_NotFoundError:
+                    log(f"==== Vector Store {vs.id} not found ====")
+            if all:
+                for sf in store_files:
+                    self.client.files.delete(file_id=sf.id)
+        else:
+            self.client.files.delete(file_id=file_id)
+        self.tools.pop("file_search", None)
+        self.save()
+        return self.client.files.list()
+
+    def attach_file(self, file_contents, filename="dbdata.json"):
+        # Upload the user provided file to OpenAI
+        self.tools["file_search"] = {"type": "file_search"}
+        # Create a vector store
+        if vs := self.client.beta.vector_stores.list().data:
+            self.vector_store = vs[0].id
+        else:
+            self.vector_store = self.client.beta.vector_stores.create(
+                name="Data Reference",
+                expires_after={"anchor": "last_active_at", "days": 14},
+            ).id
+
+        file_obj = self.client.files.create(
+            file=(filename, file_contents), purpose="assistants"
+        )
+
+        self.client.beta.vector_stores.files.create(
+            vector_store_id=self.vector_store,
+            file_id=file_obj.id,
+        )
+        self.client.beta.assistants.update(
+            self._get_agent_id(),
+            tools=list(self.tools.values()),
+            tool_resources={"file_search": {"vector_store_ids": [self.vector_store]}},
+        )
+        self.save()
+        return file_obj.id
+
+    def _add_function(self, user_function):
+        user_function["strict"] = True
+        user_function["parameters"]["additionalProperties"] = False
+        if not user_function["parameters"].get("required"):
+            user_function["parameters"]["required"] = list(
+                user_function["parameters"]["properties"].keys()
+            )
+
+        self.tools["function"] = {"type": "function", "function": user_function}
+        self.client.beta.assistants.update(
+            self._get_agent_id(), tools=list(self.tools.values())
+        )
+        return """
+IMPORTANT: Always use the function 'response' tool to respond to the user with only the requested JSON schema. DO NOT add any text to the response outside of the JSON schema.
+
+        """
+
+    def _format_messages(self, messages):
+        message_list = []
+        if isinstance(messages, str):
+            message_list.insert(0, {"role": "user", "content": messages})
+        else:
+            for message in messages:
+                if isinstance(message, str):
+                    message_list.insert(0, {"role": "user", "content": message})
+                else:
+                    raise Exception(
+                        f"==== Invalid message: {message} ====\nMust be a string "
+                    )
+        return message_list
+
+    def generate_json(self, messages, function, additional_instructions=""):
+        # _instructions_addition = self._add_function(function)
+        function["strict"] = True
+        function["parameters"]["additionalProperties"] = False
+        function["parameters"]["required"] = list(
+            function["parameters"]["properties"].keys()
+        )
+
+        formatted_messages = self._format_messages(messages)
+        thread = self.client.beta.threads.create(messages=formatted_messages)
+        # log(function, _print=True)
+        running_job = True
+        while running_job:
+            try:
+                run = self.client.beta.threads.runs.create_and_poll(
+                    thread_id=thread.id,
+                    assistant_id=self._get_agent_id(),
+                    additional_instructions=additional_instructions,
+                    parallel_tool_calls=False,
+                    tools=[
+                        {"type": "file_search"},
+                        {"type": "function", "function": function},
+                    ],
+                    tool_choice={
+                        "type": "function",
+                        "function": {"name": function["name"]},
+                    },
+                )
+                log(f"==== Job Status: {run.status} ====", _print=True)
+                if run.status in [
+                    "failed",
+                    "expired",
+                    "canceled",
+                    "completed",
+                    "incomplete",
+                    "requires_action",
+                ]:
+                    running_job = False
+
+            except openai.error.BadRequestError as e:
+                # Handle specific bad request errors
+                error_message = e.json_body.get("error", {}).get("message", "")
+                if "already has an active run" in error_message:
+                    log("Previous run is still active. Waiting...", _print=True)
+                    time.sleep(2)  # wait before retrying or checking run status
+                else:
+                    raise e
+
+        # while run.status in ["queued", "in_progress"]:
+        #     run = self.client.beta.threads.runs.retrieve(
+        #         thread_id=thread.id,
+        #         run_id=run.id,
+        #     )
+        #     time.sleep(0.5)
+        if run.status in ["failed", "expired", "canceled"]:
+            log(f"==== !!! ERROR !!!: {run.last_error} ====", _print=True)
+            return None
+        log("=================== RUN COMPLETED ===================", _print=True)
+        log(run.status, _print=True)
+        if run.status == "completed":
+            response = self.client.beta.threads.messages.list(thread_id=thread.id)
+            results = response.data[0].content[0].text.value
+        elif run.status == "requires_action":
+            results = run.required_action.submit_tool_outputs.tool_calls[
+                0
+            ].function.arguments
+        else:
+            log(f"====Status: {run.status} Error: {run.last_error} ====", _print=True)
+            return None
+
+        results = results[results.find("{") : results.rfind("}") + 1]
+        try:
+            results = json.loads(results, strict=False)
+        except Exception:
+            print(f"==== Invalid JSON:\n{results}", _print=True)
+            return {}
+        else:
+            log(f"==== Results: {results}", _print=True)
+            log("=================== END REPORT ===================", _print=True)
+            return results
+
+    def generate_text(self, messages, additional_instructions=""):
+        formatted_messages = self._format_messages(messages)
+        thread = self.client.beta.threads.create(messages=formatted_messages)
+
+        run = self.client.beta.threads.runs.create(
+            thread_id=thread.id,
+            assistant_id=self._get_agent_id(),
+            additional_instructions=additional_instructions,
+            parallel_tool_calls=False,
+        )
+
+        while run.status in ["queued", "in_progress"]:
+            run = self.client.beta.threads.runs.retrieve(
+                thread_id=thread.id,
+                run_id=run.id,
+            )
+            time.sleep(0.5)
+            log(f"==== Job Status: {run.status} ====", _print=True)
+
+        if run.status in ["failed", "expired", "canceled"]:
+            log(f"==== Error: {run.last_error} ====", _print=True)
+            return None
+        log("=================== RUN COMPLETED ===================", _print=True)
+        log(run.status, _print=True)
+        if run.status == "completed":
+            response = self.client.beta.threads.messages.list(thread_id=thread.id)
+            results = response.data[0].content[0].text.value
+        else:
+            log(f"====Status: {run.status} Error: {run.last_error} ====", _print=True)
+            return None
+
+        log(results, _print=True)
+        log("=================== END REPORT ===================", _print=True)
+        return results
+
+    def generate_audio(self, prompt, file_path, **kwargs):
+        voice = kwargs.get("voice") or random.choice(
+            ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
+        )
+        response = self.client.audio.speech.create(
+            model="tts-1",
+            voice=voice,
+            input=prompt,
+        )
+
+        return response.stream_to_file(file_path)
+
+    def generate_image(self, prompt, **kwargs):
+        image = None
+        try:
+            response = self.client.images.generate(
+                model=self._image_model,
+                prompt=prompt,
+                response_format="b64_json",
+                **kwargs,
+            )
+            image_dict = response.data[0]
+        except Exception as e:
+            print(f"==== Error: Unable to create image ====\n\n{e}")
+        else:
+            image = b64decode(image_dict.b64_json)
+        return image
+
+    def summarize_text(self, text, primer=""):
+        message = [
+            {
+                "role": "system",
+                "content": f"You are a highly skilled AI trained in language comprehension and summarization.{primer}",
+            },
+            {"role": "user", "content": text},
+        ]
+        response = self.client.chat.completions.create(
+            model=self._text_model, messages=message
+        )
+        try:
+            result = response.choices[0].message.content
+        except Exception as e:
+            log(f"{type(e)}:{e}\n\n Unable to generate content ====")
+            return None
+
+        return result

autonomous/ai/oaiagent.py

@@ -1,214 +1,40 @@
-import json
-import os
-import random
-import time
-from base64 import b64decode
+from autonomous import log
+from autonomous.model.autoattr import ReferenceAttr
+from autonomous.model.automodel import AutoModel
 
-from openai import OpenAI
-
-from autonomous import AutoModel, log
+from .models.openai import OpenAIModel
 
 
 class OAIAgent(AutoModel):
-    client = None
-    attributes = {
-        "model": "gpt-4o",
-        "_agent_id": None,
-        "messages": [],
-        "tools": {},
-        "vector_store": None,
-        "name": "agent",
-        "instructions": "You are highly skilled AI trained to assist with various tasks.",
-        "description": "A helpful AI assistant trained to assist with various tasks.",
-    }
-
-    def __init__(self, **kwargs):
-        self.client = OpenAI(api_key=os.environ.get("OPENAI_KEY"))
+    client_model = ReferenceAttr(choices=[OpenAIModel])
+    _ai_model = OpenAIModel
 
     @property
-    def agent_id(self):
-        if not self._agent_id or not self.client.beta.assistants.retrieve(
-            self._agent_id
-        ):
-            agent = self.client.beta.assistants.create(
-                instructions=self.instructions,
-                description=self.description,
-                name=self.name,
-                model=self.model,
-            )
-            self._agent_id = agent.id
-            log(f"==== Creating Agent with ID: {self._agent_id} ====")
+    def client(self):
+        if self.client_model is None:
+            self.client_model = self._ai_model()
             self.save()
-        return self._agent_id
-
-    @agent_id.setter
-    def agent_id(self, value):
-        self._agent_id = value
-
-    def clear_agent(self):
-        self.client.beta.assistants.delete(self.agent_id)
-        self.agent_id = ""
-
-    def get_agent(self):
-        return self.client.beta.assistants.retrieve(self.agent_id)
+        return self.client_model
 
     def clear_files(self, file_id=None):
-        if self.vector_store:
-            if not file_id:
-                vector_store_files = self.client.beta.vector_stores.files.list(
-                    vector_store_id=self.vector_store
-                ).data
-                for vsf in vector_store_files:
-                    self.client.files.delete(file_id=vsf.id)
-            else:
-                self.client.files.delete(file_id=file_id)
-            self.tools.pop("file_search", None)
-            self.save()
-        return self.client.files.list()
+        return self.client.clear_files(file_id)
 
     def attach_file(self, file_contents, filename="dbdata.json"):
-        # Upload the user provided file to OpenAI
-        self.tools["file_search"] = {"type": "file_search"}
-        # Create a vector store
-        if not self.vector_store:
-            vs = self.client.beta.vector_stores.list().data
-            if vs:
-                self.vector_store = vs[0].id
-            else:
-                self.vector_store = self.client.beta.vector_stores.create(
-                    name="Data Reference"
-                ).id
-
-        file_obj = self.client.files.create(
-            file=(filename, file_contents), purpose="assistants"
-        )
-
-        self.client.beta.vector_stores.files.create(
-            vector_store_id=self.vector_store, file_id=file_obj.id
-        )
-        self.client.beta.assistants.update(
-            self.agent_id,
-            tools=list(self.tools.values()),
-            tool_resources={"file_search": {"vector_store_ids": [self.vector_store]}},
-        )
-        self.save()
-        return file_obj.id
-
-    def _add_function(self, user_function):
-        self.tools["function"] = {"type": "function", "function": user_function}
-        self.client.beta.assistants.update(
-            self.agent_id, tools=list(self.tools.values())
-        )
-        return """
-        IMPORTANT: always use the function 'response' tool to respond to the user with the requested JSON schema. Never add any other text to the response.
-        """
-
-    def _format_messages(self, messages):
-        message_list = []
-        if isinstance(messages, str):
-            message_list.insert(0, {"role": "user", "content": messages})
-        else:
-            for message in messages:
-                if isinstance(message, str):
-                    message_list.insert(0, {"role": "user", "content": message})
-                else:
-                    raise Exception(
-                        f"==== Invalid message: {message} ====\nMust be a string "
-                    )
-        return message_list
+        return self.client.attach_file(file_contents, filename)
 
     def generate(self, messages, function=None, additional_instructions=""):
-        _instructions_addition = (
-            self._add_function(function) if function else additional_instructions
-        )
-
-        formatted_messages = self._format_messages(messages)
-        thread = self.client.beta.threads.create(messages=formatted_messages)
-
-        run = self.client.beta.threads.runs.create(
-            thread_id=thread.id,
-            assistant_id=self.agent_id,
-            additional_instructions=_instructions_addition,
-            parallel_tool_calls=False,
-        )
-
-        while run.status in ["queued", "in_progress"]:
-            run = self.client.beta.threads.runs.retrieve(
-                thread_id=thread.id,
-                run_id=run.id,
-            )
-            time.sleep(0.5)
-            log(f"==== Job Status: {run.status} ====")
-            print(f"==== Job Status: {run.status} ====")
-
-        if run.status in ["failed", "expired", "canceled"]:
-            log(f"==== Error: {run.last_error} ====")
-            print(f"==== Error: {run.last_error} ====")
-            return None
-        print("=================== RUN COMPLETED ===================")
-        print(run.status)
-        if run.status == "completed":
-            response = self.client.beta.threads.messages.list(thread_id=thread.id)
-            results = response.data[0].content[0].text.value
-        elif run.status == "requires_action":
-            results = run.required_action.submit_tool_outputs.tool_calls[
-                0
-            ].function.arguments
+        if function is None:
+            return self.client.generate_text(messages, additional_instructions)
         else:
-            log(f"====Status: {run.status} Error: {run.last_error} ====")
-            print(f"====Status: {run.status} Error: {run.last_error} ====")
-            return None
-
-        if function:
-            results = results[results.find("{") : results.rfind("}") + 1]
-            try:
-                results = json.loads(results, strict=False)
-            except Exception:
-                print(f"==== Invalid JSON:\n{results}")
-                log(f"==== Invalid JSON:\n{results}")
-
-        print(results)
-        print("=================== END REPORT ===================")
-        return results
+            return self.client.generate_json(
+                messages, function, additional_instructions
+            )
 
     def generate_audio(self, prompt, file_path, **kwargs):
-        voice = kwargs.get("voice") or random.choice(
-            ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
-        )
-        response = self.client.audio.speech.create(
-            model="tts-1",
-            voice=voice,
-            input=prompt,
-        )
-
-        return response.stream_to_file(file_path)
+        return self.client.generate_audio(self, file_path, **kwargs)
 
     def generate_image(self, prompt, **kwargs):
-        image = None
-        try:
-            response = self.client.images.generate(
-                model="dall-e-3", prompt=prompt, response_format="b64_json", **kwargs
-            )
-            image_dict = response.data[0]
-        except Exception as e:
-            print(f"==== Error: Unable to create image ====\n\n{e}")
-        else:
-            image = b64decode(image_dict.b64_json)
-        return image
+        return self.client.generate_image(prompt, **kwargs)
 
     def summarize_text(self, text, primer=""):
-        message = [
-            {
-                "role": "system",
-                "content": f"You are a highly skilled AI trained in language comprehension and summarization.{primer}",
-            },
-            {"role": "user", "content": text},
-        ]
-        response = self.client.chat.completions.create(model="gpt-4o", messages=message)
-        try:
-            result = response.choices[0].message.content
-        except Exception as e:
-            log(f"{type(e)}:{e}\n\n Unable to generate content ====")
-            return None
-
-        return result
+        return self.client.generate_image(text, primer)