autonomous-app 0.2.25__tar.gz → 0.3.0__tar.gz

{autonomous_app-0.2.25 → autonomous_app-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autonomous-app
-Version: 0.2.25
+Version: 0.3.0
 Summary: Containerized application framework built on Flask with additional libraries and tools for rapid development of web applications.
 Author-email: Steven A Moore <samoore@binghamton.edu>
 License: MIT License
@@ -25,27 +25,26 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
 Project-URL: homepage, https://github.com/Sallenmoore/autonomous
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Flask
-Requires-Dist: icecream
 Requires-Dist: setuptools
 Requires-Dist: python-dotenv
 Requires-Dist: PyGithub
 Requires-Dist: pygit2
-Requires-Dist: cloudinary
+Requires-Dist: mongoengine
 Requires-Dist: pillow
-Requires-Dist: pymongo
+Requires-Dist: redis
 Requires-Dist: jsmin
 Requires-Dist: requests
 Requires-Dist: gunicorn
 Requires-Dist: Authlib
-Requires-Dist: openai>=1.21.1
-Requires-Dist: validators
+Requires-Dist: rq
+Requires-Dist: openai>=1.42
 Requires-Dist: dateparser
 Requires-Dist: python-slugify
 

{autonomous_app-0.2.25 → autonomous_app-0.3.0}/pyproject.toml

@@ -10,10 +10,10 @@ authors = [
 description = "Containerized application framework built on Flask with additional libraries and tools for rapid development of web applications."
 dynamic = ["version", "dependencies"]
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 license={file = "LICENSE"}
 classifiers=[
-    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
@@ -35,7 +35,7 @@ where = ["src"]
 include = ["autonomous*"]
 
 [tool.pytest.ini_options]
-addopts = "--cov=autonomous -rx -l -x -s --log-level=INFO --ignore=src --no-cov-on-fail -v --pdb --cov-reset"
+addopts = "--cov=autonomous -rx -l -x -s --log-level=INFO --ignore=src --no-cov-on-fail -v --pdb --cov-reset "
 
 testpaths = [
      "tests",

{autonomous_app-0.2.25 → autonomous_app-0.3.0}/requirements.txt

@@ -8,8 +8,6 @@ Flask
 
 ##### Debugging, Logging, and Documentation #####
 
-icecream
-
 ##### System #####
 
 setuptools
@@ -19,10 +17,9 @@ python-dotenv
 
 PyGithub
 pygit2
-
-cloudinary
+mongoengine
 pillow
-pymongo
+redis
 
 ##### Frontend #####
 
@@ -38,14 +35,12 @@ gunicorn
 Authlib
 
 ##### Async #####
-
+rq
 
 ##### AI #####
 
-openai >= 1.21.1
+openai >= 1.42
 
 ##### Parsing #####
-
-validators
 dateparser
 python-slugify

autonomous_app-0.3.0/src/autonomous/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.3.00"
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from .logger import log

autonomous_app-0.3.0/src/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_app-0.3.0/src/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_app-0.3.0/src/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_app-0.3.0/src/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_app-0.3.0/src/autonomous/ai/oaiagent.py

@@ -0,0 +1,53 @@
+import io
+import json
+import os
+import random
+import time
+from base64 import b64decode
+
+from openai import OpenAI
+from pydantic import model_validator
+
+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_model = ReferenceAttr()
+    _ai_model = OpenAIModel
+
+    @property
+    def client(self):
+        if self.client_model is None:
+            self.client_model = self._ai_model()
+            self.save()
+        return self.client_model
+
+    def __init__(self, **kwargs):
+        self._client = OpenAI(api_key=os.environ.get("OPENAI_KEY"))
+
+    def clear_files(self, file_id=None):
+        return self.client.clear_files(file_id)
+
+    def attach_file(self, file_contents, filename="dbdata.json"):
+        return self.client.attach_file(file_contents, filename)
+
+    def generate(self, messages, function=None, additional_instructions=""):
+        if function is None:
+            return self.client.generate_text(messages, additional_instructions)
+        else:
+            return self.client.generate_json(
+                messages, function, additional_instructions
+            )
+
+    def generate_audio(self, prompt, file_path, **kwargs):
+        return self.client.generate_audio(self, file_path, **kwargs)
+
+    def generate_image(self, prompt, **kwargs):
+        return self.client.generate_image(prompt, **kwargs)
+
+    def summarize_text(self, text, primer=""):
+        return self.client.generate_image(text, primer)

autonomous_app-0.3.0/src/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_app-0.2.25 → autonomous_app-0.3.0}/src/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,

{autonomous_app-0.2.25 → autonomous_app-0.3.0}/src/autonomous/auth/user.py

@@ -5,7 +5,7 @@ This module provides a User class that uses the OpenIDAuth class for authenticat
 from datetime import datetime
 
 from autonomous import log
-from autonomous.model.autoattribute import AutoAttribute
+from autonomous.model.autoattr import DateTimeAttr, StringAttr
 from autonomous.model.automodel import AutoModel
 
 
@@ -14,15 +14,13 @@ class AutoUser(AutoModel):
     This class represents a user who can authenticate using OpenID.
     """
 
-    attributes = {
-        "name": AutoAttribute("TEXT"),
-        "email": AutoAttribute("TEXT", required=True),
-        "last_login": datetime.now(),
-        "state": "unauthenticated",
-        "provider": None,
-        "role": "user",
-        "token": None,
-    }
+    name = StringAttr(default="Anonymous")
+    email = StringAttr(required=True)
+    last_login = DateTimeAttr(default=datetime.now)
+    state = StringAttr(default="unauthenticated")
+    provider = StringAttr()
+    role = StringAttr(default="guest")
+    token = StringAttr()
 
     def __eq__(self, other):
         return self.pk == other.pk