autonomous-app 0.3.18__py3-none-any.whl → 0.3.19__py3-none-any.whl

autonomous/ai/models/gemini.py

@@ -0,0 +1,244 @@
+import io
+import json
+import os
+import random
+import wave
+
+from google import genai
+from google.genai import types
+from pydub import AudioSegment
+
+from autonomous import log
+from autonomous.model.autoattr import DictAttr, ListAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+
+class GeminiAIModel(AutoModel):
+    _client = None
+    _text_model = "gemini-2.5-pro"
+    _summary_model = "gemini-2.5-flash"
+    _image_model = "gemini-2.5-flash-image-preview"
+    _json_model = "gemini-2.5-pro"
+    _stt_model = "gemini-2.5-flash"
+    _tts_model = "gemini-2.5-flash-preview-tts"
+    messages = ListAttr(StringAttr(default=[]))
+    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 = genai.Client(api_key=os.environ.get("GOOGLEAI_KEY"))
+        return self._client
+
+    def _add_function(self, user_function):
+        # This function is now a bit more advanced to conform to the Tool Use schema
+        tool_schema = {
+            "name": user_function.get("name"),
+            "description": user_function.get("description"),
+            "parameters": user_function.get("parameters"),
+        }
+
+        # Validate that the schema has a name, description, and parameters
+        if not all(
+            [tool_schema["name"], tool_schema["description"], tool_schema["parameters"]]
+        ):
+            raise ValueError(
+                "Tool schema must have a 'name', 'description', and 'parameters' field."
+            )
+
+        return tool_schema
+
+    def _create_wav_header(
+        self, raw_audio_bytes, channels=1, rate=24000, sample_width=2
+    ):
+        """Creates an in-memory WAV file from raw PCM audio bytes."""
+        buffer = io.BytesIO()
+        with wave.open(buffer, "wb") as wav_file:
+            # Set audio parameters
+            wav_file.setnchannels(channels)
+            wav_file.setsampwidth(sample_width)
+            wav_file.setframerate(rate)  # 16,000 Hz sample rate
+
+            # Write the raw audio data
+            wav_file.writeframes(raw_audio_bytes)
+
+        buffer.seek(0)
+        return buffer
+
+    def generate_json(self, message, function, additional_instructions=""):
+        # The API call must use the 'tools' parameter instead of 'response_json_schema'
+        function_definition = self._add_function(function)
+
+        response = self.client.models.generate_content(
+            model=self._json_model,
+            contents=message,
+            config=types.GenerateContentConfig(
+                system_instruction=f"{self.instructions}.{additional_instructions}",
+                tools=[types.Tool(function_declarations=[function_definition])],
+                tool_config={
+                    "function_calling_config": {
+                        "mode": "ANY",  # Force a function call
+                    }
+                },
+            ),
+        )
+
+        # The response is now a ToolCall, not a JSON string
+        try:
+            # log(response.candidates[0].content.parts[0].function_call, _print=True)
+            tool_call = response.candidates[0].content.parts[0].function_call
+            if tool_call and tool_call.name == function["name"]:
+                return tool_call.args
+            else:
+                log(
+                    "==== Model did not return a tool call or returned the wrong one. ===="
+                )
+                log(f"Response: {response.text}", _print=True)
+                return {}
+        except Exception as e:
+            log(f"==== Failed to parse ToolCall response: {e} ====")
+            return {}
+
+    def generate_text(self, message, additional_instructions=""):
+        response = self.client.models.generate_content(
+            model=self._text_model,
+            config=types.GenerateContentConfig(
+                system_instruction=f"{self.instructions}.{additional_instructions}",
+            ),
+            contents=message,
+        )
+
+        # log(results, _print=True)
+        # log("=================== END REPORT ===================", _print=True)
+        return response.text
+
+    def generate_audio_text(self, audio_file):
+        response = self.client.models.generate_content(
+            model=self._stt_model,
+            contents=[
+                "Transcribe this audio clip",
+                types.Part.from_bytes(
+                    data=audio_file,
+                    mime_type="audio/mp3",
+                ),
+            ],
+        )
+        return response.text
+
+    def generate_audio(self, prompt, voice=None):
+        voice = voice or random.choice(
+            [
+                "Zephyr",
+                "Puck",
+                "Charon",
+                "Kore",
+                "Fenrir",
+                "Leda",
+                "Orus",
+                "Aoede",
+                "Callirhoe",
+                "Autonoe",
+                "Enceladus",
+                "Iapetus",
+                "Umbriel",
+                "Algieba",
+                "Despina",
+                "Erinome",
+                "Algenib",
+                "Rasalgethi",
+                "Laomedeia",
+                "Achernar",
+                "Alnilam",
+                "Schedar",
+                "Gacrux",
+                "Pulcherrima",
+                "Achird",
+                "Zubenelgenubi",
+                "Vindemiatrix",
+                "Sadachbia",
+                "Sadaltager",
+                "Sulafar",
+            ]
+        )
+
+        try:
+            response = self.client.models.generate_content(
+                model=self._tts_model,
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    response_modalities=["AUDIO"],
+                    speech_config=types.SpeechConfig(
+                        voice_config=types.VoiceConfig(
+                            prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                                voice_name=voice,
+                            )
+                        )
+                    ),
+                ),
+            )
+            blob = response.candidates[0].content.parts[0].inline_data
+
+            # Create a WAV file in memory from the raw audio bytes
+            wav_buffer = self._create_wav_header(blob.data)
+
+            # 2. Load the WAV audio using pydub, which will now correctly read the header
+            audio_segment = AudioSegment.from_file(wav_buffer, format="wav")
+
+            # 3. Create a new in-memory buffer for the MP3 output
+            mp3_buffer = io.BytesIO()
+
+            # 4. Export the audio segment directly to the in-memory buffer
+            audio_segment.export(mp3_buffer, format="mp3")
+
+            # 5. Return the bytes from the buffer, not the filename
+            return mp3_buffer.getvalue()
+
+        except Exception as e:
+            log(
+                f"==== Error: Unable to generate audio ====\n{type(e)}:{e}", _print=True
+            )
+            # You can return a default empty byte string or re-raise the exception
+            raise e
+
+    def generate_image(self, prompt, **kwargs):
+        image = None
+        try:
+            response = self.client.models.generate_content(
+                model=self._image_model,
+                contents=[prompt],
+            )
+            image_parts = [
+                part.inline_data.data
+                for part in response.candidates[0].content.parts
+                if part.inline_data
+            ]
+            # log(image_parts, _print=True)
+            image = image_parts[0]
+        except Exception as e:
+            log(f"==== Error: Unable to create image ====\n\n{e}", _print=True)
+            raise e
+        return image
+
+    def summarize_text(self, text, primer=""):
+        primer = primer or self.instructions
+        response = self.client.models.generate_content(
+            model=self._summary_model,
+            config=types.GenerateContentConfig(
+                system_instruction=f"{primer}",
+            ),
+            contents=text,
+        )
+        log(response)
+        try:
+            result = response.candidates[0].content.parts[0].text
+        except Exception as e:
+            log(f"{type(e)}:{e}\n\n Unable to generate content ====")
+            return None
+
+        return result

autonomous/ai/models/local.py

@@ -0,0 +1,99 @@
+import io
+import json
+import os
+import random
+import time
+from base64 import b64decode
+
+import openai
+from ollama import ChatResponse, chat
+
+from autonomous import log
+from autonomous.model.autoattr import DictAttr, ListAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+
+class LocalAIModel(AutoModel):
+    _client = None
+    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 = "deepseek-r1"  # OpenAI(api_key=os.environ.get("OPENAI_KEY"))
+        return self._client
+
+    def clear_agent(self):
+        pass
+
+    def clear_agents(self):
+        pass
+
+        # def _get_agent_id(self):
+        #     pass
+
+        # def _add_function(self, user_function):
+        pass
+
+    def _format_messages(self, messages):
+        pass
+
+    def clear_files(self, file_id=None):
+        pass
+
+    def attach_file(self, file_contents, filename="dbdata.json"):
+        pass
+
+    def generate_json(self, messages, function, additional_instructions=""):
+        message = messages + additional_instructions
+        message += f"""
+IMPORTANT: Respond in JSON FORMAT using the SCHEMA below. DO NOT add any text to the response outside of the supplied JSON schema:
+{function}
+"""
+        response: ChatResponse = chat(
+            model=self.client,
+            messages=[
+                {
+                    "role": "user",
+                    "content": message,
+                },
+            ],
+        )
+        return response.message.content
+
+    def generate_text(self, messages, additional_instructions=""):
+        message = messages + additional_instructions
+        response: ChatResponse = chat(
+            model=self.client,
+            messages=[
+                {
+                    "role": "user",
+                    "content": message,
+                },
+            ],
+        )
+        return response.message.content
+
+    def generate_audio(self, prompt, **kwargs):
+        raise NotImplementedError
+
+    def generate_image(self, prompt, **kwargs):
+        raise NotImplementedError
+
+    def summarize_text(self, text, primer=""):
+        response: ChatResponse = chat(
+            model=self.client,
+            messages=[
+                {
+                    "role": "system",
+                    "content": f"You are a highly skilled AI trained in language comprehension and summarization.{primer}",
+                },
+                {"role": "user", "content": text},
+            ],
+        )
+        return response.message.content

autonomous/ai/models/openai.py

@@ -16,7 +16,7 @@ from autonomous.model.automodel import AutoModel
 
 class OpenAIModel(AutoModel):
     _client = None
-    _text_model = "gpt-4o-mini"
+    _text_model = "o3-mini"
     _image_model = "dall-e-3"
     _json_model = "gpt-4o"
     agent_id = StringAttr()
@@ -40,7 +40,10 @@ class OpenAIModel(AutoModel):
     def delete(self):
         self.clear_files()
         if self.agent_id:
-            self.client.beta.assistants.delete(self.agent_id)
+            try:
+                self.client.beta.assistants.delete(self.agent_id)
+            except openai_NotFoundError:
+                log(f"==== Agent with ID: {self.agent_id} not found ====")
         return super().delete()
 
     def clear_agent(self):
@@ -51,15 +54,16 @@ class OpenAIModel(AutoModel):
 
     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()
+        if assistants:
+            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):
         try:
@@ -79,9 +83,9 @@ class OpenAIModel(AutoModel):
 
     def clear_files(self, file_id=None):
         if not file_id:
-            for vs in self.client.beta.vector_stores.list().data:
+            for vs in self.client.vector_stores.list().data:
                 try:
-                    self.client.beta.vector_stores.delete(vs.id)
+                    self.client.vector_stores.delete(vs.id)
                 except openai_NotFoundError:
                     log(f"==== Vector Store {vs.id} not found ====")
             for sf in self.client.files.list().data:
@@ -97,8 +101,8 @@ class OpenAIModel(AutoModel):
         self.tools["file_search"] = {"type": "file_search"}
         # Create a vector store
         try:
-            if vs := self.client.beta.vector_stores.list().data:
-                self.vector_store = self.client.beta.vector_stores.retrieve(
+            if vs := self.client.vector_stores.list().data:
+                self.vector_store = self.client.vector_stores.retrieve(
                     vector_store_id=vs[0].id
                 ).id
             else:
@@ -106,17 +110,17 @@ class OpenAIModel(AutoModel):
                     self.client.files.delete(file_id=sf.id)
                 raise FileNotFoundError("No vector store found")
         except FileNotFoundError:
-            self.vector_store = self.client.beta.vector_stores.create(
+            self.vector_store = self.client.vector_stores.create(
                 name="World Reference",
                 expires_after={"anchor": "last_active_at", "days": 14},
             ).id
-        log(f"==== Vector Store ID: {self.vector_store}====")
+        log(f"==== Vector Store ID: {self.vector_store}====", _print=True)
         # Attach File
         file_obj = self.client.files.create(
             file=(filename, file_contents), purpose="assistants"
         )
-        log(f"==== FileStore ID: {file_obj.id}====")
-        self.client.beta.vector_stores.files.create(
+        log(f"==== FileStore ID: {file_obj.id}====", _print=True)
+        self.client.vector_stores.files.create(
             vector_store_id=self.vector_store,
             file_id=file_obj.id,
         )
@@ -198,14 +202,14 @@ IMPORTANT: Always use the function 'response' tool to respond to the user with o
                 ]:
                     running_job = False
 
-            except openai.BadRequestError as e:
+            except openai.BadRequestError as err:
                 # Handle specific bad request errors
-                error_message = e.json_body.get("error", {}).get("message", "")
-                if "already has an active run" in error_message:
+                log(f"==== Error: {err} ====", _print=True)
+                if "already has an active run" in str(err):
                     log("Previous run is still active. Waiting...", _print=True)
                     time.sleep(2)  # wait before retrying or checking run status
                 else:
-                    raise e
+                    raise err
 
         # while run.status in ["queued", "in_progress"]:
         #     run = self.client.beta.threads.runs.retrieve(
@@ -217,7 +221,7 @@ IMPORTANT: Always use the function 'response' tool to respond to the user with o
             log(f"==== !!! ERROR !!!: {run.last_error} ====", _print=True)
             return None
         log("=================== RUN COMPLETED ===================", _print=True)
-        log(run.status, _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
@@ -236,8 +240,8 @@ IMPORTANT: Always use the function 'response' tool to respond to the user with o
             log(f"==== Invalid JSON:\n{results}", _print=True)
             return {}
         else:
-            log(f"==== Results: {results}", _print=True)
-            log("=================== END REPORT ===================", _print=True)
+            # log(f"==== Results: {results}", _print=True)
+            # log("=================== END REPORT ===================", _print=True)
             return results
 
     def generate_text(self, messages, additional_instructions=""):
@@ -278,16 +282,34 @@ IMPORTANT: Always use the function 'response' tool to respond to the user with o
 
     def generate_audio(self, prompt, **kwargs):
         voice = kwargs.get("voice") or random.choice(
-            ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
+            [
+                "alloy",
+                "ash",
+                "ballad",
+                "coral",
+                "echo",
+                "fable",
+                "onyx",
+                "nova",
+                "sage",
+                "shimmer",
+            ]
         )
         response = self.client.audio.speech.create(
             model="tts-1",
             voice=voice,
             input=prompt,
         )
-        log(response, _print=True)
+        # log(response, _print=True)
         return response.read()
 
+    def generate_audio_text(self, audio_file, **kwargs):
+        response = self.client.audio.transcriptions.create(
+            model="gpt-4o-transcribe", file=audio_file, language="en", **kwargs
+        )
+        log(response, _print=True)
+        return response.text
+
     def generate_image(self, prompt, **kwargs):
         image = None
         try:
@@ -299,7 +321,8 @@ IMPORTANT: Always use the function 'response' tool to respond to the user with o
             )
             image_dict = response.data[0]
         except Exception as e:
-            print(f"==== Error: Unable to create image ====\n\n{e}")
+            log(f"==== Error: Unable to create image ====\n\n{e}", _print=True)
+            raise e
         else:
             image = b64decode(image_dict.b64_json)
         return image

autonomous/ai/textagent.py

@@ -14,12 +14,6 @@ class TextAgent(BaseAgent):
         default="A helpful AI assistant trained to assist with generating text according to the given requirements."
     )
 
-    def clear_files(self, file_id=None):
-        return self.get_client().clear_files(file_id)
-
-    def attach_file(self, file_contents, filename="dbdata.json"):
-        return self.get_client().attach_file(file_contents, filename)
-
     def summarize_text(self, text, primer=""):
         return self.get_client().summarize_text(text, primer)
 

autonomous/db/fields.py

@@ -721,8 +721,7 @@ class EmbeddedDocumentField(BaseField):
             or issubclass(document_type, EmbeddedDocument)
         ):
             self.error(
-                "Invalid embedded document class provided to an "
-                "EmbeddedDocumentField"
+                "Invalid embedded document class provided to an EmbeddedDocumentField"
             )
 
         self.document_type_obj = document_type

autonomous/db/queryset/base.py

@@ -117,10 +117,7 @@ class BaseQuerySet:
         if q_obj:
             # Make sure proper query object is passed.
             if not isinstance(q_obj, QNode):
-                msg = (
-                    "Not a query object: %s. "
-                    "Did you intend to use key=value?" % q_obj
-                )
+                msg = "Not a query object: %s. Did you intend to use key=value?" % q_obj
                 raise InvalidQueryError(msg)
             query &= q_obj
 

autonomous/db/queryset/queryset.py

@@ -1,3 +1,4 @@
+from autonomous import log
 from autonomous.db.errors import OperationError
 from autonomous.db.queryset.base import (
     CASCADE,

autonomous/db/queryset/transform.py

@@ -4,6 +4,7 @@ import pymongo
 from bson import SON, ObjectId
 from bson.dbref import DBRef
 
+from autonomous import log
 from autonomous.db.base import UPDATE_OPERATORS
 from autonomous.db.common import _import_class
 from autonomous.db.errors import InvalidQueryError
@@ -76,14 +77,18 @@ def query(_doc_cls=None, **kwargs):
     """Transform a query from Django-style format to Mongo format."""
     mongo_query = {}
     merge_query = defaultdict(list)
+
+    # Iterate over sorted keyword arguments
     for key, value in sorted(kwargs.items()):
         if key == "__raw__":
             handle_raw_query(value, mongo_query)
             continue
 
+        # Split the key into parts based on '__'
         parts = key.rsplit("__")
         indices = [(i, p) for i, p in enumerate(parts) if p.isdigit()]
         parts = [part for part in parts if not part.isdigit()]
+
         # Check for an operator and transform to mongo-style if there is
         op = None
         if len(parts) > 1 and parts[-1] in MATCH_OPERATORS:
@@ -93,6 +98,7 @@ def query(_doc_cls=None, **kwargs):
         if len(parts) > 1 and parts[-1] == "":
             parts.pop()
 
+        # Check for negation
         negate = False
         if len(parts) > 1 and parts[-1] == "not":
             parts.pop()
@@ -115,7 +121,7 @@ def query(_doc_cls=None, **kwargs):
                 if isinstance(field, str):
                     parts.append(field)
                     append_field = False
-                # is last and CachedReferenceField
+                # Handle CachedReferenceField
                 elif isinstance(field, CachedReferenceField) and fields[-1] == field:
                     parts.append("%s._id" % field.db_field)
                 else:
@@ -139,17 +145,14 @@ def query(_doc_cls=None, **kwargs):
                 # Raise an error if the in/nin/all/near param is not iterable.
                 value = _prepare_query_for_iterable(field, op, value)
 
-            # If we're querying a GenericReferenceField, we need to alter the
-            # key depending on the value:
-            # * If the value is a DBRef, the key should be "field_name._ref".
-            # * If the value is an ObjectId, the key should be "field_name._ref.$id".
+            # Handle GenericReferenceField
             if isinstance(field, GenericReferenceField):
                 if isinstance(value, DBRef):
                     parts[-1] += "._ref"
                 elif isinstance(value, ObjectId):
                     parts[-1] += "._ref.$id"
 
-        # if op and op not in COMPARISON_OPERATORS:
+        # Handle different operators
         if op:
             if op in GEO_OPERATORS:
                 value = _geo_operator(field, op, value)
@@ -166,9 +169,7 @@ def query(_doc_cls=None, **kwargs):
                     value = field.prepare_query_value(op, value)
                 value = {"$elemMatch": value}
             elif op in CUSTOM_OPERATORS:
-                NotImplementedError(
-                    'Custom method "%s" has not ' "been implemented" % op
-                )
+                NotImplementedError('Custom method "%s" has not been implemented' % op)
             elif op not in STRING_OPERATORS:
                 value = {"$" + op: value}
 
@@ -439,7 +440,7 @@ def _geo_operator(field, op, value):
             value = {"$within": {"$box": value}}
         else:
             raise NotImplementedError(
-                'Geo method "%s" has not been ' "implemented for a GeoPointField" % op
+                'Geo method "%s" has not been implemented for a GeoPointField' % op
             )
     else:
         if op == "geo_within":

autonomous/model/autoattr.py

@@ -64,6 +64,13 @@ class ReferenceAttr(GenericReferenceField):
 class ListAttr(ListField):
     def __get__(self, instance, owner):
         results = super().__get__(instance, owner)
+
+        # sanity check
+        if not isinstance(results, list):
+            super().__set__(instance, [])
+            results = super().__get__(instance, owner)
+
+        # log(f"ListAttr: {results}")
         if isinstance(self.field, ReferenceAttr):
             i = 0
             while i < len(results):
@@ -78,9 +85,6 @@ class ListAttr(ListField):
                     # log(f"Object Not Found: {results[i]}")
         return results
 
-    # def append(self, obj):
-    #     results = super().__get__(instance, owner) or []
-
 
 class DictAttr(DictField):
     def __get__(self, instance, owner):
@@ -96,6 +100,16 @@ class DictAttr(DictField):
             results[key] = lazy_obj
         return results
 
+    # def __set__(self, instance, value):
+    #     import traceback
+
+    #     traceback.print_stack()
+
+    #     log(value, instance.player_messages, _print=True)
+    #     result = super().__set__(instance, value) or {}
+    #     log(value, instance.player_messages, _print=True)
+    #     return result
+
 
 class EnumAttr(EnumField):
     pass