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

autonomous/__init__.py

@@ -1,4 +1,7 @@
-__version__ = "0.2.25"
+__version__ = "0.3.00"
+
+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()
+    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()
+    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()
+    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,280 @@
+import json
+import os
+import random
+import time
+from base64 import b64decode
+
+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 = StringAttr(default="gpt-4o")
+    image_model = StringAttr(default="dall-e-3")
+    json_model = StringAttr(default="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):
+        if not file_id:
+            store_files = self.client.files.list().data
+            for sf in store_files:
+                self.client.files.delete(file_id=sf.id)
+            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 ====")
+        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"]["required"] = list(
+            user_function["parameters"]["properties"].keys()
+        )
+        user_function["parameters"]["additionalProperties"] = False
+
+        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 the 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)
+        _instructions_addition += 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=_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
+        else:
+            log(f"====Status: {run.status} Error: {run.last_error} ====")
+            print(f"====Status: {run.status} Error: {run.last_error} ====")
+            return None
+
+        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}")
+            return {}
+        else:
+            log(f"==== Results: {results} ====")
+            print(results)
+            print("=================== END REPORT ===================")
+            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(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
+        else:
+            log(f"====Status: {run.status} Error: {run.last_error} ====")
+            print(f"====Status: {run.status} Error: {run.last_error} ====")
+            return None
+
+        print(results)
+        print("=================== END REPORT ===================")
+        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="gpt-4o-mini", 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,3 +1,4 @@
+import io
 import json
 import os
 import random
@@ -5,210 +6,48 @@ import time
 from base64 import b64decode
 
 from openai import OpenAI
+from pydantic import model_validator
 
-from autonomous import AutoModel, log
+from autonomous import log
+from autonomous.model.autoattr import ReferenceAttr
+from autonomous.model.automodel import AutoModel
 
+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"))
+class OAIAgent(AutoModel):
+    client_model = ReferenceAttr()
+    _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
+        return self.client_model
 
-    @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)
+    def __init__(self, **kwargs):
+        self._client = OpenAI(api_key=os.environ.get("OPENAI_KEY"))
 
     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)

autonomous/ai/textagent.py

@@ -0,0 +1,35 @@
+from autonomous import log
+from autonomous.model.autoattr import ReferenceAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+from .models.openai import OpenAIModel
+
+
+class TextAgent(AutoModel):
+    client = ReferenceAttr()
+    name = StringAttr(default="textagent")
+    instructions = StringAttr(
+        default="You are highly skilled AI trained to assist with generating text according to the given requirements."
+    )
+    description = StringAttr(
+        default="A helpful AI assistant trained to assist with generating text according to the given requirements."
+    )
+
+    _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 summarize_text(self, text, primer=""):
+        return self.get_client().summarize_text(text, primer)
+
+    def generate(self, messages, additional_instructions=""):
+        return self.get_client().generate_text(messages, additional_instructions)

autonomous/auth/autoauth.py

@@ -4,14 +4,14 @@ from functools import wraps
 
 import requests
 from authlib.integrations.requests_client import OAuth2Auth, OAuth2Session
-from flask import current_app, redirect, request, session, url_for
+from flask import redirect, session, url_for
 
 from autonomous import log
 from autonomous.auth.user import AutoUser
 
 
 class AutoAuth:
-    user_class = AutoUser
+    user_class: type[AutoUser] = AutoUser
 
     def __init__(
         self,