py-aidol 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

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,

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",
+            )
+        )

aidol/api/companion.py

@@ -1,3 +1,4 @@
+# pylint: disable=duplicate-code
 """
 Companion API router
 
@@ -9,21 +10,24 @@ 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, Query, status
+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
-
-
-class CompanionSingleItemResponse(BaseModel):
-    """Single item response for Companion (public)."""
-
-    data: CompanionPublic
+from aidol.schemas import (
+    Companion,
+    CompanionCreate,
+    CompanionPublic,
+    CompanionUpdate,
+    Gender,
+)
+from aidol.services.companion_service import to_companion_public
 
 
 class CompanionPaginatedResponse(BaseModel):
@@ -45,11 +49,31 @@ class CompanionRouter(
     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)"""
+        """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)"""
@@ -59,33 +83,48 @@ class CompanionRouter(
             response_model=CompanionPaginatedResponse,
             status_code=status.HTTP_200_OK,
             summary="List Companions",
-            description="List all Companions with optional filtering (public endpoint)",
+            description="List all Companions with optional filtering by gender and cast status",
         )
         async def list_companions(
-            current: int = Query(1, ge=1, description="Current page number"),
-            page_size: int = Query(10, ge=1, le=100, description="Items per page"),
-            sort_param: str | None = Query(
-                None,
-                alias="sort",
-                description='Sorting criteria in JSON format. Example: [["createdAt","desc"]]',
-            ),
-            filters_param: str | None = Query(
-                None,
-                alias="filters",
-                description="Filter conditions (JSON format)",
+            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 pagination, sorting, and filtering."""
-            sort_list, filter_list = self._parse_query_params(sort_param, filters_param)
+            """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(
-                current=current,
-                page_size=page_size,
-                sort=sort_list,
-                filters=filter_list,
+                filters=filter_list if filter_list else None,
             )
             # Convert to Public schema (exclude system_prompt)
-            public_items = [CompanionPublic(**c.model_dump()) for c in items]
+            public_items = [to_companion_public(c) for c in items]
             return CompanionPaginatedResponse(data=public_items, total=total)
 
     def _register_public_create_route(self) -> None:
@@ -93,30 +132,33 @@ class CompanionRouter(
 
         @self.router.post(
             f"/{self.resource_name}",
-            response_model=CompanionSingleItemResponse,
+            response_model=CompanionPublic,
             status_code=status.HTTP_201_CREATED,
             summary="Create Companion",
-            description="Create a new Companion (public endpoint)",
+            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."""
-            created = repository.create(request)
-            # Convert to Public schema (exclude system_prompt)
-            public_companion = CompanionPublic(**created.model_dump())
-            return CompanionSingleItemResponse(data=public_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=CompanionSingleItemResponse,
+            response_model=CompanionPublic,
             status_code=status.HTTP_200_OK,
             summary="Get Companion",
-            description="Get Companion by ID (public endpoint)",
+            description="Get Companion by ID (public endpoint). Returns companion data directly.",
             responses={
                 404: {"model": ErrorResponse, "description": "Companion not found"},
             },
@@ -127,14 +169,85 @@ class CompanionRouter(
         ):
             """Get Companion by ID."""
             companion = self._get_item_or_404(repository, item_id)
-            # Convert to Public schema (exclude system_prompt)
-            public_companion = CompanionPublic(**companion.model_dump())
-            return CompanionSingleItemResponse(data=public_companion)
+            # 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",
@@ -144,8 +257,10 @@ def create_companion_router(
     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")
@@ -155,6 +270,8 @@ def create_companion_router(
         FastAPI APIRouter instance
     """
     router = CompanionRouter(
+        google_api_key=google_api_key,
+        image_storage=image_storage,
         model_class=Companion,
         create_schema=CompanionCreate,
         update_schema=CompanionUpdate,