First working Docker build and run

.dockerignore

@@ -46,7 +46,7 @@ coverage.xml
 
 # Environments
 .env
-.venv
+.venv/
 env/
 venv/
 ENV/

Dockerfile

@@ -13,13 +13,13 @@ RUN apt-get update \
  && apt-get clean \
  && rm -rf /var/lib/apt/lists/*
 
-# Copy project files.
-COPY pyproject.toml README.md ./
-COPY src/ ./src/
-
 # Install Python dependencies.
-RUN pip install --no-cache-dir --upgrade pip \
- && pip install --no-cache-dir .
+COPY pyproject.toml ./
+RUN pip install --no-cache-dir --upgrade pip
+
+# Copy project files and build.
+COPY src/ ./src/
+RUN pip install --no-cache-dir .
 
 # Create a non-root user and switch to it.
 RUN useradd -m appuser

pyproject.toml

@@ -20,6 +20,7 @@ classifiers = [
 ]
 dependencies = [
     "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0",
     "fastapi>=0.100.0",
     "uvicorn>=0.22.0",
     "loguru>=0.7.0",
@@ -27,6 +28,7 @@ dependencies = [
     "httpx>=0.24.1",
     "tenacity>=8.2.2",
     "pybreaker>=1.0.2",
+    "pytz>=2025.2",
     "apscheduler>=3.10.1",
     "slack-sdk>=3.21.3",
     "pymongo>=4.4.1",

src/ctp_slack_bot/api/main.py

@@ -0,0 +1,60 @@
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from loguru import logger
+
+from ctp_slack_bot.api.routes import router
+from ctp_slack_bot.core.config import settings
+from ctp_slack_bot.core.logging import setup_logging
+from ctp_slack_bot.tasks.scheduler import start_scheduler, stop_scheduler
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Lifespan context manager for FastAPI application.
+    Handles startup and shutdown events.
+    """
+    # Setup logging
+    #setup_logging()
+    logger.info("Starting application")
+    
+    # Start scheduler
+    #scheduler = start_scheduler()
+    #logger.info("Started scheduler")
+    
+    yield
+    
+    # Shutdown
+    logger.info("Shutting down application")
+    #stop_scheduler(scheduler)
+    #logger.info("Stopped scheduler")
+
+
+app = FastAPI(
+    title="CTP Slack Bot",
+    description="A Slack bot for processing and analyzing Zoom transcripts using AI",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+# Include routers
+app.include_router(router)
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    uvicorn.run(
+        "main:app",
+        host="localhost", #settings.API_HOST,
+        port="8000" #settings.API_PORT,
+        #reload=settings.DEBUG,
+    )

src/ctp_slack_bot/api/routes.py

@@ -0,0 +1,61 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+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
+
+router = APIRouter(prefix="/api/v1")
+
+
+# @router.post("/transcripts/analyze", response_model=TranscriptResponse)
+# async def analyze_transcript(
+#     request: TranscriptRequest,
+#     transcript_service: TranscriptService = Depends(get_transcript_service),
+# ):
+#     """
+#     Analyze a Zoom transcript and return insights.
+#     """
+#     logger.info(f"Analyzing transcript: {request.transcript_id}")
+#     try:
+#         result = await transcript_service.analyze_transcript(request)
+#         return result
+#     except Exception as e:
+#         logger.error(f"Error analyzing transcript: {e}")
+#         raise HTTPException(
+#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#             detail="Failed to analyze transcript",
+#         )
+
+
+# @router.post("/slack/message")
+# async def send_slack_message(
+#     channel: str,
+#     message: str,
+#     slack_service: SlackService = Depends(get_slack_service),
+# ):
+#     """
+#     Send a message to a Slack channel.
+#     """
+#     logger.info(f"Sending message to Slack channel: {channel}")
+#     try:
+#         result = await slack_service.send_message(channel, message)
+#         return {"status": "success", "message_ts": result.get("ts")}
+#     except Exception as e:
+#         logger.error(f"Error sending Slack message: {e}")
+#         raise HTTPException(
+#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#             detail="Failed to send Slack message",
+#         )
+
+
+# @router.post("/slack/webhook", include_in_schema=False)
+# async def slack_webhook(
+#     slack_service: SlackService = Depends(get_slack_service),
+# ):
+#     """
+#     Webhook endpoint for Slack events.
+#     """
+#     # This would typically handle Slack verification and event processing
+#     return {"challenge": "challenge_token"}

src/ctp_slack_bot/core/config.py

@@ -0,0 +1,58 @@
+from functools import lru_cache
+from typing import Literal, Optional
+
+from pydantic import Field, SecretStr, validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    Application settings loaded from environment variables.
+    """
+    # API Configuration
+    API_HOST: str = "0.0.0.0"
+    API_PORT: int = 8000
+    DEBUG: bool = False
+    
+    # MongoDB Configuration
+    MONGODB_URI: Optional[SecretStr] = None # TODO: Remove optionality
+    MONGODB_DB_NAME: str = "ctp_slack_bot"
+    
+    # Slack Configuration
+    SLACK_BOT_TOKEN: Optional[SecretStr] = None # TODO: Remove optionality
+    SLACK_SIGNING_SECRET: Optional[SecretStr] = None # TODO: Remove optionality
+    SLACK_APP_TOKEN: Optional[SecretStr] = None
+    
+    # Hugging Face Configuration
+    HF_API_TOKEN: Optional[SecretStr] = None
+    
+    # Logging Configuration
+    LOG_LEVEL: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
+    LOG_FORMAT: Literal["text", "json"] = "json"
+    
+    # APScheduler Configuration
+    SCHEDULER_TIMEZONE: str = "UTC"
+    
+    @validator("MONGODB_URI")
+    def validate_mongodb_uri(cls, v):
+        """Validate MongoDB URI format"""
+        #if not v.get_secret_value().startswith("mongodb"):
+        #    raise ValueError("MONGODB_URI must be a valid MongoDB connection string")
+        return v
+    
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=True,
+    )
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """
+    Get cached settings instance.
+    """
+    return Settings()
+
+
+settings = get_settings()

src/ctp_slack_bot/core/logging.py

@@ -0,0 +1,102 @@
+import logging
+import sys
+from typing import Dict, Union
+
+from loguru import logger
+
+from ctp_slack_bot.core.config import settings
+
+
+class InterceptHandler(logging.Handler):
+    """
+    Intercept standard logging messages toward Loguru.
+    
+    This handler intercepts all standard logging messages and redirects them
+    to Loguru, allowing unified logging across the application.
+    """
+    
+    def emit(self, record: logging.LogRecord) -> None:
+        # Get corresponding Loguru level if it exists
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            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 = frame.f_back
+            depth += 1
+        
+        logger.opt(depth=depth, exception=record.exc_info).log(
+            level, record.getMessage()
+        )
+
+
+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.
+    """
+    # Remove default loguru handler
+    logger.remove()
+    
+    # Determine log format
+    if settings.LOG_FORMAT == "json":
+        log_format = {
+            "time": "{time:YYYY-MM-DD HH:mm:ss.SSS}",
+            "level": "{level}",
+            "message": "{message}",
+            "module": "{module}",
+            "function": "{function}",
+            "line": "{line}",
+        }
+        format_string = lambda record: record["message"]
+    else:
+        format_string = (
+            "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+            "<level>{level: <8}</level> | "
+            "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
+            "<level>{message}</level>"
+        )
+    
+    # Add console handler
+    logger.add(
+        sys.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(
+            "logs/app.log",
+            rotation="10 MB",
+            retention="1 week",
+            compression="zip",
+            format=format_string,
+            level=settings.LOG_LEVEL,
+            serialize=(settings.LOG_FORMAT == "json"),
+        )
+    
+    # Intercept standard logging messages
+    logging.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)
+    
+    logger.info(f"Logging configured with level {settings.LOG_LEVEL}")

src/ctp_slack_bot/tasks/scheduler.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+from typing import Optional
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+from loguru import logger
+from pytz import timezone
+
+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
+
+
+def start_scheduler() -> AsyncIOScheduler:
+    """
+    Start and configure the APScheduler instance.
+    
+    Returns:
+        AsyncIOScheduler: Configured scheduler instance
+    """
+    scheduler = AsyncIOScheduler(timezone=timezone(settings.SCHEDULER_TIMEZONE))
+    
+    # Add jobs to the scheduler
+    
+    # Daily error report at 7 AM
+    # scheduler.add_job(
+    #     send_error_report,
+    #     CronTrigger(hour=7, minute=0),
+    #     id="daily_error_report",
+    #     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),
+    #     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: Optional[AsyncIOScheduler] = None) -> None:
+    """
+    Shutdown the scheduler gracefully.
+    
+    Args:
+        scheduler: The scheduler instance to shut down
+    """
+    if scheduler is not None and scheduler.running:
+        logger.info("Shutting down scheduler")
+        scheduler.shutdown(wait=False)
+        logger.info("Scheduler shutdown complete")