autonomous-app 0.3.32__tar.gz → 0.3.34__tar.gz

{autonomous_app-0.3.32 → autonomous_app-0.3.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autonomous-app
-Version: 0.3.32
+Version: 0.3.34
 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>
 Project-URL: homepage, https://github.com/Sallenmoore/autonomous

{autonomous_app-0.3.32 → autonomous_app-0.3.34}/pyproject.toml

@@ -40,6 +40,10 @@ where = ["src"]
 include = ["autonomous*"]
 
 [tool.pytest.ini_options]
+env_files = [
+    "tests/.testenv"
+]
+env_override_existing_values = 1
 addopts = "--cov=autonomous -rx -l -x -s --log-level=INFO --ignore=src --no-cov-on-fail -v --pdb --cov-reset "
 
 testpaths = [

{autonomous_app-0.3.32 → autonomous_app-0.3.34}/src/autonomous/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.32"
+__version__ = "0.3.34"
 
 from dotenv import load_dotenv
 

autonomous_app-0.3.34/src/autonomous/ai/audioagent.py

@@ -0,0 +1,37 @@
+import os
+
+from autonomous import log
+from autonomous.ai.baseagent import BaseAgent
+from autonomous.model.autoattr import StringAttr
+
+
+class AudioAgent(BaseAgent):
+    name = StringAttr(default="audioagent")
+
+    provider = StringAttr(default="gemini")
+
+    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."
+    )
+
+    def generate(self, prompt, voice=None):
+        return self.get_client(
+            os.environ.get("TTS_AI_AGENT", self.provider)
+        ).generate_audio(prompt, voice=voice)
+
+    def transcribe(
+        self, audio, prompt="Transcribe this audio clip", display_name="audio.mp3"
+    ):
+        return self.get_client(
+            os.environ.get("TRANSCRIBE_AI_AGENT", self.provider)
+        ).generate_transcription(
+            audio,
+            prompt=prompt,
+            display_name=display_name,
+        )
+
+    def available_voices(self, filters=[]):
+        return self.get_client().list_voices(filters=filters)

autonomous_app-0.3.34/src/autonomous/ai/baseagent.py

@@ -0,0 +1,117 @@
+from autonomous import log
+from autonomous.model.autoattr import ReferenceAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+from .models.gemini import GeminiAIModel
+from .models.local_model import LocalAIModel
+
+
+class BaseAgent(AutoModel):
+    meta = {"abstract": True, "allow_inheritance": True, "strict": False}
+
+    # 2. Map string names to classes
+    MODEL_REGISTRY = {
+        "local": LocalAIModel,
+        "gemini": GeminiAIModel,
+    }
+
+    # 3. Allow client to be ANY of the supported models
+    client = ReferenceAttr(choices=[LocalAIModel, GeminiAIModel])
+
+    # 4. Add a provider field (default to local, can be overridden per agent)
+    provider = StringAttr(default="gemini")
+
+    def delete(self):
+        if self.client:
+            self.client.delete()
+        return super().delete()
+
+    def get_agent_id(self):
+        return self.get_client().id
+
+    def get_client(self, provider=None):
+        # 5. Determine which class to use based on the provider string
+        model_class = self.MODEL_REGISTRY.get(provider or self.provider, LocalAIModel)
+        # If we already have a client, but it's the WRONG type (e.g. we switched providers), we might want to re-instantiate. For simplicity, we check if it exists first.
+        if not isinstance(self.client, model_class):
+            if self.client:
+                log(
+                    f"Re-instantiating client for agent {self.name} from {type(self.client).__name__} to {model_class.__name__}"
+                )
+                self.client.delete()
+            self.client = model_class(
+                name=self.name,
+                instructions=self.instructions,
+                description=self.description,
+            )
+            self.client.save()
+            self.save()
+
+        return self.client
+
+    # def get_embedding(self, text):
+    #     """Helper to get embeddings for vector search"""
+    #     try:
+    #         res = requests.post(f"{self._media_url}/embeddings", json={"text": text})
+    #         res.raise_for_status()
+    #         return res.json()["embedding"]
+    #     except Exception:
+    #         return []
+
+    # def gather_context(self, prompt, focus_object_id=None):
+    #     """
+    #     Retrieves context string from Mongo/Redis.
+    #     Previously 'build_hybrid_context' in LocalAIModel.
+    #     """
+    #     context_str = ""
+
+    #     # 1. Fetch from MongoDB (Focus Object)
+    #     if focus_object_id:
+    #         try:
+    #             oid = (
+    #                 ObjectId(focus_object_id)
+    #                 if isinstance(focus_object_id, str)
+    #                 else focus_object_id
+    #             )
+    #             if main_obj := self._mongo_db.objects.find_one({"_id": oid}):
+    #                 context_str += f"### FOCUS OBJECT ###\n{main_obj}\n"
+    #                 ref_ids = main_obj.get("associations", []) or []
+    #                 if world_id := main_obj.get("world"):
+    #                     ref_ids.append(world_id)
+    #                 ref_ids.extend(main_obj.get("stories", []) or [])
+    #                 ref_ids.extend(main_obj.get("events", []) or [])
+
+    #                 if ref_ids:
+    #                     valid_oids = [
+    #                         ObjectId(rid) if isinstance(rid, str) else rid
+    #                         for rid in ref_ids
+    #                     ]
+    #                     if valid_oids:
+    #                         associated_objs = self._mongo_db.objects.find(
+    #                             {"_id": {"$in": valid_oids}}
+    #                         )
+    #                         context_str += "\n### ASSOCIATED REFERENCES ###\n"
+    #                         for obj in associated_objs:
+    #                             context_str += f"- {obj}\n"
+    #                 context_str += "\n"
+    #         except Exception as e:
+    #             print(f"Context Error: {e}")
+
+    #     # 2. Fetch from Redis (Vector Search)
+    #     if len(prompt) > 10:
+    #         vector = self.get_embedding(prompt)
+    #         if vector:
+    #             try:
+    #                 q = "*=>[KNN 2 @vector $blob AS score]"
+    #                 params = {"blob": np.array(vector, dtype=np.float32).tobytes()}
+    #                 results = self._redis.ft("search_index").search(
+    #                     q, query_params=params
+    #                 )
+    #                 if results.docs:
+    #                     context_str += "\n### RELEVANT LORE ###\n"
+    #                     for doc in results.docs:
+    #                         context_str += f"- {doc.content}\n"
+    #             except Exception:
+    #                 pass
+
+    #     return context_str

autonomous_app-0.3.34/src/autonomous/ai/imageagent.py

@@ -0,0 +1,36 @@
+import os
+
+from autonomous.ai.baseagent import BaseAgent
+from autonomous.model.autoattr import StringAttr
+
+
+class ImageAgent(BaseAgent):
+    name = StringAttr(default="imageagent")
+
+    # Force this agent to use Gemini
+    provider = StringAttr(default="gemini")
+
+    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."
+    )
+
+    def generate(
+        self,
+        prompt,
+        negative_prompt="",
+        aspect_ratio="3:4",
+        image_size="2K",
+        files=None,
+    ):
+        return self.get_client(
+            os.environ.get("IMAGE_AI_AGENT", self.provider)
+        ).generate_image(
+            prompt,
+            aspect_ratio=aspect_ratio,
+            negative_prompt=negative_prompt,
+            image_size=image_size,
+            files=files,
+        )

autonomous_app-0.3.34/src/autonomous/ai/jsonagent.py

@@ -0,0 +1,36 @@
+import json
+import os
+
+from autonomous.ai.baseagent import BaseAgent
+from autonomous.model.autoattr import StringAttr
+
+
+class JSONAgent(BaseAgent):
+    name = StringAttr(default="jsonagent")
+
+    # Force this agent to use Gemini
+    provider = StringAttr(default="gemini")
+
+    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."
+    )
+
+    def generate(
+        self, message, function, additional_instructions="", uri="", context=""
+    ):
+        result = self.get_client(
+            os.environ.get("JSON_AI_AGENT", self.provider)
+        ).generate_json(
+            message, function, additional_instructions, uri=uri, context=context
+        )
+        if isinstance(result, str):
+            try:
+                result = json.loads(result)
+            except json.JSONDecodeError:
+                raise ValueError(f"Invalid JSON response from AI model.\n\n{result}")
+        elif not isinstance(result, dict):
+            raise ValueError(f"Invalid JSON response from AI model.\n\n{result}")
+        return result

{autonomous_app-0.3.32 → autonomous_app-0.3.34}/src/autonomous/ai/models/gemini.py

@@ -1,4 +1,5 @@
 import io
+import json
 import os
 import random
 import re
@@ -32,6 +33,7 @@ class GeminiAIModel(AutoModel):
     description = StringAttr(
         default="A helpful AI assistant trained to assist with various tasks."
     )
+    file_refs = ListAttr(StringAttr(default=[]))
 
     MAX_FILES = 14
     MAX_SUMMARY_TOKEN_LENGTH = 10000
@@ -111,56 +113,69 @@ class GeminiAIModel(AutoModel):
         buffer.seek(0)
         return buffer
 
-    def _add_files(self, file_list):
-        existing_files = self.client.files.list()
-        log(f"Existing files: {[f.display_name for f in existing_files]}", _print=True)
-        for f in existing_files:
-            # Delete old files (older than 10 minutes)
-            age_seconds = (
-                (time.time() - f.update_time.timestamp())
-                if f.update_time
-                else (time.time() - f.create_time.timestamp())
-            )
-            log(age_seconds, _print=True)
-            if age_seconds > 900:
-                result = self.client.files.delete(name=f.name)
-                log(f"Deleting old version of {f.name}: {result}", _print=True)
-        file_refs = []
-        for file_dict in file_list:
-            fn = file_dict["name"]
-            fileobj = file_dict["file"]
-            log(f"Uploading new {fn}...", _print=True)
+    def _add_context(self, context):
+        # Create in-memory file
+        context_data = (
+            json.dumps(context, indent=2) if isinstance(context, dict) else str(context)
+        )
+
+        f = io.BytesIO(context_data.encode("utf-8"))
+        f.name = f"context-{self.pk}"
+        return self._add_files([{"name": f.name, "file": f}])
+
+    def _add_files(self, file_list, mime_type="application/json"):
+        uploaded_files = []
+        for f in file_list[: self.MAX_FILES]:
+            fn = f["name"]
+            try:
+                result = self.client.files.delete(name=fn)
+            except Exception as e:
+                pass
+                # log(f"No existing file to delete for {fn}: {e}", _print=True)
+            else:
+                pass
+                # log(f"Deleting old version of {fn}: {result}", _print=True)
+
+            # If the content is raw bytes, wrap it in BytesIO
+            file_content = f["file"]
+            if isinstance(file_content, bytes):
+                fileobj = io.BytesIO(file_content)
+            else:
+                fileobj = file_content
             uploaded_file = self.client.files.upload(
-                file=fileobj.name,
-                config={"mime_type": "application/json", "display_name": fn},
+                file=fileobj,
+                config={"mime_type": mime_type, "display_name": fn},
             )
-            # 4. Wait for processing (Usually instant for JSON, critical for Video/PDF)
+            uploaded_files.append(uploaded_file)
 
             # This ensures the file is 'ACTIVE' before you use it in a prompt.
             while uploaded_file.state.name == "PROCESSING":
-                time.sleep(1)
+                time.sleep(0.5)
                 uploaded_file = self.client.get_file(uploaded_file.name)
-            file_refs.append(uploaded_file)
-            return file_refs
-
-    def upload(self, file):
-        return self._add_files([file])
+        self.file_refs = [f.name for f in self.client.files.list()]  # Update file_refs
+        self.save()
+        return uploaded_files
 
-    def generate_json(self, message, function, additional_instructions="", **kwargs):
-        # The API call must use the 'tools' parameter instead of 'response_json_schema'
+    def generate_json(
+        self, message, function, additional_instructions="", uri="", context={}
+    ):
         function_definition = self._add_function(function)
 
         contents = [message]
-        if uri := kwargs.get("uri"):
+        if context:
+            contents.extend(self._add_context(context))
+            additional_instructions += (
+                f"\nUse the uploaded context file for reference: context-{self.pk}\n"
+            )
+
+        if uri:
             contents.append(
                 Part.from_uri(
                     file_uri=uri,
                     mime_type="application/json",
                 ),
             )
-
-        if files := kwargs.get("files"):
-            contents += self._add_files(files)
+            additional_instructions += "\nUse the provided uri file for reference\n"
 
         response = self.client.models.generate_content(
             model=self._json_model,
@@ -192,9 +207,15 @@ class GeminiAIModel(AutoModel):
             log(f"==== Failed to parse ToolCall response: {e} ====")
             return {}
 
-    def generate_text(self, message, additional_instructions="", **kwargs):
+    def generate_text(self, message, additional_instructions="", uri="", context={}):
         contents = [message]
-        if uri := kwargs.get("uri"):
+        if context:
+            contents.extend(self._add_context(context))
+            additional_instructions += (
+                f"\nUse the uploaded context file for reference: context-{self.pk}\n"
+            )
+
+        if uri:
             contents.append(
                 Part.from_uri(
                     file_uri=uri,
@@ -202,9 +223,6 @@ class GeminiAIModel(AutoModel):
                 ),
             )
 
-        if files := kwargs.get("files"):
-            contents += self._add_files(files)
-
         response = self.client.models.generate_content(
             model=self._text_model,
             config=types.GenerateContentConfig(
@@ -217,7 +235,7 @@ class GeminiAIModel(AutoModel):
         # log("=================== END REPORT ===================", _print=True)
         return response.text
 
-    def summarize_text(self, text, primer="", **kwargs):
+    def summarize_text(self, text, primer=""):
         primer = primer or self.instructions
 
         updated_prompt_list = []
@@ -248,14 +266,17 @@ class GeminiAIModel(AutoModel):
                 full_summary += summary + "\n"
         return summary
 
-    def generate_audio_text(
-        self, audio_file, prompt="Transcribe this audio clip", **kwargs
+    def generate_transcription(
+        self,
+        audio_file,
+        prompt="Transcribe this audio clip",
+        display_name="audio.mp3",
     ):
         myfile = self.client.files.upload(
             file=io.BytesIO(audio_file),
             config={
                 "mime_type": "audio/mp3",
-                "display_name": kwargs.get("display_name", "audio.mp3"),
+                "display_name": display_name,
             },
         )
 
@@ -277,7 +298,7 @@ class GeminiAIModel(AutoModel):
                 voices.append(voice)
         return voices
 
-    def generate_audio(self, prompt, voice=None, **kwargs):
+    def generate_audio(self, prompt, voice=None):
         voice = voice or random.choice(self.list_voices())
         try:
             response = self.client.models.generate_content(
@@ -318,22 +339,20 @@ class GeminiAIModel(AutoModel):
             # You can return a default empty byte string or re-raise the exception
             raise e
 
-    def generate_image(self, prompt, **kwargs):
+    def generate_image(
+        self,
+        prompt,
+        negative_prompt="",
+        files=None,
+        aspect_ratio="3:4",
+        image_size="2K",
+    ):
         image = None
         contents = [prompt]
 
-        if kwargs.get("files"):
-            counter = 0
-            for fn, f in kwargs.get("files").items():
-                media = io.BytesIO(f)
-                myfile = self.client.files.upload(
-                    file=media,
-                    config={"mime_type": "image/webp", "display_name": fn},
-                )
-                contents += [myfile]
-                counter += 1
-                if counter >= self.MAX_FILES:
-                    break
+        if files:
+            filerefs = self._add_files(files, mime_type="image/webp")
+            contents.extend(filerefs)
 
         try:
             # log(self._image_model, contents, _print=True)
@@ -364,8 +383,8 @@ class GeminiAIModel(AutoModel):
                         ),
                     ],
                     image_config=types.ImageConfig(
-                        aspect_ratio=kwargs.get("aspect_ratio", "3:4"),
-                        image_size=kwargs.get("image_size", "2K"),
+                        aspect_ratio=aspect_ratio,
+                        image_size=image_size,
                     ),
                 ),
             )