remove models update from migrations (#80)

* add bot models update script

* add last question at field

* update README.md

bot_microservice/core/bot/managment/update_gpt_models.py

@@ -0,0 +1,13 @@
+import asyncio
+import sys
+from pathlib import Path
+
+from loguru import logger
+
+if __name__ == "__main__":
+    sys.path.append(str(Path(__file__).parent.parent.parent.parent))
+    from core.bot.services import ChatGptService
+
+    chatgpt_service = ChatGptService.build()
+    asyncio.run(chatgpt_service.update_chatgpt_models())
+    logger.info("chatgpt models has been updated")

bot_microservice/core/bot/repository.py

@@ -38,6 +38,18 @@ class ChatGPTRepository:
         async with self.db.session() as session:
             await session.execute(query)
 
+    async def delete_all_chatgpt_models(self) -> None:
+        query = delete(ChatGptModels)
+        async with self.db.session() as session:
+            await session.execute(query)
+
+    async def bulk_insert_chatgpt_models(self, models_priority: list[dict[str, Any]]) -> None:
+        models = [ChatGptModels(**model_priority) for model_priority in models_priority]
+
+        async with self.db.session() as session:
+            session.add_all(models)
+            await session.commit()
+
     async def add_chatgpt_model(self, model: str, priority: int) -> dict[str, str | int]:
         query = (
             insert(ChatGptModels)

bot_microservice/core/bot/services.py

@@ -14,7 +14,7 @@ from speech_recognition import (
     UnknownValueError as SpeechRecognizerError,
 )
 
-from constants import AUDIO_SEGMENT_DURATION
+from constants import AUDIO_SEGMENT_DURATION, ChatGptModelsEnum
 from core.auth.models.users import User
 from core.auth.repository import UserRepository
 from core.auth.services import UserService
@@ -24,6 +24,77 @@ from infra.database.db_adapter import Database
 from settings.config import settings
 
 
+@dataclass
+class ChatGptService:
+    repository: ChatGPTRepository
+    user_service: UserService
+
+    @classmethod
+    def build(cls) -> "ChatGptService":
+        db = Database(settings=settings)
+        repository = ChatGPTRepository(settings=settings, db=db)
+        user_repository = UserRepository(db=db)
+        user_service = UserService(repository=user_repository)
+        return ChatGptService(repository=repository, user_service=user_service)
+
+    async def get_chatgpt_models(self) -> Sequence[ChatGptModels]:
+        return await self.repository.get_chatgpt_models()
+
+    async def request_to_chatgpt(self, question: str | None) -> str:
+        question = question or "Привет!"
+        chatgpt_model = await self.get_current_chatgpt_model()
+        return await self.repository.ask_question(question=question, chatgpt_model=chatgpt_model)
+
+    async def request_to_chatgpt_microservice(self, question: str) -> Response:
+        chatgpt_model = await self.get_current_chatgpt_model()
+        return await self.repository.request_to_chatgpt_microservice(question=question, chatgpt_model=chatgpt_model)
+
+    async def get_current_chatgpt_model(self) -> str:
+        return await self.repository.get_current_chatgpt_model()
+
+    async def change_chatgpt_model_priority(self, model_id: int, priority: int) -> None:
+        return await self.repository.change_chatgpt_model_priority(model_id=model_id, priority=priority)
+
+    async def update_chatgpt_models(self) -> None:
+        await self.repository.delete_all_chatgpt_models()
+        models = ChatGptModelsEnum.base_models_priority()
+        await self.repository.bulk_insert_chatgpt_models(models)
+
+    async def reset_all_chatgpt_models_priority(self) -> None:
+        return await self.repository.reset_all_chatgpt_models_priority()
+
+    async def add_chatgpt_model(self, gpt_model: str, priority: int) -> dict[str, str | int]:
+        return await self.repository.add_chatgpt_model(model=gpt_model, priority=priority)
+
+    async def delete_chatgpt_model(self, model_id: int) -> None:
+        return await self.repository.delete_chatgpt_model(model_id=model_id)
+
+    async def get_or_create_bot_user(
+        self,
+        user_id: int,
+        email: str | None = None,
+        username: str | None = None,
+        first_name: str | None = None,
+        last_name: str | None = None,
+        ban_reason: str | None = None,
+        is_active: bool = True,
+        is_superuser: bool = False,
+    ) -> User:
+        return await self.user_service.get_or_create_user_by_id(
+            user_id=user_id,
+            email=email,
+            username=username,
+            first_name=first_name,
+            last_name=last_name,
+            ban_reason=ban_reason,
+            is_active=is_active,
+            is_superuser=is_superuser,
+        )
+
+    async def update_bot_user_message_count(self, user_id: int) -> None:
+        await self.user_service.update_user_message_count(user_id)
+
+
 class SpeechToTextService:
     def __init__(self, filename: str) -> None:
         self.filename = filename
@@ -87,69 +158,3 @@ class SpeechToTextService:
                 except SpeechRecognizerError as error:
                     logger.error("error recognizing text with google", error=error)
                     raise
-
-
-@dataclass
-class ChatGptService:
-    repository: ChatGPTRepository
-    user_service: UserService
-
-    @classmethod
-    def build(cls) -> "ChatGptService":
-        db = Database(settings=settings)
-        repository = ChatGPTRepository(settings=settings, db=db)
-        user_repository = UserRepository(db=db)
-        user_service = UserService(repository=user_repository)
-        return ChatGptService(repository=repository, user_service=user_service)
-
-    async def get_chatgpt_models(self) -> Sequence[ChatGptModels]:
-        return await self.repository.get_chatgpt_models()
-
-    async def request_to_chatgpt(self, question: str | None) -> str:
-        question = question or "Привет!"
-        chatgpt_model = await self.get_current_chatgpt_model()
-        return await self.repository.ask_question(question=question, chatgpt_model=chatgpt_model)
-
-    async def request_to_chatgpt_microservice(self, question: str) -> Response:
-        chatgpt_model = await self.get_current_chatgpt_model()
-        return await self.repository.request_to_chatgpt_microservice(question=question, chatgpt_model=chatgpt_model)
-
-    async def get_current_chatgpt_model(self) -> str:
-        return await self.repository.get_current_chatgpt_model()
-
-    async def change_chatgpt_model_priority(self, model_id: int, priority: int) -> None:
-        return await self.repository.change_chatgpt_model_priority(model_id=model_id, priority=priority)
-
-    async def reset_all_chatgpt_models_priority(self) -> None:
-        return await self.repository.reset_all_chatgpt_models_priority()
-
-    async def add_chatgpt_model(self, gpt_model: str, priority: int) -> dict[str, str | int]:
-        return await self.repository.add_chatgpt_model(model=gpt_model, priority=priority)
-
-    async def delete_chatgpt_model(self, model_id: int) -> None:
-        return await self.repository.delete_chatgpt_model(model_id=model_id)
-
-    async def get_or_create_bot_user(
-        self,
-        user_id: int,
-        email: str | None = None,
-        username: str | None = None,
-        first_name: str | None = None,
-        last_name: str | None = None,
-        ban_reason: str | None = None,
-        is_active: bool = True,
-        is_superuser: bool = False,
-    ) -> User:
-        return await self.user_service.get_or_create_user_by_id(
-            user_id=user_id,
-            email=email,
-            username=username,
-            first_name=first_name,
-            last_name=last_name,
-            ban_reason=ban_reason,
-            is_active=is_active,
-            is_superuser=is_superuser,
-        )
-
-    async def update_bot_user_message_count(self, user_id: int) -> None:
-        await self.user_service.update_user_message_count(user_id)