Move more components into dependency injection container

.env.template

@@ -3,10 +3,6 @@
 # Application Configuration
 DEBUG=TRUE
 
-# Logging Configuration
-LOG_LEVEL=INFO
-LOG_FORMAT=text
-
 # APScheduler Configuration
 SCHEDULER_TIMEZONE=UTC
 

Dockerfile

@@ -5,7 +5,7 @@ WORKDIR /app
 # Set environment variables.
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
-    PYTHONPATH=/app
+    PYTHONPATH=/app/src
 
 # Install system dependencies.
 RUN apt-get update \
@@ -25,5 +25,8 @@ RUN pip install --no-cache-dir .
 RUN useradd -m appuser
 USER appuser
 
+# Expose a volume mount for logs
+VOLUME ./logs
+
 # Run the application.
-CMD ["python", "-m", "src.ctp_slack_bot.api.main"]
+CMD ["python", "-m", "ctp_slack_bot.app"]

pyproject.toml

@@ -19,28 +19,24 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "more-itertools>=10.6.0",
-    "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",
+    "more-itertools>=10.6.0",
     "python-dotenv>=1.1.0",
-    "httpx>=0.28.1",
-    "tenacity>=9.1.2",
-    "pybreaker>=1.3.0",
+    "loguru>=0.7.3",
+    "fastapi>=0.115.12",
+    "dependency-injector>=4.46.0",
     "pytz>=2025.2",
     "apscheduler>=3.11.0",
+#    "tenacity>=9.1.2",
+#    "pybreaker>=1.3.0",
     "aiohttp>=3.11.16",
+    "webvtt-py>=0.5.1",
     "slack-sdk>=3.35.0",
     "slack_bolt>=1.23.0",
-    "pymongo>=4.11.3 ",
-    "webvtt-py>=0.5.1",
-    "openai>=1.70.0",
-#    "langchain>=0.3.23",
-#    "transformers>=4.51.0",
-#    "torch>=2.6.0",
+    "motor>=3.7.0",
+    "openai>=1.70.0"
+
 ]
 
 [project.optional-dependencies]

scripts/run-dev.sh

@@ -2,4 +2,4 @@
 
 parent_path=$(cd "$(dirname "${BASH_SOURCE[0]}")"; pwd -P)
 
-python3 "${parent_path}/../src/ctp_slack_bot/api/main.py"
+LOG_LEVEL=DEBUG python3 "${parent_path}/../src/ctp_slack_bot/app.py"

src/ctp_slack_bot/api/main.py

@@ -1,63 +0,0 @@
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
-from asyncio import run as run_async
-from contextlib import asynccontextmanager
-from dependency_injector.wiring import inject, Provide
-from fastapi import FastAPI, HTTPException, Depends
-from loguru import logger
-from typing import Any, AsyncGenerator
-from slack_bolt.async_app import AsyncApp
-from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
-from starlette.requests import Request
-from starlette.responses import Response
-from threading import Thread
-from typing import Any, Dict, Self
-
-from ctp_slack_bot.containers import Container
-from ctp_slack_bot.core.config import Settings
-from ctp_slack_bot.core.logging import setup_logging
-from ctp_slack_bot.core.response_rendering import PrettyJSONResponse
-from ctp_slack_bot.tasks import start_scheduler, stop_scheduler
-
-async def main() -> None:
-    container = Container()
-    container.wire(packages=['ctp_slack_bot'])
-
-    # Setup logging.
-    setup_logging(container)
-    logger.info("Starting application")
-
-    # Start the scheduler.
-    scheduler = start_scheduler(container)
-    logger.info("Started scheduler")
-
-    # Initialize primordial dependencies in container.
-    container.primordial_services()
-
-    # Start Slack socket mode in a background thread and set up an event handler for the Bolt app.
-    bolt_app = container.slack_bolt_app()
-    slack_service = container.slack_service()
-    @bolt_app.event("message")
-    async def handle_message(body: Dict[str, Any]) -> None:
-        logger.debug("Ignored regular message: {}", body.get("event").get("text"))
-        #await slack_service.process_message(body)
-    @bolt_app.event("app_mention")
-    async def handle_app_mention(body: Dict[str, Any]) -> None:
-        #logger.debug("Ignored app mention: {}", body.get("event").get("text"))
-        await slack_service.process_message(body)
-
-    # Start Socket Mode handler in a background thread
-    socket_mode_handler = AsyncSocketModeHandler(
-        app=bolt_app,
-        app_token=container.settings().SLACK_APP_TOKEN.get_secret_value()
-    )
-    logger.info("Starting Slack Socket Mode handler…")
-    await socket_mode_handler.start_async()
-
-    # Shutdown.
-    logger.info("Shutting down application")
-    stop_scheduler(scheduler)
-    logger.info("Stopped scheduler")
-
-if __name__ == "__main__":
-    # run()
-    run_async(main())

src/ctp_slack_bot/app.py

@@ -0,0 +1,34 @@
+from asyncio import run
+from loguru import logger
+
+from ctp_slack_bot.containers import Container
+from ctp_slack_bot.core.logging import setup_logging
+
+async def main() -> None:
+    # Setup logging.
+    setup_logging()
+    logger.info("Starting application…")
+
+    # Set up dependency injection container.
+    container = Container()
+    container.wire(packages=['ctp_slack_bot'])
+
+    # Kick off services which should be active from the start.
+    container.content_ingestion_service()
+    container.question_dispatch_service()
+
+    # Start the scheduler.
+    schedule_service = container.schedule_service()
+    schedule_service.start()
+
+    # Start the Slack socket mode handler in a background thread.
+    socket_mode_handler = container.socket_mode_handler()
+    logger.info("Starting Slack Socket Mode handler…")
+    await socket_mode_handler.start_async()
+
+    # Shutdown. (This will never execute, because the socket mode handler never returns.)
+    logger.info("Shutting down application…")
+    schedule_service.stop()
+
+if __name__ == "__main__":
+    run(main())

src/ctp_slack_bot/containers.py

@@ -1,9 +1,10 @@
 from dependency_injector.containers import DeclarativeContainer
-from dependency_injector.providers import Factory, List, Singleton
+from dependency_injector.providers import Resource, Singleton
+from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
 from slack_bolt.async_app import AsyncApp
 
 from ctp_slack_bot.core.config import Settings
-from ctp_slack_bot.db.mongo_db import MongoDB
+from ctp_slack_bot.db.mongo_db import MongoDBResource
 from ctp_slack_bot.db.repositories import MongoVectorizedChunkRepository
 from ctp_slack_bot.services.answer_retrieval_service import AnswerRetrievalService
 from ctp_slack_bot.services.content_ingestion_service import ContentIngestionService
@@ -12,7 +13,8 @@ from ctp_slack_bot.services.embeddings_model_service import EmbeddingsModelServi
 from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
 from ctp_slack_bot.services.language_model_service import LanguageModelService
 from ctp_slack_bot.services.question_dispatch_service import QuestionDispatchService
-from ctp_slack_bot.services.slack_service import SlackService
+from ctp_slack_bot.services.schedule_service import ScheduleService
+from ctp_slack_bot.services.slack_service import SlackServiceResource
 from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
 from ctp_slack_bot.services.vectorization_service import VectorizationService
 
@@ -20,12 +22,9 @@ from ctp_slack_bot.services.vectorization_service import VectorizationService
 class Container(DeclarativeContainer):
     settings = Singleton(Settings)
     event_brokerage_service = Singleton(EventBrokerageService)
-    slack_bolt_app = Factory(AsyncApp, token=settings.provided.SLACK_BOT_TOKEN().get_secret_value())
-    mongo_db = Singleton(MongoDB, settings=settings) # TODO: generalize to any database.
-    vectorized_chunk_repository = Singleton(
-        MongoVectorizedChunkRepository,
-        mongo_db=mongo_db
-    )
+    schedule_service = Singleton(ScheduleService, settings=settings)
+    mongo_db = Resource(MongoDBResource, settings=settings) # TODO: generalize to any database.
+    vectorized_chunk_repository = Singleton(MongoVectorizedChunkRepository, mongo_db=mongo_db)
     vector_database_service = Singleton(VectorDatabaseService, settings=settings, mongo_db=mongo_db)
     embeddings_model_service = Singleton(EmbeddingsModelService, settings=settings)
     vectorization_service = Singleton(VectorizationService, settings=settings, embeddings_model_service=embeddings_model_service)
@@ -34,5 +33,6 @@ class Container(DeclarativeContainer):
     language_model_service = Singleton(LanguageModelService, settings=settings)
     answer_retrieval_service = Singleton(AnswerRetrievalService, settings=settings, event_brokerage_service=event_brokerage_service, language_model_service=language_model_service)
     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, event_brokerage_service=event_brokerage_service, slack_bolt_app=slack_bolt_app)
-    primordial_services = List(settings, event_brokerage_service, slack_bolt_app, slack_service, vectorized_chunk_repository, question_dispatch_service, content_ingestion_service)
+    slack_bolt_app = Singleton(AsyncApp, token=settings.provided.SLACK_BOT_TOKEN().get_secret_value())
+    slack_service = Resource(SlackServiceResource, event_brokerage_service=event_brokerage_service, slack_bolt_app=slack_bolt_app)
+    socket_mode_handler = Singleton(lambda _, app, app_token: AsyncSocketModeHandler(app, app_token), slack_service, slack_bolt_app, settings.provided.SLACK_APP_TOKEN().get_secret_value())

src/ctp_slack_bot/core/config.py

@@ -1,11 +1,13 @@
 from pydantic import Field, MongoDsn, NonNegativeFloat, NonNegativeInt, PositiveInt, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
-from typing import Literal, Optional
+from types import MappingProxyType
+from typing import Literal, Mapping, Optional, Self
 
 class Settings(BaseSettings): # TODO: Strong guarantees of validity, because garbage in = garbage out, and settings flow into all the nooks and crannies
     """
     Application settings loaded from environment variables.
     """
+
     # Application Configuration
     DEBUG: bool = False
 
@@ -13,17 +15,11 @@ class Settings(BaseSettings): # TODO: Strong guarantees of validity, because gar
     LOG_LEVEL: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = Field(default_factory=lambda data: "DEBUG" if data.get("DEBUG", False) else "INFO")
     LOG_FORMAT: Literal["text", "json"] = "json"
 
-    # API Configuration
-    API_HOST: str = "0.0.0.0"
-    API_PORT: int = 8000
-
     # APScheduler Configuration
     SCHEDULER_TIMEZONE: Optional[str] = "UTC"
 
     # Slack Configuration
-    SLACK_USER_TOKEN: Optional[SecretStr] = None
     SLACK_BOT_TOKEN: SecretStr
-    SLACK_SIGNING_SECRET: Optional[SecretStr] = None
     SLACK_APP_TOKEN: SecretStr
 
     # Vectorization Configuration
@@ -32,7 +28,7 @@ class Settings(BaseSettings): # TODO: Strong guarantees of validity, because gar
     CHUNK_SIZE: PositiveInt
     CHUNK_OVERLAP: NonNegativeInt
     TOP_K_MATCHES: PositiveInt
-    
+
     # MongoDB Configuration
     MONGODB_URI: SecretStr # TODO: Contemplate switching to MongoDsn type for the main URL, and separate out the credentials to SecretStr variables.
     MONGODB_NAME: str
@@ -52,4 +48,9 @@ class Settings(BaseSettings): # TODO: Strong guarantees of validity, because gar
         env_file=".env",
         env_file_encoding="utf-8",
         case_sensitive=True,
+        extra="allow",
+        frozen=True
     )
+
+    def get_extra_environment_variables(self: Self) -> Mapping[str, str]:
+        return MappingProxyType(self.__pydantic_extra__)

src/ctp_slack_bot/core/logging.py

@@ -1,11 +1,9 @@
-from dependency_injector.wiring import Provide
 from logging import __file__ as logging_file, basicConfig, currentframe, getLogger, Handler, INFO, LogRecord
 from loguru import logger
+from os import getenv
 from sys import stderr
 from typing import Self
 
-from ctp_slack_bot.containers import Container
-
 class InterceptHandler(Handler):
     """
     Intercept standard logging messages toward Loguru.
@@ -32,22 +30,23 @@ class InterceptHandler(Handler):
         )
 
 
-def setup_logging(container: "Container") -> None: # TODO: Perhaps get rid of the container dependence since we only need two settings.
+def setup_logging() -> None:
     """
     Configure logging with Loguru.
     
-    This function sets up Loguru as the main logging provider,
-    configures the log format based on settings, and intercepts
-    standard logging messages.
+    This function sets up Loguru as the main logging provider, configures the log format based on environment variables,
+    and intercepts standard logging messages.
     """
-    from ctp_slack_bot.containers import Container
-    settings = container.settings() if container else Provide[Container.settings]
 
-    # Remove default loguru handler
+    # Get logger configuration from environment variables.
+    log_level = getenv("LOG_LEVEL", "INFO")
+    log_format = getenv("LOG_FORMAT", "text")
+
+    # Remove default loguru handler.
     logger.remove()
 
-    # Determine log format
-    if settings.LOG_FORMAT == "json":
+    # Determine log format.
+    if log_format == "json":
         log_format = {
             "time": "{time:YYYY-MM-DD HH:mm:ss.SSS}",
             "level": "{level}",
@@ -65,33 +64,33 @@ def setup_logging(container: "Container") -> None: # TODO: Perhaps get rid of th
             "<level>{message}</level>"
         )
 
-    # Add console handler
+    # Add console handler.
     logger.add(
         stderr,
         format=format_string,
-        level=settings.LOG_LEVEL,
-        serialize=(settings.LOG_FORMAT == "json"),
+        level=log_level,
+        serialize=(log_format == "json"),
         backtrace=True,
         diagnose=True,
     )
 
-    # Add file handler for non-DEBUG environments
-    if settings.LOG_LEVEL != "DEBUG":
+    # Add file handler for non-DEBUG environments.
+    if log_level != "DEBUG":
         logger.add(
             "logs/app.log",
             rotation="10 MB",
             retention="1 week",
             compression="zip",
             format=format_string,
-            level=settings.LOG_LEVEL,
-            serialize=(settings.LOG_FORMAT == "json"),
+            level=log_level,
+            serialize=(log_format == "json"),
         )
 
-    # Intercept standard logging messages
+    # Intercept standard logging messages.
     basicConfig(handlers=[InterceptHandler()], level=0, force=True)
 
-    # Update logging levels for some noisy libraries
+    # Update logging levels for some noisy libraries.
     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}")
+    logger.info(f"Logging configured with level {log_level}")

src/ctp_slack_bot/db/mongo_db.py

@@ -1,7 +1,8 @@
+from dependency_injector.resources import Resource
 from motor.motor_asyncio import AsyncIOMotorClient
 from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
 from loguru import logger
-from pydantic import BaseModel, model_validator, PrivateAttr
+from pydantic import BaseModel, PrivateAttr
 from typing import Any, Dict, Optional, Self
 import asyncio
 
@@ -18,14 +19,11 @@ class MongoDB(BaseModel):
     class Config:
         arbitrary_types_allowed = True
     
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
-        """Initialize MongoDB connection after model creation."""
-        self._initialize_client()
+    def __init__(self: Self, **data: Dict[str, Any]) -> None:
+        super().__init__(**data)
         logger.debug("Created {}", self.__class__.__name__)
-        return self
     
-    def _initialize_client(self: Self) -> None:
+    def connect(self: Self) -> None:
         """Initialize MongoDB client with settings."""
         try:
             connection_string = self.settings.MONGODB_URI.get_secret_value()
@@ -58,7 +56,7 @@ class MongoDB(BaseModel):
         """Get the MongoDB client instance."""
         if self._client is None:
             logger.warning("MongoDB client not initialized. Attempting to initialize.")
-            self._initialize_client()
+            self.connect()
             if self._client is None:
                 raise ConnectionError("Failed to initialize MongoDB client")
         return self._client
@@ -68,7 +66,7 @@ class MongoDB(BaseModel):
         """Get the MongoDB database instance."""
         if self._db is None:
             logger.warning("MongoDB database not initialized. Attempting to initialize client.")
-            self._initialize_client()
+            self.connect()
             if self._db is None:
                 raise ConnectionError("Failed to initialize MongoDB database")
         return self._db
@@ -146,3 +144,9 @@ class MongoDB(BaseModel):
             logger.info("MongoDB connection closed")
             self._client = None
             self._db = None
+
+class MongoDBResource(Resource):
+    def init(self: Self, settings: Settings) -> MongoDB:
+        mongo_db = MongoDB(settings=settings)
+        mongo_db.connect()
+        return mongo_db

src/ctp_slack_bot/services/answer_retrieval_service.py

@@ -1,5 +1,5 @@
 from loguru import logger
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 from typing import Collection, Self
 
 from ctp_slack_bot.core import Settings
@@ -18,10 +18,12 @@ class AnswerRetrievalService(BaseModel):
     event_brokerage_service: EventBrokerageService
     language_model_service: LanguageModelService
 
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
+    class Config:
+        frozen=True
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
         logger.debug("Created {}", self.__class__.__name__)
-        return self
 
     async def push(self: Self, question: SlackMessage, context: Collection[Chunk]) -> None:
         channel_to_respond_to = question.channel

src/ctp_slack_bot/services/content_ingestion_service.py

@@ -1,5 +1,5 @@
 from loguru import logger
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 from typing import Self, Sequence
 
 from ctp_slack_bot.core import Settings
@@ -19,12 +19,14 @@ class ContentIngestionService(BaseModel):
     vector_database_service: VectorDatabaseService
     vectorization_service: VectorizationService
 
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
-        logger.debug("Created {}", self.__class__.__name__)
+    class Config:
+        frozen=True
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
         self.event_brokerage_service.subscribe(EventType.INCOMING_CONTENT, self.process_incoming_content)
         self.event_brokerage_service.subscribe(EventType.INCOMING_SLACK_MESSAGE, self.process_incoming_slack_message)
-        return self
+        logger.debug("Created {}", self.__class__.__name__)
 
     async def process_incoming_content(self: Self, content: Content) -> None:
         logger.debug("Content ingestion service received content with metadata: {}", content.get_metadata())

src/ctp_slack_bot/services/context_retrieval_service.py

@@ -1,5 +1,5 @@
 from loguru import logger
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 from typing import Self, Sequence
 
 from ctp_slack_bot.core.config import Settings
@@ -16,11 +16,12 @@ class ContextRetrievalService(BaseModel):
     vectorization_service: VectorizationService
     vector_database_service: VectorDatabaseService
 
-    # Should not allow initialization calls to bubble up all the way to the surface ― sequester in `post_init` or the class on which it depends.
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
+    class Config:
+        frozen=True
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
         logger.debug("Created {}", self.__class__.__name__)
-        return self
 
     async def get_context(self: Self, message: SlackMessage) -> Sequence[Chunk]:
         """

src/ctp_slack_bot/services/embeddings_model_service.py

@@ -1,6 +1,6 @@
 from loguru import logger
 from openai import OpenAI
-from pydantic import BaseModel, PrivateAttr, model_validator
+from pydantic import BaseModel, PrivateAttr
 from typing import Any, Dict, Sequence, Self
 
 from ctp_slack_bot.core import Settings
@@ -13,14 +13,13 @@ class EmbeddingsModelService(BaseModel):
     settings: Settings
     _open_ai_client: PrivateAttr = PrivateAttr()
 
+    class Config:
+        frozen=True
+
     def __init__(self: Self, **data: Dict[str, Any]) -> None:
         super().__init__(**data)
         self._open_ai_client = OpenAI(api_key=self.settings.OPENAI_API_KEY.get_secret_value())
-
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
         logger.debug("Created {}", self.__class__.__name__)
-        return self
 
     def get_embeddings(self: Self, texts: Sequence[str]) -> Sequence[Sequence[float]]:
         """Get embeddings for a collection of texts using OpenAI’s API.

src/ctp_slack_bot/services/event_brokerage_service.py

@@ -1,7 +1,7 @@
 from asyncio import create_task, iscoroutinefunction, to_thread
 from collections import defaultdict
 from loguru import logger
-from pydantic import BaseModel, model_validator, PrivateAttr
+from pydantic import BaseModel, PrivateAttr
 from typing import Any, Callable, Dict, List, Self
 
 from ctp_slack_bot.enums import EventType
@@ -13,10 +13,12 @@ class EventBrokerageService(BaseModel):
 
     _subscribers: PrivateAttr = PrivateAttr(default_factory=lambda: defaultdict(list))
 
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
+    class Config:
+        frozen=True
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
         logger.debug("Created {}", self.__class__.__name__)
-        return self
 
     def subscribe(self: Self, type: EventType, callback: Callable) -> None:
         """Subscribe to an event type with a callback function."""

src/ctp_slack_bot/services/language_model_service.py

@@ -1,7 +1,7 @@
 from loguru import logger
 from openai import OpenAI
 from openai.types.chat import ChatCompletion
-from pydantic import BaseModel, PrivateAttr, model_validator
+from pydantic import BaseModel, PrivateAttr
 from typing import Collection, Self
 
 from ctp_slack_bot.core import Settings
@@ -15,14 +15,13 @@ class LanguageModelService(BaseModel):
     settings: Settings
     _open_ai_client: PrivateAttr = PrivateAttr()
 
+    class Config:
+        frozen=True
+
     def __init__(self: Self, **data) -> None:
         super().__init__(**data)
         self._open_ai_client = OpenAI(api_key=self.settings.OPENAI_API_KEY.get_secret_value())
-
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
         logger.debug("Created {}", self.__class__.__name__)
-        return self
 
     def answer_question(self, question: str, context: Collection[Chunk]) -> str:
         """Generate a response using OpenAI’s API with retrieved context.
@@ -35,21 +34,22 @@ class LanguageModelService(BaseModel):
             str: Generated answer
         """
         logger.debug("Generating response for question “{}” using {} context chunks…", question, len(context))
-        messages = [
-            {"role": "system", "content": self.settings.SYSTEM_PROMPT},
-            {"role": "user", "content": 
-                f"""Student Question: {question}
-
-                Context from class materials and transcripts:
-                {'\n'.join(chunk.text for chunk in context)}
-
-                Please answer the Student Question based on the Context from class materials and transcripts. If the context doesn’t contain relevant information, acknowledge that and suggest asking the professor."""}
-        ]
-        response: ChatCompletion = self._open_ai_client.chat.completions.create(
-            model=self.settings.CHAT_MODEL,
-            messages=messages,
-            max_tokens=self.settings.MAX_TOKENS,
-            temperature=self.settings.TEMPERATURE
-        )
+        # messages = [
+        #     {"role": "system", "content": self.settings.SYSTEM_PROMPT},
+        #     {"role": "user", "content": 
+        #         f"""Student Question: {question}
+
+        #         Context from class materials and transcripts:
+        #         {'\n'.join(chunk.text for chunk in context)}
+
+        #         Please answer the Student Question based on the Context from class materials and transcripts. If the context doesn’t contain relevant information, acknowledge that and suggest asking the professor."""}
+        # ]
+        # response: ChatCompletion = self._open_ai_client.chat.completions.create(
+        #     model=self.settings.CHAT_MODEL,
+        #     messages=messages,
+        #     max_tokens=self.settings.MAX_TOKENS,
+        #     temperature=self.settings.TEMPERATURE
+        # )
         
-        return response.choices[0].message.content
+        # return response.choices[0].message.content
+        return f"Mock response to “{question}”"

src/ctp_slack_bot/services/question_dispatch_service.py

@@ -1,6 +1,6 @@
 # from asyncio import create_task
 from loguru import logger
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 from typing import Self
 
 from ctp_slack_bot.core import Settings
@@ -21,11 +21,13 @@ class QuestionDispatchService(BaseModel):
     context_retrieval_service: ContextRetrievalService
     answer_retrieval_service: AnswerRetrievalService
 
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
-        logger.debug("Created {}", self.__class__.__name__)
+    class Config:
+        frozen=True
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
         self.event_brokerage_service.subscribe(EventType.INCOMING_SLACK_MESSAGE, self.__process_incoming_slack_message)
-        return self
+        logger.debug("Created {}", self.__class__.__name__)
 
     async def __process_incoming_slack_message(self: Self, message: SlackMessage) -> None:
         if message.subtype != 'bot_message':

src/ctp_slack_bot/services/schedule_service.py

@@ -0,0 +1,57 @@
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+from asyncio import create_task, iscoroutinefunction, to_thread
+from datetime import datetime
+from loguru import logger
+from pydantic import BaseModel, PrivateAttr
+from pytz import timezone
+from typing import Optional, Self
+
+from ctp_slack_bot.core import Settings
+
+class ScheduleService(BaseModel):
+    """
+    Service for running scheduled tasks.
+    """
+
+    settings: Settings
+    _scheduler: PrivateAttr
+
+    class Config:
+        frozen=True
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
+        zone = self.settings.SCHEDULER_TIMEZONE
+        self._configure_jobs()
+        self._scheduler = AsyncIOScheduler(timezone=timezone(zone))
+        logger.debug("Created {}", self.__class__.__name__)
+
+    def _configure_jobs(self: Self) -> None:
+        # Example jobs (uncomment and implement as needed)
+        # self._scheduler.add_job(
+        #     send_error_report,
+        #     CronTrigger(hour=7, minute=0),
+        #     id="daily_error_report",
+        #     name="Daily Error Report",
+        #     replace_existing=True,
+        # )
+        # self._scheduler.add_job(
+        #     cleanup_old_transcripts,
+        #     CronTrigger(day_of_week="sun", hour=1, minute=0),
+        #     id="weekly_transcript_cleanup",
+        #     name="Weekly Transcript Cleanup",
+        #     replace_existing=True,
+        # )
+        pass
+
+    def start(self: Self) -> None:
+        self._scheduler.start()
+        logger.info("Started scheduler.")
+
+    def stop(self: Self) -> None:
+        if self._scheduler.running:
+            self._scheduler.shutdown(wait=False)
+            logger.info("Shut down scheduler.")
+        else:
+            logger.debug("The scheduler is not running. There is no scheduler to shut down.")

src/ctp_slack_bot/services/slack_service.py

@@ -1,8 +1,9 @@
+from dependency_injector.resources import Resource
 from loguru import logger
 from openai import OpenAI
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 from slack_bolt.async_app import AsyncApp
-from typing import Any, Dict, Self
+from typing import Any, Mapping, Self
 
 from ctp_slack_bot.enums import EventType
 from ctp_slack_bot.models import SlackMessage, SlackResponse
@@ -19,14 +20,14 @@ class SlackService(BaseModel):
 
     class Config:
         arbitrary_types_allowed = True
+        frozen=True
 
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
         self.event_brokerage_service.subscribe(EventType.OUTGOING_SLACK_RESPONSE, self.send_message)
         logger.debug("Created {}", self.__class__.__name__)
-        return self
 
-    def adapt_event_payload(self: Self, event: Dict[str, Any]) -> SlackMessage:
+    def adapt_event_payload(self: Self, event: Mapping[str, Any]) -> SlackMessage:
         return SlackMessage(
             type=event.get("type"),
             subtype=event.get("subtype"),
@@ -40,10 +41,29 @@ class SlackService(BaseModel):
             event_ts=event.get("event_ts")
         )
 
-    async def process_message(self: Self, event: Dict[str, Any]) -> None:
+    async def process_message(self: Self, event: Mapping[str, Any]) -> None:
         slack_message = self.adapt_event_payload(event.get("event", {}))
         logger.debug("Received message from Slack: {}", slack_message)
         await self.event_brokerage_service.publish(EventType.INCOMING_SLACK_MESSAGE, slack_message)
 
     async def send_message(self: Self, message: SlackResponse) -> None:
         await self.slack_bolt_app.client.chat_postMessage(channel=message.channel, text=message.text, thread_ts=message.thread_ts)
+
+    async def handle_message_event(self: Self, body: Mapping[str, Any]) -> None:
+        logger.debug("Ignored regular message: {}", body.get("event", {}).get("text"))
+        # await self.process_message(body)
+
+    async def handle_app_mention_event(self: Self, body: Mapping[str, Any]) -> None:
+        logger.debug("Received app mention for processing: {}", body.get("event", {}).get("text"))
+        await self.process_message(body)
+
+    def register(self: Self) -> None:
+        self.slack_bolt_app.event("message")(self.handle_message_event)
+        self.slack_bolt_app.event("app_mention")(self.handle_app_mention_event)
+        logger.debug("Registered 2 handlers for Slack Bolt message and app mention events.")
+
+class SlackServiceResource(Resource):
+    def init(self: Self, event_brokerage_service: EventBrokerageService, slack_bolt_app: AsyncApp) -> SlackService:
+        slack_service = SlackService(event_brokerage_service=event_brokerage_service, slack_bolt_app=slack_bolt_app)
+        slack_service.register()
+        return slack_service

src/ctp_slack_bot/services/vector_database_service.py

@@ -1,5 +1,5 @@
 from loguru import logger
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 from typing import Any, Collection, Dict, List, Optional, Self, Sequence
 
 from ctp_slack_bot.core import Settings
@@ -13,12 +13,13 @@ class VectorDatabaseService(BaseModel): # TODO: this should not rely specificall
     settings: Settings
     mongo_db: MongoDB
 
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
+    class Config:
+        frozen=True
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
         logger.debug("Created {}", self.__class__.__name__)
-        return self
-    
-    # TODO: Weight cost of going all async.
+
     async def store(self: Self, chunks: Collection[VectorizedChunk]) -> None:
         """
         Stores vectorized chunks and their embedding vectors in the database.

src/ctp_slack_bot/services/vectorization_service.py

@@ -1,5 +1,5 @@
 from loguru import logger
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 from typing import Self, Sequence
 
 from ctp_slack_bot.core import Settings
@@ -14,10 +14,12 @@ class VectorizationService(BaseModel):
     settings: Settings
     embeddings_model_service: EmbeddingsModelService
 
-    @model_validator(mode='after')
-    def post_init(self: Self) -> Self:
+    class Config:
+        frozen=True
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
         logger.debug("Created {}", self.__class__.__name__)
-        return self
 
     def vectorize(self: Self, chunks: Sequence[Chunk]) -> Sequence[VectorizedChunk]:
         embeddings = self.embeddings_model_service.get_embeddings([chunk.text for chunk in chunks])

src/ctp_slack_bot/tasks/__init__.py

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

src/ctp_slack_bot/tasks/scheduler.py

@@ -1,60 +0,0 @@
-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.containers import Container
-
-@inject
-def start_scheduler(container: Container) -> AsyncIOScheduler:
-    """
-    Start and configure the APScheduler instance.
-    
-    Returns:
-        AsyncIOScheduler: Configured scheduler instance
-    """
-    settings = container.settings() if container else Provide[Container.settings]
-    zone = settings.SCHEDULER_TIMEZONE
-    scheduler = AsyncIOScheduler(timezone=timezone(zone))
-    
-    # Add jobs to the scheduler.
-    # scheduler.add_job(
-    #     send_error_report,
-    #     CronTrigger(hour=7, minute=0),
-    #     id="daily_error_report",
-    #     name="Daily Error Report",
-    #     replace_existing=True,
-    # )
-    # scheduler.add_job(
-    #     cleanup_old_transcripts,
-    #     CronTrigger(day_of_week="sun", hour=1, minute=0),
-    #     id="weekly_transcript_cleanup",
-    #     name="Weekly Transcript Cleanup",
-    #     replace_existing=True,
-    # )
-    
-    # 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)
-    
-    return scheduler
-
-
-def stop_scheduler(scheduler: AsyncIOScheduler) -> None:
-    """
-    Shutdown the scheduler gracefully.
-    
-    Args:
-        scheduler: The scheduler instance to shut down
-    """
-    if scheduler.running:
-        logger.info("Shutting down scheduler")
-        scheduler.shutdown(wait=False)
-        logger.info("Scheduler shutdown complete")