autonomous-app 0.3.29__tar.gz → 0.3.31__tar.gz

{autonomous_app-0.3.29 → autonomous_app-0.3.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autonomous-app
-Version: 0.3.29
+Version: 0.3.31
 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
@@ -24,8 +24,8 @@ Requires-Dist: gunicorn
 Requires-Dist: Authlib
 Requires-Dist: rq
 Requires-Dist: ollama
-Requires-Dist: openai>=1.42
 Requires-Dist: google-genai
+Requires-Dist: sentence-transformers
 Requires-Dist: dateparser
 Requires-Dist: python-slugify
 Requires-Dist: pydub

{autonomous_app-0.3.29 → autonomous_app-0.3.31}/requirements.txt

@@ -39,8 +39,8 @@ rq
 
 ##### AI #####
 ollama
-openai >= 1.42
 google-genai
+sentence-transformers
 
 ##### Parsing #####
 dateparser

{autonomous_app-0.3.29 → autonomous_app-0.3.31}/src/autonomous/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.29"
+__version__ = "0.3.31"
 
 from dotenv import load_dotenv
 

{autonomous_app-0.3.29 → autonomous_app-0.3.31}/src/autonomous/ai/baseagent.py

@@ -23,12 +23,11 @@ class BaseAgent(AutoModel):
         return self.get_client().id
 
     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()
+        self.client = self._ai_model(
+            name=self.name,
+            instructions=self.instructions,
+            description=self.description,
+        )
+        self.client.save()
+        self.save()
         return self.client

autonomous_app-0.3.31/src/autonomous/ai/models/local_model.py

@@ -0,0 +1,301 @@
+import io
+import json
+import os
+import random
+
+import numpy as np
+import pymongo
+import redis
+import requests
+from bson.objectid import ObjectId
+from pydub import AudioSegment
+
+from autonomous import log
+from autonomous.model.autoattr import ListAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+
+class LocalAIModel(AutoModel):
+    messages = ListAttr(StringAttr(default=[]))
+    name = StringAttr(default="agent")
+    instructions = StringAttr(default="You are a helpful AI.")
+    description = StringAttr(default="A Local AI Model using Ollama and Media AI.")
+
+    # Config
+    _ollama_url = os.environ.get("OLLAMA_API_BASE", "http://ollama:11434/api")
+    _media_url = os.environ.get("MEDIA_API_BASE", "http://media_ai:5005")
+    _text_model = "llama3"
+    _json_model = "llama3"
+
+    # DB Connections
+    _mongo_client = pymongo.MongoClient("mongodb://db:27017/")
+    _mongo_db = os.getenv("DB_DB", "default")
+    _redis = redis.Redis(host="cachedb", port=6379, decode_responses=True)
+
+    VOICES = {
+        "Zephyr": ["female"],
+        "Puck": ["male"],
+        "Charon": ["male"],
+        "Kore": ["female"],
+        "Fenrir": ["non-binary"],
+        "Leda": ["female"],
+        "Orus": ["male"],
+        "Aoede": ["female"],
+        "Callirhoe": ["female"],
+        "Autonoe": ["female"],
+        "Enceladus": ["male"],
+        "Iapetus": ["male"],
+        "Umbriel": ["male"],
+        "Algieba": ["male"],
+        "Despina": ["female"],
+        "Erinome": ["female"],
+        "Algenib": ["male"],
+        "Rasalgethi": ["non-binary"],
+        "Laomedeia": ["female"],
+        "Achernar": ["female"],
+        "Alnilam": ["male"],
+        "Schedar": ["male"],
+        "Gacrux": ["female"],
+        "Pulcherrima": ["non-binary"],
+        "Achird": ["male"],
+        "Zubenelgenubi": ["male"],
+        "Vindemiatrix": ["female"],
+        "Sadachbia": ["male"],
+        "Sadaltager": ["male"],
+        "Sulafar": ["female"],
+    }
+
+    def _convert_tools_to_json_schema(self, user_function):
+        schema = {
+            "name": user_function.get("name"),
+            "description": user_function.get("description", ""),
+            "parameters": user_function.get("parameters", {}),
+        }
+        return json.dumps(schema, indent=2)
+
+    def get_embedding(self, text):
+        try:
+            res = requests.post(f"{self._media_url}/embeddings", json={"text": text})
+            res.raise_for_status()
+            return res.json()["embedding"]
+        except Exception as e:
+            log(f"Embedding Error: {e}", _print=True)
+            return []
+
+    def build_hybrid_context(self, prompt, focus_object_id=None):
+        cache_key = f"ctx:{focus_object_id}:{len(prompt) // 50}"
+        cached_ctx = self._redis.get(cache_key)
+        if cached_ctx:
+            return cached_ctx
+
+        context_str = ""
+        # --- PART 1: MONGODB ---
+        if focus_object_id:
+            try:
+                oid = (
+                    ObjectId(focus_object_id)
+                    if isinstance(focus_object_id, str)
+                    else focus_object_id
+                )
+                main_obj = self._mongo_db.objects.find_one({"_id": oid})
+
+                if main_obj:
+                    context_str += "### FOCUS OBJECT ###\n" + prompt
+                    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:
+                log(f"Mongo Association Error: {e}", _print=True)
+
+        # --- PART 2: REDIS ---
+        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 += "### RELEVANT LORE ###\n"
+                        for doc in results.docs:
+                            context_str += f"- {doc.content}\n"
+                except Exception:
+                    pass
+
+        self._redis.set(cache_key, context_str, ex=120)
+        return context_str
+
+    def generate_json(self, message, function, additional_instructions="", **kwargs):
+        """
+        UPDATED: Uses correct /api/chat payload structure (messages list)
+        """
+        schema_str = self._convert_tools_to_json_schema(function)
+        focus_pk = kwargs.get("focus_object")
+        world_context = self.build_hybrid_context(message, focus_object_id=focus_pk)
+
+        full_system_prompt = (
+            f"{self.instructions}. {additional_instructions}\n"
+            f"You must respond strictly with a valid JSON object matching this schema:\n"
+            f"{schema_str}\n"
+            f"Do not include markdown formatting or explanations."
+            f"You must strictly adhere to the following context:\n"
+            f"{world_context}"
+        )
+
+        # FIX: Using 'messages' instead of 'prompt'/'system'
+        payload = {
+            "model": "llama3",
+            "messages": [
+                {"role": "system", "content": full_system_prompt},
+                {"role": "user", "content": message},
+            ],
+            "format": "json",
+            "stream": False,
+            "keep_alive": "24h",
+        }
+
+        try:
+            response = requests.post(f"{self._ollama_url}/chat", json=payload)
+            response.raise_for_status()
+
+            # FIX: Chat API returns 'message' -> 'content'
+            result_text = response.json().get("message", {}).get("content", "{}")
+            return json.loads(result_text)
+
+        except Exception as e:
+            log(f"==== LocalAI JSON Error: {e} ====", _print=True)
+            return {}
+
+    def generate_text(self, message, additional_instructions="", **kwargs):
+        """
+        UPDATED: Uses correct /api/chat payload structure
+        """
+        focus_pk = kwargs.get("focus_object")
+        world_context = self.build_hybrid_context(message, focus_object_id=focus_pk)
+
+        full_system_prompt = (
+            f"{self.instructions}. {additional_instructions}\n"
+            f"You must strictly adhere to the following context:\n"
+            f"{world_context}"
+        )
+
+        payload = {
+            "model": "llama3",
+            "messages": [
+                {"role": "system", "content": full_system_prompt},
+                {"role": "user", "content": message},
+            ],
+            "stream": False,
+            "keep_alive": "24h",
+        }
+
+        try:
+            response = requests.post(f"{self._ollama_url}/chat", json=payload)
+            response.raise_for_status()
+            # FIX: Chat API returns 'message' -> 'content'
+            return response.json().get("message", {}).get("content", "")
+        except Exception as e:
+            log(f"==== LocalAI Text Error: {e} ====", _print=True)
+            return "Error generating text."
+
+    def summarize_text(self, text, primer="", **kwargs):
+        primer = primer or "Summarize the following text concisely."
+        max_chars = 12000
+        chunks = [text[i : i + max_chars] for i in range(0, len(text), max_chars)]
+
+        full_summary = ""
+        for chunk in chunks:
+            payload = {
+                "model": "llama3",
+                "messages": [{"role": "user", "content": f"{primer}:\n\n{chunk}"}],
+                "stream": False,
+                "keep_alive": "24h",
+            }
+            try:
+                res = requests.post(f"{self._ollama_url}/chat", json=payload)
+                full_summary += res.json().get("message", {}).get("content", "") + "\n"
+            except Exception as e:
+                log(f"Summary Error: {e}", _print=True)
+                break
+
+        return full_summary
+
+    def generate_audio_text(self, audio_file, prompt="", **kwargs):
+        try:
+            if isinstance(audio_file, bytes):
+                f_obj = io.BytesIO(audio_file)
+            else:
+                f_obj = audio_file
+            files = {"file": ("audio.mp3", f_obj, "audio/mpeg")}
+            response = requests.post(f"{self._media_url}/transcribe", files=files)
+            response.raise_for_status()
+            return response.json().get("text", "")
+        except Exception as e:
+            log(f"STT Error: {e}", _print=True)
+            return ""
+
+    def generate_audio(self, prompt, voice=None, **kwargs):
+        voice = voice or random.choice(list(self.VOICES.keys()))
+        try:
+            payload = {"text": prompt, "voice": voice}
+            response = requests.post(f"{self._media_url}/tts", json=payload)
+            response.raise_for_status()
+            wav_bytes = response.content
+            audio = AudioSegment.from_file(io.BytesIO(wav_bytes), format="wav")
+            mp3_buffer = io.BytesIO()
+            audio.export(mp3_buffer, format="mp3")
+            return mp3_buffer.getvalue()
+        except Exception as e:
+            log(f"TTS Error: {e}", _print=True)
+            return None
+
+    def generate_image(self, prompt, negative_prompt="", **kwargs):
+        try:
+            data = {"prompt": prompt, "negative_prompt": negative_prompt}
+            files = {}
+            if kwargs.get("files"):
+                for fn, f_bytes in kwargs.get("files").items():
+                    if isinstance(f_bytes, bytes):
+                        file_obj = io.BytesIO(f_bytes)
+                    else:
+                        file_obj = f_bytes
+                    files["file"] = (fn, file_obj, "image/png")
+                    break
+            if files:
+                response = requests.post(
+                    f"{self._media_url}/generate-image", data=data, files=files
+                )
+            else:
+                response = requests.post(f"{self._media_url}/generate-image", data=data)
+            response.raise_for_status()
+            return response.content
+        except Exception as e:
+            log(f"Image Gen Error: {e}", _print=True)
+            return None
+
+    def list_voices(self, filters=[]):
+        if not filters:
+            return list(self.VOICES.keys())
+        voices = []
+        for voice, attribs in self.VOICES.items():
+            if any(f.lower() in attribs for f in filters):
+                voices.append(voice)
+        return voices

{autonomous_app-0.3.29 → autonomous_app-0.3.31}/src/autonomous/db/__init__.py

@@ -5,6 +5,7 @@
 # `from autonomous.db import *` and then `connect('testdb')`.
 from autonomous.db import (
     connection,
+    db_sync,
     document,
     errors,
     fields,
@@ -12,6 +13,7 @@ from autonomous.db import (
     signals,
 )
 from autonomous.db.connection import *  # noqa: F401
+from autonomous.db.db_sync import *  # noqa: F401
 from autonomous.db.document import *  # noqa: F401
 from autonomous.db.errors import *  # noqa: F401
 from autonomous.db.fields import *  # noqa: F401
@@ -28,14 +30,11 @@ __all__ = (
 )
 
 
-VERSION = (0, 29, 0)
+VERSION = (0, 30, 0)
 
 
 def get_version():
-    """Return the VERSION as a string.
-
-    For example, if `VERSION == (0, 10, 7)`, return '0.10.7'.
-    """
+    """Return the VERSION as a string."""
     return ".".join(map(str, VERSION))
 
 

autonomous_app-0.3.31/src/autonomous/db/db_sync.py

@@ -0,0 +1,140 @@
+import os
+import time
+import urllib.parse
+import uuid
+from datetime import datetime
+
+import numpy as np
+import pymongo
+import redis
+import requests
+
+# CONFIGURATION
+db_host = os.getenv("DB_HOST", "db")
+db_port = os.getenv("DB_PORT", 27017)
+password = urllib.parse.quote_plus(str(os.getenv("DB_PASSWORD")))
+username = urllib.parse.quote_plus(str(os.getenv("DB_USERNAME")))
+MEDIA_URL = "http://media_ai_internal:5005"
+REDIS_HOST = os.getenv("REDIS_HOST", "cachedb")
+MONGO_URI = f"mongodb://{username}:{password}@{db_host}:{db_port}/?authSource=admin"
+
+# DB SETUP
+r = redis.Redis(host=REDIS_HOST, port=6379, decode_responses=True)
+
+mongo = pymongo.MongoClient(MONGO_URI)
+db = mongo[os.getenv("DB_DB")]
+# connect(host=f"mongodb://{username}:{password}@{host}:{port}/{dbname}?authSource=admin")
+
+
+def get_vector(text):
+    """Helper to get embedding from your Media AI container"""
+    try:
+        resp = requests.post(f"{MEDIA_URL}/embeddings", json={"text": text}, timeout=30)
+        if resp.status_code == 200:
+            return resp.json()["embedding"]
+    except Exception as e:
+        print(f"Vector Gen Failed: {e}")
+    return None
+
+
+def process_single_object_sync(object_id, collection_name, token):
+    """
+    THE WORKER FUNCTION (Runs in Background).
+    It is safe to sleep here because we are not in the web request.
+    """
+    str_id = str(object_id)
+    token_key = f"sync_token:{collection_name}:{str_id}"
+
+    # 1. THE DEBOUNCE WAIT (Happens in background)
+    print(f"Debouncing {str_id} for 5 seconds...")
+    time.sleep(5)
+
+    # 2. THE VERIFICATION
+    # Check if a newer save happened while we slept
+    current_active_token = r.get(token_key)
+
+    if current_active_token != token:
+        print(f"Skipping sync for {str_id}: Superseded by a newer save.")
+        return
+
+    # 3. THE EXECUTION (Embedding generation)
+    print(f"Processing Sync for: {str_id} in {collection_name}")
+
+    from bson.objectid import ObjectId
+
+    # FIX: Use dynamic collection access instead of db.objects
+    try:
+        # Tries to convert string ID to ObjectId.
+        # If your DB uses String IDs, remove the ObjectId() wrapper.
+        oid = ObjectId(object_id)
+        doc = db[collection_name].find_one({"_id": oid})
+    except Exception:
+        # Fallback if ID is not a valid ObjectId string
+        doc = db[collection_name].find_one({"_id": object_id})
+
+    if not doc:
+        print(f"Object {object_id} not found in collection '{collection_name}'")
+        # Optional: Remove from Redis index if it exists
+        r.delete(f"lore:{object_id}")
+        return
+
+    # 2. Construct Searchable Text
+    # (Existing logic...)
+    searchable_text = (
+        f"{doc.get('name', '')}: {doc.get('description', '')} {doc.get('history', '')}"
+    )
+
+    if len(searchable_text) < 10:
+        return
+
+    # 3. Generate Vector
+    vector = get_vector(searchable_text)
+
+    # 4. Save to Redis Index
+    if vector:
+        r.hset(
+            f"lore:{object_id}",
+            mapping={
+                "mongo_id": str(object_id),
+                "collection": collection_name,  # Useful for debugging
+                "content": searchable_text,
+                "vector": np.array(vector, dtype=np.float32).tobytes(),
+                "last_synced": datetime.utcnow().isoformat(),
+            },
+        )
+        print(f"Successfully Indexed: {doc.get('name')}")
+
+
+def request_indexing(object_id, collection_name):
+    """
+    THE TRIGGER FUNCTION (Runs in Main App).
+    MUST BE FAST. NO SLEEPING HERE.
+    """
+    print("Requesting Indexing...")
+    # Import your Queue Wrapper
+    from autonomous.tasks.autotask import AutoTasks
+
+    # Initialize the Task Runner
+    task_runner = AutoTasks()
+
+    str_id = str(object_id)
+    token_key = f"sync_token:{collection_name}:{str_id}"
+
+    # 1. GENERATE NEW TOKEN
+    current_token = str(uuid.uuid4())
+
+    # 2. SAVE TOKEN TO REDIS (Instant)
+    r.set(token_key, current_token, ex=300)
+
+    # 3. ENQUEUE THE TASK (Instant)
+    try:
+        task_runner.task(
+            process_single_object_sync,  # The function to run later
+            object_id=str_id,
+            collection_name=collection_name,
+            token=current_token,
+        )
+        return True
+    except Exception as e:
+        print(f"Sync Enqueue failed: {e}")
+        return False

{autonomous_app-0.3.29 → autonomous_app-0.3.31}/src/autonomous/model/automodel.py

@@ -8,6 +8,7 @@ from autonomous import log
 from autonomous.db import Document, connect, signals
 from autonomous.db.errors import ValidationError
 from autonomous.db.fields import DateTimeField
+from autonomous.db import db_sync
 
 host = os.getenv("DB_HOST", "db")
 port = os.getenv("DB_PORT", 27017)
@@ -240,6 +241,9 @@ class AutoModel(Document):
         """
         obj = super().save()
         self.pk = obj.pk
+
+        db_sync.request_indexing(self.pk, collection_name=self._get_collection_name())
+
         return self.pk
 
     @classmethod

autonomous_app-0.3.31/src/autonomous/tasks/autotask.py

@@ -0,0 +1,80 @@
+import os
+from redis import Redis
+from rq import Queue
+from rq.job import Job
+
+class AutoTask:
+    def __init__(self, job):
+        self.job = job
+
+    @property
+    def id(self):
+        return self.job.id
+
+    @property
+    def status(self):
+        return self.job.get_status()
+
+    @property
+    def result(self):
+        # Simplified result fetching
+        return {
+            "id": self.id,
+            "return_value": self.job.result,
+            "status": self.status,
+            "error": self.job.exc_info
+        }
+
+class AutoTasks:
+    _connection = None
+    queue = None
+
+    # Config stays the same
+    config = {
+        "host": os.environ.get("REDIS_HOST", "cachedb"),
+        "port": os.environ.get("REDIS_PORT", 6379),
+        "password": os.environ.get("REDIS_PASSWORD"),
+        "username": os.environ.get("REDIS_USERNAME"),
+        "db": os.environ.get("REDIS_DB", 0),
+    }
+
+    def __init__(self, queue_name="default"):
+        if not AutoTasks._connection:
+            options = {}
+            if AutoTasks.config.get("password"):
+                options["password"] = AutoTasks.config.get("password")
+
+            # Create Redis Connection
+            AutoTasks._connection = Redis(
+                host=AutoTasks.config.get("host"),
+                port=AutoTasks.config.get("port"),
+                decode_responses=False, # RQ requires bytes, not strings
+                **options,
+            )
+
+        # Initialize Queue
+        AutoTasks.queue = Queue(queue_name, connection=AutoTasks._connection)
+
+    def task(self, func, *args, **kwargs):
+        """
+        Enqueues a job to Redis. Does NOT start a worker.
+        """
+        job_timeout = kwargs.pop("_task_job_timeout", 3600)
+
+        # Enqueue the job
+        # func can be a string path or the function object itself
+        job = AutoTasks.queue.enqueue(
+            func,
+            args=args,
+            kwargs=kwargs,
+            job_timeout=job_timeout
+        )
+
+        return AutoTask(job)
+
+    def get_task(self, job_id):
+        try:
+            job = Job.fetch(job_id, connection=AutoTasks._connection)
+            return AutoTask(job)
+        except Exception:
+            return None

autonomous_app-0.3.31/src/autonomous/tasks/task_router.py

@@ -0,0 +1,24 @@
+import re
+
+
+class TaskRouterBase:
+    """
+    Maps URL paths to Task Functions.
+    Acts as the central registry for all background tasks.
+    """
+
+    # Format: (Regex Pattern, Function Object)
+
+    @classmethod
+    def resolve(cls, path):
+        """
+        Parses the path, finds the matching function, and extracts arguments.
+        Returns: (function_obj, kwargs_dict) or (None, None)
+        """
+        for pattern, func in cls.ROUTES:
+            match = re.match(pattern, path)
+            if match:
+                return func, match.groupdict()
+        return None, None
+
+    ROUTES = []

{autonomous_app-0.3.29 → autonomous_app-0.3.31}/src/autonomous_app.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autonomous-app
-Version: 0.3.29
+Version: 0.3.31
 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
@@ -24,8 +24,8 @@ Requires-Dist: gunicorn
 Requires-Dist: Authlib
 Requires-Dist: rq
 Requires-Dist: ollama
-Requires-Dist: openai>=1.42
 Requires-Dist: google-genai
+Requires-Dist: sentence-transformers
 Requires-Dist: dateparser
 Requires-Dist: python-slugify
 Requires-Dist: pydub