py-aidol 0.3.0__tar.gz → 0.5.0__tar.gz

{py_aidol-0.3.0 → py_aidol-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-aidol
-Version: 0.3.0
+Version: 0.5.0
 Summary: Create and chat with your own AI idol group
 License: Apache-2.0
 Keywords: kpop,idol,aidol,ai-companion,chatbot,image-generation
@@ -16,6 +16,9 @@ Requires-Dist: aioia-core (>=2.2.0,<3.0.0)
 Requires-Dist: fastapi (>=0.115.12,<0.116.0)
 Requires-Dist: google-genai (>=1.60.0,<2.0.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: langchain-core (>=0.3.0)
+Requires-Dist: langchain-openai (>=0.3.0)
+Requires-Dist: litellm (>=1.60.0)
 Requires-Dist: openai (>=1.0.0)
 Requires-Dist: pillow (>=10.0.0,<11.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
@@ -34,7 +37,7 @@ AI 아이돌 그룹 생성 및 채팅 Python 패키지
 ## 주요 기능
 
 - AI 아이돌 그룹/멤버 CRUD
-- DALL-E 3 이미지 생성 (엠블럼, 프로필)
+- Google Gemini 이미지 생성 (엠블럼, 프로필)
 - 텍스트 채팅 (페르소나 기반 응답)
 - Buppy 통합 Adapter 패턴
 
@@ -62,7 +65,7 @@ from aidol.factories import AIdolRepositoryFactory, CompanionRepositoryFactory
 # AIdol 라우터
 aidol_router = AIdolRouter(
     repository_factory=AIdolRepositoryFactory(),
-    openai_settings=openai_settings,
+    google_settings=google_settings,
     image_storage=image_storage,
 )
 
@@ -87,11 +90,27 @@ make format
 
 ## 환경 변수
 
-### 필수 (이미지 생성 시)
+### 이미지 생성 인증 (선택, ADC 지원)
 
 | 변수 | 설명 |
 |------|------|
-| `OPENAI_API_KEY` | OpenAI API 키 |
+| `GOOGLE_API_KEY` | Google API 키 (Google AI API) |
+| `GOOGLE_CLOUD_PROJECT` | GCP 프로젝트 ID (Vertex AI) |
+
+**인증 방법:**
+
+**Option 1: Google AI API (API Key)**
+```bash
+export GOOGLE_API_KEY=your-api-key
+```
+
+**Option 2: Vertex AI (ADC)**
+```bash
+export GOOGLE_CLOUD_PROJECT=your-project-id
+gcloud auth application-default login  # 로컬 개발
+```
+
+> **참고**: Vertex AI 사용 시 `location=global`이 하드코딩되어 있습니다 (Gemini 이미지 생성 모델 요구사항).
 
 ### 선택
 
@@ -106,7 +125,8 @@ make format
 
 - aioia-core (공통 인프라)
 - FastAPI, SQLAlchemy, Pydantic
-- OpenAI (이미지 생성, 채팅)
+- Google Generative AI (이미지 생성)
+- OpenAI (채팅)
 - Pillow (이미지 처리)
 
 ## 라이선스

{py_aidol-0.3.0 → py_aidol-0.5.0}/README.md

@@ -5,7 +5,7 @@ AI 아이돌 그룹 생성 및 채팅 Python 패키지
 ## 주요 기능
 
 - AI 아이돌 그룹/멤버 CRUD
-- DALL-E 3 이미지 생성 (엠블럼, 프로필)
+- Google Gemini 이미지 생성 (엠블럼, 프로필)
 - 텍스트 채팅 (페르소나 기반 응답)
 - Buppy 통합 Adapter 패턴
 
@@ -33,7 +33,7 @@ from aidol.factories import AIdolRepositoryFactory, CompanionRepositoryFactory
 # AIdol 라우터
 aidol_router = AIdolRouter(
     repository_factory=AIdolRepositoryFactory(),
-    openai_settings=openai_settings,
+    google_settings=google_settings,
     image_storage=image_storage,
 )
 
@@ -58,11 +58,27 @@ make format
 
 ## 환경 변수
 
-### 필수 (이미지 생성 시)
+### 이미지 생성 인증 (선택, ADC 지원)
 
 | 변수 | 설명 |
 |------|------|
-| `OPENAI_API_KEY` | OpenAI API 키 |
+| `GOOGLE_API_KEY` | Google API 키 (Google AI API) |
+| `GOOGLE_CLOUD_PROJECT` | GCP 프로젝트 ID (Vertex AI) |
+
+**인증 방법:**
+
+**Option 1: Google AI API (API Key)**
+```bash
+export GOOGLE_API_KEY=your-api-key
+```
+
+**Option 2: Vertex AI (ADC)**
+```bash
+export GOOGLE_CLOUD_PROJECT=your-project-id
+gcloud auth application-default login  # 로컬 개발
+```
+
+> **참고**: Vertex AI 사용 시 `location=global`이 하드코딩되어 있습니다 (Gemini 이미지 생성 모델 요구사항).
 
 ### 선택
 
@@ -77,7 +93,8 @@ make format
 
 - aioia-core (공통 인프라)
 - FastAPI, SQLAlchemy, Pydantic
-- OpenAI (이미지 생성, 채팅)
+- Google Generative AI (이미지 생성)
+- OpenAI (채팅)
 - Pillow (이미지 처리)
 
 ## 라이선스

{py_aidol-0.3.0 → py_aidol-0.5.0}/aidol/api/__init__.py

@@ -3,11 +3,14 @@ AIdol API routers
 """
 
 from aidol.api.aidol import AIdolRouter, create_aidol_router
+from aidol.api.chatroom import ChatroomRouter, create_chatroom_router
 from aidol.api.companion import CompanionRouter, create_companion_router
 
 __all__ = [
     "AIdolRouter",
+    "ChatroomRouter",
     "CompanionRouter",
     "create_aidol_router",
+    "create_chatroom_router",
     "create_companion_router",
 ]

{py_aidol-0.3.0 → py_aidol-0.5.0}/aidol/api/aidol.py

@@ -21,6 +21,7 @@ from aidol.protocols import (
     ImageStorageProtocol,
 )
 from aidol.schemas import AIdol, AIdolCreate, AIdolPublic, AIdolUpdate
+from aidol.settings import GoogleGenAISettings
 
 
 class AIdolCreateResponse(BaseModel):
@@ -41,11 +42,11 @@ class AIdolRouter(
 
     def __init__(
         self,
-        google_api_key: str | None,
+        google_settings: GoogleGenAISettings | None,
         image_storage: ImageStorageProtocol,
         **kwargs,
     ):
-        self.google_api_key = google_api_key
+        self.google_settings = google_settings
         self.image_storage = image_storage
         super().__init__(**kwargs)
 
@@ -55,7 +56,7 @@ class AIdolRouter(
         register_image_generation_route(
             router=self.router,
             resource_name=self.resource_name,
-            google_api_key=self.google_api_key,
+            google_settings=self.google_settings,
             image_storage=self.image_storage,
         )
 
@@ -142,7 +143,7 @@ class AIdolRouter(
 
 
 def create_aidol_router(
-    google_api_key: str | None,
+    google_settings: GoogleGenAISettings | None,
     db_session_factory: sessionmaker,
     repository_factory: AIdolRepositoryFactoryProtocol,
     image_storage: ImageStorageProtocol,
@@ -155,7 +156,7 @@ def create_aidol_router(
     Create AIdol router with dependency injection.
 
     Args:
-        google_api_key: Google API Key for image generation
+        google_settings: Google API settings (uses ADC if api_key is None)
         db_session_factory: Database session factory
         repository_factory: Factory implementing AIdolRepositoryFactoryProtocol
         image_storage: Image storage for permanent URLs
@@ -168,7 +169,7 @@ def create_aidol_router(
         FastAPI APIRouter instance
     """
     router = AIdolRouter(
-        google_api_key=google_api_key,
+        google_settings=google_settings,
         image_storage=image_storage,
         model_class=AIdol,
         create_schema=AIdolCreate,

py_aidol-0.5.0/aidol/api/chatroom.py

@@ -0,0 +1,325 @@
+"""
+Chatroom API router
+
+Implements BaseCrudRouter pattern for consistency with aioia-core patterns.
+"""
+
+from aioia_core.auth import UserInfoProvider
+from aioia_core.errors import ErrorResponse
+from aioia_core.fastapi import BaseCrudRouter
+from aioia_core.settings import JWTSettings, OpenAIAPISettings
+from fastapi import APIRouter, Depends, HTTPException, status
+from humps import camelize
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
+from pydantic import BaseModel, ConfigDict, Field
+from sqlalchemy.orm import Session, sessionmaker
+
+from aidol.context import MessageContextBuilder
+from aidol.protocols import (
+    ChatroomRepositoryFactoryProtocol,
+    ChatroomRepositoryProtocol,
+    CompanionRepositoryFactoryProtocol,
+)
+from aidol.providers.llm import OpenAILLMProvider
+from aidol.schemas import (
+    Chatroom,
+    ChatroomCreate,
+    ChatroomUpdate,
+    CompanionMessageCreate,
+    Message,
+    MessageCreate,
+    ModelSettings,
+    Persona,
+    SenderType,
+)
+from aidol.services import ResponseGenerationService
+from aidol.settings import Settings
+
+# Maximum number of messages to fetch for conversation history
+DEFAULT_HISTORY_LIMIT = 200
+
+
+class ChatroomSingleItemResponse(BaseModel):
+    """Single item response for chatroom."""
+
+    data: Chatroom
+
+
+class GenerateResponse(BaseModel):
+    """Response schema for generate_response endpoint."""
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=camelize)
+
+    message_id: str = Field(..., description="Message ID")
+    content: str = Field(..., description="AI response content")
+
+
+def _to_langchain_messages(messages: list[Message]) -> list[BaseMessage]:
+    """
+    Convert Message schemas to LangChain BaseMessage format.
+
+    Args:
+        messages: List of Message from repository.
+
+    Returns:
+        List of LangChain BaseMessage (HumanMessage or AIMessage).
+    """
+    result: list[BaseMessage] = []
+    for msg in messages:
+        if msg.sender_type == SenderType.USER:
+            result.append(HumanMessage(content=msg.content))
+        else:
+            result.append(AIMessage(content=msg.content))
+    return result
+
+
+class ChatroomRouter(
+    BaseCrudRouter[Chatroom, ChatroomCreate, ChatroomUpdate, ChatroomRepositoryProtocol]
+):
+    """
+    Chatroom router with custom message endpoints.
+
+    Extends BaseCrudRouter for consistent architecture pattern.
+    Disables default CRUD endpoints and provides custom message endpoints.
+    """
+
+    def __init__(
+        self,
+        model_settings: Settings,
+        openai_settings: OpenAIAPISettings,
+        companion_repository_factory: CompanionRepositoryFactoryProtocol,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.model_settings = model_settings
+        self.openai_settings = openai_settings
+        self.companion_repository_factory = companion_repository_factory
+
+    def _register_routes(self) -> None:
+        """Register routes (fancall pattern: public CRUD + message endpoints)"""
+        # Chatroom CRUD (public, no auth)
+        self._register_public_create_route()
+        self._register_public_get_route()
+
+        # Message endpoints (public)
+        self._register_get_messages_route()
+        self._register_send_message_route()
+        self._register_generate_response_route()
+
+    def _register_public_create_route(self) -> None:
+        """POST /{resource_name} - Create a chatroom (public, fancall pattern)"""
+
+        @self.router.post(
+            f"/{self.resource_name}",
+            response_model=ChatroomSingleItemResponse,
+            status_code=status.HTTP_201_CREATED,
+            summary="Create chatroom",
+            description="Create a new chatroom (public endpoint)",
+        )
+        async def create_chatroom(
+            request: ChatroomCreate,
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Create a new chatroom."""
+            created = repository.create(request)
+            return ChatroomSingleItemResponse(data=created)
+
+    def _register_public_get_route(self) -> None:
+        """GET /{resource_name}/{id} - Get a chatroom (public, fancall pattern)"""
+
+        @self.router.get(
+            f"/{self.resource_name}/{{item_id}}",
+            response_model=ChatroomSingleItemResponse,
+            status_code=status.HTTP_200_OK,
+            summary="Get chatroom",
+            description="Get chatroom by ID (public endpoint)",
+            responses={
+                404: {"model": ErrorResponse, "description": "Chatroom not found"},
+            },
+        )
+        async def get_chatroom(
+            item_id: str,
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Get chatroom by ID."""
+            chatroom = self._get_item_or_404(repository, item_id)
+            return ChatroomSingleItemResponse(data=chatroom)
+
+    def _register_get_messages_route(self) -> None:
+        """GET /{resource_name}/{id}/messages - Get messages from a chatroom"""
+
+        @self.router.get(
+            f"/{self.resource_name}/{{item_id}}/messages",
+            response_model=list[Message],
+            status_code=status.HTTP_200_OK,
+            summary="Get messages",
+            description="Get messages from a chatroom",
+        )
+        async def get_messages(
+            item_id: str,
+            limit: int = 100,
+            offset: int = 0,
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Get messages from a chatroom."""
+            return repository.get_messages_by_chatroom_id(
+                chatroom_id=item_id,
+                limit=limit,
+                offset=offset,
+            )
+
+    def _register_send_message_route(self) -> None:
+        """POST /{resource_name}/{id}/messages - Send a message to a chatroom"""
+
+        @self.router.post(
+            f"/{self.resource_name}/{{item_id}}/messages",
+            response_model=Message,
+            status_code=status.HTTP_201_CREATED,
+            summary="Send message",
+            description="Send a message to a chatroom",
+        )
+        async def send_message(
+            item_id: str,
+            request: MessageCreate,
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Send a message to a chatroom."""
+            # Verify chatroom exists
+            self._get_item_or_404(repository, item_id)
+
+            # Enforce sender_type as USER to prevent spoofing
+            request.sender_type = SenderType.USER
+
+            # Pass MessageCreate directly (aioia-core pattern)
+            return repository.add_message_to_chatroom(
+                chatroom_id=item_id,
+                message=request,
+            )
+
+    def _register_generate_response_route(self) -> None:
+        """POST /{resource_name}/{id}/companions/{companion_id}/response - Generate AI response"""
+
+        @self.router.post(
+            f"/{self.resource_name}/{{item_id}}/companions/{{companion_id}}/response",
+            response_model=GenerateResponse,
+            status_code=status.HTTP_201_CREATED,
+            summary="Generate AI response",
+            description="Generate AI response for a chatroom with a specific companion",
+        )
+        async def generate_response(
+            item_id: str,
+            companion_id: str,
+            db_session: Session = Depends(self.get_db_dep),
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Generate AI response for a chatroom."""
+            # Verify chatroom exists
+            self._get_item_or_404(repository, item_id)
+
+            # Get companion repository with same db session (Buppy pattern)
+            companion_repository = self.companion_repository_factory.create_repository(
+                db_session
+            )
+
+            # Get companion by ID
+            companion = companion_repository.get_by_id(companion_id)
+            if companion is None:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail=f"Companion with id {companion_id} not found",
+                )
+
+            # Get conversation history
+            messages = repository.get_messages_by_chatroom_id(
+                chatroom_id=item_id,
+                limit=DEFAULT_HISTORY_LIMIT,
+                offset=0,
+            )
+
+            # Convert to LangChain BaseMessage format
+            # Reverse: DB returns newest-first, LLM needs chronological order
+            langchain_messages = _to_langchain_messages(list(reversed(messages)))
+
+            # Create persona from companion (KST fixed for MVP)
+            persona = Persona(
+                name=companion.name,
+                system_prompt=companion.system_prompt,
+                timezone_name="Asia/Seoul",
+            )
+            provider = OpenAILLMProvider(settings=self.openai_settings)
+            model_settings = ModelSettings(chat_model=self.model_settings.openai_model)
+
+            # Generate text response using ResponseGenerationService
+            context = (
+                MessageContextBuilder(provider, persona)
+                .with_persona()
+                .with_real_time_context()
+                .with_current_conversation(langchain_messages)
+                .build()
+            )
+            service = ResponseGenerationService(provider, model_settings)
+            response_text = service.generate_response(context)
+
+            # Save companion message (repository handles commit)
+            # Use CompanionMessageCreate (no id) - aioia-core pattern
+            companion_message = repository.add_message_to_chatroom(
+                chatroom_id=item_id,
+                message=CompanionMessageCreate(
+                    content=response_text,
+                    companion_id=companion_id,
+                ),
+            )
+
+            return GenerateResponse(
+                message_id=companion_message.id,
+                content=response_text,
+            )
+
+
+def create_chatroom_router(
+    openai_settings: OpenAIAPISettings,
+    model_settings: Settings,
+    companion_repository_factory: CompanionRepositoryFactoryProtocol,
+    db_session_factory: sessionmaker,
+    repository_factory: ChatroomRepositoryFactoryProtocol,
+    jwt_settings: JWTSettings | None = None,
+    user_info_provider: UserInfoProvider | None = None,
+    resource_name: str = "chatrooms",
+    tags: list[str] | None = None,
+) -> APIRouter:
+    """
+    Create chatroom router with dependency injection.
+
+    Args:
+        openai_settings: OpenAI API settings for LLM provider
+        model_settings: Environment settings for aidol
+        companion_repository_factory: Factory for CompanionRepository.
+            For standalone: Use aidol.factories.CompanionRepositoryFactory.
+            For platform integration: Use CompanionRepositoryFactoryAdapter.
+        db_session_factory: Database session factory
+        repository_factory: Factory implementing ChatroomRepositoryFactoryProtocol.
+            For standalone: Use aidol.factories.ChatroomRepositoryFactory.
+            For platform integration: Use ChatroomRepositoryFactoryAdapter.
+        jwt_settings: Optional JWT settings for authentication
+        user_info_provider: Optional user info provider
+        resource_name: Resource name for routes (default: "chatrooms")
+        tags: Optional OpenAPI tags
+
+    Returns:
+        FastAPI APIRouter instance
+    """
+    router = ChatroomRouter(
+        model_settings=model_settings,
+        openai_settings=openai_settings,
+        companion_repository_factory=companion_repository_factory,
+        model_class=Chatroom,
+        create_schema=ChatroomCreate,
+        update_schema=ChatroomUpdate,
+        db_session_factory=db_session_factory,
+        repository_factory=repository_factory,
+        user_info_provider=user_info_provider,
+        jwt_secret_key=jwt_settings.secret_key if jwt_settings else None,
+        resource_name=resource_name,
+        tags=tags or ["Aidol"],
+    )
+    return router.get_router()

{py_aidol-0.3.0 → py_aidol-0.5.0}/aidol/api/common.py

@@ -14,12 +14,13 @@ from aidol.schemas import (
     ImageGenerationResponse,
 )
 from aidol.services import ImageGenerationService
+from aidol.settings import GoogleGenAISettings
 
 
 def register_image_generation_route(
     router: APIRouter,
     resource_name: str,
-    google_api_key: str | None,
+    google_settings: GoogleGenAISettings | None,
     image_storage: ImageStorageProtocol,
 ) -> None:
     """
@@ -28,7 +29,7 @@ def register_image_generation_route(
     Args:
         router: FastAPI APIRouter instance
         resource_name: Resource name for the route path
-        google_api_key: Google API Key
+        google_settings: Google API settings (API Key or Vertex AI with ADC)
         image_storage: Image Storage instance
     """
 
@@ -45,7 +46,7 @@ def register_image_generation_route(
     async def generate_image(request: ImageGenerationRequest):
         """Generate image from prompt."""
         # Generate and download image
-        service = ImageGenerationService(api_key=google_api_key)
+        service = ImageGenerationService(settings=google_settings)
         image = service.generate_and_download_image(
             prompt=request.prompt,
             size="1024x1024",