removed stiffs related to fast api app as this repo will only have lightning and pytorch

app/api/chat.py

@@ -1,45 +0,0 @@
-from fastapi import APIRouter, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.schemas.chat import ChatMessage, ChatResponse
-from app.crud.chat_crud import create_chat_message
-from app.tasks.chat_task import process_chat_message
-from src.number_manipulation import add_random_number
-from app.db.database import get_db
-from aiocache import caches
-
-router = APIRouter()
-
-
-@router.post("/chat", response_model=ChatResponse)
-async def chat(message: ChatMessage, db: AsyncSession = Depends(get_db)):
-    cache = caches.get("default")
-    cache_key = f"chat:{message.user_input}:{message.content}"
-
-    # Attempt to retrieve the cached response
-    cached_response = await cache.get(cache_key)
-    if cached_response:
-        return ChatResponse(**cached_response)
-
-    # Process user input if not cached
-    processed_value = add_random_number(message.user_input)
-    message_id = await create_chat_message(
-        db=db,
-        content=message.content,
-        user_input=message.user_input,
-        processed_value=processed_value,
-    )
-
-    # Trigger background task
-    process_chat_message.delay(message.content)
-
-    # Prepare the response data
-    response_data = {
-        "message_id": message_id,
-        "status": "Message received",
-        "processed_value": processed_value,
-    }
-
-    # Cache the response data
-    await cache.set(cache_key, response_data, ttl=300)  # Cache for 5 minutes
-
-    return ChatResponse(**response_data)

app/core/celery_app.py

@@ -1,8 +0,0 @@
-from celery import Celery
-from app.core.config import settings
-
-celery_app = Celery("chat_tasks", broker=settings.redis_url, backend=settings.redis_url)
-
-celery_app.conf.update(
-    task_serializer="json", result_serializer="json", accept_content=["json"]
-)

app/core/config.py

@@ -1,42 +0,0 @@
-import os
-from pydantic.v1 import BaseSettings, Field
-from loguru import logger
-
-
-class Settings(BaseSettings):
-    POSTGRES_DB: str = Field("test_db", env="POSTGRES_DB")
-    POSTGRES_USER: str = Field("test_user", env="POSTGRES_USER")
-    POSTGRES_PASSWORD: str = Field("test_pass", env="POSTGRES_PASSWORD")
-
-    is_docker: bool = Field(default_factory=lambda: os.environ.get("DOCKER_ENV") == "1")
-
-    database_url: str = Field(..., env="DATABASE_URL")
-    redis_url: str = Field(..., env="REDIS_URL")
-    flower_basic_auth: str = Field(..., env="FLOWER_BASIC_AUTH")
-    broker_url: str = Field(..., env="BROKER_URL")
-    cache_backend: str = "aiocache.SimpleMemoryCache"
-
-    class Config:
-        env_file = ".env"
-
-    @classmethod
-    def create(cls):
-        """Create instance and dynamically set database and redis URLs."""
-        instance = cls()
-        # Set the correct database URL without the +asyncpg
-        instance.database_url = (
-            f"postgresql+asyncpg://{instance.POSTGRES_USER}:{instance.POSTGRES_PASSWORD}@"
-            f"{'localhost' if not instance.is_docker else 'postgres'}:5432/{instance.POSTGRES_DB}"
-        )
-        instance.redis_url = (
-            f"redis://{'localhost' if not instance.is_docker else 'redis'}:6379/0"
-        )
-        instance.broker_url = instance.redis_url
-        return instance
-
-
-# Instantiate Settings
-settings = Settings.create()
-
-if __name__ == "__main__":
-    logger.info(f"Settings: {settings.dict()}")

app/crud/chat_crud.py

@@ -1,14 +0,0 @@
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.db.models import ChatMessageModel
-
-
-async def create_chat_message(
-    db: AsyncSession, content: str, user_input: int, processed_value: int
-):
-    new_message = ChatMessageModel(
-        content=content, user_input=user_input, processed_value=processed_value
-    )
-    db.add(new_message)
-    await db.commit()
-    await db.refresh(new_message)  # Fetches the latest state after commit
-    return new_message.id

app/db/database.py

@@ -1,17 +0,0 @@
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import sessionmaker, declarative_base
-from app.core.config import settings
-
-# Create an async engine
-engine = create_async_engine(settings.database_url, echo=True)
-
-# Async session factory
-SessionLocal = sessionmaker(bind=engine, class_=AsyncSession, expire_on_commit=False)
-
-Base = declarative_base()
-
-
-# Dependency for asynchronous database session
-async def get_db():
-    async with SessionLocal() as session:
-        yield session

app/db/models.py

@@ -1,12 +0,0 @@
-from sqlalchemy import Column, Integer, String, DateTime, func
-from app.db.database import Base
-
-
-class ChatMessageModel(Base):
-    __tablename__ = "chat_messages"
-
-    id = Column(Integer, primary_key=True, index=True)
-    content = Column(String, nullable=False)
-    user_input = Column(Integer, nullable=False)
-    processed_value = Column(Integer, nullable=False)
-    timestamp = Column(DateTime, server_default=func.now())

app/schemas/chat.py

@@ -1,12 +0,0 @@
-from pydantic import BaseModel
-
-
-class ChatMessage(BaseModel):
-    content: str
-    user_input: int
-
-
-class ChatResponse(BaseModel):
-    message_id: int
-    status: str
-    processed_value: int

app/tasks/chat_task.py

@@ -1,6 +0,0 @@
-from app.core.celery_app import celery_app
-
-
-@celery_app.task
-def process_chat_message(content: str):
-    print(f"Processing message: {content}")

src/number_manipulation.py

@@ -1,7 +0,0 @@
-import random
-
-
-def add_random_number(user_input: int) -> int:
-    random_addition = random.randint(1, 100)  # Add a random number between 1 and 100
-    result = user_input + random_addition
-    return result

src/test_infra.py

@@ -1,36 +0,0 @@
-import asyncpg
-import aioredis
-from loguru import logger
-from app.core.config import settings
-
-
-async def test_postgres_connection(database_url: str):
-    try:
-        conn = await asyncpg.connect(database_url)
-        logger.info("Successfully connected to PostgreSQL!")
-        await conn.close()
-    except Exception as e:
-        logger.error(f"Failed to connect to PostgreSQL: {e}")
-
-
-async def test_redis_connection(redis_url: str):
-    try:
-        redis = await aioredis.from_url(redis_url)
-        await redis.ping()  # Send a ping to check connection
-        logger.info("Successfully connected to Redis!")
-        await redis.close()
-    except Exception as e:
-        logger.error(f"Failed to connect to Redis: {e}")
-
-
-async def main():
-    logger.info(f"Settings: {settings.dict()}")
-
-    await test_postgres_connection(settings.database_url.replace("+asyncpg", ""))
-    await test_redis_connection(settings.redis_url)
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    asyncio.run(main())

tests/test_db_connection.py

@@ -1,17 +0,0 @@
-import pytest
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import text
-from app.db.database import get_db
-
-
-@pytest.mark.asyncio
-async def test_database_connection():
-    # Use the get_db dependency directly for testing
-    async for session in get_db():
-        assert isinstance(
-            session, AsyncSession
-        ), "Session is not an instance of AsyncSession"
-
-        # Check if the session can execute a simple query
-        result = await session.execute(text("SELECT 1"))
-        assert result.scalar() == 1, "Database did not return expected result"