autonomous-app 0.3.29__py3-none-any.whl → 0.3.31__py3-none-any.whl

autonomous/__init__.py

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

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/ai/models/local_model.py

@@ -2,10 +2,12 @@ import io
 import json
 import os
 import random
-import re
-import wave
 
+import numpy as np
+import pymongo
+import redis
 import requests
+from bson.objectid import ObjectId
 from pydub import AudioSegment
 
 from autonomous import log
@@ -14,21 +16,22 @@ from autonomous.model.automodel import AutoModel
 
 
 class LocalAIModel(AutoModel):
-    # Configuration
-    _ollama_url = os.environ.get("OLLAMA_API_BASE", "http://ollama_internal:11434/api")
-    _media_url = os.environ.get("MEDIA_API_BASE", "http://media_ai_internal:5005")
-
-    # Models to use in Ollama
-    _text_model = "mistral-nemo"
-    _json_model = "mistral-nemo"
-
     messages = ListAttr(StringAttr(default=[]))
     name = StringAttr(default="agent")
-    instructions = StringAttr(
-        default="You are highly skilled AI trained to assist with various tasks."
-    )
+    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)
 
-    # Keep your voice list (mapped to random seeds/embeddings in the future)
     VOICES = {
         "Zephyr": ["female"],
         "Puck": ["male"],
@@ -63,44 +66,118 @@ class LocalAIModel(AutoModel):
     }
 
     def _convert_tools_to_json_schema(self, user_function):
-        """
-        Ollama doesn't support 'tools' strictly yet.
-        We convert the tool definition into a system prompt instruction.
-        """
         schema = {
             "name": user_function.get("name"),
-            "parameters": user_function.get("parameters"),
+            "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):
         """
-        Mimics Gemini's tool use by forcing Ollama into JSON mode
-        and injecting the schema into the prompt.
+        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)
 
-        system_prompt = (
+        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": self._json_model,
-            "prompt": message,
-            "system": system_prompt,
-            "format": "json",  # Force JSON mode
+            "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}/generate", json=payload)
+            response = requests.post(f"{self._ollama_url}/chat", json=payload)
             response.raise_for_status()
-            result_text = response.json().get("response", "{}")
 
-            # log(f"Raw Local JSON: {result_text}", _print=True)
+            # FIX: Chat API returns 'message' -> 'content'
+            result_text = response.json().get("message", {}).get("content", "{}")
             return json.loads(result_text)
 
         except Exception as e:
@@ -109,54 +186,52 @@ class LocalAIModel(AutoModel):
 
     def generate_text(self, message, additional_instructions="", **kwargs):
         """
-        Standard text generation via Ollama.
+        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": self._text_model,
-            "prompt": message,
-            "system": f"{self.instructions}. {additional_instructions}",
+            "model": "llama3",
+            "messages": [
+                {"role": "system", "content": full_system_prompt},
+                {"role": "user", "content": message},
+            ],
             "stream": False,
+            "keep_alive": "24h",
         }
 
-        # Handle 'files' (Ollama supports images in base64, but not arbitrary files easily yet)
-        # If files are text, you should read them and append to prompt.
-        if file_list := kwargs.get("files"):
-            for file_dict in file_list:
-                fn = file_dict["name"]
-                fileobj = file_dict["file"]
-                if fn.lower().endswith((".txt", ".md", ".json", ".csv")):
-                    content = fileobj.read()
-                    if isinstance(content, bytes):
-                        content = content.decode("utf-8", errors="ignore")
-                    payload["prompt"] += f"\n\nContents of {fn}:\n{content}"
-
         try:
-            response = requests.post(f"{self._ollama_url}/generate", json=payload)
+            response = requests.post(f"{self._ollama_url}/chat", json=payload)
             response.raise_for_status()
-            return response.json().get("response", "")
+            # 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."
-
-        # Simple chunking logic (similar to your original)
-        # Note: Mistral-Nemo has a large context window (128k), so chunking
-        # is less necessary than with older models, but we keep it for safety.
-        max_chars = 12000  # Roughly 3k tokens
+        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": self._text_model,
-                "prompt": f"{primer}:\n\n{chunk}",
+                "model": "llama3",
+                "messages": [{"role": "user", "content": f"{primer}:\n\n{chunk}"}],
                 "stream": False,
+                "keep_alive": "24h",
             }
             try:
-                res = requests.post(f"{self._ollama_url}/generate", json=payload)
-                full_summary += res.json().get("response", "") + "\n"
+                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
@@ -164,99 +239,59 @@ class LocalAIModel(AutoModel):
         return full_summary
 
     def generate_audio_text(self, audio_file, prompt="", **kwargs):
-        """
-        Sends audio bytes to the Media AI container for Whisper transcription.
-        """
         try:
-            # Prepare the file for upload
-            # audio_file is likely bytes, so we wrap in BytesIO if needed
             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):
-        """
-        Sends text to the Media AI container for TTS.
-        """
         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()
-
-            # Response content is WAV bytes
             wav_bytes = response.content
-
-            # Convert to MP3 to match your original interface (using pydub)
             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, **kwargs):
-        """
-        Generates an image using Local AI.
-        If 'files' are provided, performs Image-to-Image generation using the first file as reference.
-        """
+    def generate_image(self, prompt, negative_prompt="", **kwargs):
         try:
-            # Prepare the multipart data
-            # We send the prompt as a form field
-            data = {"prompt": prompt}
+            data = {"prompt": prompt, "negative_prompt": negative_prompt}
             files = {}
-
-            # Check if reference images were passed
             if kwargs.get("files"):
-                # Take the first available file
                 for fn, f_bytes in kwargs.get("files").items():
-                    # If f_bytes is bytes, wrap in IO, else assume it's file-like
                     if isinstance(f_bytes, bytes):
                         file_obj = io.BytesIO(f_bytes)
                     else:
                         file_obj = f_bytes
-
-                    # Add to the request files
-                    # Key must be 'file' to match server.py logic
                     files["file"] = (fn, file_obj, "image/png")
-                    break  # We only support 1 reference image for SD Img2Img
-
-            # Send Request
+                    break
             if files:
-                # Multipart/form-data request (Prompt + File)
                 response = requests.post(
                     f"{self._media_url}/generate-image", data=data, files=files
                 )
             else:
-                # Standard request (Prompt only) - server.py handles request.form vs json
-                # But our updated server expects form data for consistency
                 response = requests.post(f"{self._media_url}/generate-image", data=data)
-
             response.raise_for_status()
-
-            # Returns WebP bytes directly
             return response.content
-
         except Exception as e:
             log(f"Image Gen Error: {e}", _print=True)
             return None
 
     def list_voices(self, filters=[]):
-        # Same logic as before
         if not filters:
             return list(self.VOICES.keys())
         voices = []
@@ -264,9 +299,3 @@ class LocalAIModel(AutoModel):
             if any(f.lower() in attribs for f in filters):
                 voices.append(voice)
         return voices
-
-    # Unused methods from original that don't apply to Local AI
-    def upload(self, file):
-        # Local models don't really have a "File Store" API like Gemini.
-        # We handle context by passing text directly in prompt.
-        pass

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/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/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/tasks/autotask.py

@@ -1,12 +1,7 @@
-import importlib
 import os
-import subprocess
-
 from redis import Redis
-from rq import Queue, Worker
-
-from autonomous import log
-
+from rq import Queue
+from rq.job import Job
 
 class AutoTask:
     def __init__(self, job):
@@ -18,127 +13,68 @@ class AutoTask:
 
     @property
     def status(self):
-        status = self.job.get_status()
-        if status in ["running", "queued", "started"]:
-            return "running"
-        return status
-
-    @property
-    def running(self):
-        return self.status == "running"
-
-    @property
-    def finished(self):
-        return self.status == "finished"
-
-    @property
-    def failed(self):
-        return self.status == "failed"
+        return self.job.get_status()
 
     @property
     def result(self):
-        result = self.job.latest_result()
-        result_dict = {
+        # Simplified result fetching
+        return {
             "id": self.id,
-            "return_value": result.return_value if result else None,
+            "return_value": self.job.result,
             "status": self.status,
-            "error": result.exc_string
-            if result and result.type in [result.Type.FAILED, result.Type.STOPPED]
-            else None,
+            "error": self.job.exc_info
         }
 
-        return result_dict
-
-    @property
-    def return_value(self):
-        return self.result.get("return_value")
-
-
 class AutoTasks:
     _connection = None
     queue = None
-    workers = []
-    all_tasks = []
+
+    # Config stays the same
     config = {
-        "host": os.environ.get("REDIS_HOST"),
-        "port": os.environ.get("REDIS_PORT"),
+        "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="default", num_workers=3):
+    def __init__(self, queue_name="default"):
         if not AutoTasks._connection:
             options = {}
-
-            if AutoTasks.config.get("username"):
-                options["username"] = AutoTasks.config.get("username")
-            if AutoTasks.config.get("username"):
+            if AutoTasks.config.get("password"):
                 options["password"] = AutoTasks.config.get("password")
-            if AutoTasks.config.get("db"):
-                options["db"] = AutoTasks.config.get("db")
 
+            # 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,
             )
-        AutoTasks.queue = Queue(queue, connection=AutoTasks._connection)
+
+        # Initialize Queue
+        AutoTasks.queue = Queue(queue_name, connection=AutoTasks._connection)
 
     def task(self, func, *args, **kwargs):
         """
-        :param job: job function
-        :param args: job function args
-        :param kwargs: job function kwargs
-        args and kwargs: use these to explicitly pass arguments and keyword to the underlying job function.
-        _task_<option>:pass options to the task object
-        :return: job
+        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,
-            job_timeout=kwargs.get("_task_job_timeout", 3600),
             args=args,
             kwargs=kwargs,
+            job_timeout=job_timeout
         )
-        self.create_worker(func)
-        new_task = AutoTask(job)
-        AutoTasks.all_tasks.append(new_task)
-        return new_task
-
-    def create_worker(self, func):
-        # Get the module containing the target_function
-        module = func.__module__
-
-        # Get the file path of the module
-        module_path = importlib.import_module(module).__file__
 
-        # Set the PYTHONPATH environment variable
-        pythonpath = os.path.dirname(module_path)
-        env = os.environ.copy()
-        env["PYTHONPATH"] = pythonpath
+        return AutoTask(job)
 
-        rq_user_pass = f"{self.config['username']}:{self.config['password']}"
-        rq_url = f"{self.config['host']}:{self.config['port']}"
-        rq_db = self.config["db"]
-        rq_worker_command = (
-            f"rq worker --url redis://{rq_user_pass}@{rq_url}/{rq_db} --burst"
-        )
-
-        worker = subprocess.Popen(rq_worker_command, shell=True, env=env)
-        self.workers.append(worker)
-        return worker
-
-    # get job given its id
     def get_task(self, job_id):
-        # breakpoint()
-        task = AutoTasks.queue.fetch_job(job_id)
-        return AutoTask(task)
-
-    # get job given its id
-    def get_tasks(self):
-        return [AutoTask(w) for w in Worker.all(queue=AutoTasks.queue)]
-
-    def clear(self):
-        AutoTasks.queue.empty()
-        AutoTasks.all_tasks = []
+        try:
+            job = Job.fetch(job_id, connection=AutoTasks._connection)
+            return AutoTask(job)
+        except Exception:
+            return None

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.dist-info → autonomous_app-0.3.31.dist-info}/METADATA

@@ -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.dist-info → autonomous_app-0.3.31.dist-info}/RECORD

@@ -1,9 +1,9 @@
-autonomous/__init__.py,sha256=j-9rQTP_Ejh4XtrStDlXn9R3weOnMognFa40DRWU_V0,95
+autonomous/__init__.py,sha256=IYpCcBa6pM-33askQSaMEQIruv9EItiurnkTkM6Q-Uc,95
 autonomous/cli.py,sha256=z4AaGeWNW_uBLFAHng0J_lfS9v3fXemK1PeT85u4Eo4,42
 autonomous/logger.py,sha256=NQtgEaTWNAWfLSgqSP7ksXj1GpOuCgoUV711kSMm-WA,2022
 autonomous/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autonomous/ai/audioagent.py,sha256=SvPLzKgqUnrkcsR7y93aURSrStIrryuntQMPS1SzUXw,1033
-autonomous/ai/baseagent.py,sha256=sJDIrCzhUp1OwkfyRqT0ZaB1fk5pV8K5L3jaTxzi9DI,940
+autonomous/ai/baseagent.py,sha256=d6OYOk8LGHlDPNcqDmEX2PpWeerl-bIBL73IZ_T78oU,880
 autonomous/ai/imageagent.py,sha256=bIOrgg_CM-rgfyLme7V9vPqP8WKVMIAVoB2E9lLtIRk,521
 autonomous/ai/jsonagent.py,sha256=VQGhK0RFo0H_eVH9dAyf4_lp-RIpdgH988joLoKjm94,1065
 autonomous/ai/textagent.py,sha256=1yM1aMvws64PocvG_L-POMDKjxq2JDuGqgc3haUHybU,926
@@ -11,7 +11,7 @@ autonomous/ai/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 autonomous/ai/models/aws.py,sha256=bGDjnGTm350zOqor9IsICzUkBUN2bubGI_ZssQuSXIw,12715
 autonomous/ai/models/deepseek.py,sha256=fkoi-hJp60yFlZ9Cb9PdUrmNSErYltQ5ezkUI75llXc,2734
 autonomous/ai/models/gemini.py,sha256=jrTMbh8SAdzzz27elOhs82iwjyutYcy8fvTOSdW-GFQ,14247
-autonomous/ai/models/local_model.py,sha256=GBXUelGUObo33BYaPVbCqI0asYaFLET2JNMFSXqxngw,9846
+autonomous/ai/models/local_model.py,sha256=jWLTHBLb-6GtrMeDNctUTucX7HFZfla5NsfGfFsNPJ0,11297
 autonomous/ai/models/openai.py,sha256=2-LttCm6woGklaLbs1H5LjlbfM-7leDwGmC9vksSqW4,13135
 autonomous/apis/version_control/GHCallbacks.py,sha256=AyiUlYfV5JePi11GVyqYyXoj5UTbPKzS-HRRI94rjJo,1069
 autonomous/apis/version_control/GHOrganization.py,sha256=mi2livdsGurKiifbvuLwiFbdDzL77IlEfhwEa-tG77I,1155
@@ -23,10 +23,11 @@ autonomous/auth/autoauth.py,sha256=OizuMhmFjNzmsUijIbjGcQ5FxzVeoy9-NMFsx_TDsOE,3
 autonomous/auth/github.py,sha256=dHf84bJdV9rXGcvRLzWCPW9CvuA-VEmqYi_QQFwd2kY,886
 autonomous/auth/google.py,sha256=cHmqbyNEPTKipc3WkYcD1XPOyqcWEFW0Ks4qJYmGvPw,1049
 autonomous/auth/user.py,sha256=1yDu04yNSURzBzok6C5Dn-_mv0fGefvjrxj9ikCktqY,2726
-autonomous/db/__init__.py,sha256=9frkXJrl_OUemUQteXCTPqC8ECyxjE91Gi2mgTq26Fw,1159
+autonomous/db/__init__.py,sha256=2mNynmYV0I_J3-W4Aw1cojAQrHf4aHZT1Ow9xUdmM18,1154
 autonomous/db/common.py,sha256=BUN2x_XuQBRFcq54TGPx4yLMLJdgytdbIt07QWr4CSM,2551
 autonomous/db/connection.py,sha256=j_-eMre4ade9Y8GejJcMbQQiSEimL4j2vIQxaXViKxI,17754
 autonomous/db/context_managers.py,sha256=_nH2ajCL8Xy90AuB2rKaryR4iF8Q8ksU3Nei_mZj-DE,9918
+autonomous/db/db_sync.py,sha256=dTJ8QO1-_OJkNJL-Bb8lHQkWpdOHyDRIVB4w3WW5lCU,4308
 autonomous/db/dereference.py,sha256=EgbpPCXtDZqD_ZuY1Wd4o3ltRy8qEo3C5yRh5_c9fLE,12776
 autonomous/db/document.py,sha256=oZKdTaoqwv9fCHiv450rIxgINASQF3J9FzIsUOUXHhw,44428
 autonomous/db/errors.py,sha256=_QeCotid1kmr7_W0QyH6NUrwwYN9eced_yyyiop0Xlw,4108
@@ -48,16 +49,16 @@ autonomous/db/queryset/manager.py,sha256=fXu95TlGChdJWTRA4OnY_Ik25JzezJ2_qPqmH78
 autonomous/db/queryset/queryset.py,sha256=SRLYWAQUXgcfNzeMPiH5Mm4WZIemHTNQ24y2EIisNQU,5969
 autonomous/db/queryset/transform.py,sha256=IIZKf_io60zPTIwJ5KcPcrJOOOOjD2yQU7coYClL1Iw,19461
 autonomous/db/queryset/visitor.py,sha256=AN09lR6hWYUlKJC7G1sktvnWy5hrFnpoQhi58bOXbA4,5470
-autonomous/model/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 autonomous/model/autoattr.py,sha256=FUnQrw65CcZumYiTsQ7U6G6UDGqbeekka-cjz6Sfchc,2675
-autonomous/model/automodel.py,sha256=F9rlsna1QYg8mVb-5ErKx5fEXxvaogVxWeeaJQBOOjs,8166
+autonomous/model/automodel.py,sha256=9QE9_m6oW7kgZc-eIzzRA9Ib-RkX4fpmHRjl7ns_pwg,8289
 autonomous/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autonomous/storage/imagestorage.py,sha256=SmBjBNBlP1ZEjxdOnGVzCHZhbEhMKTUQC2TbpWbejDE,6168
 autonomous/storage/localstorage.py,sha256=FzrR6O9mMGAZt5dDgqzkeOQVfGRXCygR0kksz2MPpwE,2286
 autonomous/tasks/__init__.py,sha256=pn7iZ14MhcHUdzcLkfkd4-45wgPP0tXahAz_cFgb_Tg,32
-autonomous/tasks/autotask.py,sha256=aK5iapDhgcAic3F5ZYMAhNKJkOepj8yWwbMizKDzUwQ,4153
+autonomous/tasks/autotask.py,sha256=9Fi7juGEEq8OVEQYES7sEkU21bkBhtBAIQ-Js5fMXDc,2193
+autonomous/tasks/task_router.py,sha256=W09HtRUuhwlnGxM5w4l6Hzw6mfS6L4ljWiMzD3ZVFeU,601
 autonomous/utils/markdown.py,sha256=tf8vlHARiQO1X_aGbqlYozzP_TbdiDRT9EEP6aFRQo0,2153
-autonomous_app-0.3.29.dist-info/METADATA,sha256=VEPJShGjhIrEukUwiMTlIDiu7bbkEnrvoy2r03WBsQo,3015
-autonomous_app-0.3.29.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-autonomous_app-0.3.29.dist-info/top_level.txt,sha256=ZyxWWDdbvZekF3UFunxl4BQsVDb_FOW3eTn0vun_jb4,11
-autonomous_app-0.3.29.dist-info/RECORD,,
+autonomous_app-0.3.31.dist-info/METADATA,sha256=Nz_e0D8StzIr6uAFxzXlazvrva2rFu8GzV2WTayCRDE,3024
+autonomous_app-0.3.31.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+autonomous_app-0.3.31.dist-info/top_level.txt,sha256=ZyxWWDdbvZekF3UFunxl4BQsVDb_FOW3eTn0vun_jb4,11
+autonomous_app-0.3.31.dist-info/RECORD,,

autonomous/model/__init__.py

@@ -1 +0,0 @@
-