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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-aidol
-Version: 0.2.0
+Version: 0.3.0
 Summary: Create and chat with your own AI idol group
 License: Apache-2.0
 Keywords: kpop,idol,aidol,ai-companion,chatbot,image-generation
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 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: openai (>=1.0.0)
 Requires-Dist: pillow (>=10.0.0,<11.0.0)

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

@@ -1,3 +1,4 @@
+# pylint: disable=duplicate-code
 """
 AIdol API router
 
@@ -8,32 +9,24 @@ Public access pattern: no authentication required.
 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 aioia_core.settings import JWTSettings
+from fastapi import APIRouter, Depends, HTTPException, Response, status
 from pydantic import BaseModel
 from sqlalchemy.orm import sessionmaker
 
+from aidol.api.common import register_image_generation_route
 from aidol.protocols import (
     AIdolRepositoryFactoryProtocol,
     AIdolRepositoryProtocol,
     ImageStorageProtocol,
 )
-from aidol.schemas import (
-    AIdol,
-    AIdolCreate,
-    AIdolPublic,
-    AIdolUpdate,
-    ImageGenerationData,
-    ImageGenerationRequest,
-    ImageGenerationResponse,
-)
-from aidol.services import ImageGenerationService
+from aidol.schemas import AIdol, AIdolCreate, AIdolPublic, AIdolUpdate
 
 
-class AIdolSingleItemResponse(BaseModel):
-    """Single item response for AIdol (public)."""
+class AIdolCreateResponse(BaseModel):
+    """Response for AIdol creation (only id)."""
 
-    data: AIdolPublic
+    id: str
 
 
 class AIdolRouter(
@@ -48,49 +41,92 @@ class AIdolRouter(
 
     def __init__(
         self,
-        openai_settings: OpenAIAPISettings,
+        google_api_key: str | None,
         image_storage: ImageStorageProtocol,
         **kwargs,
     ):
-        super().__init__(**kwargs)
-        self.openai_settings = openai_settings
+        self.google_api_key = google_api_key
         self.image_storage = image_storage
+        super().__init__(**kwargs)
 
     def _register_routes(self) -> None:
         """Register routes (public CRUD + image generation)"""
-        self._register_image_generation_route()
+        # Register shared image generation route
+        register_image_generation_route(
+            router=self.router,
+            resource_name=self.resource_name,
+            google_api_key=self.google_api_key,
+            image_storage=self.image_storage,
+        )
+
         self._register_public_create_route()
         self._register_public_get_route()
+        self._register_public_update_route()
+
+    def _register_public_update_route(self) -> None:
+        """PATCH /{resource_name}/{id} - Update AIdol group (public)"""
+
+        @self.router.patch(
+            f"/{self.resource_name}/{{item_id}}",
+            response_model=AIdolPublic,
+            status_code=status.HTTP_200_OK,
+            summary="Update AIdol group",
+            description="Update AIdol group by ID (public endpoint). Returns updated AIdol data directly.",
+            responses={
+                404: {"model": ErrorResponse, "description": "AIdol group not found"},
+            },
+        )
+        async def update_aidol(
+            item_id: str,
+            data: AIdolUpdate,
+            repository: AIdolRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Update AIdol group."""
+            # TODO: Verify ClaimToken if strict ownership is required (Sprint 1)
+            updated = repository.update(item_id, data)
+            if not updated:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="AIdol group not found",
+                )
+
+            # Return updated AIdol as public schema
+            return AIdolPublic(**updated.model_dump())
 
     def _register_public_create_route(self) -> None:
         """POST /{resource_name} - Create an AIdol group (public)"""
 
         @self.router.post(
             f"/{self.resource_name}",
-            response_model=AIdolSingleItemResponse,
+            response_model=AIdolCreateResponse,
             status_code=status.HTTP_201_CREATED,
             summary="Create AIdol group",
-            description="Create a new AIdol group (public endpoint)",
+            description="Create a new AIdol group (public endpoint). Returns only the created id.",
         )
         async def create_aidol(
             request: AIdolCreate,
+            response: Response,
             repository: AIdolRepositoryProtocol = Depends(self.get_repository_dep),
         ):
             """Create a new AIdol group."""
             created = repository.create(request)
-            # Convert to Public schema (exclude claim_token)
-            public_aidol = AIdolPublic(**created.model_dump())
-            return AIdolSingleItemResponse(data=public_aidol)
+
+            # Set ClaimToken header
+            if created.claim_token:
+                response.headers["ClaimToken"] = created.claim_token
+
+            # Return only id
+            return AIdolCreateResponse(id=created.id)
 
     def _register_public_get_route(self) -> None:
         """GET /{resource_name}/{id} - Get an AIdol group (public)"""
 
         @self.router.get(
             f"/{self.resource_name}/{{item_id}}",
-            response_model=AIdolSingleItemResponse,
+            response_model=AIdolPublic,
             status_code=status.HTTP_200_OK,
             summary="Get AIdol group",
-            description="Get AIdol group by ID (public endpoint)",
+            description="Get AIdol group by ID (public endpoint). Returns AIdol data directly.",
             responses={
                 404: {"model": ErrorResponse, "description": "AIdol group not found"},
             },
@@ -101,54 +137,12 @@ class AIdolRouter(
         ):
             """Get AIdol group by ID."""
             aidol = self._get_item_or_404(repository, item_id)
-            # Convert to Public schema (exclude claim_token)
-            public_aidol = AIdolPublic(**aidol.model_dump())
-            return AIdolSingleItemResponse(data=public_aidol)
-
-    def _register_image_generation_route(self) -> None:
-        """POST /{resource_name}/images - Generate image for AIdol or Companion"""
-
-        @self.router.post(
-            f"/{self.resource_name}/images",
-            response_model=ImageGenerationResponse,
-            status_code=status.HTTP_201_CREATED,
-            summary="Generate image",
-            description="Generate image for AIdol emblem or Companion profile",
-            responses={
-                500: {"model": ErrorResponse, "description": "Image generation failed"},
-            },
-        )
-        async def generate_image(request: ImageGenerationRequest):
-            """Generate image from prompt."""
-            # Generate and download image (TTS pattern: service returns data)
-            service = ImageGenerationService(self.openai_settings)
-            image = service.generate_and_download_image(
-                prompt=request.prompt,
-                size="1024x1024",
-                quality="standard",
-            )
-
-            if image is None:
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail="Image generation failed",
-                )
-
-            # Upload to permanent storage (TTS pattern: API layer orchestrates)
-            image_url = self.image_storage.upload_image(image)
-
-            return ImageGenerationResponse(
-                data=ImageGenerationData(
-                    image_url=image_url,
-                    width=1024,
-                    height=1024,
-                    format="png",
-                )
-            )
+            # Return AIdol as public schema
+            return AIdolPublic(**aidol.model_dump())
 
 
 def create_aidol_router(
-    openai_settings: OpenAIAPISettings,
+    google_api_key: str | None,
     db_session_factory: sessionmaker,
     repository_factory: AIdolRepositoryFactoryProtocol,
     image_storage: ImageStorageProtocol,
@@ -161,7 +155,7 @@ def create_aidol_router(
     Create AIdol router with dependency injection.
 
     Args:
-        openai_settings: OpenAI API settings for image generation
+        google_api_key: Google API Key for image generation
         db_session_factory: Database session factory
         repository_factory: Factory implementing AIdolRepositoryFactoryProtocol
         image_storage: Image storage for permanent URLs
@@ -174,7 +168,7 @@ def create_aidol_router(
         FastAPI APIRouter instance
     """
     router = AIdolRouter(
-        openai_settings=openai_settings,
+        google_api_key=google_api_key,
         image_storage=image_storage,
         model_class=AIdol,
         create_schema=AIdolCreate,

py_aidol-0.3.0/aidol/api/common.py

@@ -0,0 +1,71 @@
+"""
+Common API utilities.
+
+Shared functions for registering common routes across different routers.
+"""
+
+from aioia_core.errors import ErrorResponse
+from fastapi import APIRouter, HTTPException, status
+
+from aidol.protocols import ImageStorageProtocol
+from aidol.schemas import (
+    ImageGenerationData,
+    ImageGenerationRequest,
+    ImageGenerationResponse,
+)
+from aidol.services import ImageGenerationService
+
+
+def register_image_generation_route(
+    router: APIRouter,
+    resource_name: str,
+    google_api_key: str | None,
+    image_storage: ImageStorageProtocol,
+) -> None:
+    """
+    Register image generation route to the given router.
+
+    Args:
+        router: FastAPI APIRouter instance
+        resource_name: Resource name for the route path
+        google_api_key: Google API Key
+        image_storage: Image Storage instance
+    """
+
+    @router.post(
+        f"/{resource_name}/images",
+        response_model=ImageGenerationResponse,
+        status_code=status.HTTP_201_CREATED,
+        summary="Generate image",
+        description=f"Generate image for {resource_name}",
+        responses={
+            500: {"model": ErrorResponse, "description": "Image generation failed"},
+        },
+    )
+    async def generate_image(request: ImageGenerationRequest):
+        """Generate image from prompt."""
+        # Generate and download image
+        service = ImageGenerationService(api_key=google_api_key)
+        image = service.generate_and_download_image(
+            prompt=request.prompt,
+            size="1024x1024",
+            quality="standard",
+        )
+
+        if image is None:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Image generation failed",
+            )
+
+        # Upload to permanent storage
+        image_url = image_storage.upload_image(image)
+
+        return ImageGenerationResponse(
+            data=ImageGenerationData(
+                image_url=image_url,
+                width=1024,
+                height=1024,
+                format="png",
+            )
+        )

py_aidol-0.3.0/aidol/api/companion.py

@@ -0,0 +1,285 @@
+# pylint: disable=duplicate-code
+"""
+Companion API router
+
+Public endpoints for Companion creation and retrieval.
+Public access pattern: no authentication required.
+"""
+
+from aioia_core.auth import UserInfoProvider
+from aioia_core.errors import ErrorResponse
+from aioia_core.fastapi import BaseCrudRouter
+from aioia_core.settings import JWTSettings
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from pydantic import BaseModel
+from sqlalchemy.orm import sessionmaker
+
+from aidol.api.common import register_image_generation_route
+from aidol.protocols import (
+    CompanionRepositoryFactoryProtocol,
+    CompanionRepositoryProtocol,
+    ImageStorageProtocol,
+)
+from aidol.schemas import (
+    Companion,
+    CompanionCreate,
+    CompanionPublic,
+    CompanionUpdate,
+    Gender,
+)
+from aidol.services.companion_service import to_companion_public
+
+
+class CompanionPaginatedResponse(BaseModel):
+    """Paginated response for Companion (public)."""
+
+    data: list[CompanionPublic]
+    total: int
+
+
+class CompanionRouter(
+    BaseCrudRouter[
+        Companion, CompanionCreate, CompanionUpdate, CompanionRepositoryProtocol
+    ]
+):
+    """
+    Companion router with public endpoints.
+
+    Public CRUD pattern: no authentication required.
+    Returns CompanionPublic (excludes system_prompt) for all responses.
+    """
+
+    def __init__(
+        self,
+        google_api_key: str | None,
+        image_storage: ImageStorageProtocol,
+        **kwargs,
+    ):
+        self.google_api_key = google_api_key
+        self.image_storage = image_storage
+        super().__init__(**kwargs)
+
+    def _register_routes(self) -> None:
+        """Register routes (public CRUD + image generation)"""
+        # Register shared image generation route
+        register_image_generation_route(
+            router=self.router,
+            resource_name=self.resource_name,
+            google_api_key=self.google_api_key,
+            image_storage=self.image_storage,
+        )
+
+        self._register_public_list_route()
+        self._register_public_create_route()
+        self._register_public_get_route()
+        self._register_public_update_route()
+        self._register_public_delete_route()
+
+    def _register_public_list_route(self) -> None:
+        """GET /{resource_name} - List Companions (public)"""
+
+        @self.router.get(
+            f"/{self.resource_name}",
+            response_model=CompanionPaginatedResponse,
+            status_code=status.HTTP_200_OK,
+            summary="List Companions",
+            description="List all Companions with optional filtering by gender and cast status",
+        )
+        async def list_companions(
+            gender: Gender | None = Query(None, description="Filter by gender"),
+            is_cast: bool | None = Query(
+                None, alias="isCast", description="Filter by cast status"
+            ),
+            aidol_id: str | None = Query(None, description="Filter by AIdol Group ID"),
+            repository: CompanionRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """List Companions with optional gender and isCast filters."""
+            filter_list: list[dict] = []
+
+            # Add filters only if provided
+            if gender is not None:
+                filter_list.append(
+                    {"field": "gender", "operator": "eq", "value": gender.value}
+                )
+
+            # Filter by aidol_id if provided
+            if aidol_id is not None:
+                filter_list.append(
+                    {"field": "aidol_id", "operator": "eq", "value": aidol_id}
+                )
+
+            # isCast is derived from aidol_id presence
+            # isCast=true → aidol_id is not null (belongs to a group)
+            # isCast=false → aidol_id is null (not in a group)
+            if is_cast is True:
+                filter_list.append(
+                    {"field": "aidol_id", "operator": "ne", "value": None}
+                )
+            elif is_cast is False:
+                filter_list.append(
+                    {"field": "aidol_id", "operator": "eq", "value": None}
+                )
+
+            items, total = repository.get_all(
+                filters=filter_list if filter_list else None,
+            )
+            # Convert to Public schema (exclude system_prompt)
+            public_items = [to_companion_public(c) for c in items]
+            return CompanionPaginatedResponse(data=public_items, total=total)
+
+    def _register_public_create_route(self) -> None:
+        """POST /{resource_name} - Create a Companion (public)"""
+
+        @self.router.post(
+            f"/{self.resource_name}",
+            response_model=CompanionPublic,
+            status_code=status.HTTP_201_CREATED,
+            summary="Create Companion",
+            description="Create a new Companion. Returns the created companion data.",
+        )
+        async def create_companion(
+            request: CompanionCreate,
+            repository: CompanionRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Create a new Companion."""
+            # Exclude system_prompt from request - should not be set via API
+            sanitized_data = request.model_dump(exclude={"system_prompt"})
+            sanitized_request = CompanionCreate(**sanitized_data)
+
+            created = repository.create(sanitized_request)
+            # Return created companion as public schema
+            return to_companion_public(created)
+
+    def _register_public_get_route(self) -> None:
+        """GET /{resource_name}/{id} - Get a Companion (public)"""
+
+        @self.router.get(
+            f"/{self.resource_name}/{{item_id}}",
+            response_model=CompanionPublic,
+            status_code=status.HTTP_200_OK,
+            summary="Get Companion",
+            description="Get Companion by ID (public endpoint). Returns companion data directly.",
+            responses={
+                404: {"model": ErrorResponse, "description": "Companion not found"},
+            },
+        )
+        async def get_companion(
+            item_id: str,
+            repository: CompanionRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Get Companion by ID."""
+            companion = self._get_item_or_404(repository, item_id)
+            # Return companion as public schema
+            return to_companion_public(companion)
+
+    def _register_public_update_route(self) -> None:
+        """PATCH /{resource_name}/{id} - Update Companion (public)"""
+
+        @self.router.patch(
+            f"/{self.resource_name}/{{item_id}}",
+            response_model=CompanionPublic,
+            status_code=status.HTTP_200_OK,
+            summary="Update Companion",
+            description="Update Companion by ID (public endpoint). Returns updated companion data directly.",
+            responses={
+                404: {"model": ErrorResponse, "description": "Companion not found"},
+            },
+        )
+        async def update_companion(
+            item_id: str,
+            data: CompanionUpdate,
+            repository: CompanionRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Update Companion."""
+            # Exclude system_prompt from request - should not be set via API
+            sanitized_data = data.model_dump(
+                exclude={"system_prompt"}, exclude_unset=True
+            )
+            sanitized_request = CompanionUpdate(**sanitized_data)
+
+            updated = repository.update(item_id, sanitized_request)
+            if not updated:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Companion not found",
+                )
+
+            # Return updated companion as public schema
+            return to_companion_public(updated)
+
+    def _register_public_delete_route(self) -> None:
+        """DELETE /{resource_name}/{id} - Remove Companion from Group (public)"""
+
+        @self.router.delete(
+            f"/{self.resource_name}/{{item_id}}",
+            response_model=CompanionPublic,
+            status_code=status.HTTP_200_OK,
+            summary="Remove Companion from Group",
+            description="Remove Companion from AIdol group (unassign aidol_id). Does not delete the record.",
+            responses={
+                404: {"model": ErrorResponse, "description": "Companion not found"},
+            },
+        )
+        async def delete_companion(
+            item_id: str,
+            repository: CompanionRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Remove Companion from Group (Unassign)."""
+            # Get item first
+            self._get_item_or_404(repository, item_id)
+
+            # Update aidol_id to None (remove from group)
+            update_data = CompanionUpdate(aidol_id=None)
+
+            updated = repository.update(item_id, update_data)
+
+            if not updated:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Companion not found",
+                )
+
+            # Return updated companion as public schema
+            return to_companion_public(updated)
+
+
+def create_companion_router(
+    google_api_key: str | None,
+    db_session_factory: sessionmaker,
+    repository_factory: CompanionRepositoryFactoryProtocol,
+    image_storage: ImageStorageProtocol,
+    jwt_settings: JWTSettings | None = None,
+    user_info_provider: UserInfoProvider | None = None,
+    resource_name: str = "companions",
+    tags: list[str] | None = None,
+) -> APIRouter:
+    """
+    Create Companion router with dependency injection.
+
+    Args:
+        google_api_key: Google API Key for image generation
+        db_session_factory: Database session factory
+        repository_factory: Factory implementing CompanionRepositoryFactoryProtocol
+        image_storage: Image storage for permanent URLs
+        jwt_settings: Optional JWT settings for authentication
+        user_info_provider: Optional user info provider
+        resource_name: Resource name for routes (default: "companions")
+        tags: Optional OpenAPI tags
+
+    Returns:
+        FastAPI APIRouter instance
+    """
+    router = CompanionRouter(
+        google_api_key=google_api_key,
+        image_storage=image_storage,
+        model_class=Companion,
+        create_schema=CompanionCreate,
+        update_schema=CompanionUpdate,
+        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 ["Companion"],
+    )
+    return router.get_router()