app/dependencies.py

"""Dependency injection configuration."""
from fastapi import Depends
from sqlalchemy.orm import Session
from app.database import get_db
from app.ports.storage import StoragePort
from app.ports.document_processor import DocumentProcessorPort
from app.ports.embedder import EmbedderPort
from app.ports.vector_db import VectorDBPort
from app.ports.llm import LLMPort
from app.services.storage_adapter import MinIOStorageAdapter
from app.services.db_storage_adapter import DatabaseStorageAdapter
from app.services.document_processor_adapter import DocumentProcessorAdapter
from app.services.embedder_adapter import SentenceTransformerAdapter
from app.services.vector_db_adapter import QdrantAdapter
from app.services.pinecone_adapter import PineconeAdapter
from app.services.llm_adapter import GroqAdapter
from app.services.chunking_service import ChunkingService
from app.application.document_service import DocumentService
from app.application.chat_service import ChatService
from app.config import get_settings
from functools import lru_cache

settings = get_settings()


# Singleton instances
@lru_cache()
def get_storage_port() -> StoragePort:
    # Always use DB storage - no external storage service needed
    return DatabaseStorageAdapter()


@lru_cache()
def get_document_processor_port() -> DocumentProcessorPort:
    return DocumentProcessorAdapter()


@lru_cache()
def get_embedder_port() -> EmbedderPort:
    return SentenceTransformerAdapter()


@lru_cache()
def get_vector_db_port() -> VectorDBPort:
    if settings.USE_PINECONE:
        return PineconeAdapter()
    return QdrantAdapter()


@lru_cache()
def get_llm_port() -> LLMPort:
    return GroqAdapter()


@lru_cache()
def get_chunking_service_dep() -> ChunkingService:
    return ChunkingService()


# Service factories
def get_document_service(
    db: Session = Depends(get_db),
    storage: StoragePort = Depends(get_storage_port),
    processor: DocumentProcessorPort = Depends(get_document_processor_port),
    embedder: EmbedderPort = Depends(get_embedder_port),
    vector_db: VectorDBPort = Depends(get_vector_db_port),
    chunking: ChunkingService = Depends(get_chunking_service_dep)
) -> DocumentService:
    return DocumentService(
        storage=storage,
        processor=processor,
        embedder=embedder,
        vector_db=vector_db,
        chunking_service=chunking,
        db=db
    )


def get_chat_service(
    db: Session = Depends(get_db),
    embedder: EmbedderPort = Depends(get_embedder_port),
    vector_db: VectorDBPort = Depends(get_vector_db_port),
    llm: LLMPort = Depends(get_llm_port)
) -> ChatService:
    return ChatService(
        embedder=embedder,
        vector_db=vector_db,
        llm=llm,
        db=db
    )