aiteamutils 0.2.58__tar.gz → 0.2.60__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiteamutils
-Version: 0.2.58
+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.58 → 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.58/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
-            )