autonomous-app 0.3.28__py3-none-any.whl → 0.3.30__py3-none-any.whl

autonomous/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.28"
+__version__ = "0.3.30"
 
 from dotenv import load_dotenv
 

autonomous/ai/baseagent.py

@@ -3,24 +3,16 @@ from autonomous.model.autoattr import ReferenceAttr
 from autonomous.model.automodel import AutoModel
 
 from .models.gemini import GeminiAIModel
+from .models.local_model import LocalAIModel
 from .models.openai import OpenAIModel
 
 
-def clear_agents():
-    for agent in OpenAIModel.all():
-        log(f"Deleting {agent.name}")
-        agent.clear_agents()
-        agent.clear_files()
-        agent.delete()
-    return "Success"
-
-
 class BaseAgent(AutoModel):
     meta = {"abstract": True, "allow_inheritance": True, "strict": False}
 
-    client = ReferenceAttr(choices=[GeminiAIModel])
+    client = ReferenceAttr(choices=[LocalAIModel])
 
-    _ai_model = GeminiAIModel
+    _ai_model = LocalAIModel
 
     def delete(self):
         if self.client:
@@ -31,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

@@ -0,0 +1,392 @@
+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_internal:11434/api")
+    _media_url = os.environ.get("MEDIA_API_BASE", "http://media_ai_internal:5005")
+    _text_model = "mistral-nemo"
+    _json_model = "mistral-nemo"
+
+    # 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):
+        """
+        Ollama doesn't support 'tools' strictly yet.
+        We convert the tool definition into a system prompt instruction.
+        """
+        # If the user passes a raw dictionary (like a Gemini tool definition)
+        # we extract the relevant parts for the schema.
+        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):
+        """
+        Builds context based on RELATIONAL ASSOCIATIONS + SEMANTIC LORE.
+        """
+
+        # 1. Create a Cache Key based on what defines the "Scene"
+        # We assume 'focus_object_id' + rough prompt length captures the context enough
+        cache_key = f"ctx:{focus_object_id}:{len(prompt) // 50}"
+
+        # 2. Check Cache
+        cached_ctx = self._redis.get(cache_key)
+        if cached_ctx:
+            return cached_ctx
+
+        context_str = ""
+
+        # --- PART 1: MONGODB (Relational Associations) ---
+        # If we are focusing on a specific object, fetch it and its specific refs.
+        if focus_object_id:
+            try:
+                # 1. Fetch the Main Object
+                # Handle both string ID and ObjectId
+                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:
+                    # Start the context with the main object itself
+                    context_str += "### FOCUS OBJECT ###\n"
+                    context_str += prompt
+
+                    # 2. Extract References (Associations)
+                    # 1. Start with the main list
+                    ref_ids = main_obj.get("associations", []) or []
+
+                    # 2. Safely add single fields (if they exist)
+                    if world_id := main_obj.get("world"):
+                        ref_ids.append(world_id)
+
+                    # 3. Safely add lists (ensure they are lists)
+                    ref_ids.extend(main_obj.get("stories", []) or [])
+                    ref_ids.extend(main_obj.get("events", []) or [])
+
+                    if ref_ids:
+                        # Convert all to ObjectIds if they are strings
+                        valid_oids = []
+                        for rid in ref_ids:
+                            try:
+                                valid_oids.append(
+                                    ObjectId(rid) if isinstance(rid, str) else rid
+                                )
+                            except:
+                                pass
+
+                        # 3. Fetch all associated objects in ONE query
+                        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:
+                                log(f"Associated Obj: {obj}", _print=True)
+                                context_str += f"- {obj}\n"
+
+                    context_str += "\n"
+            except Exception as e:
+                log(f"Mongo Association Error: {e}", _print=True)
+
+        # --- PART 2: REDIS (Semantic Search) ---
+        # We keep this! It catches "Lore" or "Rules" that aren't explicitly linked in the DB.
+        # e.g., If the sword is "Elven", this finds "Elven History" even if not linked by ID.
+        if len(prompt) > 10:
+            vector = self.get_embedding(prompt)
+            if vector:
+                try:
+                    q = "*=>[KNN 2 @vector $blob AS score]"  # Lowered to 2 to save tokens
+                    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 as e:
+                    pass
+
+        # 3. Save to Cache (Expire in 60s)
+        # This prevents hammering the DB/Vector engine during a rapid conversation
+        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.
+        """
+        schema_str = self._convert_tools_to_json_schema(function)
+
+        focus_pk = kwargs.get("focus_object")
+
+        # Build Relational Context
+        world_context = self.build_hybrid_context(message, focus_object_id=focus_pk)
+
+        # Construct 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}"
+        )
+
+        payload = {
+            "model": self._json_model,
+            "prompt": message,
+            "system": full_system_prompt,
+            "format": "json",  # Force JSON mode
+            "stream": False,
+            "keep_alive": "24h",
+        }
+
+        try:
+            response = requests.post(f"{self._ollama_url}/generate", json=payload)
+            response.raise_for_status()
+            result_text = response.json().get("response", "{}")
+
+            # log(f"Raw Local JSON: {result_text}", _print=True)
+            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):
+        """
+        Standard text generation via Ollama.
+        """
+        focus_pk = kwargs.get("focus_object")
+
+        # Build Relational Context
+        world_context = self.build_hybrid_context(message, focus_object_id=focus_pk)
+
+        # Construct System Prompt
+        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": full_system_prompt,
+            "stream": False,
+            "keep_alive": "24h",
+        }
+
+        try:
+            response = requests.post(f"{self._ollama_url}/generate", json=payload)
+            response.raise_for_status()
+            return response.json().get("response", "")
+        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
+        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}",
+                "stream": False,
+                "keep_alive": "24h",
+            }
+            try:
+                res = requests.post(f"{self._ollama_url}/generate", json=payload)
+                full_summary += res.json().get("response", "") + "\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):
+        """
+        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, negative_prompt="", **kwargs):
+        """
+        Generates an image using Local AI.
+        If 'files' are provided, performs Image-to-Image generation using the first file as reference.
+        """
+        try:
+            # Prepare the multipart data
+            # We send the prompt as a form field
+            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
+                    # TODO: Support multiple images if needed
+                    files["file"] = (fn, file_obj, "image/png")
+                    break  # We only support 1 reference image for SD Img2Img
+
+            # Send Request
+            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 = []
+        for voice, attribs in self.VOICES.items():
+            if any(f.lower() in attribs for f in filters):
+                voices.append(voice)
+        return voices

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,

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.
+    """
+    # 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)
+    # CRITICAL CHANGE: We use task_runner.task() instead of calling the function directly.
+    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,26 @@
+import re
+import tasks
+
+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.28.dist-info → autonomous_app-0.3.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autonomous-app
-Version: 0.3.28
+Version: 0.3.30
 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.28.dist-info → autonomous_app-0.3.30.dist-info}/RECORD

@@ -1,9 +1,9 @@
-autonomous/__init__.py,sha256=cf_i1xIW4gWRL34z5iRAHqNKq4XELsusys3f4hdY1sQ,95
+autonomous/__init__.py,sha256=yFrrhxW5lT1IN2kECktEvBt4l8fh93BpQSg-lHky7BQ,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=HYCqC4HmK5afNMunmTkhRE8O0OaONl2GxXnISkdOM58,1094
+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.py,sha256=fkoi-hJp60yFlZ9Cb9PdUrmNSErYltQ5ezkUI75llXc,2734
+autonomous/ai/models/local_model.py,sha256=xBwj2f_gvQQhL5YuTHZiStPAunDiPfpjOj_SDPajMN0,14710
 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=jn6bmC6lM-Q9RxW_1WXmj6ogwQYd_5HDIDbAGLXlbu4,1172
 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=wURiDhfI_RfYDDcdRtYLZbjmeK0hUn-9A4IrI0sfi4o,4363
 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=-MrohYTwjj6oTvhRytod6JFCzojAH6dGDnbIwrb18mQ,614
 autonomous/utils/markdown.py,sha256=tf8vlHARiQO1X_aGbqlYozzP_TbdiDRT9EEP6aFRQo0,2153
-autonomous_app-0.3.28.dist-info/METADATA,sha256=HgUXCoGnskzg9FAnSZwfEGXB-5l1Rksw0XTMnGp6bBk,3015
-autonomous_app-0.3.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-autonomous_app-0.3.28.dist-info/top_level.txt,sha256=ZyxWWDdbvZekF3UFunxl4BQsVDb_FOW3eTn0vun_jb4,11
-autonomous_app-0.3.28.dist-info/RECORD,,
+autonomous_app-0.3.30.dist-info/METADATA,sha256=lRnKwOxeMj3hzPPrUEuob3c3QbnSaUjPjqrkfFumGDg,3024
+autonomous_app-0.3.30.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+autonomous_app-0.3.30.dist-info/top_level.txt,sha256=ZyxWWDdbvZekF3UFunxl4BQsVDb_FOW3eTn0vun_jb4,11
+autonomous_app-0.3.30.dist-info/RECORD,,

{autonomous_app-0.3.28.dist-info → autonomous_app-0.3.30.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

autonomous/ai/models/local.py

@@ -1,99 +0,0 @@
-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/model/__init__.py

@@ -1 +0,0 @@
-