Merge pull request #2 from CUNYTechPrep/dependency-injection

README.MD

@@ -1,5 +1,10 @@
 # CTP Slack Bot
 
+## _Modus Operandi_ in a Nutshell
+
+* Intelligently responds to Slack messages based on a repository of data.
+* Periodically checks for new content to add to its repository.
+
 ## Tech Stack
 
 * Hugging Face Spaces for hosting and serverless API
@@ -7,7 +12,10 @@
 * MongoDB for data persistence
 * Docker for containerization
 * Python
-    * See `pyproject.toml` for Python packages.
+    * FastAPI for serving HTTP requests
+    * httpx for making HTTP requests
+    * APScheduler for running periodic tasks in the background
+    * See `pyproject.toml` for additional Python packages.
 
 ## General Project Structure
 
@@ -26,7 +34,8 @@
 * `scripts/`: utility scripts for development, deployment, etc.
     * `run-dev.sh`: script to run the application locally
 * `notebooks/`: Jupyter notebooks for exploration and model development
-* `.env`: local environment variables for development purposes
+* `.env`: local environment variables for development purposes (to be created for local use only from `.env.template`)
+* `Dockerfile`: Docker container build definition
 
 ## How to Run the Application
 
@@ -34,6 +43,18 @@
 
 Just run the Docker image. 😉
 
+Build it with:
+
+```sh
+docker build . -t ctp-slack-bot
+```
+
+Run it with:
+
+```sh
+docker run --env-file=.env -p 8000:8000 --name my-ctp-slack-bot-instance ctp-slack-bot
+```
+
 ### For Development
 
 Development usually requires rapid iteration. That means a change in the code ought to be reflected as soon as possible in the behavior of the application.

pyproject.toml

@@ -19,34 +19,37 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "pydantic>=2.0.0",
-    "pydantic-settings>=2.0.0",
-    "fastapi>=0.100.0",
-    "uvicorn>=0.22.0",
-    "loguru>=0.7.0",
-    "python-dotenv>=1.0.0",
-    "httpx>=0.24.1",
-    "tenacity>=8.2.2",
-    "pybreaker>=1.0.2",
+    "dependency-injector>=4.46.0",
+    "pydantic>=2.11.2",
+    "pydantic-settings>=2.8.1",
+    "fastapi>=0.115.12",
+    "uvicorn>=0.34.0",
+    "loguru>=0.7.3",
+    "python-dotenv>=1.1.0",
+    "httpx>=0.28.1",
+    "tenacity>=9.1.2",
+    "pybreaker>=1.3.0",
     "pytz>=2025.2",
-    "apscheduler>=3.10.1",
-    "slack-sdk>=3.21.3",
-    "pymongo>=4.4.1",
-    "webvtt-py>=0.4.6",
-    "langchain>=0.0.200",
-    "transformers>=4.30.0",
-    "torch>=2.0.0",
+    "apscheduler>=3.11.0",
+    "slack-sdk>=3.35.0",
+    "pymongo>=4.11.3 ",
+    "numpy>=2.2.4",
+    "webvtt-py>=0.5.1",
+    "openai>=1.70.0",
+#    "langchain>=0.3.23",
+#    "transformers>=4.51.0",
+#    "torch>=2.6.0",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=7.3.1",
-    "pytest-cov>=4.1.0",
-    "mypy>=1.3.0",
+    "pytest>=8.3.5",
+    "pytest-cov>=6.1.1",
+    "mypy>=1.15.0",
     "types-pytz>=2025.2",
-    "black>=23.3.0",
-    "isort>=5.12.0",
-    "ruff>=0.0.270",
+    "black>=25.1.0",
+    "isort>=6.0.1",
+    "ruff>=0.11.4",
 ]
 
 [project.urls]

src/ctp_slack_bot/__init__.py

@@ -0,0 +1 @@
+from ctp_slack_bot.containers import Container

src/ctp_slack_bot/api/__init__.py

@@ -0,0 +1 @@
+from ctp_slack_bot.api.main import app, run

src/ctp_slack_bot/api/main.py

@@ -1,14 +1,14 @@
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Depends
 from loguru import logger
-from typing import AsyncGenerator, Never
+from typing import AsyncGenerator
+from dependency_injector.wiring import inject, Provide
 
+from ctp_slack_bot import Container
 from ctp_slack_bot.api.routes import router
-from ctp_slack_bot.core.config import Settings, settings
-from ctp_slack_bot.core.logging import setup_logging
+from ctp_slack_bot.core import Settings, setup_logging
 from ctp_slack_bot.core.response_rendering import PrettyJSONResponse
-from ctp_slack_bot.tasks.scheduler import start_scheduler, stop_scheduler
-
+from ctp_slack_bot.tasks import start_scheduler, stop_scheduler
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator:
@@ -16,20 +16,25 @@ async def lifespan(app: FastAPI) -> AsyncGenerator:
     Lifespan context manager for FastAPI application.
     Handles startup and shutdown events.
     """
-    # Setup logging
-    setup_logging()
+    # Initialize container and wire the container to modules that need dependency injection.
+    container = Container()
+    container.wire(packages=['ctp_slack_bot'])
+    app.container = container
+
+    # Setup logging.
+    setup_logging(container)
     logger.info("Starting application")
-    
-    # Start scheduler
-    #scheduler = start_scheduler()
-    #logger.info("Started scheduler")
-    
-    yield
-    
-    # Shutdown
+
+    # Start the scheduler.
+    scheduler = start_scheduler(container)
+    logger.info("Started scheduler")
+
+    yield # control to FastAPI until shutdown.
+
+    # Shutdown.
     logger.info("Shutting down application")
-    #stop_scheduler(scheduler)
-    #logger.info("Stopped scheduler")
+    stop_scheduler(scheduler)
+    logger.info("Stopped scheduler")
 
 
 app = FastAPI(
@@ -39,30 +44,27 @@ app = FastAPI(
     lifespan=lifespan,
 )
 
-# Include routers
+# Include routers.
 app.include_router(router)
 
+# Provide a minimalist health check endpoint for clients to detect availability.
 @app.get("/health")
-async def health() -> dict[str, str]:
+async def get_health() -> dict[str, str]:
     """Health check"""
     return {
         "status": "healthy"
     }
 
-@app.get("/env", response_class=PrettyJSONResponse)
-async def env() -> Settings:
-    """Server-internal environment variables"""
-    if not settings.DEBUG:
-        raise HTTPException(status_code=404)
-    return settings
-
-
-if __name__ == "__main__":
+# Alternate starting path for development
+def run() -> None:
     import uvicorn
-    
+    settings = Settings() # type: ignore
     uvicorn.run(
         "main:app",
         host=settings.API_HOST,
         port=settings.API_PORT,
         reload=settings.DEBUG
     )
+
+if __name__ == "__main__":
+    run()

src/ctp_slack_bot/api/routes.py

@@ -1,13 +1,19 @@
 from fastapi import APIRouter, Depends, HTTPException, status
+from dependency_injector.wiring import inject, Provide
 from loguru import logger
 
-#from ctp_slack_bot.api.dependencies import get_slack_service, get_transcript_service
-#from ctp_slack_bot.models.transcript import TranscriptRequest, TranscriptResponse
-#from ctp_slack_bot.services.slack_service import SlackService
-#from ctp_slack_bot.services.transcript_service import TranscriptService
+from ctp_slack_bot import Container
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.services import SlackService
 
 router = APIRouter(prefix="/api/v1")
 
+@router.get("/env", response_model=Settings)
+@inject
+async def get_env(settings: Settings = Depends(Provide[Container.settings])) -> Settings:
+    if not settings.DEBUG:
+        raise HTTPException(status_code=404)
+    return settings
 
 # @router.post("/transcripts/analyze", response_model=TranscriptResponse)
 # async def analyze_transcript(

src/ctp_slack_bot/containers.py

@@ -0,0 +1,44 @@
+from dependency_injector.containers import DeclarativeContainer
+from dependency_injector.providers import Factory, Singleton
+from openai import OpenAI
+
+from ctp_slack_bot.core.config import Settings
+from ctp_slack_bot.db.mongo_db import MongoDB
+from ctp_slack_bot.services.answer_retrieval_service import AnswerRetrievalService
+from ctp_slack_bot.services.content_ingestion_service import ContentIngestionService
+from ctp_slack_bot.services.context_retrieval_service import ContextRetrievalService
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+from ctp_slack_bot.services.question_dispatch_service import QuestionDispatchService
+from ctp_slack_bot.services.slack_service import SlackService
+from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
+from ctp_slack_bot.services.vectorization_service import VectorizationService
+
+
+class Container(DeclarativeContainer):
+    settings = Singleton(Settings)
+
+    event_brokerage_service = Singleton(EventBrokerageService)
+
+    mongo_db = Singleton(MongoDB, settings=settings)
+
+    # Repositories
+    # transcript_repository = Factory(
+    #     # Your transcript repository class
+    #     db=db
+    # )
+
+    open_ai_client = Factory(OpenAI, api_key=settings.provided.OPENAI_API_KEY) # TODO: poor practice to do it this way; create a LanguageModelService that creates an OpenAI client.
+
+    vector_database_service = Singleton(VectorDatabaseService, settings=settings, mongo_db=mongo_db)
+
+    vectorization_service = Singleton(VectorizationService, settings=settings, client=open_ai_client)
+
+    content_ingestion_service = Singleton(ContentIngestionService, settings=settings, event_brokerage_service=event_brokerage_service, vector_database_service=vector_database_service, vectorization_service=vectorization_service)
+
+    context_retrieval_service = Singleton(ContextRetrievalService, settings=settings, vectorization_service=vectorization_service, vector_database_service=vector_database_service)
+
+    answer_retrieval_service = Singleton(AnswerRetrievalService, settings=settings, event_brokerage_service=event_brokerage_service, client=open_ai_client)
+
+    question_dispatch_service = Singleton(QuestionDispatchService, settings=settings, event_brokerage_service=event_brokerage_service, content_ingestion_service=content_ingestion_service, context_retrieval_service=context_retrieval_service, answer_retrieval_service=answer_retrieval_service)
+
+    slack_service = Singleton(SlackService, settings=settings, event_brokerage_service=event_brokerage_service)

src/ctp_slack_bot/core/__init__.py

@@ -0,0 +1,2 @@
+from ctp_slack_bot.core.config import Settings
+from ctp_slack_bot.core.logging import logger, setup_logging

src/ctp_slack_bot/core/config.py

@@ -1,9 +1,6 @@
-from functools import lru_cache
-from typing import Literal, Optional
-
 from pydantic import Field, MongoDsn, NonNegativeFloat, NonNegativeInt, PositiveInt, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
-
+from typing import Literal, Optional
 
 class Settings(BaseSettings): # TODO: Strong guarantees of validity, because garbage in = garbage out, and settings flow into all the nooks and crannies
     """
@@ -54,14 +51,3 @@ class Settings(BaseSettings): # TODO: Strong guarantees of validity, because gar
         env_file_encoding="utf-8",
         case_sensitive=True,
     )
-
-
-@lru_cache
-def get_settings() -> Settings:
-    """
-    Get cached settings instance.
-    """
-    return Settings() # type: ignore
-
-
-settings = get_settings()

src/ctp_slack_bot/core/logging.py

@@ -1,13 +1,9 @@
-import logging
-import sys
-from typing import Dict, Union
-
+from logging import __file__ as logging_file, basicConfig, currentframe, getLogger, Handler, INFO, LogRecord
 from loguru import logger
+from sys import stderr
+from typing import Dict, Union
 
-from ctp_slack_bot.core.config import settings
-
-
-class InterceptHandler(logging.Handler):
+class InterceptHandler(Handler):
     """
     Intercept standard logging messages toward Loguru.
     
@@ -15,7 +11,7 @@ class InterceptHandler(logging.Handler):
     to Loguru, allowing unified logging across the application.
     """
     
-    def emit(self, record: logging.LogRecord) -> None:
+    def emit(self, record: LogRecord) -> None:
         # Get corresponding Loguru level if it exists
         try:
             level = logger.level(record.levelname).name
@@ -23,8 +19,8 @@ class InterceptHandler(logging.Handler):
             level = record.levelno
         
         # Find caller from where the logged message originated
-        frame, depth = logging.currentframe(), 2
-        while frame and frame.f_code.co_filename == logging.__file__:
+        frame, depth = currentframe(), 2
+        while frame and frame.f_code.co_filename == logging_file:
             frame = frame.f_back
             depth += 1
         
@@ -33,7 +29,7 @@ class InterceptHandler(logging.Handler):
         )
 
 
-def setup_logging() -> None:
+def setup_logging(container: "Container") -> None:
     """
     Configure logging with Loguru.
     
@@ -41,9 +37,12 @@ def setup_logging() -> None:
     configures the log format based on settings, and intercepts
     standard logging messages.
     """
+    from ctp_slack_bot import Container
+    settings = container.settings() if container else Provide[Container.settings]
+
     # Remove default loguru handler
     logger.remove()
-    
+
     # Determine log format
     if settings.LOG_FORMAT == "json":
         log_format = {
@@ -62,17 +61,17 @@ def setup_logging() -> None:
             "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
             "<level>{message}</level>"
         )
-    
+
     # Add console handler
     logger.add(
-        sys.stderr,
+        stderr,
         format=format_string,
         level=settings.LOG_LEVEL,
         serialize=(settings.LOG_FORMAT == "json"),
         backtrace=True,
         diagnose=True,
     )
-    
+
     # Add file handler for non-DEBUG environments
     if settings.LOG_LEVEL != "DEBUG":
         logger.add(
@@ -84,19 +83,12 @@ def setup_logging() -> None:
             level=settings.LOG_LEVEL,
             serialize=(settings.LOG_FORMAT == "json"),
         )
-    
+
     # Intercept standard logging messages
-    logging.basicConfig(handlers=[InterceptHandler()], level=0, force=True)
-    
+    basicConfig(handlers=[InterceptHandler()], level=0, force=True)
+
     # Update logging levels for some noisy libraries
-    for logger_name in [
-        "uvicorn",
-        "uvicorn.error",
-        "fastapi",
-        "httpx",
-        "apscheduler",
-        "pymongo",
-    ]:
-        logging.getLogger(logger_name).setLevel(logging.INFO)
-    
+    for logger_name in ("uvicorn", "uvicorn.error", "fastapi", "httpx", "apscheduler", "pymongo"):
+        getLogger(logger_name).setLevel(INFO)
+
     logger.info(f"Logging configured with level {settings.LOG_LEVEL}")

src/ctp_slack_bot/db/MongoDB.py

@@ -1,122 +0,0 @@
-from motor.motor_asyncio import AsyncIOMotorClient
-from pymongo import IndexModel, ASCENDING
-import logging
-from typing import Optional
-
-from ctp_slack_bot.core.config import settings
-
-logger = logging.getLogger(__name__)
-
-class MongoDB:
-    """
-    MongoDB connection and initialization class.
-    Handles connection to MongoDB, database selection, and index creation.
-    """
-    def __init__(self):
-        self.client: Optional[AsyncIOMotorClient] = None
-        self.db = None
-        self.vector_collection = None
-        self.initialized = False
-
-    async def connect(self):
-        """
-        Connect to MongoDB using connection string from settings.
-        """
-        if self.client is not None:
-            return
-
-        if not settings.MONGODB_URI:
-            raise ValueError("MONGODB_URI is not set in environment variables")
-
-        try:
-            # Create MongoDB connection
-            self.client = AsyncIOMotorClient(settings.MONGODB_URI.get_secret_value())
-            self.db = self.client[settings.MONGODB_DB_NAME]
-            self.vector_collection = self.db["vector_store"]
-            logger.info(f"Connected to MongoDB: {settings.MONGODB_DB_NAME}")
-        except Exception as e:
-            logger.error(f"Error connecting to MongoDB: {str(e)}")
-            raise
-
-    async def initialize(self):
-        """
-        Initialize MongoDB with required collections and indexes.
-        """
-        if self.initialized:
-            return
-        
-        if not self.client:
-            await self.connect()
-        
-        try:
-            # Create vector index for similarity search
-            await self.create_vector_index()
-            self.initialized = True
-            logger.info("MongoDB initialized successfully")
-        except Exception as e:
-            logger.error(f"Error initializing MongoDB: {str(e)}")
-            raise
-
-    async def create_vector_index(self):
-        """
-        Create vector index for similarity search using MongoDB Atlas Vector Search.
-        """
-        try:
-            # Check if index already exists
-            existing_indexes = await self.vector_collection.list_indexes().to_list(length=None)
-            index_names = [index.get('name') for index in existing_indexes]
-            
-            if "vector_index" not in index_names:
-                # Create vector search index
-                index_definition = {
-                    "mappings": {
-                        "dynamic": True,
-                        "fields": {
-                            "embedding": {
-                                "dimensions": settings.VECTOR_DIMENSION,
-                                "similarity": "cosine",
-                                "type": "knnVector"
-                            }
-                        }
-                    }
-                }
-                
-                # Create the index
-                await self.db.command({
-                    "createIndexes": self.vector_collection.name,
-                    "indexes": [
-                        {
-                            "name": "vector_index",
-                            "key": {"embedding": "vector"},
-                            "weights": {"embedding": 1},
-                            "vectorSearchOptions": index_definition
-                        }
-                    ]
-                })
-                
-                # Create additional metadata indexes for filtering
-                await self.vector_collection.create_index([("metadata.source", ASCENDING)])
-                await self.vector_collection.create_index([("metadata.timestamp", ASCENDING)])
-                
-                logger.info("Vector search index created")
-            else:
-                logger.info("Vector search index already exists")
-                
-        except Exception as e:
-            logger.error(f"Error creating vector index: {str(e)}")
-            raise
-
-    async def close(self):
-        """
-        Close MongoDB connection.
-        """
-        if self.client:
-            self.client.close()
-            self.client = None
-            self.db = None
-            self.vector_collection = None
-            self.initialized = False
-            logger.info("MongoDB connection closed")
-
-# Create a singleton instance
-mongodb = MongoDB() 

src/ctp_slack_bot/db/__init__.py

@@ -0,0 +1 @@
+from ctp_slack_bot.db.mongo_db import MongoDB

src/ctp_slack_bot/db/mongo_db.py

@@ -0,0 +1,127 @@
+#from motor.motor_asyncio import AsyncIOMotorClient
+from loguru import logger
+from pydantic import BaseModel, model_validator
+#from pymongo import IndexModel, ASCENDING
+from typing import Optional, Self
+
+from ctp_slack_bot.core.config import Settings
+
+class MongoDB(BaseModel):
+    """
+    MongoDB connection and initialization class.
+    Handles connection to MongoDB, database selection, and index creation.
+    """
+
+    settings: Settings
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
+    def __init__(self: Self, settings: Settings) -> Self:
+        #self.client: Optional[AsyncIOMotorClient] = None
+        #self.db = None
+        #self.vector_collection = None
+        #self.initialized = False
+        pass # The above initialization needs to be done some other way.
+
+    # async def connect(self):
+    #     """
+    #     Connect to MongoDB using connection string from settings.
+    #     """
+    #     if self.client is not None:
+    #         return
+
+    #     if not settings.MONGODB_URI:
+    #         raise ValueError("MONGODB_URI is not set in environment variables")
+
+    #     try:
+    #         # Create MongoDB connection
+    #         self.client = AsyncIOMotorClient(settings.MONGODB_URI.get_secret_value())
+    #         self.db = self.client[settings.MONGODB_DB_NAME]
+    #         self.vector_collection = self.db["vector_store"]
+    #         logger.info(f"Connected to MongoDB: {settings.MONGODB_DB_NAME}")
+    #     except Exception as e:
+    #         logger.error(f"Error connecting to MongoDB: {str(e)}")
+    #         raise
+
+    # async def initialize(self):
+    #     """
+    #     Initialize MongoDB with required collections and indexes.
+    #     """
+    #     if self.initialized:
+    #         return
+        
+    #     if not self.client:
+    #         await self.connect()
+        
+    #     try:
+    #         # Create vector index for similarity search
+    #         await self.create_vector_index()
+    #         self.initialized = True
+    #         logger.info("MongoDB initialized successfully")
+    #     except Exception as e:
+    #         logger.error(f"Error initializing MongoDB: {str(e)}")
+    #         raise
+
+    # async def create_vector_index(self):
+    #     """
+    #     Create vector index for similarity search using MongoDB Atlas Vector Search.
+    #     """
+    #     try:
+    #         # Check if index already exists
+    #         existing_indexes = await self.vector_collection.list_indexes().to_list(length=None)
+    #         index_names = [index.get('name') for index in existing_indexes]
+            
+    #         if "vector_index" not in index_names:
+    #             # Create vector search index
+    #             index_definition = {
+    #                 "mappings": {
+    #                     "dynamic": True,
+    #                     "fields": {
+    #                         "embedding": {
+    #                             "dimensions": settings.VECTOR_DIMENSION,
+    #                             "similarity": "cosine",
+    #                             "type": "knnVector"
+    #                         }
+    #                     }
+    #                 }
+    #             }
+                
+    #             # Create the index
+    #             await self.db.command({
+    #                 "createIndexes": self.vector_collection.name,
+    #                 "indexes": [
+    #                     {
+    #                         "name": "vector_index",
+    #                         "key": {"embedding": "vector"},
+    #                         "weights": {"embedding": 1},
+    #                         "vectorSearchOptions": index_definition
+    #                     }
+    #                 ]
+    #             })
+                
+    #             # Create additional metadata indexes for filtering
+    #             await self.vector_collection.create_index([("metadata.source", ASCENDING)])
+    #             await self.vector_collection.create_index([("metadata.timestamp", ASCENDING)])
+                
+    #             logger.info("Vector search index created")
+    #         else:
+    #             logger.info("Vector search index already exists")
+                
+    #     except Exception as e:
+    #         logger.error(f"Error creating vector index: {str(e)}")
+    #         raise
+
+    # async def close(self):
+    #     """
+    #     Close MongoDB connection.
+    #     """
+    #     if self.client:
+    #         self.client.close()
+    #         self.client = None
+    #         self.db = None
+    #         self.vector_collection = None
+    #         self.initialized = False
+    #         logger.info("MongoDB connection closed")

src/ctp_slack_bot/models/__init__.py

@@ -0,0 +1,4 @@
+from ctp_slack_bot.models.base import Content, Ingestible, Metadata
+from ctp_slack_bot.models.content import RetreivedContext
+from ctp_slack_bot.models.slack import SlackMessage
+from ctp_slack_bot.models.vector_query import VectorQuery

src/ctp_slack_bot/models/{VectorQuery.py → vector_query.py}

@@ -1,6 +1,5 @@
 from pydantic import BaseModel, Field, validator
 from typing import Optional, List, Dict, Any
-from ctp_slack_bot.core.config import settings
 
 class VectorQuery(BaseModel):
     """Model for vector database similarity search queries.
@@ -12,6 +11,6 @@ class VectorQuery(BaseModel):
         filter_metadata: Optional filters for metadata fields
     """
     query_text: str
-    k: int = Field(default=settings.TOP_K_MATCHES)
+    k: int
     score_threshold: float = Field(default=0.7)
-    filter_metadata: Optional[Dict[str, Any]] = None
+    filter_metadata: Optional[Dict[str, Any]] = None

src/ctp_slack_bot/services/__init__.py

@@ -0,0 +1,8 @@
+from ctp_slack_bot.services.answer_retrieval_service import AnswerRetrievalService
+from ctp_slack_bot.services.content_ingestion_service import ContentIngestionService
+from ctp_slack_bot.services.context_retrieval_service import ContextRetrievalService
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+from ctp_slack_bot.services.question_dispatch_service import QuestionDispatchService
+from ctp_slack_bot.services.slack_service import SlackService
+from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
+from ctp_slack_bot.services.vectorization_service import VectorizationService

src/ctp_slack_bot/services/{AnswerQuestionService.py → answer_retrieval_service.py}

@@ -1,17 +1,30 @@
-from pydantic import BaseModel, validator
-from typing import List, Optional, Tuple
-from ctp_slack_bot.core.config import settings
-import numpy as np
+# from asyncio import create_task
+from loguru import logger
 from openai import OpenAI
-from ctp_slack_bot.models.slack import SlackMessage
-from ctp_slack_bot.models.content import RetreivedContext
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Self, Tuple
 
-class GenerateAnswer():
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+
+
+class AnswerRetrievalService(BaseModel): # TODO: this should separate the OpenAI backend out into its own service.
     """
     Service for language model operations.
     """
-    def __init__(self):
-        self.client = OpenAI(api_key=settings.OPENAI_API_KEY)
+
+    settings: Settings
+    event_brokerage_service: EventBrokerageService
+    client: OpenAI # TODO: this should separate the OpenAI backend out into its own service, one that is agnostic.
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
 
     def generate_answer(self, question: SlackMessage, context: List[RetreivedContext]) -> str:
             """Generate a response using OpenAI's API with retrieved context.
@@ -50,11 +63,3 @@ class GenerateAnswer():
             )
             
             return response.choices[0].message.content
-
-
-
-### REMOVE BELOW, PUT SOMEWHERE IN TESTS BUT IDK WHERE YET
-# sm = SlackMessage(text="What is the capital of France?", channel_id="123", user_id="456", timestamp="789")
-# context = [RetreivedContext(contextual_text="The capital of France is Paris", metadata_source="class materials", similarity_score=0.95)]
-# a = GenerateAnswer()
-# a.generate_answer(sm, context)

src/ctp_slack_bot/services/content_ingestion_service.py

@@ -0,0 +1,21 @@
+from loguru import logger
+from pydantic import BaseModel, model_validator
+from typing import Self
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
+from ctp_slack_bot.services.vectorization_service import VectorizationService
+
+class ContentIngestionService(BaseModel):
+    """
+    Service for ingesting content.
+    """
+
+    settings: Settings
+    vector_database_service: VectorDatabaseService
+    vectorization_service: VectorizationService
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self

src/ctp_slack_bot/services/{ContextRetrievalService.py → context_retrieval_service.py}

@@ -1,29 +1,31 @@
-import logging
-from typing import List, Dict, Any, Optional
+from loguru import logger
+from pydantic import BaseModel, model_validator
+from typing import Any, Dict, List, Optional, Self
 
-from ctp_slack_bot.models.slack import SlackMessage
-from ctp_slack_bot.models.content import RetreivedContext
-from ctp_slack_bot.models.VectorQuery import VectorQuery
-from ctp_slack_bot.services.VectorizationService import VectorizationService
-from ctp_slack_bot.services.VectorDatabaseService import VectorDatabaseService
-from ctp_slack_bot.core.config import settings
+from ctp_slack_bot.core.config import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage, VectorQuery
+from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
+from ctp_slack_bot.services.vectorization_service import VectorizationService
 
-logger = logging.getLogger(__name__)
-
-class ContextRetrievalService:
+class ContextRetrievalService(BaseModel):
     """
     Service for retrieving relevant context from the vector database based on user questions.
     """
-    
-    def __init__(self):
-        self.vectorization_service = VectorizationService()
-        self.vector_db_service = VectorDatabaseService()
+
+    settings: Settings
+    vectorization_service: VectorizationService
+    vector_database_service: VectorDatabaseService
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
     
     async def initialize(self):
         """
         Initialize the required services.
         """
-        await self.vector_db_service.initialize()
+        await self.vector_database_service.initialize()
     
     async def get_context(self, message: SlackMessage) -> List[RetreivedContext]:
         """
@@ -62,7 +64,7 @@ class ContextRetrievalService:
             )
             
             # Search for similar content in vector database
-            context_results = await self.vector_db_service.search_by_similarity(
+            context_results = await self.vector_database_service.search_by_similarity(
                 query=vector_query,
                 query_embedding=query_embedding
             )

src/ctp_slack_bot/services/event_brokerage_service.py

@@ -0,0 +1,38 @@
+# from asyncio import create_task
+from loguru import logger
+from openai import OpenAI
+from pydantic import BaseModel, model_validator
+from typing import Any, Callable, Dict, List, Self
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.services.content_ingestion_service import ContentIngestionService
+from ctp_slack_bot.services.context_retrieval_service import ContextRetrievalService
+
+
+class EventBrokerageService(BaseModel):
+    """
+    Service for brokering events between services.
+    """
+
+    subscribers: Dict[str, List[Callable]] = {}
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
+    def subscribe(self: Self, event_type: str, callback: Callable) -> None:
+        """Subscribe to an event type with a callback function."""
+        if event_type not in self.subscribers:
+            self.subscribers[event_type] = []
+        self.subscribers[event_type].append(callback)
+    
+    def publish(self: Self, event_type: str, data: Any = None) -> None:
+        """Publish an event with optional data to all subscribers."""
+        if event_type in self.subscribers:
+            for callback in self.subscribers[event_type]:
+                callback(data)

src/ctp_slack_bot/services/question_dispatch_service.py

@@ -0,0 +1,31 @@
+# from asyncio import create_task
+from loguru import logger
+from openai import OpenAI
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Self, Tuple
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.services.answer_retrieval_service import AnswerRetrievalService
+from ctp_slack_bot.services.context_retrieval_service import ContextRetrievalService
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+
+
+class QuestionDispatchService(BaseModel):
+    """
+    Service for determining whether a Slack message constitutes a question.
+    """
+
+    settings: Settings
+    event_brokerage_service: EventBrokerageService
+    context_retrieval_service: ContextRetrievalService
+    answer_retrieval_service: AnswerRetrievalService
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
+    def push(self: Self, message: SlackMessage) -> None:
+        context = self.context_retrieval_service.get_context(message)
+        self.answer_retrieval_service.generate_answer(message, context)

src/ctp_slack_bot/services/slack_service.py

@@ -0,0 +1,23 @@
+# from asyncio import create_task
+from loguru import logger
+from openai import OpenAI
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Self, Tuple
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+
+
+class SlackService(BaseModel):
+    """
+    Service for interfacing with Slack.
+    """
+
+    settings: Settings
+    event_brokerage_service: EventBrokerageService
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self

src/ctp_slack_bot/services/{VectorDatabaseService.py → vector_database_service.py}

@@ -1,18 +1,24 @@
-import logging
-from typing import List, Dict, Any, Optional
-# import numpy as np
+from loguru import logger
+from pydantic import BaseModel, model_validator
+from typing import Any, Dict, List, Optional, Self
 
-from ctp_slack_bot.db.MongoDB import mongodb
-from ctp_slack_bot.models.VectorQuery import VectorQuery
-from ctp_slack_bot.models.content import RetreivedContext
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.db import MongoDB
+from ctp_slack_bot.models import VectorQuery, RetreivedContext
 
-logger = logging.getLogger(__name__)
-
-class VectorDatabaseService:
+class VectorDatabaseService(BaseModel): # TODO: this should not rely specifically on MongoDB.
     """
     Service for storing and retrieving vector embeddings from MongoDB.
     """
-    
+
+    settings: Settings
+    mongo_db: MongoDB
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
     async def initialize(self):
         """
         Initialize the database connection.

src/ctp_slack_bot/services/{VectorizationService.py → vectorization_service.py}

@@ -1,17 +1,26 @@
-from pydantic import BaseModel, validator
-from typing import List, Optional
-from ctp_slack_bot.core.config import settings
+from loguru import logger
 import numpy as np
 from openai import OpenAI
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Self
 
+from ctp_slack_bot.core import Settings
 
-class VectorizationService():
+class VectorizationService(BaseModel):
     """
     Service for vectorizing chunks of text data.
     """
-    def __init__(self):
-        self.client = OpenAI(api_key=settings.OPENAI_API_KEY)
 
+    settings: Settings
+    client: OpenAI # TODO: this should separate the OpenAI backend out into its own service, one that is agnostic.
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
         
     def get_embeddings(self, texts: List[str]) -> np.ndarray:
         """Get embeddings for a list of texts using OpenAI's API.
@@ -28,7 +37,7 @@ class VectorizationService():
         try:
             # Use the initialized client instead of the global openai module
             response = self.client.embeddings.create(
-                model=settings.EMBEDDING_MODEL,
+                model=self.settings.EMBEDDING_MODEL,
                 input=texts,
                 encoding_format="float"  # Ensure we get raw float values
             )
@@ -36,9 +45,9 @@ class VectorizationService():
             # Extract embeddings and verify dimensions
             embeddings = np.array([data.embedding for data in response.data])
             
-            if embeddings.shape[1] != settings.VECTOR_DIMENSION:
+            if embeddings.shape[1] != self.settings.VECTOR_DIMENSION:
                 raise ValueError(
-                    f"Embedding dimension mismatch. Expected {settings.VECTOR_DIMENSION}, "
+                    f"Embedding dimension mismatch. Expected {self.settings.VECTOR_DIMENSION}, "
                     f"but got {embeddings.shape[1]}. Please update VECTOR_DIMENSION "
                     f"in config.py to match the model's output."
                 )

src/ctp_slack_bot/tasks/__init__.py

@@ -0,0 +1 @@
+from ctp_slack_bot.tasks.scheduler import start_scheduler, stop_scheduler

src/ctp_slack_bot/tasks/scheduler.py

@@ -1,28 +1,26 @@
-from datetime import datetime
-from typing import Optional
-
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.triggers.cron import CronTrigger
+from datetime import datetime
+from dependency_injector.wiring import inject, Provide
 from loguru import logger
 from pytz import timezone
+from typing import Optional
 
-from ctp_slack_bot.core.config import settings
-#from ctp_slack_bot.tasks.error_report import send_error_report
-#from ctp_slack_bot.tasks.transcript_cleanup import cleanup_old_transcripts
-
+from ctp_slack_bot import Container
 
-def start_scheduler() -> AsyncIOScheduler:
+@inject
+def start_scheduler(container: Container) -> AsyncIOScheduler:
     """
     Start and configure the APScheduler instance.
     
     Returns:
         AsyncIOScheduler: Configured scheduler instance
     """
-    scheduler = AsyncIOScheduler(timezone=timezone(settings.SCHEDULER_TIMEZONE))
+    settings = container.settings() if container else Provide[Container.settings]
+    zone = settings.SCHEDULER_TIMEZONE
+    scheduler = AsyncIOScheduler(timezone=timezone(zone))
     
-    # Add jobs to the scheduler
-    
-    # Daily error report at 7 AM
+    # Add jobs to the scheduler.
     # scheduler.add_job(
     #     send_error_report,
     #     CronTrigger(hour=7, minute=0),
@@ -30,8 +28,6 @@ def start_scheduler() -> AsyncIOScheduler:
     #     name="Daily Error Report",
     #     replace_existing=True,
     # )
-    
-    # Weekly transcript cleanup on Sundays at 1 AM
     # scheduler.add_job(
     #     cleanup_old_transcripts,
     #     CronTrigger(day_of_week="sun", hour=1, minute=0),
@@ -40,25 +36,25 @@ def start_scheduler() -> AsyncIOScheduler:
     #     replace_existing=True,
     # )
     
-    # Start the scheduler
+    # Start the scheduler.
     scheduler.start()
     logger.info("Scheduler started with timezone: {}", settings.SCHEDULER_TIMEZONE)
-    logger.info("Next run for error report: {}", 
-                scheduler.get_job("daily_error_report").next_run_time)
-    logger.info("Next run for transcript cleanup: {}", 
-                scheduler.get_job("weekly_transcript_cleanup").next_run_time)
+    # logger.info("Next run for error report: {}", 
+    #             scheduler.get_job("daily_error_report").next_run_time)
+    # logger.info("Next run for transcript cleanup: {}", 
+    #             scheduler.get_job("weekly_transcript_cleanup").next_run_time)
     
     return scheduler
 
 
-def stop_scheduler(scheduler: Optional[AsyncIOScheduler] = None) -> None:
+def stop_scheduler(scheduler: AsyncIOScheduler) -> None:
     """
     Shutdown the scheduler gracefully.
     
     Args:
         scheduler: The scheduler instance to shut down
     """
-    if scheduler is not None and scheduler.running:
+    if scheduler.running:
         logger.info("Shutting down scheduler")
         scheduler.shutdown(wait=False)
         logger.info("Scheduler shutdown complete")