TriCacheLLM-MMA 0.1.0__py3-none-any.whl

portable_cache_Ai/portable_cache_rerankAi.py

@@ -0,0 +1,132 @@
+# File: portable_cache_Ai/portable_cache_rerankAi.py
+import cohere
+from typing import Optional, Any
+from pathlib import Path
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from langchain_core.documents import Document as LangChainDocument
+from portable_cache_utils.protable_cache_DynamicEnv_maker import get_settings
+from portable_cache_dbSchema import Paths
+
+class CohereManager:
+    """Encapsulates the Cohere client to prevent import-time crashes."""
+    def __init__(self):
+        self._client: Optional[cohere.ClientV2] = None
+        self._current_api_key: Optional[str] = None
+
+    def _get_cohere_api_key_from_registry(self) -> Optional[str]:
+        """Sneaks a peek into the SQLite registry DB to grab the true source-of-truth cohere_api_key."""
+        try:
+            settings = get_settings()
+            db_path = Path(settings.portable_cache_registry_db)
+            if not db_path.exists():
+                return None
+            
+            sync_engine = create_engine(f"sqlite:///{db_path}")
+            SessionLocal = sessionmaker(bind=sync_engine)
+            with SessionLocal() as session:
+                path_record = session.query(Paths).filter_by(id=1).first()
+                
+            sync_engine.dispose()
+            if path_record and path_record.cohere_api_key:
+                return path_record.cohere_api_key
+        except Exception:
+            pass
+        return None
+
+    def get_client(self, api_key: Optional[str] = None) -> cohere.ClientV2:
+        """Lazily initializes the Cohere V2 client using explicit arg, registry DB, or settings/env."""
+        settings = get_settings()
+        
+        target_api_key = api_key or self._get_cohere_api_key_from_registry() or settings.portable_cache_cohere_api_key
+        
+        if not target_api_key:
+            raise ValueError("Cohere API key not found! Run create_cache_system first or set your API key.")
+        
+        if self._client is None or self._current_api_key != target_api_key:
+            self._current_api_key = target_api_key
+            self._client = cohere.ClientV2(api_key=target_api_key)
+        
+        return self._client
+
+cohere_manager = CohereManager()
+
+async def portable_cache_cohere_rerank(
+    question: str, 
+    user_id: Any,
+    received_docs: list[LangChainDocument], 
+    top_k: int,
+) -> dict:
+    """
+    Enterprise portable wrapper for document reranking using Cohere's native cross-encoder API.
+    Returns a clean dict: {"success": bool, "data": list[LangChainDocument] | None, "error": str | None}
+    """
+    print(f"CACHE_RERANK_STARTED where user_id: {user_id}") 
+    
+    if not question or not question.strip():
+        print(f"CACHE_RERANK_FAILED: Empty input question for user_id: {user_id}")
+        return {
+            "success": False,
+            "data": None,
+            "error": "Input text is empty"
+        }
+    
+    if not received_docs:
+        print(f"CACHE_RERANK_FAILED: No documents received for user_id: {user_id}")
+        return {
+            "success": False,
+            "data": None,
+            "error": "Re-ranker got no data, meaning retriever returned empty candidates."
+        }
+
+    documents_text = [doc.page_content for doc in received_docs]
+    
+    try:
+        print(f"CACHE_RERANK_PROVIDER_REQUEST where user_id: {user_id}")
+        client = cohere_manager.get_client()
+        rerank_model = get_settings().portable_cache_cohere_rerank_model
+        
+        response = client.rerank(
+            model=rerank_model,
+            query=question,
+            documents=documents_text,
+            top_n=min(top_k, len(documents_text)),
+        )
+        print(f"CACHE_RERANK_PROVIDER_SUCCESS where user_id: {user_id}")
+    except Exception as e:
+        print(f"CACHE_RERANK_ERROR where error: {str(e)} and user_id: {user_id}")
+        return {
+            "success": False,
+            "data": None,
+            "error": str(e)
+        }
+
+    print(f"CACHE_RERANK_MAPPING_STARTED where user_id: {user_id}")
+    reranked_docs: list[LangChainDocument] = []
+    try:
+        for result in response.results:
+            original_doc = received_docs[result.index]
+            updated_metadata = dict(original_doc.metadata or {})
+            updated_metadata["rerank_score"] = float(result.relevance_score)
+
+            reranked_docs.append(
+                LangChainDocument(
+                    page_content=original_doc.page_content,
+                    metadata=updated_metadata,
+                )
+            )
+        print(f"CACHE_RERANK_MAPPING_SUCCESS where user_id: {user_id}")
+    except Exception as e:
+        print(f"CACHE_RERANK_MAPPING_ERROR where error: {str(e)} and user_id: {user_id}")
+        return {
+            "success": False,
+            "data": None,
+            "error": "Failed to map reranked results to documents."
+        }
+
+    print(f"CACHE_RERANK_COMPLETED where user_id: {user_id}")
+    return {
+        "success": True,
+        "data": reranked_docs,
+        "error": None
+    }

portable_cache_bgWorkers/portable_cache_celery_conf.py

@@ -0,0 +1,51 @@
+# File: portable_cache_bgWorkers/portable_cache_celery_conf.py
+from pathlib import Path
+from celery import Celery
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from portable_cache_utils.protable_cache_DynamicEnv_maker import get_settings
+from portable_cache_dbSchema import Paths
+
+def get_celery_redis_url() -> str:
+    """Sneaks a peek into the SQLite registry DB to grab the true source-of-truth redis_url for Celery."""
+    try:
+        settings = get_settings()
+        if settings.protable_cache_registry_db:
+            db_path = Path(settings.protable_cache_registry_db)
+            if db_path.exists():
+                sync_engine = create_engine(f"sqlite:///{db_path}")
+                SessionLocal = sessionmaker(bind=sync_engine)
+                with SessionLocal() as session:
+                    path_record = session.query(Paths).filter_by(id=1).first()
+                sync_engine.dispose()
+                if path_record and path_record.redis_url:
+                    return path_record.redis_url
+    except Exception:
+        pass
+    
+    return get_settings().portable_cache_redis_url
+
+redis_base_url = get_celery_redis_url()
+
+celery_app = Celery(
+    "fastapi_ai_backend",
+    broker=redis_base_url,
+    backend=redis_base_url.rsplit("/", 1)[0] + "/1",
+)
+
+celery_app.conf.imports = (
+    "portable_cache_bgWorkers.portable_cache_workers",
+)
+
+celery_app.conf.task_default_queue = "default"
+celery_app.conf.task_routes = {
+    "ai.*": { 
+        "queue": "ai"
+    },
+    "retri.*": {  
+        "queue": "retri"
+    },
+    "maintenance.*": {
+        "queue": "maintenance"
+    },
+}

portable_cache_bgWorkers/portable_cache_workers.py

@@ -0,0 +1,163 @@
+# File: portable_cache_bgWorkers/portable_cache_workers.py
+import asyncio
+from pathlib import Path
+from typing import Any
+from portable_cache_bgWorkers.portable_cache_celery_conf import celery_app
+from portable_cache_schemas.portable_cache_dbConf import db_manager
+import json
+from portable_cache_dbSchema import CacheVDBResource
+from portable_cache_utils.protable_cache_DynamicEnv_maker import get_settings
+from portable_cache_schemas.portable_cache_schemas import CacheVDBStatus 
+from langchain_core.documents import Document as LangChainDocument
+from sqlalchemy import select
+from portable_cache_utils.portable_cache_embedding_model import embedding_model
+from langchain_chroma import Chroma
+from datetime import datetime, timezone
+from portable_cache_dbSchema import Paths
+from sqlalchemy import text
+import time
+
+@celery_app.task(bind=True, max_retries=3, name="ai.cache_vdb")
+def create_cache_vdb_worker(self, user_id: int):
+    try:
+        return asyncio.run(
+            create_cache_vdb_async(
+                task_instance=self,
+                user_id=user_id,
+            )
+        )
+    except Exception as exc:
+        raise self.retry(exc=exc, countdown=10)
+
+async def create_cache_vdb_async(task_instance: Any, user_id: int):
+    async with db_manager.celery_session() as db:
+        try:
+            result = await db.execute(select(Paths).filter_by(id=1))
+            path_record = result.scalars().first()
+            
+            if path_record and path_record.chroma_db_dir:
+                base_chroma_dir = path_record.chroma_db_dir
+            else:
+                base_chroma_dir = get_settings().portable_cache_chroma_db_dir
+                
+            user_cache_dir = Path(base_chroma_dir) / f"user_{user_id}"
+            await asyncio.to_thread(
+                user_cache_dir.mkdir,
+                parents=True,
+                exist_ok=True,
+            )
+
+            await asyncio.to_thread(
+                lambda: Chroma(
+                    collection_name=f"question_cache_{user_id}",
+                    embedding_function=embedding_model,
+                    persist_directory=str(user_cache_dir),
+                )
+            )
+
+            stmt = select(CacheVDBResource).where(
+                CacheVDBResource.user_id == user_id
+            )
+            result = await db.execute(stmt)
+            cache_res = result.scalar_one_or_none()
+
+            if cache_res is None:
+                raise RuntimeError(
+                    f"Cache VDB resource record not found in DB for user {user_id}"
+                )
+
+            cache_res.status = CacheVDBStatus.READY
+            cache_res.vdb_path = str(user_cache_dir)
+            cache_res.failure_reason = None
+            await db.commit()
+
+            return {
+                "status": "READY",
+                "user_id": user_id,
+            }
+
+        except Exception as exc:
+            stmt = select(CacheVDBResource).where(
+                CacheVDBResource.user_id == user_id
+            )
+            result = await db.execute(stmt)
+            cache_res = result.scalar_one_or_none()
+
+            if cache_res:
+                cache_res.status = CacheVDBStatus.FAILED
+                cache_res.failure_reason = str(exc)
+                await db.commit()
+
+            raise
+
+
+@celery_app.task(bind=True, max_retries=3, name="ai.push_cache_vdb")
+def push_responce_in_cache_worker(self, user_id: int, question: str, model_output_dict: dict):
+    try:
+        return asyncio.run(
+            push_response_in_cache_async(
+                task_instance=self,
+                user_id=user_id,
+                question=question,
+                model_output_dict=model_output_dict
+            )
+        )
+    except Exception as exc:
+        raise self.retry(exc=exc, countdown=10)
+
+async def push_response_in_cache_async(task_instance: Any, user_id, question: str, model_output_dict: dict) -> str | None:
+    print(f"CACHE_VDB_PUSH_ASYNC_ENTERED where user_id: {user_id}")
+    async with db_manager.celery_session() as db:
+        try:
+            response_json_str = json.dumps(model_output_dict)
+
+            cache_metadata = {
+                "user_id": user_id,
+                "question": question,
+                "llm_response": response_json_str,
+                "created_at": datetime.now(timezone.utc).isoformat(),
+                "timestamp": time.time()
+            }
+
+            cache_document = LangChainDocument(
+                page_content=question,
+                metadata=cache_metadata
+            )
+
+            stmt = select(CacheVDBResource).where(
+                CacheVDBResource.user_id == user_id
+            )
+
+            result = await db.execute(stmt)
+            cache_res = result.scalar_one_or_none()
+
+            if cache_res is None:
+                raise RuntimeError(
+                    f"Cache VDB resource record not found for user {user_id}"
+                )
+
+            if not cache_res.vdb_path:
+                raise RuntimeError(
+                    f"Cache VDB path not found for user {user_id}"
+                )
+
+            user_cache_vdb_path = Path(cache_res.vdb_path)
+
+            user_cache_vdb = await asyncio.to_thread(
+                lambda: Chroma(
+                    collection_name=f"question_cache_{user_id}",
+                    embedding_function=embedding_model,
+                    persist_directory=str(user_cache_vdb_path),
+                )
+            )
+
+            await asyncio.to_thread(
+                user_cache_vdb.add_documents,
+                documents=[cache_document]
+            )
+
+            return cache_metadata["created_at"]
+
+        except Exception as exc:
+            print(f"AI_SERVICE_FAILED, ---WARNING--- | user_id: {user_id} and error: {str(exc)}")
+            raise

portable_cache_schemas/portable_cache_dbBase.py

@@ -0,0 +1,3 @@
+# File: portable_cache_schemas/portable_cache_dbBase.py
+from sqlalchemy.orm import declarative_base
+Base = declarative_base()

portable_cache_schemas/portable_cache_dbConf.py

@@ -0,0 +1,147 @@
+# File: portable_cache_schemas/portable_cache_dbConf.py
+import sqlite3
+from pathlib import Path
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy import event
+from portable_cache_schemas.portable_cache_dbBase import Base
+from portable_cache_utils.protable_cache_DynamicEnv_maker import get_settings
+
+
+class DatabaseManager:
+    """
+    Professional Singleton Manager to handle dynamic engine creation 
+    without module-level 'None' globals or manual boot order guessing.
+    """
+    def __init__(self):
+        self.celery_engine = None
+        self.norma_engine = None
+        self.CelerySessionLocal = None
+        self.AsyncSessionLocal = None
+        self._initialized = False
+
+    def initialize(self, db_path: str | Path):
+        """Explicitly initializes the engines and session makers."""
+        if self._initialized:
+            return
+
+        resolved_path = Path(db_path)
+        resolved_path.parent.mkdir(parents=True, exist_ok=True)
+        DATABASE_URL = f"sqlite+aiosqlite:///{resolved_path}"
+
+        self.celery_engine = create_async_engine(
+            DATABASE_URL,
+            connect_args={"timeout": 30},
+        )
+        self.norma_engine = create_async_engine(
+            DATABASE_URL,
+            pool_size=20,
+            max_overflow=10,
+            pool_timeout=30,
+            pool_recycle=3600
+        )
+
+        self.CelerySessionLocal = async_sessionmaker(
+            bind=self.celery_engine,
+            class_=AsyncSession,
+            autoflush=False,
+            expire_on_commit=False,
+        )
+
+        self.AsyncSessionLocal = async_sessionmaker(
+            bind=self.norma_engine,
+            class_=AsyncSession,
+            autoflush=False,
+            expire_on_commit=False,
+        )
+
+        @event.listens_for(self.celery_engine.sync_engine, "connect")
+        #"connect" is a SQLAlchemy lifecycle event. It tells SQLAlchemy: "Fire this function the exact millisecond a brand new raw 
+        #connection to the SQLite database is successfully opened."
+        #now sqlite3 is syncro to rlly catch the new connection we need to tap into sync_engine!
+        def set_sqlite_pragma(dbapi_connection, connection_record):
+            #raw database connection -> dbapi_connection
+            #connection_record -> its detail
+            cursor = dbapi_connection.cursor()
+            cursor.execute("PRAGMA foreign_keys=ON")
+            cursor.close()
+            #no return was intentional
+
+        self._initialized = True #made ture for said obj
+
+    def _auto_bootstrap_if_needed(self):
+        """Self-heals and auto-initializes if a worker or process calls it blindly."""
+        if self._initialized:
+            return #now we return not above here
+
+        try:
+            settings = get_settings()
+            registry_db = getattr(settings, "portable_cache_registry_db", None)
+            if registry_db and Path(registry_db).exists():
+                conn = sqlite3.connect(registry_db)
+                cursor = conn.cursor()
+                cursor.execute("SELECT db_path FROM paths WHERE id = 1")
+                row = cursor.fetchone()
+                conn.close()
+                
+                if row and row[0]:
+                    self.initialize(row[0])
+                    return
+        except Exception:
+            pass
+
+        raise RuntimeError(
+            "Database not initialized! Call init_cache_database(db_path) explicitly "
+            "or ensure the registry database is seeded."
+        )
+
+    #oh ok ig ill tell u, @property is like typedeff of c++ on drungs asside form being a rename its capable of running stuff as u can see 
+    #when i need CelerySessionLocal instead of me doing: async with db_manager.CelerySessionLocal as db: i can simaplly async with db_manager.async_session() as db:
+    @property
+    def celery_session(self):
+        self._auto_bootstrap_if_needed()
+        return self.CelerySessionLocal
+
+    @property
+    def async_session(self):
+        self._auto_bootstrap_if_needed()
+        return self.AsyncSessionLocal
+
+
+# Instantiate a single global manager for the application lifecycle
+db_manager = DatabaseManager()
+
+
+def init_cache_database(db_path: str | Path):
+    """Initializes engines and session makers using the path provided by the user's system startup."""
+    db_manager.initialize(db_path)
+
+
+async def init_db_tables():
+    if db_manager.celery_engine is None: #u may ask this wouldnt happen tho? 
+        db_manager._auto_bootstrap_if_needed() #and if it did inside it we are accessing settings() which isnt created on 1st run
+        #ur correct! this is here for nth run, where env is alredy created so settings() would exist dw! for cold start!
+
+    async with db_manager.celery_engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def get_db():
+    """Dependency for yielding database sessions safely with automatic lazy loading."""
+    SessionMaker = db_manager.async_session
+    async with SessionMaker() as session:
+        yield session
+
+
+# PEP 562 Module-Level Dynamic Attributes for legacy code/imports compatibility
+def __getattr__(name):
+    if name == "CelerySessionLocal":
+        return db_manager.celery_session
+    if name == "AsyncSessionLocal":
+        return db_manager.async_session
+    if name == "celery_engine":
+        db_manager._auto_bootstrap_if_needed()
+        return db_manager.celery_engine
+    if name == "norma_engine":
+        db_manager._auto_bootstrap_if_needed()
+        return db_manager.norma_engine
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

portable_cache_schemas/portable_cache_schemas.py

@@ -0,0 +1,8 @@
+# File: portable_cache_schemas/portable_cache_schemas.py
+
+import enum
+class CacheVDBStatus(enum.Enum):
+    PENDING = "PENDING"
+    PROCESSING = "PROCESSING"
+    READY = "READY"
+    FAILED = "FAILED"

portable_cache_utils/portable_cache_embedding_model.py

@@ -0,0 +1,7 @@
+# # File: portable_cache_utils/portable_cache_embedding_model.py
+from langchain_huggingface import HuggingFaceEmbeddings
+from portable_cache_utils.protable_cache_DynamicEnv_maker import get_settings
+
+embedding_model = HuggingFaceEmbeddings(
+    model_name=get_settings().portable_cache_cache_proj_embedding_model
+)

portable_cache_utils/protable_cache_DynamicEnv_maker.py

@@ -0,0 +1,152 @@
+# File: portable_cache_utils/protable_cache_DynamicEnv_maker.py
+import os
+from pathlib import Path
+from typing import Any, Optional
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from portable_cache_dbSchema import Paths
+from sqlalchemy import create_engine, select
+from pydantic import model_validator
+
+
+
+_INTERNAL_ENV_FILE = (
+    Path.cwd()
+    / ".portable_cache_internal"
+    / ".env_protable_cache"
+)
+
+class Settings(BaseSettings):
+    portable_cache_embedding_model: str = "all-MiniLM-L6-v2"
+    portable_cache_chroma_db_dir: str = "./chroma_cache_storage"
+    portable_cache_cohere_rerank_model: str = "rerank-english-v3.0"
+    portable_cache_cohere_api_key: Optional[str] = None 
+    portable_cache_redis_url: str = "redis://localhost:6379/0" 
+    portable_cache_registry_db: Optional[str] = None
+    portable_cache_cache_proj_embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2"
+    
+    @model_validator(mode="after")
+    def assemble_registry_path(self) -> "Settings":
+        if not self.portable_cache_registry_db:
+            self.portable_cache_registry_db = str(
+                Path(self.portable_cache_chroma_db_dir) / "registry.db"
+            )
+        return self
+
+    model_config = SettingsConfigDict(
+            env_file=_INTERNAL_ENV_FILE if _INTERNAL_ENV_FILE.exists() else (
+                Path(__file__).resolve().parent.parent
+                    / ".portable_cache_internal"
+                    / ".env_protable_cache"
+            ),  
+            env_file_encoding="utf-8",
+            extra="ignore"
+        )
+
+def get_settings() -> Settings:
+    """Always returns a fresh Settings instance loaded from current environment / file."""
+    return Settings()
+
+
+def system_key(redis_url: str, cohere_api_key: str, chroma_db_dir: str = "./chroma_cache_storage", local_cache_dir: Path = None, portable_cache_registry_db: Path = None) -> dict[str, Any]:
+    if not redis_url or not cohere_api_key:
+        raise ValueError("'redis_url' and 'cohere_api_key' are strictly required to initialize the cache system.")
+
+    try:
+        resolved_chroma = str(Path(chroma_db_dir).resolve())
+        
+        if local_cache_dir:
+            cache_dir = Path(local_cache_dir)
+        else:
+            cache_dir = (Path.cwd() / ".portable_cache_internal")
+            
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        
+        if portable_cache_registry_db:
+            db_file = portable_cache_registry_db.resolve()
+        else:
+            db_file = cache_dir / "registry.db"
+        db_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        resolved_db_path = str(db_file)
+        env_file = cache_dir / ".env_protable_cache"
+
+        env_lines = []
+        if env_file.exists():
+            env_lines = env_file.read_text().splitlines()
+
+        configs = {
+            "PORTABLE_CACHE_REDIS_URL": redis_url,
+            "PORTABLE_CACHE_COHERE_API_KEY": cohere_api_key,
+            "PORTABLE_CACHE_CHROMA_DB_DIR": resolved_chroma,
+            "PORTABLE_CACHE_REGISTRY_DB": resolved_db_path
+        }
+
+        for key, val in configs.items():
+            os.environ[key] = val
+            updated = False
+            for i, line in enumerate(env_lines):
+                if line.startswith(f"{key}="):
+                    env_lines[i] = f"{key}={val}"
+                    updated = True
+                    break
+            if not updated:
+                env_lines.append(f"{key}={val}")
+
+        env_file.write_text("\n".join(env_lines) + "\n")
+
+        sync_engine = create_engine(f"sqlite:///{db_file}")
+        from sqlalchemy.orm import sessionmaker
+        SessionLocal = sessionmaker(bind=sync_engine)
+        
+        with SessionLocal() as session:
+            path_record = session.query(Paths).filter_by(id=1).first()
+            if path_record:
+                path_record.portable_env_path = str(env_file.resolve())
+                path_record.chroma_db_dir = resolved_chroma
+                path_record.redis_url = redis_url
+                path_record.db_path = resolved_db_path
+                path_record.cohere_api_key = cohere_api_key  
+            else:
+                path_record = Paths(
+                    id=1,
+                    portable_env_path=str(env_file.resolve()),
+                    chroma_db_dir=resolved_chroma,
+                    redis_url=redis_url,
+                    db_path=resolved_db_path,
+                    cohere_api_key=cohere_api_key  
+                )
+                session.add(path_record)
+            session.commit()
+        
+        print("Portable Cache initialized, saved to .env, and recorded in registry Paths table successfully!")
+        return {"success": True, "configured": list(configs.keys())}
+        
+    except Exception as e:
+        print(f"Error initializing Portable Cache configuration: {str(e)}")
+        return {"success": False, "error": str(e), "configured": []}
+
+
+async def get_stored_paths() -> dict:
+    """Instantly pulls absolute paths and credentials from SQLite,
+    immune to working directory changes.
+    """
+    from portable_cache_schemas.portable_cache_dbConf import db_manager
+
+    async with db_manager.async_session() as session:
+        result = await session.execute(
+            select(Paths).filter_by(id=1)
+        )
+        record = result.scalars().first()
+
+        if not record:
+            raise RuntimeError(
+                "Portable Cache not initialized! Run system_key() first."
+            )
+
+        return {
+            "env_path": record.portable_env_path,
+            "chroma_dir": record.chroma_db_dir,
+            "redis_url": record.redis_url,
+            "db_path": record.db_path,
+            "cohere_api_key": record.cohere_api_key,
+        }