aiteamutils 0.2.48__tar.gz → 0.2.101__tar.gz

{aiteamutils-0.2.48 → aiteamutils-0.2.101}/.gitignore

@@ -13,15 +13,10 @@ build/
 .vscode/
 .idea/
 
-# Client specific
-clients/
-!clients/.gitkeep
-!frontend/src/clients
-
 # Logs
 *.log
 npm-debug.log*
 
 # System
 .DS_Store
-Thumbs.db 
+Thumbs.db

{aiteamutils-0.2.48 → aiteamutils-0.2.101}/PKG-INFO

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

{aiteamutils-0.2.48 → aiteamutils-0.2.101}/aiteamutils/__init__.py

@@ -1,11 +1,4 @@
 from .base_model import Base
-from .database import (
-    DatabaseService,
-    DatabaseServiceManager,
-    get_db,
-    get_database_service,
-    lifespan
-)
 from .exceptions import (
     CustomException,
     ErrorCode,
@@ -34,13 +27,6 @@ __all__ = [
     "BaseService",
     "BaseRepository",
     
-    # Database
-    "DatabaseService",
-    "DatabaseServiceManager",
-    "get_db",
-    "get_database_service",
-    "lifespan",
-    
     # Exceptions
     "CustomException",
     "ErrorCode",

{aiteamutils-0.2.48 → aiteamutils-0.2.101}/aiteamutils/base_model.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, TypeVar, Generic, Optional
 from ulid import ULID
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
@@ -23,10 +23,21 @@ class BaseColumn(Base):
         doc="ULID",
         nullable=False
     )
-    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
+    created_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP(timezone=True),
+        default=datetime.now(timezone.utc),
+        index=True
+    )
     updated_at: Mapped[datetime] = mapped_column(
-        default=datetime.utcnow,
-        onupdate=datetime.utcnow
+        TIMESTAMP(timezone=True),
+        default=datetime.now(timezone.utc),
+        onupdate=datetime.now(timezone.utc),
+        index=True
+    )
+    deleted_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP(timezone=True),
+        default=None,
+        nullable=True
     )
     is_deleted: Mapped[bool] = mapped_column(
         default=False,

aiteamutils-0.2.101/aiteamutils/base_repository.py

@@ -0,0 +1,150 @@
+#기본 라이브러리
+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],
+        exclude_entities: List[str] | None = None
+    ) -> ModelType:
+        try:
+            return await create_entity(
+                session=self.session,
+                model=self.model,
+                entity_data=entity_data,
+                exclude_entities=exclude_entities
+            )
+        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],
+        exclude_entities: List[str] | None = None
+    ) -> ModelType:
+        try:
+            return await update_entity(
+                session=self.session,
+                model=self.model,
+                update_data=update_data,
+                conditions=conditions,
+                exclude_entities=exclude_entities
+            )
+        except CustomException as e:
+            raise e
+        
+    async def delete(
+        self,
+        conditions: Dict[str, Any]
+    ) -> bool:
+        await delete_entity(
+            session=self.session,
+            model=self.model,
+            conditions=conditions
+        )
+        return True
+    #########################
+    # 조회 및 검색 메서드 #
+    #########################
+    async def list(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[List[Dict[str, Any]]] = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None,
+        order: Optional[List[Dict[str, str]]] = 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,
+                order=order
+            )
+        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.101/aiteamutils/base_service.py

@@ -0,0 +1,301 @@
+#기본 라이브러리
+from fastapi import Request
+from typing import TypeVar, Generic, Type, Dict, Any, Union, List, Optional, Literal
+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, verify_jwt_token, verify_role_permission
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+
+class BaseService(Generic[ModelType]):
+    ##################
+    # 초기화 영역 #
+    ##################
+    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,
+        request: Request,
+        entity_data: Dict[str, Any],
+        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,
+        org_ulid_position: str = "organization_ulid",
+        role_permission: str | None = None,
+        token_settings: Dict[str, Any] | None = None
+    ) -> ModelType:
+        
+        if role_permission:
+            permission_result = await verify_role_permission(
+                request=request,
+                role_permission=role_permission,
+                token_settings=token_settings,
+                org_ulid_position=org_ulid_position
+            )
+        
+            if not permission_result:
+                raise CustomException(
+                    ErrorCode.FORBIDDEN,
+                    detail=f"{role_permission}",
+                    source_function=f"{self.__class__.__name__}.create"
+                )
+        
+        try:
+            async with self.db_session.begin():
+                # 고유 검사 수행
+                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)
+                
+                result = await self.repository.create(
+                    entity_data=entity_data,
+                    exclude_entities=exclude_entities
+                )
+
+                # 결과 반환
+                if response_model:
+                    return process_response(result, response_model)
+                else:
+                    return result
+
+        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,
+        request: Request,
+        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,
+        response_model: Any = None,
+        org_ulid_position: str = "organization_ulid",
+        role_permission: str = "update",
+        token_settings: Dict[str, Any] | None = None
+    ) -> ModelType:
+        try:
+            async with self.db_session.begin():
+                # 고유 검사 수행
+                if unique_check:
+                    await validate_unique_fields(self.db_session, unique_check, find_value=True)
+
+                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}
+
+                result = await self.repository.update(
+                    update_data=update_data,
+                    conditions=conditions,
+                    exclude_entities=exclude_entities
+                )
+
+                if response_model:
+                    return process_response(result, response_model)
+                else:
+                    return result
+        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,
+        request: Request,
+        ulid: str | None = None,
+        conditions: Dict[str, Any] | None = None,
+        org_ulid_position: str = "organization_ulid",
+        role_permission: str = "delete",
+        token_settings: Dict[str, Any] | None = None
+    ) -> bool:
+        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,
+        request: Request,
+        skip: int = 0,
+        limit: int = 100,
+        filters: List[Dict[str, Any]] | None = None,
+        org_ulid_position: str = "organization_ulid",
+        role_permission: str | None = None,
+        response_model: Any = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None,
+        order: Optional[str] = None,
+        token_settings: Dict[str, Any] | None = None
+    ) -> List[Dict[str, Any]]:
+        filters = list(filters) if filters is not None else []
+
+        # if role_permission:
+        #     permission_result = await verify_role_permission(
+        #         request=request,
+        #         role_permission=role_permission,
+        #         token_settings=token_settings,
+        #         org_ulid_position=org_ulid_position
+        #     )
+
+        #     if permission_result and isinstance(permission_result, dict):
+        #         filters.append(permission_result)
+
+        try:
+            if order is None:
+                order = "created_at|desc"
+
+                order_by = order.split("|")
+                order = [{"field": order_by[0], "direction": order_by[1]}]
+
+            entities = await self.repository.list(
+                skip=skip,
+                limit=limit,
+                filters=filters,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins,
+                order=order
+            )
+            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,
+        request: Request,
+        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,
+        org_ulid_position: str = "organization_ulid",
+        role_permission: str = "get",
+        token_settings: Dict[str, Any] | None = 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
+            )
+

{aiteamutils-0.2.48 → aiteamutils-0.2.101}/aiteamutils/config.py

@@ -1,6 +1,5 @@
 """설정 모듈."""
 from typing import Union
-from .database import DatabaseServiceManager
 from .exceptions import CustomException, ErrorCode
 
 class Settings:
@@ -11,13 +10,28 @@ class Settings:
         jwt_algorithm: str = "HS256",
         access_token_expire_minutes: int = 30,
         token_issuer: str = "ai-team",
-        token_audience: str = "ai-team"
+        token_audience: str = "ai-team",
+        db_url: str = None,
+        db_echo: bool = False,
+        db_pool_size: int = 5,
+        db_max_overflow: int = 10,
+        db_pool_timeout: int = 30,
+        db_pool_recycle: int = 1800
     ):
+        # JWT 설정
         self.JWT_SECRET = jwt_secret
         self.JWT_ALGORITHM = jwt_algorithm
         self.ACCESS_TOKEN_EXPIRE_MINUTES = access_token_expire_minutes
         self.TOKEN_ISSUER = token_issuer
         self.TOKEN_AUDIENCE = token_audience
+        
+        # 데이터베이스 설정
+        self.DB_URL = db_url
+        self.DB_ECHO = db_echo
+        self.DB_POOL_SIZE = db_pool_size
+        self.DB_MAX_OVERFLOW = db_max_overflow
+        self.DB_POOL_TIMEOUT = db_pool_timeout
+        self.DB_POOL_RECYCLE = db_pool_recycle
 
 _settings: Union[Settings, None] = None
 
@@ -55,18 +69,14 @@ async def init_settings(
         jwt_algorithm=jwt_algorithm,
         access_token_expire_minutes=access_token_expire_minutes,
         token_issuer=token_issuer,
-        token_audience=token_audience
+        token_audience=token_audience,
+        db_url=db_url,
+        db_echo=db_echo,
+        db_pool_size=db_pool_size,
+        db_max_overflow=db_max_overflow,
+        db_pool_timeout=db_pool_timeout,
+        db_pool_recycle=db_pool_recycle
     )
-    
-    if db_url:
-        await DatabaseServiceManager.get_instance(
-            db_url=db_url,
-            db_echo=db_echo,
-            db_pool_size=db_pool_size,
-            db_max_overflow=db_max_overflow,
-            db_pool_timeout=db_pool_timeout,
-            db_pool_recycle=db_pool_recycle
-        )
 
 def get_settings() -> Settings:
     """현재 설정을 반환하는 함수