aiteamutils 0.2.59__tar.gz → 0.2.60__tar.gz

{aiteamutils-0.2.59 → aiteamutils-0.2.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiteamutils
-Version: 0.2.59
+Version: 0.2.60
 Summary: AI Team Utilities
 Project-URL: Homepage, https://github.com/yourusername/aiteamutils
 Project-URL: Issues, https://github.com/yourusername/aiteamutils/issues

{aiteamutils-0.2.59 → aiteamutils-0.2.60}/aiteamutils/__init__.py

@@ -21,7 +21,6 @@ from .base_repository import BaseRepository
 from .validators import validate_with
 from .enums import ActivityType
 from .version import __version__
-from .dependencies import setup_dependencies, register_service
 
 __all__ = [
     # Base Models
@@ -32,10 +31,6 @@ __all__ = [
     # Database
     "DatabaseService",
     
-    # Dependencies
-    "setup_dependencies",
-    "register_service",
-    
     # Exceptions
     "CustomException",
     "ErrorCode",

aiteamutils-0.2.60/aiteamutils/base_repository.py

@@ -0,0 +1,54 @@
+#기본 라이브러리
+from typing import TypeVar, Generic, Type, Any, Dict, List, Optional
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy import select
+
+#패키지 라이브러리
+from .exceptions import ErrorCode, CustomException
+from .database import list_entities
+
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+
+class BaseRepository(Generic[ModelType]):
+    def __init__(self, session: AsyncSession, model: Type[ModelType]):
+        if session is None:
+            raise CustomException(
+                ErrorCode.DB_CONNECTION_ERROR,
+                detail="Database session is not set",
+                source_function=f"{self.__class__.__name__}.session"
+            )
+        if model is None:
+            raise CustomException(
+                ErrorCode.DB_CONNECTION_ERROR,
+                detail="Model is not set",
+                source_function=f"{self.__class__.__name__}.model"
+            )
+
+        self.session = session
+        self.model = model
+    
+    @property
+    def session(self) -> AsyncSession:
+        return self._session
+    
+    async def list(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None,
+        joins: Optional[List[Any]] = None
+    ) -> List[ModelType]:
+        """
+        엔티티 목록 조회.
+        """
+        # 기본 CRUD 작업 호출
+        return await list_entities(
+            session=self.db_session,
+            model=self.model,
+            skip=skip,
+            limit=limit,
+            filters=filters,
+            joins=joins,
+        )

aiteamutils-0.2.60/aiteamutils/base_service.py

@@ -0,0 +1,60 @@
+#기본 라이브러리
+from fastapi import Request
+from typing import TypeVar, Generic, Type, Dict, Any, Union, List
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime
+#패키지 라이브러리
+from .exceptions import ErrorCode, CustomException
+from .base_repository import BaseRepository
+
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+
+class BaseService(Generic[ModelType]):
+    ##################
+    # 1. 초기화 영역 #
+    ##################
+    def __init__(
+            self,
+            model: Type[ModelType],
+            repository: BaseRepository[ModelType],
+            db_session: AsyncSession
+    ):
+        self.model = model
+        self.repository = repository
+        self.db_session = db_session
+
+    async def list(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Dict[str, Any] | None = None,
+        search_params: Dict[str, Any] | None = None,
+        model_name: str | None = None,
+    ) -> List[Dict[str, Any]]:
+        try:
+            # 모델 이름을 통한 동적 처리
+            if model_name:
+                if model_name not in self.additional_models:
+                    raise CustomException(
+                        ErrorCode.INVALID_REQUEST,
+                        detail=f"Model {model_name} not registered",
+                        source_function=f"{self.__class__.__name__}.list"
+                    )
+                model = self.additional_models[model_name]
+                return await self.repository.list(skip=skip, limit=limit, filters=filters, model=model)
+
+            return await self.repository.list(skip=skip, limit=limit, filters=filters)
+        except CustomException as e:
+            e.detail = f"Service list error for {self.repository.model.__tablename__}: {e.detail}"
+            e.source_function = f"{self.__class__.__name__}.list -> {e.source_function}"
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.list",
+                original_error=e
+            )
+
+

aiteamutils-0.2.60/aiteamutils/database.py

@@ -0,0 +1,48 @@
+#기본 라이브러리
+from typing import TypeVar, Generic, Type, Any, Dict, List, Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, and_
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.exc import SQLAlchemyError
+
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+
+#패키지 라이브러리
+from .exceptions import ErrorCode, CustomException
+
+##################
+# 1. 쿼리 실행 #
+##################
+async def list_entities(
+    session: AsyncSession,
+    model: Type[ModelType],
+    skip: int = 0,
+    limit: int = 100,
+    filters: Optional[Dict[str, Any]] = None,
+    joins: Optional[List[Any]] = None
+) -> List[Dict[str, Any]]:
+    try:
+        query = select(model)
+
+        # 필터 조건 적용
+        if filters:
+            conditions = [getattr(model, key) == value for key, value in filters.items()]
+            query = query.where(and_(*conditions))
+
+        # 조인 로딩 적용
+        if joins:
+            for join_option in joins:
+                query = query.options(join_option)
+
+        # 페이지네이션 적용
+        query = query.limit(limit).offset(skip)
+
+        result = await session.execute(query)
+        return result.scalars().unique().all()
+    except SQLAlchemyError as e:
+        raise CustomException(
+            ErrorCode.DB_READ_ERROR,
+            detail=f"{model.__name__}|{str(e)}",
+            source_function="database.list_entities",
+            original_error=e
+        )

aiteamutils-0.2.60/aiteamutils/version.py

@@ -0,0 +1,2 @@
+"""버전 정보"""
+__version__ = "0.2.60"

aiteamutils-0.2.59/aiteamutils/base_repository.py

@@ -1,208 +0,0 @@
-"""기본 레포지토리 모듈."""
-from typing import TypeVar, Generic, Dict, Any, List, Optional, Type, Union
-from sqlalchemy.orm import DeclarativeBase, Load
-from sqlalchemy.exc import IntegrityError, SQLAlchemyError
-from sqlalchemy import select, or_, and_
-from .exceptions import CustomException, ErrorCode
-from sqlalchemy.orm import joinedload
-from sqlalchemy.sql import Select
-from fastapi import Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-ModelType = TypeVar("ModelType", bound=DeclarativeBase)
-
-class BaseRepository(Generic[ModelType]):
-    ##################
-    # 1. 초기화 영역 #
-    ##################
-    def __init__(self, session: AsyncSession, model: Type[ModelType]):
-        """
-        Args:
-            session (AsyncSession): 데이터베이스 세션
-            model (Type[ModelType]): 모델 클래스
-        """
-        self.session = session
-        self.model = model
-    
-    @property
-    def session(self):
-        """현재 세션을 반환합니다."""
-        if self._session is None:
-            raise CustomException(
-                ErrorCode.DB_CONNECTION_ERROR,
-                detail="Database session is not set",
-                source_function=f"{self.__class__.__name__}.session"
-            )
-        return self._session
-    
-    @session.setter
-    def session(self, value):
-        """세션을 설정합니다."""
-        self._session = value
-
-    #######################
-    # 2. CRUD 작업     #
-    #######################
-    async def get(
-        self,
-        ulid: str
-    ) -> Optional[Dict[str, Any]]:
-        """ULID로 엔티티를 조회합니다."""
-        try:
-            stmt = select(self.model).filter_by(ulid=ulid, is_deleted=False)
-            result = await self.session.execute(stmt)
-            entity = result.scalars().unique().first()
-            
-            if not entity:
-                raise CustomException(
-                    ErrorCode.DB_NO_RESULT,
-                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                    source_function=f"{self.__class__.__name__}.get"
-                )
-            return entity
-        except CustomException as e:
-            e.detail = f"Repository error for {self.model.__tablename__}: {e.detail}"
-            e.source_function = f"{self.__class__.__name__}.get -> {e.source_function}"
-            raise e
-        except SQLAlchemyError as e:
-            raise CustomException(
-                ErrorCode.DB_QUERY_ERROR,
-                detail=f"Database error in {self.model.__tablename__}: {str(e)}",
-                source_function=f"{self.__class__.__name__}.get",
-                original_error=e
-            )
-
-    async def list(
-        self,
-        skip: int = 0,
-        limit: int = 100,
-        filters: Dict[str, Any] | None = None,
-        search_params: Dict[str, Any] | None = None
-    ) -> List[Any]:
-        """엔티티 목록을 조회합니다."""
-        try:
-            stmt = select(self.model).where(self.model.is_deleted == False)
-
-            # 필터 적용
-            if filters:
-                stmt = self._apply_filters(stmt, filters)
-
-            # 검색 적용
-            if search_params:
-                stmt = self._apply_search_params(stmt, search_params)
-
-            # 페이지네이션 적용
-            stmt = stmt.limit(limit).offset(skip)
-
-            result = await self.session.execute(stmt)
-            return result.scalars().unique().all()
-
-        except SQLAlchemyError as e:
-            raise CustomException(
-                ErrorCode.DB_QUERY_ERROR,
-                detail=f"Unexpected repository list error in {self.model.__tablename__}: {str(e)}",
-                source_function=f"{self.__class__.__name__}.list",
-                original_error=e,
-            )
-
-    async def create(self, data: Dict[str, Any]) -> ModelType:
-        """새로운 엔티티를 생성합니다."""
-        try:
-            entity = self.model(**data)
-            self.session.add(entity)
-            await self.session.flush()
-            await self.session.refresh(entity)
-            return entity
-        except IntegrityError as e:
-            await self.session.rollback()
-            self._handle_integrity_error(e, "create", data)
-        except SQLAlchemyError as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_CREATE_ERROR,
-                detail=f"Database create error in {self.model.__tablename__}: {str(e)}",
-                source_function=f"{self.__class__.__name__}.create",
-                original_error=e
-            )
-
-    async def update(self, ulid: str, data: Dict[str, Any]) -> Optional[ModelType]:
-        """기존 엔티티를 수정합니다."""
-        try:
-            stmt = select(self.model).filter_by(ulid=ulid, is_deleted=False)
-            result = await self.session.execute(stmt)
-            entity = result.scalars().first()
-            
-            if not entity:
-                raise CustomException(
-                    ErrorCode.DB_NO_RESULT,
-                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                    source_function=f"{self.__class__.__name__}.update"
-                )
-
-            for key, value in data.items():
-                setattr(entity, key, value)
-            
-            await self.session.flush()
-            await self.session.refresh(entity)
-            return entity
-            
-        except IntegrityError as e:
-            await self.session.rollback()
-            self._handle_integrity_error(e, "update", data)
-        except SQLAlchemyError as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_UPDATE_ERROR,
-                detail=f"Database update error in {self.model.__tablename__}: {str(e)}",
-                source_function=f"{self.__class__.__name__}.update",
-                original_error=e
-            )
-
-    async def delete(self, ulid: str) -> bool:
-        """엔티티를 소프트 삭제합니다."""
-        try:
-            stmt = select(self.model).filter_by(ulid=ulid, is_deleted=False)
-            result = await self.session.execute(stmt)
-            entity = result.scalars().first()
-            
-            if not entity:
-                raise CustomException(
-                    ErrorCode.DB_NO_RESULT,
-                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                    source_function=f"{self.__class__.__name__}.delete"
-                )
-
-            entity.is_deleted = True
-            await self.session.flush()
-            return True
-            
-        except SQLAlchemyError as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_DELETE_ERROR,
-                detail=f"Database delete error in {self.model.__tablename__}: {str(e)}",
-                source_function=f"{self.__class__.__name__}.delete",
-                original_error=e
-            )
-
-    async def real_delete(self, ulid: str) -> bool:
-        """엔티티를 실제로 삭제합니다."""
-        try:
-            stmt = select(self.model).filter_by(ulid=ulid)
-            result = await self.session.execute(stmt)
-            entity = result.scalars().first()
-            
-            if entity:
-                await self.session.delete(entity)
-                await self.session.flush()
-                return True
-            return False
-            
-        except SQLAlchemyError as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_DELETE_ERROR,
-                detail=f"Database real delete error in {self.model.__tablename__}: {str(e)}",
-                source_function=f"{self.__class__.__name__}.real_delete",
-                original_error=e
-            ) 

aiteamutils-0.2.59/aiteamutils/base_service.py

@@ -1,260 +0,0 @@
-"""기본 서비스 모듈."""
-from datetime import datetime
-from typing import TypeVar, Generic, Dict, Any, List, Optional, Type
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase
-from fastapi import Request
-
-from .database import DatabaseService
-from .exceptions import CustomException, ErrorCode
-from .base_repository import BaseRepository
-
-ModelType = TypeVar("ModelType", bound=DeclarativeBase)
-
-class BaseService(Generic[ModelType]):
-    def __init__(
-        self,
-        db: DatabaseService,
-        repository: Optional[BaseRepository] = None,
-        request: Optional[Request] = None
-    ):
-        """BaseService 초기화
-        
-        Args:
-            db: 데이터베이스 서비스
-            repository: 레포지토리 인스턴스 (선택)
-            request: FastAPI 요청 객체 (선택)
-        """
-        self.db = db
-        self.repository = repository
-        self.request = request
-        self.model = repository.model if repository else None
-
-    def _process_response(self, entity: ModelType, response_model: Any = None) -> Dict[str, Any]:
-        """응답 데이터를 처리합니다.
-        
-        Args:
-            entity: 처리할 엔티티
-            response_model: 응답 모델 클래스
-            
-        Returns:
-            처리된 데이터
-        """
-        if not entity:
-            return None
-            
-        # 기본 데이터 변환
-        result = {}
-        
-        # 테이블 컬럼 처리
-        for column in entity.__table__.columns:
-            value = getattr(entity, column.name)
-            if isinstance(value, datetime):
-                value = value.isoformat()
-            result[column.name] = value
-        
-        # Relationship 처리 (이미 로드된 관계만)
-        for relationship in entity.__mapper__.relationships:
-            if relationship.key not in entity.__dict__:
-                continue
-                
-            try:
-                value = getattr(entity, relationship.key)
-                if value is not None:
-                    if isinstance(value, list):
-                        result[relationship.key] = [
-                            self._process_response(item)
-                            for item in value
-                        ]
-                    else:
-                        result[relationship.key] = self._process_response(value)
-                else:
-                    result[relationship.key] = None
-            except Exception:
-                result[relationship.key] = None
-        
-        # response_model이 있는 경우 필터링
-        if response_model:
-            # response_model에 없는 필드 제거
-            keys_to_remove = [key for key in result if key not in response_model.model_fields]
-            for key in keys_to_remove:
-                result.pop(key)
-            # 모델 검증
-            return response_model(**result).model_dump()
-            
-        return result
-
-    async def create(
-        self,
-        data: Dict[str, Any],
-        response_model: Any = None
-    ) -> Dict[str, Any]:
-        """엔티티를 생성합니다.
-        
-        Args:
-            data: 생성할 데이터
-            response_model: 응답 모델 클래스
-            
-        Returns:
-            생성된 엔티티
-            
-        Raises:
-            CustomException: 생성 실패 시
-        """
-        try:
-            entity = await self.db.create_entity(self.model, data)
-            return self._process_response(entity, response_model)
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_CREATE_ERROR,
-                detail=str(e),
-                source_function=f"{self.__class__.__name__}.create",
-                original_error=e
-            )
-
-    async def get(
-        self,
-        ulid: str,
-        response_model: Any = None
-    ) -> Dict[str, Any]:
-        """엔티티를 조회합니다.
-        
-        Args:
-            ulid: 조회할 엔티티의 ULID
-            response_model: 응답 모델 클래스
-            
-        Returns:
-            조회된 엔티티
-            
-        Raises:
-            CustomException: 조회 실패 시
-        """
-        try:
-            entity = await self.db.get_entity(self.model, {"ulid": ulid, "is_deleted": False})
-            if not entity:
-                raise CustomException(
-                    ErrorCode.NOT_FOUND,
-                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                    source_function=f"{self.__class__.__name__}.get"
-                )
-            return self._process_response(entity, response_model)
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_QUERY_ERROR,
-                detail=str(e),
-                source_function=f"{self.__class__.__name__}.get",
-                original_error=e
-            )
-
-    async def list(
-        self,
-        skip: int = 0,
-        limit: int = 100,
-        filters: Optional[Dict[str, Any]] = None,
-        response_model: Any = None
-    ) -> List[Dict[str, Any]]:
-        """엔티티 목록을 조회합니다.
-        
-        Args:
-            skip: 건너뛸 레코드 수
-            limit: 조회할 최대 레코드 수
-            filters: 필터 조건
-            response_model: 응답 모델 클래스
-            
-        Returns:
-            엔티티 목록
-            
-        Raises:
-            CustomException: 조회 실패 시
-        """
-        try:
-            entities = await self.db.list_entities(
-                self.model,
-                filters=filters,
-                skip=skip,
-                limit=limit
-            )
-            return [self._process_response(entity, response_model) for entity in entities]
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_QUERY_ERROR,
-                detail=str(e),
-                source_function=f"{self.__class__.__name__}.list",
-                original_error=e
-            )
-
-    async def update(
-        self,
-        ulid: str,
-        data: Dict[str, Any],
-        response_model: Any = None
-    ) -> Dict[str, Any]:
-        """엔티티를 수정합니다.
-        
-        Args:
-            ulid: 수정할 엔티티의 ULID
-            data: 수정할 데이터
-            response_model: 응답 모델 클래스
-            
-        Returns:
-            수정된 엔티티
-            
-        Raises:
-            CustomException: 수정 실패 시
-        """
-        try:
-            entity = await self.db.get_entity(self.model, {"ulid": ulid, "is_deleted": False})
-            if not entity:
-                raise CustomException(
-                    ErrorCode.NOT_FOUND,
-                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                    source_function=f"{self.__class__.__name__}.update"
-                )
-            updated = await self.db.update_entity(entity, data)
-            return self._process_response(updated, response_model)
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_UPDATE_ERROR,
-                detail=str(e),
-                source_function=f"{self.__class__.__name__}.update",
-                original_error=e
-            )
-
-    async def delete(self, ulid: str) -> bool:
-        """엔티티를 삭제합니다.
-        
-        Args:
-            ulid: 삭제할 엔티티의 ULID
-            
-        Returns:
-            삭제 성공 여부
-            
-        Raises:
-            CustomException: 삭제 실패 시
-        """
-        try:
-            entity = await self.db.get_entity(self.model, {"ulid": ulid, "is_deleted": False})
-            if not entity:
-                raise CustomException(
-                    ErrorCode.NOT_FOUND,
-                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                    source_function=f"{self.__class__.__name__}.delete"
-                )
-            return await self.db.delete_entity(entity)
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_DELETE_ERROR,
-                detail=str(e),
-                source_function=f"{self.__class__.__name__}.delete",
-                original_error=e
-            ) 

aiteamutils-0.2.59/aiteamutils/database.py

@@ -1,207 +0,0 @@
-"""데이터베이스 유틸리티 모듈."""
-from typing import Any, Dict, Optional, Type, List, Union
-from sqlalchemy import select, and_
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.exc import IntegrityError, SQLAlchemyError
-
-from .exceptions import ErrorCode, CustomException
-from .base_model import Base
-
-class DatabaseService:
-    def __init__(self, session: AsyncSession):
-        """DatabaseService 초기화
-        
-        Args:
-            session (AsyncSession): 외부에서 주입받은 데이터베이스 세션
-        """
-        self._session = session
-    
-    @property
-    def session(self) -> AsyncSession:
-        """현재 세션을 반환합니다."""
-        if self._session is None:
-            raise CustomException(
-                ErrorCode.DB_CONNECTION_ERROR,
-                detail="session",
-                source_function="DatabaseService.session"
-            )
-        return self._session
-
-    async def create_entity(
-        self,
-        model: Type[Base],
-        entity_data: Dict[str, Any]
-    ) -> Any:
-        """엔티티를 생성합니다.
-        
-        Args:
-            model: 모델 클래스
-            entity_data: 생성할 엔티티 데이터
-            
-        Returns:
-            생성된 엔티티
-            
-        Raises:
-            CustomException: 엔티티 생성 실패 시
-        """
-        try:
-            entity = model(**entity_data)
-            self.session.add(entity)
-            await self.session.flush()
-            await self.session.refresh(entity)
-            return entity
-        except IntegrityError as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_INTEGRITY_ERROR,
-                detail=str(e),
-                source_function="DatabaseService.create_entity",
-                original_error=e
-            )
-        except Exception as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_CREATE_ERROR,
-                detail=str(e),
-                source_function="DatabaseService.create_entity",
-                original_error=e
-            )
-
-    async def get_entity(
-        self,
-        model: Type[Base],
-        filters: Dict[str, Any]
-    ) -> Optional[Any]:
-        """필터 조건으로 엔티티를 조회합니다.
-        
-        Args:
-            model: 모델 클래스
-            filters: 필터 조건
-            
-        Returns:
-            조회된 엔티티 또는 None
-            
-        Raises:
-            CustomException: 조회 실패 시
-        """
-        try:
-            stmt = select(model).filter_by(**filters)
-            result = await self.session.execute(stmt)
-            return result.scalars().first()
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_QUERY_ERROR,
-                detail=str(e),
-                source_function="DatabaseService.get_entity",
-                original_error=e
-            )
-
-    async def list_entities(
-        self,
-        model: Type[Base],
-        filters: Optional[Dict[str, Any]] = None,
-        skip: int = 0,
-        limit: int = 100
-    ) -> List[Any]:
-        """엔티티 목록을 조회합니다.
-        
-        Args:
-            model: 모델 클래스
-            filters: 필터 조건
-            skip: 건너뛸 레코드 수
-            limit: 조회할 최대 레코드 수
-            
-        Returns:
-            엔티티 목록
-            
-        Raises:
-            CustomException: 조회 실패 시
-        """
-        try:
-            stmt = select(model)
-            if filters:
-                stmt = stmt.filter_by(**filters)
-            stmt = stmt.offset(skip).limit(limit)
-            result = await self.session.execute(stmt)
-            return result.scalars().all()
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_QUERY_ERROR,
-                detail=str(e),
-                source_function="DatabaseService.list_entities",
-                original_error=e
-            )
-
-    async def update_entity(
-        self,
-        entity: Base,
-        update_data: Dict[str, Any]
-    ) -> Any:
-        """엔티티를 수정합니다.
-        
-        Args:
-            entity: 수정할 엔티티
-            update_data: 수정할 데이터
-            
-        Returns:
-            수정된 엔티티
-            
-        Raises:
-            CustomException: 수정 실패 시
-        """
-        try:
-            for key, value in update_data.items():
-                setattr(entity, key, value)
-            await self.session.flush()
-            await self.session.refresh(entity)
-            return entity
-        except IntegrityError as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_INTEGRITY_ERROR,
-                detail=str(e),
-                source_function="DatabaseService.update_entity",
-                original_error=e
-            )
-        except Exception as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_UPDATE_ERROR,
-                detail=str(e),
-                source_function="DatabaseService.update_entity",
-                original_error=e
-            )
-
-    async def delete_entity(
-        self,
-        entity: Base,
-        soft_delete: bool = True
-    ) -> bool:
-        """엔티티를 삭제합니다.
-        
-        Args:
-            entity: 삭제할 엔티티
-            soft_delete: 소프트 삭제 여부
-            
-        Returns:
-            삭제 성공 여부
-            
-        Raises:
-            CustomException: 삭제 실패 시
-        """
-        try:
-            if soft_delete:
-                entity.is_deleted = True
-                await self.session.flush()
-            else:
-                await self.session.delete(entity)
-                await self.session.flush()
-            return True
-        except Exception as e:
-            await self.session.rollback()
-            raise CustomException(
-                ErrorCode.DB_DELETE_ERROR,
-                detail=str(e),
-                source_function="DatabaseService.delete_entity",
-                original_error=e
-            )

aiteamutils-0.2.59/aiteamutils/dependencies.py

@@ -1,138 +0,0 @@
-"""의존성 관리 모듈."""
-from typing import Type, TypeVar, Dict, Any, Optional, Callable, List, AsyncGenerator
-from fastapi import Request, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from .exceptions import CustomException, ErrorCode
-from .base_service import BaseService
-from .base_repository import BaseRepository
-from .database import DatabaseService
-
-T = TypeVar("T", bound=BaseService)
-R = TypeVar("R", bound=BaseRepository)
-
-_service_registry: Dict[str, Dict[str, Any]] = {}
-_session_provider = None
-
-__all__ = [
-    "setup_dependencies",
-    "register_service",
-    "get_service"
-]
-
-def setup_dependencies(session_provider: Callable[[], AsyncGenerator[AsyncSession, None]]) -> None:
-    """의존성 설정을 초기화합니다.
-    
-    Args:
-        session_provider: 데이터베이스 세션을 제공하는 함수
-    """
-    global _session_provider
-    _session_provider = session_provider
-
-def register_service(
-    service_class: Type[T],
-    repository_class: Optional[Type[R]] = None,
-    **kwargs
-) -> None:
-    """서비스를 등록합니다.
-    
-    Args:
-        service_class: 서비스 클래스
-        repository_class: 저장소 클래스 (선택)
-        **kwargs: 추가 의존성
-    """
-    if _session_provider is None:
-        raise CustomException(
-            ErrorCode.INTERNAL_ERROR,
-            detail="Dependencies not initialized",
-            source_function="dependencies.register_service"
-        )
-        
-    service_name = service_class.__name__
-    _service_registry[service_name] = {
-        "service_class": service_class,
-        "repository_class": repository_class,
-        "dependencies": kwargs
-    }
-
-async def _get_service(
-    service_name: str,
-    session: AsyncSession,
-    request: Request
-) -> BaseService:
-    """서비스 인스턴스를 생성합니다.
-    
-    Args:
-        service_name: 서비스 이름
-        session: 데이터베이스 세션
-        request: FastAPI 요청 객체
-        
-    Returns:
-        BaseService: 서비스 인스턴스
-        
-    Raises:
-        CustomException: 서비스 생성 실패 시
-    """
-    try:
-        service_info = _service_registry.get(service_name)
-        if not service_info:
-            raise CustomException(
-                ErrorCode.SERVICE_NOT_FOUND,
-                detail=service_name,
-                source_function="dependencies._get_service"
-            )
-            
-        service_class = service_info["service_class"]
-        repository_class = service_info["repository_class"]
-        dependencies = service_info["dependencies"]
-        
-        # 데이터베이스 서비스 생성
-        db_service = DatabaseService(session=session)
-        
-        # 저장소 인스턴스 생성
-        repository = None
-        if repository_class:
-            repository = repository_class(session=session)
-            
-        # 서비스 인스턴스 생성
-        service = service_class(
-            db=db_service,
-            repository=repository,
-            request=request,
-            **dependencies
-        )
-        
-        return service
-        
-    except CustomException as e:
-        raise e
-    except Exception as e:
-        raise CustomException(
-            ErrorCode.INTERNAL_ERROR,
-            detail=str(e),
-            source_function="dependencies._get_service",
-            original_error=e
-        )
-
-def get_service(service_name: str) -> Callable:
-    """서비스 의존성을 반환합니다.
-    
-    Args:
-        service_name: 서비스 이름
-        
-    Returns:
-        Callable: 서비스 의존성 함수
-    """
-    if _session_provider is None:
-        raise CustomException(
-            ErrorCode.INTERNAL_ERROR,
-            detail="Dependencies not initialized",
-            source_function="dependencies.get_service"
-        )
-    
-    async def _get_service_dependency(
-        request: Request,
-        session: AsyncSession = Depends(_session_provider)
-    ) -> BaseService:
-        return await _get_service(service_name, session, request)
-    return _get_service_dependency

aiteamutils-0.2.59/aiteamutils/version.py

@@ -1,2 +0,0 @@
-"""버전 정보"""
-__version__ = "0.2.59"