py-aidol 0.1.0__tar.gz

py_aidol-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: py-aidol
+Version: 0.1.0
+Summary: Create and chat with your own AI idol group
+License: Apache-2.0
+Keywords: kpop,idol,aidol,ai-companion,chatbot,image-generation
+Author: AIoIA, Inc.
+Author-email: devops@aioia.ai
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+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: httpx (>=0.28.1,<0.29.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)
+Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
+Requires-Dist: pydantic[email] (>=2.5.3,<3.0.0)
+Requires-Dist: pyhumps (>=3.8.0,<4.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: sqlalchemy (>=2.0.25,<3.0.0)
+Requires-Dist: sqlalchemy-mixins (>=2.0.5,<3.0.0)
+Description-Content-Type: text/markdown
+
+# AIdol Backend
+
+AI 아이돌 그룹 생성 및 채팅 Python 패키지
+
+## 주요 기능
+
+- AI 아이돌 그룹/멤버 CRUD
+- DALL-E 3 이미지 생성 (엠블럼, 프로필)
+- 텍스트 채팅 (페르소나 기반 응답)
+- Buppy 통합 Adapter 패턴
+
+## 설치
+
+```bash
+cd backend
+poetry install
+poetry run uvicorn main:app --reload
+```
+
+API 문서:
+- Swagger UI: http://localhost:8000/docs
+- ReDoc: http://localhost:8000/redoc
+
+## 사용법
+
+### FastAPI 통합
+
+```python
+from aidol.api.aidol import AIdolRouter
+from aidol.api.companion import CompanionRouter
+from aidol.factories import AIdolRepositoryFactory, CompanionRepositoryFactory
+
+# AIdol 라우터
+aidol_router = AIdolRouter(
+    repository_factory=AIdolRepositoryFactory(),
+    openai_settings=openai_settings,
+    image_storage=image_storage,
+)
+
+# Companion 라우터
+companion_router = CompanionRouter(
+    repository_factory=CompanionRepositoryFactory(),
+)
+
+app.include_router(aidol_router.router, prefix="/api/aidol")
+app.include_router(companion_router.router, prefix="/api/aidol")
+```
+
+## 개발
+
+```bash
+poetry install
+make lint
+make type-check
+make unit-test
+make format
+```
+
+## 환경 변수
+
+### 필수 (이미지 생성 시)
+
+| 변수 | 설명 |
+|------|------|
+| `OPENAI_API_KEY` | OpenAI API 키 |
+
+### 선택
+
+| 변수 | 기본값 | 설명 |
+|------|--------|------|
+| `AIDOL_OPENAI_MODEL` | `gpt-4o-mini` | 채팅 응답 LLM 모델 |
+
+> **참고**: 데이터베이스, 모델 등 추가 설정은 기본값으로 로컬 개발 가능합니다.
+> 변경이 필요한 경우 `aidol/` 내 Settings 클래스를 참고하세요.
+
+## 의존성
+
+- aioia-core (공통 인프라)
+- FastAPI, SQLAlchemy, Pydantic
+- OpenAI (이미지 생성, 채팅)
+- Pillow (이미지 처리)
+
+## 라이선스
+
+Apache 2.0
+

py_aidol-0.1.0/README.md

@@ -0,0 +1,85 @@
+# AIdol Backend
+
+AI 아이돌 그룹 생성 및 채팅 Python 패키지
+
+## 주요 기능
+
+- AI 아이돌 그룹/멤버 CRUD
+- DALL-E 3 이미지 생성 (엠블럼, 프로필)
+- 텍스트 채팅 (페르소나 기반 응답)
+- Buppy 통합 Adapter 패턴
+
+## 설치
+
+```bash
+cd backend
+poetry install
+poetry run uvicorn main:app --reload
+```
+
+API 문서:
+- Swagger UI: http://localhost:8000/docs
+- ReDoc: http://localhost:8000/redoc
+
+## 사용법
+
+### FastAPI 통합
+
+```python
+from aidol.api.aidol import AIdolRouter
+from aidol.api.companion import CompanionRouter
+from aidol.factories import AIdolRepositoryFactory, CompanionRepositoryFactory
+
+# AIdol 라우터
+aidol_router = AIdolRouter(
+    repository_factory=AIdolRepositoryFactory(),
+    openai_settings=openai_settings,
+    image_storage=image_storage,
+)
+
+# Companion 라우터
+companion_router = CompanionRouter(
+    repository_factory=CompanionRepositoryFactory(),
+)
+
+app.include_router(aidol_router.router, prefix="/api/aidol")
+app.include_router(companion_router.router, prefix="/api/aidol")
+```
+
+## 개발
+
+```bash
+poetry install
+make lint
+make type-check
+make unit-test
+make format
+```
+
+## 환경 변수
+
+### 필수 (이미지 생성 시)
+
+| 변수 | 설명 |
+|------|------|
+| `OPENAI_API_KEY` | OpenAI API 키 |
+
+### 선택
+
+| 변수 | 기본값 | 설명 |
+|------|--------|------|
+| `AIDOL_OPENAI_MODEL` | `gpt-4o-mini` | 채팅 응답 LLM 모델 |
+
+> **참고**: 데이터베이스, 모델 등 추가 설정은 기본값으로 로컬 개발 가능합니다.
+> 변경이 필요한 경우 `aidol/` 내 Settings 클래스를 참고하세요.
+
+## 의존성
+
+- aioia-core (공통 인프라)
+- FastAPI, SQLAlchemy, Pydantic
+- OpenAI (이미지 생성, 채팅)
+- Pillow (이미지 처리)
+
+## 라이선스
+
+Apache 2.0

py_aidol-0.1.0/aidol/__init__.py

@@ -0,0 +1,7 @@
+"""
+AIdol - Asynchronous chat module for AI idol interaction
+"""
+
+__version__ = "0.1.0"
+
+# No top-level exports - use full paths for clarity

py_aidol-0.1.0/aidol/api/__init__.py

@@ -0,0 +1,13 @@
+"""
+AIdol API routers
+"""
+
+from aidol.api.aidol import AIdolRouter, create_aidol_router
+from aidol.api.companion import CompanionRouter, create_companion_router
+
+__all__ = [
+    "AIdolRouter",
+    "CompanionRouter",
+    "create_aidol_router",
+    "create_companion_router",
+]

py_aidol-0.1.0/aidol/api/aidol.py

@@ -0,0 +1,189 @@
+"""
+AIdol API router
+
+Public endpoints for AIdol group 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, OpenAIAPISettings
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+from sqlalchemy.orm import sessionmaker
+
+from aidol.protocols import (
+    AIdolRepositoryFactoryProtocol,
+    AIdolRepositoryProtocol,
+    ImageStorageProtocol,
+)
+from aidol.schemas import (
+    AIdol,
+    AIdolCreate,
+    AIdolPublic,
+    AIdolUpdate,
+    ImageGenerationData,
+    ImageGenerationRequest,
+    ImageGenerationResponse,
+)
+from aidol.services import ImageGenerationService
+
+
+class AIdolSingleItemResponse(BaseModel):
+    """Single item response for AIdol (public)."""
+
+    data: AIdolPublic
+
+
+class AIdolRouter(
+    BaseCrudRouter[AIdol, AIdolCreate, AIdolUpdate, AIdolRepositoryProtocol]
+):
+    """
+    AIdol router with public endpoints.
+
+    Public CRUD pattern: no authentication required.
+    Returns AIdolPublic (excludes claim_token) for all responses.
+    """
+
+    def __init__(
+        self,
+        openai_settings: OpenAIAPISettings,
+        image_storage: ImageStorageProtocol,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.openai_settings = openai_settings
+        self.image_storage = image_storage
+
+    def _register_routes(self) -> None:
+        """Register routes (public CRUD + image generation)"""
+        self._register_image_generation_route()
+        self._register_public_create_route()
+        self._register_public_get_route()
+
+    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,
+            status_code=status.HTTP_201_CREATED,
+            summary="Create AIdol group",
+            description="Create a new AIdol group (public endpoint)",
+        )
+        async def create_aidol(
+            request: AIdolCreate,
+            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)
+
+    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,
+            status_code=status.HTTP_200_OK,
+            summary="Get AIdol group",
+            description="Get AIdol group by ID (public endpoint)",
+            responses={
+                404: {"model": ErrorResponse, "description": "AIdol group not found"},
+            },
+        )
+        async def get_aidol(
+            item_id: str,
+            repository: AIdolRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """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",
+                )
+            )
+
+
+def create_aidol_router(
+    openai_settings: OpenAIAPISettings,
+    db_session_factory: sessionmaker,
+    repository_factory: AIdolRepositoryFactoryProtocol,
+    image_storage: ImageStorageProtocol,
+    jwt_settings: JWTSettings | None = None,
+    user_info_provider: UserInfoProvider | None = None,
+    resource_name: str = "aidols",
+    tags: list[str] | None = None,
+) -> APIRouter:
+    """
+    Create AIdol router with dependency injection.
+
+    Args:
+        openai_settings: OpenAI API settings for image generation
+        db_session_factory: Database session factory
+        repository_factory: Factory implementing AIdolRepositoryFactoryProtocol
+        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: "aidols")
+        tags: Optional OpenAPI tags
+
+    Returns:
+        FastAPI APIRouter instance
+    """
+    router = AIdolRouter(
+        openai_settings=openai_settings,
+        image_storage=image_storage,
+        model_class=AIdol,
+        create_schema=AIdolCreate,
+        update_schema=AIdolUpdate,
+        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.1.0/aidol/api/companion.py

@@ -0,0 +1,168 @@
+"""
+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, Query, status
+from pydantic import BaseModel
+from sqlalchemy.orm import sessionmaker
+
+from aidol.protocols import (
+    CompanionRepositoryFactoryProtocol,
+    CompanionRepositoryProtocol,
+)
+from aidol.schemas import Companion, CompanionCreate, CompanionPublic, CompanionUpdate
+
+
+class CompanionSingleItemResponse(BaseModel):
+    """Single item response for Companion (public)."""
+
+    data: CompanionPublic
+
+
+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 _register_routes(self) -> None:
+        """Register routes (public CRUD)"""
+        self._register_public_list_route()
+        self._register_public_create_route()
+        self._register_public_get_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 (public endpoint)",
+        )
+        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)",
+            ),
+            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)
+            items, total = repository.get_all(
+                current=current,
+                page_size=page_size,
+                sort=sort_list,
+                filters=filter_list,
+            )
+            # Convert to Public schema (exclude system_prompt)
+            public_items = [CompanionPublic(**c.model_dump()) 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=CompanionSingleItemResponse,
+            status_code=status.HTTP_201_CREATED,
+            summary="Create Companion",
+            description="Create a new Companion (public endpoint)",
+        )
+        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)
+
+    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,
+            status_code=status.HTTP_200_OK,
+            summary="Get Companion",
+            description="Get Companion by ID (public endpoint)",
+            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)
+            # Convert to Public schema (exclude system_prompt)
+            public_companion = CompanionPublic(**companion.model_dump())
+            return CompanionSingleItemResponse(data=public_companion)
+
+
+def create_companion_router(
+    db_session_factory: sessionmaker,
+    repository_factory: CompanionRepositoryFactoryProtocol,
+    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:
+        db_session_factory: Database session factory
+        repository_factory: Factory implementing CompanionRepositoryFactoryProtocol
+        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(
+        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()

py_aidol-0.1.0/aidol/factories.py

@@ -0,0 +1,24 @@
+"""
+AIdol repository factories
+
+Uses BaseRepositoryFactory for BaseCrudRouter compatibility.
+"""
+
+from aioia_core.factories import BaseRepositoryFactory
+
+from aidol.repositories.aidol import AIdolRepository
+from aidol.repositories.companion import CompanionRepository
+
+
+class AIdolRepositoryFactory(BaseRepositoryFactory[AIdolRepository]):
+    """Factory for creating AIdol repositories."""
+
+    def __init__(self):
+        super().__init__(repository_class=AIdolRepository)
+
+
+class CompanionRepositoryFactory(BaseRepositoryFactory[CompanionRepository]):
+    """Factory for creating Companion repositories."""
+
+    def __init__(self):
+        super().__init__(repository_class=CompanionRepository)

py_aidol-0.1.0/aidol/models/__init__.py

@@ -0,0 +1,8 @@
+"""
+AIdol database models
+"""
+
+from aidol.models.aidol import DBAIdol
+from aidol.models.companion import DBCompanion
+
+__all__ = ["DBAIdol", "DBCompanion"]

py_aidol-0.1.0/aidol/models/aidol.py

@@ -0,0 +1,24 @@
+"""
+AIdol database model
+
+Uses aioia_core.models.BaseModel which provides:
+- id: Mapped[str] (primary key, UUID default)
+- created_at: Mapped[datetime]
+- updated_at: Mapped[datetime]
+"""
+
+from aioia_core.models import BaseModel
+from sqlalchemy import String
+from sqlalchemy.orm import Mapped, mapped_column
+
+
+class DBAIdol(BaseModel):
+    """AIdol (group) database model"""
+
+    __tablename__ = "aidols"
+
+    # id, created_at, updated_at inherited from BaseModel
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    concept: Mapped[str | None] = mapped_column(String, nullable=True)
+    profile_image_url: Mapped[str] = mapped_column(String, nullable=False)
+    claim_token: Mapped[str | None] = mapped_column(String(36), nullable=True)

py_aidol-0.1.0/aidol/models/companion.py

@@ -0,0 +1,27 @@
+"""
+Companion database model
+
+Uses aioia_core.models.BaseModel which provides:
+- id: Mapped[str] (primary key, UUID default)
+- created_at: Mapped[datetime]
+- updated_at: Mapped[datetime]
+"""
+
+from aioia_core.models import BaseModel
+from sqlalchemy import ForeignKey, Index, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+
+class DBCompanion(BaseModel):
+    """Companion (member) database model"""
+
+    __tablename__ = "companions"
+
+    # id, created_at, updated_at inherited from BaseModel
+    aidol_id: Mapped[str | None] = mapped_column(ForeignKey("aidols.id"), nullable=True)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    biography: Mapped[str | None] = mapped_column(Text, nullable=True)
+    profile_picture_url: Mapped[str | None] = mapped_column(String, nullable=True)
+    system_prompt: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    __table_args__ = (Index("ix_companions_aidol_id", "aidol_id"),)