feat: conversation/completion_id api implementation completed

app/api/chat_api.py

@@ -145,7 +145,7 @@ async def retrieve_plot(
 
 
 # get all conversations
-@router.get("/conversations", response_model=ConversationResponse, response_model_exclude_none=True) 
+@router.get("/conversations", response_model=ConversationResponse, response_model_exclude_none=True)
 async def list_conversations(
     request: Request,
     username: str = Depends(auth_service.verify_credentials),
@@ -155,7 +155,7 @@ async def list_conversations(
     """
     logger.debug(f"Listing conversations for username: {username}")
     try:
-        return await service.find_all_conversations(username) 
+        return await service.find_all_conversations(username)
     except Exception as e:
         logger.error(f"Error in list_conversations: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))

app/config/security_config.py

@@ -16,6 +16,7 @@ class SecurityConfig(BaseSettings):
     ENABLED: bool = True
     DEFAULT_USERNAME: str = "admin"
 
+
 @lru_cache()
 def get_security_config() -> SecurityConfig:
-    return SecurityConfig() 
+    return SecurityConfig()

app/core/api_response.py

@@ -16,6 +16,7 @@ MOCK_DIR = env.str("MOCK_DIR", "resources/mock")
 # Deprecated code. because we are using mongomock-motor for database_type=embedded
 # TODO: remove this code after we switch to real database
 
+
 def url_to_filename(url: str, method: str) -> str:
     """
     Convert API URL to mock filename.

app/core/initial_setup/setup.py

@@ -37,7 +37,7 @@ class InitialSetup:
             if db_config.DATABASE_TYPE != "embedded":
                 logger.info("Skipping initial setup as database type is not embedded")
                 return
-            
+
             # if MONGO_URI is not set, it means we are using embedded database
             # last check is for the case of using mongomock-motor for database_type=embedded
             # so last exit before the bridge :) turkish joke
@@ -46,24 +46,24 @@ class InitialSetup:
                 logger.warning("Deleting all chat completions in the embedded database")
                 await self.chat_repository.db.chat_completion.delete_many({})
                 logger.warning("Deleting all chat completions in the embedded database done")
-            
+
             chat_completions = self._load_initial_data()
             logger.info(f"Loaded {len(chat_completions)} initial chat completions")
-            
+
             for completion in chat_completions:
                 try:
                     found_id = await self.chat_repository.find_by_id(completion.completion_id)
                     if found_id:
                         logger.debug(f"Chat completion already exists: {found_id}")
                         continue
-                        
+
                     saved = await self.chat_repository.save(completion)
                     logger.info(f"Successfully saved chat completion: {saved.completion_id}")
-                    
+
                 except Exception as e:
                     logger.error(f"Error saving chat completion {completion.completion_id}: {e}")
                     raise
-                
+
         except Exception as e:
             logger.error(f"Setup failed: {e}")
             raise

app/mapper/base_mapper.py

@@ -1,26 +1,27 @@
 from abc import ABC, abstractmethod
 from typing import TypeVar, Generic, List
 
-T = TypeVar('T')
-U = TypeVar('U')
+T = TypeVar("T")
+U = TypeVar("U")
+
 
 class BaseMapper(Generic[T, U], ABC):
     """Base mapper class for mapping between model and schema objects."""
-    
+
     @abstractmethod
     def to_schema(self, model: T) -> U:
         """Map from model to schema."""
         pass
-    
+
     @abstractmethod
     def to_model(self, schema: U) -> T:
         """Map from schema to model."""
         pass
-    
+
     def to_schema_list(self, models: List[T]) -> List[U]:
         """Map a list of models to schemas."""
         return [self.to_schema(model) for model in models]
-    
+
     def to_model_list(self, schemas: List[U]) -> List[T]:
         """Map a list of schemas to models."""
-        return [self.to_model(schema) for schema in schemas] 
+        return [self.to_model(schema) for schema in schemas]

app/mapper/conversation_mapper.py

@@ -10,9 +10,6 @@ class ConversationMapper(BaseMapper[ChatCompletion, ConversationItemResponse]):
 
     def to_schema(self, model: ChatCompletion) -> ConversationItemResponse:
         """Convert ChatCompletion model to ConversationItem schema."""
-        # Convert datetime to Unix timestamp
-        created_timestamp = int(model.created_date.timestamp()) if model.created_date else None
-        last_updated_timestamp = int(model.last_updated_date.timestamp()) if model.last_updated_date else None
 
         # Get the first message content as title if title is not set
         title = model.title
@@ -23,8 +20,8 @@ class ConversationMapper(BaseMapper[ChatCompletion, ConversationItemResponse]):
         return ConversationItemResponse(
             completion_id=model.completion_id,
             title=title,
-            create_time=created_timestamp,
-            update_time=last_updated_timestamp,
+            create_time=model.created_date,
+            update_time=model.last_updated_date,
             is_archived=model.is_archived,
             is_starred=model.is_starred,
         )

app/model/chat_model.py

@@ -84,12 +84,13 @@ class ChatCompletion(BaseModel):
     """
     A chat completion.
     """
+
     id: Optional[ObjectId] = Field(alias="_id", default_factory=ObjectId, description="MongoDB unique identifier")
     completion_id: Optional[str] = Field(None, description="The unique identifier for the chat completion")
 
     # openai compatible fields
     model: Optional[str] = Field(None, description="The model used for the chat completion", examples=["gpt-4o-mini", "gpt-4o", "gpt-3.5-turbo"])
-    messages: List[ChatMessage] = Field(..., description="The messages in the chat completion")
+    messages: Optional[List[ChatMessage]] = Field(None, description="The messages in the chat completion")
 
     # not implemented yet
     # temperature: float = Field(default=0.7,ge=0.0, le=1.0, description="What sampling temperature to use, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.")
@@ -121,14 +122,10 @@ class ChatCompletion(BaseModel):
         description="The date and time the chat completion was last updated",
     )
 
-
-    class Config():
+    class Config:
         populate_by_name = True
         arbitrary_types_allowed = True
-        json_encoders = {
-            ObjectId: lambda o: str(o),
-            datetime: lambda o: o.isoformat()
-        }
+        json_encoders = {ObjectId: lambda o: str(o), datetime: lambda o: o.isoformat()}
 
     def __str__(self):
         return f"""

app/repository/chat_repository.py

@@ -9,10 +9,13 @@ import pymongo
 
 class DocumentNotFoundError(Exception):
     """Raised when a document is not found in the database."""
+
     pass
 
+
 # TODO: llm_model, llm_provider will come from .env file
 
+
 class ChatRepository:
     def __init__(self):
         logger.info("Initializing ChatRepository")
@@ -33,13 +36,13 @@ class ChatRepository:
             Exception: If the chat completion is not created
         """
         logger.info(f"Creating new chat completion for user: {entity.created_by}")
-        
+
         entity.completion_id = str(uuid.uuid4()) if entity.completion_id is None else entity.completion_id
-        entity_dict = entity.model_dump(by_alias=True) 
+        entity_dict = entity.model_dump(by_alias=True)
 
         # MongoDB'ye kaydet
         insert_result = await self.db.chat_completion.insert_one(entity_dict)
-        
+
         if not insert_result.inserted_id:
             logger.error(f"Failed to create new chat completion with ID: {entity.completion_id}")
             raise Exception(f"Failed to create chat completion with ID: {entity.completion_id}")
@@ -50,13 +53,13 @@ class ChatRepository:
     async def _update(self, entity: ChatCompletion) -> ChatCompletion:
         """
         Update an existing chat completion in the database.
-        
+
         Args:
             entity (ChatCompletion): The chat completion entity to update
-            
+
         Returns:
             ChatCompletion: The updated chat completion
-            
+
         Raises:
             ValueError: If completion_id is not provided
             DocumentNotFoundError: If the document to update is not found
@@ -65,37 +68,34 @@ class ChatRepository:
             raise ValueError("Cannot update chat completion without completion_id")
 
         logger.info(f"Updating chat completion with ID: {entity.completion_id}")
-        
+
         # these fields are not updatable
         non_updatable_fields = {"created_date", "created_by", "completion_id"}
-        
+
         # get the model data and remove the non-updatable fields
-        update_payload = {
-            k: v for k, v in entity.model_dump(by_alias=True).items() 
-            if k not in non_updatable_fields
-        }
-        
+        update_payload = {k: v for k, v in entity.model_dump(by_alias=True).items() if k not in non_updatable_fields}
+
         if not update_payload:
             logger.warning(f"No updatable fields found for chat completion ID: {entity.completion_id}")
             return await self.find_by_id(entity.completion_id)
-        
+
         query = {"completion_id": entity.completion_id}
         update = {"$set": update_payload}
-        
+
         try:
             result = await self.db.chat_completion.update_one(query, update)
-            
+
             if result.matched_count == 0:
                 logger.error(f"Chat completion with ID {entity.completion_id} not found for update")
                 raise DocumentNotFoundError(f"Chat completion with ID {entity.completion_id} not found")
-                
+
             if result.modified_count == 0:
                 logger.info(f"Chat completion with ID {entity.completion_id} matched but not modified")
             else:
                 logger.info(f"Successfully updated chat completion with ID: {entity.completion_id}")
-                
+
             return await self.find_by_id(entity.completion_id)
-            
+
         except Exception as e:
             logger.error(f"Error updating chat completion with ID {entity.completion_id}: {str(e)}")
             raise
@@ -106,9 +106,8 @@ class ChatRepository:
         it will be updated. Otherwise, a new chat completion will be created.
         """
         logger.debug(f"BEGIN REPO: save chat completion. username: {entity.created_by}, completion_id: {entity.completion_id}")
-        
-        try:
 
+        try:
             result = await self.find_by_id(entity.completion_id)
             if result:
                 return await self._update(entity)
@@ -156,8 +155,8 @@ class ChatRepository:
         Example : completion_id = "123"
         """
         logger.debug(f"BEGIN REPO: find chat completion by id. input parameters: completion_id: {completion_id}, projection: {projection}")
-
-        entity_doc = await self.db.chat_completion.find_one({"completion_id": completion_id}, projection)
+        query = {"completion_id": completion_id}
+        entity_doc = await self.db.chat_completion.find_one(query, projection)
 
         if entity_doc:
             logger.trace(f"REPO find_by_id. Found entity_doc: {entity_doc}")

app/security/auth_service.py

@@ -12,12 +12,12 @@ api_key_header = APIKeyHeader(
     name="Authorization",
     scheme_name="ApiKeyAuth",
     description="API key in the format: sk-{username}-{base64_encoded_data}",
-    auto_error=False  # API key olmadığında otomatik hata vermesini engelle
+    auto_error=False,  # API key olmadığında otomatik hata vermesini engelle
 )
 
 
 class AuthService:
-    def __init__(self): 
+    def __init__(self):
         self.api_key_header = api_key_header
         self.security_config = get_security_config()
 
@@ -87,20 +87,20 @@ class AuthService:
                 detail=f"Invalid API key: {str(e)}",
             )
 
-    async def verify_credentials(self, api_key: str =  Security(api_key_header)) -> str:
+    async def verify_credentials(self, api_key: str = Security(api_key_header)) -> str:
         """Verify API key and extract username."""
         logger.trace(f"BEGIN: api_key: {api_key}")
-        
+
         if not self.security_config.ENABLED:
             logger.info("Security is disabled, using default username: " + self.security_config.DEFAULT_USERNAME)
             return self.security_config.DEFAULT_USERNAME
-        
+
         if not api_key:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
                 detail="API key is required when security is enabled",
             )
-            
+
         username = self.decode_api_key(api_key)
         result = username
         logger.trace(f"END: result: {result}")

app/service/chat_service.py

@@ -1,13 +1,8 @@
 import datetime
 from typing import List
 from app.repository.chat_repository import ChatRepository
-from app.schema.chat_schema import (
-    ChatCompletionRequest,
-    ChatCompletionResponse,
-    ChoiceResponse,
-    MessageResponse,
-)
-from app.model.chat_model import ChatCompletion, ChatMessage
+from app.schema.chat_schema import ChatCompletionRequest, ChatCompletionResponse
+from app.model.chat_model import ChatMessage
 from app.mapper.chat_mapper import ChatMapper
 from app.mapper.conversation_mapper import ConversationMapper
 import uuid
@@ -28,7 +23,7 @@ class ChatService:
 
         # Convert request to model
         entity = self.chat_mapper.to_model(request)
-        
+
         if entity.completion_id:
             entity.completion_id = str(uuid.uuid4())
             entity.created_by = username
@@ -65,10 +60,16 @@ class ChatService:
         result = self.conversation_mapper.to_schema_list(entities)
         return ConversationResponse(items=result, total=len(result), limit=100, offset=0)
 
-
-
     async def find_conversation_by_id(self, completion_id: str) -> ConversationResponse:
         """Find a conversation by its completion ID."""
-        entity = await self.chat_repository.find_by_id(completion_id)
-        result = self.conversation_mapper.to_schema(entity) if entity else None
-        return ConversationResponse(items=[result], total=1, limit=1, offset=0)
+        logger.debug(f"BEGIN SERVICE: find_conversation_by_id for completion_id: {completion_id}")
+        projection = {"messages": 0, "_id": 0}
+        entity = await self.chat_repository.find_by_id(completion_id, projection=projection)
+        logger.debug(f"END SERVICE: find_conversation_by_id for completion_id: {completion_id}, entity: {entity}")
+
+        if entity:
+            # Tekil kayıt için doğrudan dönüşüm yapıyoruz
+            result = self.conversation_mapper.to_schema(entity)
+            return result
+        else:
+            return None