aiteamutils 0.2.72__tar.gz → 0.2.75__tar.gz

{aiteamutils-0.2.72 → aiteamutils-0.2.75}/PKG-INFO

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

{aiteamutils-0.2.72 → aiteamutils-0.2.75}/aiteamutils/base_model.py

@@ -23,10 +23,17 @@ class BaseColumn(Base):
         doc="ULID",
         nullable=False
     )
-    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
+    created_at: Mapped[datetime] = mapped_column(
+        default=datetime.utcnow,
+        index=True
+    )
     updated_at: Mapped[datetime] = mapped_column(
         default=datetime.utcnow,
-        onupdate=datetime.utcnow
+        onupdate=datetime.utcnow,
+        index=True
+    )
+    deleted_at: Mapped[datetime] = mapped_column(
+        default=None,
     )
     is_deleted: Mapped[bool] = mapped_column(
         default=False,

aiteamutils-0.2.75/aiteamutils/base_repository.py

@@ -0,0 +1,141 @@
+#기본 라이브러리
+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,
+    get_entity,
+    create_entity,
+    update_entity,
+    delete_entity
+)
+
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+
+class BaseRepository(Generic[ModelType]):
+    def __init__(self, session: AsyncSession, model: Type[ModelType]):
+        self._session = session
+        self.model = model
+    
+    @property
+    def session(self) -> AsyncSession:
+        return self._session
+    
+    @session.setter
+    def session(self, value: AsyncSession):
+        if value is None:
+            raise CustomException(
+                ErrorCode.DB_CONNECTION_ERROR,
+                detail="Session cannot be None",
+                source_function=f"{self.__class__.__name__}.session"
+            )
+        self._session = value
+   
+    #######################
+    # 입력 및 수정, 삭제 #
+    ####################### 
+    async def create(self, entity_data: Dict[str, Any]) -> ModelType:
+        try:
+            return await create_entity(
+                session=self.session,
+                model=self.model,
+                entity_data=entity_data
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.create",
+                original_error=e
+            )
+        
+    async def update(
+        self,
+        update_data: Dict[str, Any],
+        conditions: Dict[str, Any]
+    ) -> ModelType:
+        try:
+            return await update_entity(
+                session=self.session,
+                model=self.model,
+                update_data=update_data,
+                conditions=conditions
+            )
+        except CustomException as e:
+            raise e
+        
+    async def delete(
+        self,
+        conditions: Dict[str, Any]
+    ) -> None:
+        await delete_entity(
+            session=self.session,
+            model=self.model,
+            conditions=conditions
+        )
+    
+    #########################
+    # 조회 및 검색 메서드 #
+    #########################
+    async def list(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None
+    ) -> List[ModelType]:
+        """
+        엔티티 목록 조회.
+        """
+        try:
+            # 기본 CRUD 작업 호출
+            return await list_entities(
+                session=self.session,
+                model=self.model,
+                skip=skip,
+                limit=limit,
+                filters=filters,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.list",
+                original_error=e
+            )
+        
+    async def get(
+        self,
+        conditions: Dict[str, Any] | None = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None
+    ) -> ModelType:
+        try:
+            return await get_entity(
+                session=self.session,
+                model=self.model,
+                conditions=conditions,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.get",
+                original_error=e
+            )

aiteamutils-0.2.75/aiteamutils/base_service.py

@@ -0,0 +1,258 @@
+#기본 라이브러리
+from fastapi import Request
+from typing import TypeVar, Generic, Type, Dict, Any, Union, List, Optional
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime
+from ulid import ULID
+
+#패키지 라이브러리
+from .exceptions import ErrorCode, CustomException
+from .base_repository import BaseRepository
+from .database import (
+    process_response,
+    validate_unique_fields
+)
+from .security import hash_password
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+
+class BaseService(Generic[ModelType]):
+    ##################
+    # 1. 초기화 영역 #
+    ##################
+    def __init__(
+            self,
+            model: Type[ModelType],
+            repository: BaseRepository[ModelType],
+            db_session: AsyncSession,
+            additional_models: Dict[str, Type[DeclarativeBase]] = None,
+    ):
+        self.model = model
+        self.repository = repository
+        self.db_session = db_session
+        self.additional_models = additional_models or {},
+    
+    #######################
+    # 입력 및 수정, 삭제 #
+    #######################
+    async def create(
+        self,
+        entity_data: Dict[str, Any],
+        model_name: str | None = None,
+        response_model: Any = None,
+        exclude_entities: List[str] | None = None,
+        unique_check: List[Dict[str, Any]] | None = None,
+        fk_check: List[Dict[str, Any]] | None = None,
+    ) -> ModelType:
+        
+        try:
+            # 고유 검사 수행
+            if unique_check:
+                await validate_unique_fields(self.db_session, unique_check, find_value=True)
+            # 외래 키 검사 수행
+            if fk_check:
+                await validate_unique_fields(self.db_session, fk_check, find_value=False)
+            # 비밀번호가 있으면 해시 처리
+            if "password" in entity_data:
+                entity_data["password"] = hash_password(entity_data["password"])
+            # 제외할 엔티티가 있으면 제외
+            if exclude_entities:
+                entity_data = {k: v for k, v in entity_data.items() if k not in exclude_entities}
+
+            # repository의 create 메서드를 트랜잭션 내에서 실행
+            return await self.repository.create(entity_data)
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            # 다른 예외 처리
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.create",
+                original_error=e
+            )
+        
+    async def update(
+        self,
+        ulid: str | None = None,
+        update_data: Dict[str, Any] | None = None,
+        conditions: Dict[str, Any] | None = None,
+        unique_check: List[Dict[str, Any]] | None = None,
+        exclude_entities: List[str] | None = None
+    ) -> ModelType:
+        try:
+            # 고유 검사 수행
+            if unique_check:
+                await validate_unique_fields(self.db_session, unique_check, find_value=True)
+            # 비밀번호가 있으면 해시 처리
+            if "password" in update_data:
+                update_data["password"] = hash_password(update_data["password"])
+            # 제외할 엔티티가 있으면 제외
+            if exclude_entities:
+                update_data = {k: v for k, v in update_data.items() if k not in exclude_entities}
+
+            if not ulid and not conditions:
+                raise CustomException(
+                    ErrorCode.INVALID_INPUT,
+                    detail="Either 'ulid' or 'conditions' must be provided.",
+                    source_function="database.update_entity"
+                )
+
+            # ulid로 조건 생성
+            if ulid:
+                if not ULID.from_str(ulid):
+                    raise CustomException(
+                        ErrorCode.VALIDATION_ERROR,
+                        detail=ulid,
+                        source_function=f"{self.__class__.__name__}.update"
+                    )
+                
+                conditions = {"ulid": ulid}
+
+            return await self.repository.update(
+                update_data=update_data,
+                conditions=conditions
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.update",
+                original_error=e
+            )
+
+    async def delete(
+        self,
+        ulid: str | None = None,
+        conditions: Dict[str, Any] | None = None
+    ) -> None:
+        try:
+            if not ULID.from_str(ulid):
+                raise CustomException(
+                    ErrorCode.VALIDATION_ERROR,
+                    detail=ulid,
+                    source_function=f"{self.__class__.__name__}.delete"
+                )
+            
+            if not ulid and not conditions:
+                raise CustomException(
+                    ErrorCode.INVALID_INPUT,
+                    detail="Either 'ulid' or 'conditions' must be provided.",
+                    source_function="database.update_entity"
+                )
+
+            # ulid로 조건 생성
+            if ulid:
+                conditions = {"ulid": ulid}
+
+            conditions["is_deleted"] = False
+
+            return await self.repository.delete(
+                conditions=conditions
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.delete",
+                original_error=e
+            )
+
+    #########################
+    # 조회 및 검색 메서드 #
+    #########################
+    async def list(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        filters: List[Dict[str, Any]] | None = None,
+        model_name: str | None = None,
+        response_model: Any = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = 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]
+                entities = await self.repository.list(
+                    skip=skip,
+                    limit=limit,
+                    filters=filters,
+                    model=model
+                )
+                return [process_response(entity, response_model) for entity in entities]
+
+            entities = await self.repository.list(
+                skip=skip,
+                limit=limit,
+                filters=filters,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins
+            )
+            return [process_response(entity, response_model) for entity in entities]
+        
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                source_function=f"{self.__class__.__name__}.list",
+                original_error=e
+            )
+        
+    async def get(
+        self,
+        ulid: str,
+        model_name: str | None = None,
+        response_model: Any = None,
+        conditions: Dict[str, Any] | None = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None
+    ):
+        try:
+            if not ulid and not conditions:
+                raise CustomException(
+                    ErrorCode.INVALID_INPUT,
+                    detail="Either 'ulid' or 'conditions' must be provided.",
+                    source_function="database.update_entity"
+                )
+
+            # ulid로 조건 생성
+            if ulid:
+                if not ULID.from_str(ulid):
+                    raise CustomException(
+                        ErrorCode.VALIDATION_ERROR,
+                        detail=ulid,
+                        source_function=f"{self.__class__.__name__}.update"
+                    )
+                
+                conditions = {"ulid": ulid}
+            
+            entity = await self.repository.get(
+                conditions=conditions,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins
+            )
+            return process_response(entity, response_model)
+
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.get",
+                original_error=e
+            )
+