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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autonomous-app
-Version: 0.3.29
+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.29 → autonomous_app-0.3.30}/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.30}/src/autonomous/__init__.py

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

{autonomous_app-0.3.29 → autonomous_app-0.3.30}/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.29 → autonomous_app-0.3.30}/src/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
+    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")
-
-    # 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."
-    )
+    # 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"],
@@ -67,12 +70,123 @@ class LocalAIModel(AutoModel):
         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"),
-            "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):
+        """
+        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
@@ -80,19 +194,28 @@ class LocalAIModel(AutoModel):
         """
         schema_str = self._convert_tools_to_json_schema(function)
 
-        system_prompt = (
+        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": system_prompt,
+            "system": full_system_prompt,
             "format": "json",  # Force JSON mode
             "stream": False,
+            "keep_alive": "24h",
         }
 
         try:
@@ -111,25 +234,26 @@ class LocalAIModel(AutoModel):
         """
         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": f"{self.instructions}. {additional_instructions}",
+            "system": full_system_prompt,
             "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.raise_for_status()
@@ -153,6 +277,7 @@ class LocalAIModel(AutoModel):
                 "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)
@@ -209,7 +334,7 @@ class LocalAIModel(AutoModel):
             log(f"TTS Error: {e}", _print=True)
             return None
 
-    def generate_image(self, prompt, **kwargs):
+    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.
@@ -217,7 +342,7 @@ class LocalAIModel(AutoModel):
         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
@@ -232,6 +357,7 @@ class LocalAIModel(AutoModel):
 
                     # 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
 
@@ -264,9 +390,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_app-0.3.29 → autonomous_app-0.3.30}/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,

autonomous_app-0.3.30/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.
+    """
+    # 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_app-0.3.29 → autonomous_app-0.3.30}/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.30/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.30/src/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.29 → autonomous_app-0.3.30}/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.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.29 → autonomous_app-0.3.30}/src/autonomous_app.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ src/autonomous/db/__init__.py
 src/autonomous/db/common.py
 src/autonomous/db/connection.py
 src/autonomous/db/context_managers.py
+src/autonomous/db/db_sync.py
 src/autonomous/db/dereference.py
 src/autonomous/db/document.py
 src/autonomous/db/errors.py
@@ -52,7 +53,6 @@ src/autonomous/db/queryset/manager.py
 src/autonomous/db/queryset/queryset.py
 src/autonomous/db/queryset/transform.py
 src/autonomous/db/queryset/visitor.py
-src/autonomous/model/__init__.py
 src/autonomous/model/autoattr.py
 src/autonomous/model/automodel.py
 src/autonomous/storage/__init__.py
@@ -60,6 +60,7 @@ src/autonomous/storage/imagestorage.py
 src/autonomous/storage/localstorage.py
 src/autonomous/tasks/__init__.py
 src/autonomous/tasks/autotask.py
+src/autonomous/tasks/task_router.py
 src/autonomous/utils/markdown.py
 src/autonomous_app.egg-info/PKG-INFO
 src/autonomous_app.egg-info/SOURCES.txt

{autonomous_app-0.3.29 → autonomous_app-0.3.30}/src/autonomous_app.egg-info/requires.txt

@@ -13,8 +13,8 @@ gunicorn
 Authlib
 rq
 ollama
-openai>=1.42
 google-genai
+sentence-transformers
 dateparser
 python-slugify
 pydub

autonomous_app-0.3.29/src/autonomous/model/__init__.py

@@ -1 +0,0 @@
-

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

@@ -1,144 +0,0 @@
-import importlib
-import os
-import subprocess
-
-from redis import Redis
-from rq import Queue, Worker
-
-from autonomous import log
-
-
-class AutoTask:
-    def __init__(self, job):
-        self.job = job
-
-    @property
-    def id(self):
-        return self.job.id
-
-    @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"
-
-    @property
-    def result(self):
-        result = self.job.latest_result()
-        result_dict = {
-            "id": self.id,
-            "return_value": result.return_value if result else None,
-            "status": self.status,
-            "error": result.exc_string
-            if result and result.type in [result.Type.FAILED, result.Type.STOPPED]
-            else None,
-        }
-
-        return result_dict
-
-    @property
-    def return_value(self):
-        return self.result.get("return_value")
-
-
-class AutoTasks:
-    _connection = None
-    queue = None
-    workers = []
-    all_tasks = []
-    config = {
-        "host": os.environ.get("REDIS_HOST"),
-        "port": os.environ.get("REDIS_PORT"),
-        "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):
-        if not AutoTasks._connection:
-            options = {}
-
-            if AutoTasks.config.get("username"):
-                options["username"] = AutoTasks.config.get("username")
-            if AutoTasks.config.get("username"):
-                options["password"] = AutoTasks.config.get("password")
-            if AutoTasks.config.get("db"):
-                options["db"] = AutoTasks.config.get("db")
-
-            AutoTasks._connection = Redis(
-                host=AutoTasks.config.get("host"),
-                port=AutoTasks.config.get("port"),
-                **options,
-            )
-        AutoTasks.queue = Queue(queue, 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
-        """
-
-        job = AutoTasks.queue.enqueue(
-            func,
-            job_timeout=kwargs.get("_task_job_timeout", 3600),
-            args=args,
-            kwargs=kwargs,
-        )
-        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
-
-        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 = []