aiteamutils 0.2.64__py3-none-any.whl → 0.2.66__py3-none-any.whl

aiteamutils/base_repository.py

@@ -13,24 +13,8 @@ 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"
-            )
-        print(f"BaseRepository.__init__() called with session: {session} and model: {model}")
-
         self._session = session
         self.model = model
-        
-        print(f"BaseRepository initialized with session: {session} and model: {model}")
     
     @property
     def session(self) -> AsyncSession:
@@ -51,7 +35,7 @@ class BaseRepository(Generic[ModelType]):
         skip: int = 0,
         limit: int = 100,
         filters: Optional[Dict[str, Any]] = None,
-        joins: Optional[List[Any]] = None
+        joins: Optional[List[Any]] = None,
     ) -> List[ModelType]:
         """
         엔티티 목록 조회.

aiteamutils/base_service.py

@@ -4,9 +4,14 @@ 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
+from .database import (
+    process_response,
+    build_search_filters
+)
 
 ModelType = TypeVar("ModelType", bound=DeclarativeBase)
 
@@ -18,28 +23,13 @@ class BaseService(Generic[ModelType]):
             self,
             model: Type[ModelType],
             repository: BaseRepository[ModelType],
-            db_session: AsyncSession
+            db_session: AsyncSession,
+            additional_models: Dict[str, Type[DeclarativeBase]] = None,
     ):
-        if not repository:
-            raise CustomException(
-                ErrorCode.INVALID_REQUEST,
-                detail="Repository is not set",
-                source_function=f"{self.__class__.__name__}.__init__"
-            )
-        if not db_session:
-            raise CustomException(
-                ErrorCode.INVALID_REQUEST,
-                detail="Database session is not set",
-                source_function=f"{self.__class__.__name__}.__init__"
-            )
-        print(f"BaseService.__init__() called with repository: {repository} and db_session: {db_session}")
-
-
         self.model = model
         self.repository = repository
         self.db_session = db_session
-
-        print(f"BaseService initialized with repository: {repository} and db_session: {db_session}")
+        self.additional_models = additional_models or {},
 
     async def list(
         self,
@@ -48,8 +38,19 @@ class BaseService(Generic[ModelType]):
         filters: Dict[str, Any] | None = None,
         search_params: Dict[str, Any] | None = None,
         model_name: str | None = None,
+        request: Request | None = None,
+        response_model: Any = None
     ) -> List[Dict[str, Any]]:
         try:
+            # 검색 조건 처리 및 필터 병합
+            if search_params:
+                search_filters = build_search_filters(request, search_params)
+                if filters:
+                    # 기존 filters와 search_filters 병합 (search_filters가 우선 적용)
+                    filters.update(search_filters)
+                else:
+                    filters = search_filters
+
             # 모델 이름을 통한 동적 처리
             if model_name:
                 if model_name not in self.additional_models:

aiteamutils/database.py

@@ -4,14 +4,184 @@ 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 datetime import datetime
 
 #패키지 라이브러리
 from .exceptions import ErrorCode, CustomException
 
+
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+
+##################
+# 전처리 #
+##################
+
+
+
 ##################
-# 1. 쿼리 실행 #
+# 응답 처리 #
+##################
+def process_columns(
+        entity: ModelType,
+        exclude_extra_data: bool = True
+) -> Dict[str, Any]:
+    """엔티티의 컬럼들을 처리합니다.
+
+    Args:
+        entity (ModelType): 처리할 엔티티
+        exclude_extra_data (bool, optional): extra_data 컬럼 제외 여부. Defaults to True.
+
+    Returns:
+        Dict[str, Any]: 처리된 컬럼 데이터
+    """
+    result = {}
+    for column in entity.__table__.columns:
+        if exclude_extra_data and column.name == 'extra_data':
+            continue
+            
+        # 필드 값 처리
+        if hasattr(entity, column.name):
+            value = getattr(entity, column.name)
+            if isinstance(value, datetime):
+                value = value.isoformat()
+            result[column.name] = value
+        elif hasattr(entity, 'extra_data') and isinstance(entity.extra_data, dict):
+            result[column.name] = entity.extra_data.get(column.name)
+        else:
+            result[column.name] = None
+    
+    # extra_data의 내용을 최상위 레벨로 업데이트
+    if hasattr(entity, 'extra_data') and isinstance(entity.extra_data, dict):
+        result.update(entity.extra_data or {})
+            
+    return result
+
+def process_response(
+        entity: ModelType,
+        response_model: Any = None
+) -> Dict[str, Any]:
+    """응답 데이터를 처리합니다.
+    extra_data의 내용을 최상위 레벨로 변환하고, 라우터에서 선언한 응답 스키마에 맞게 데이터를 변환합니다.
+
+    Args:
+        entity (ModelType): 처리할 엔티티
+        response_model (Any, optional): 응답 스키마. Defaults to None.
+
+    Returns:
+        Dict[str, Any]: 처리된 엔티티 데이터
+    """
+    if not entity:
+        return None
+
+    # 모든 필드 처리
+    result = process_columns(entity)
+    
+    # Relationship 처리 (이미 로드된 관계만 처리)
+    for relationship in entity.__mapper__.relationships:
+        if not relationship.key in entity.__dict__:
+            continue
+            
+        try:
+            value = getattr(entity, relationship.key)
+            # response_model이 있는 경우 해당 필드의 annotation type을 가져옴
+            nested_response_model = None
+            if response_model and relationship.key in response_model.model_fields:
+                field_info = response_model.model_fields[relationship.key]
+                nested_response_model = field_info.annotation
+            
+            if value is not None:
+                if isinstance(value, list):
+                    result[relationship.key] = [
+                        process_response(item, nested_response_model)
+                        for item in value
+                    ]
+                else:
+                    result[relationship.key] = process_response(value, nested_response_model)
+            else:
+                result[relationship.key] = None
+        except Exception:
+            result[relationship.key] = None
+
+    # response_model이 있는 경우 필터링
+    if response_model:
+        # 현재 키 목록을 저장
+        current_keys = list(result.keys())
+        # response_model에 없는 키 제거
+        for key in current_keys:
+            if key not in response_model.model_fields:
+                result.pop(key)
+        # 모델 검증 및 업데이트
+        result.update(response_model(**result).model_dump())
+            
+    return result
+
+
+##################
+# 조건 처리 #
+##################
+def build_search_filters(
+        request: Dict[str, Any],
+        search_params: Dict[str, Dict[str, Any]]
+) -> Dict[str, Any]:
+    """
+    요청 데이터와 검색 파라미터를 기반으로 필터 조건을 생성합니다.
+
+    Args:
+        request: 요청 데이터 (key-value 형태).
+        search_params: 검색 조건 설정을 위한 파라미터.
+
+    Returns:
+        filters: 필터 조건 딕셔너리.
+    """
+    filters = {}
+    for key, param in search_params.items():
+        value = request.get(key)
+        if value is not None:
+            if param["like"]:
+                filters[key] = {"field": param["fields"][0], "operator": "like", "value": f"%{value}%"}
+            else:
+                filters[key] = {"field": param["fields"][0], "operator": "eq", "value": value}
+    return filters
+
+def build_conditions(
+        filters: Dict[str, Any],
+        model: Type[ModelType]
+) -> List[Any]:
+    """
+    필터 조건을 기반으로 SQLAlchemy 조건 리스트를 생성합니다.
+
+    Args:
+        filters: 필터 조건 딕셔너리.
+        model: SQLAlchemy 모델 클래스.
+
+    Returns:
+        List[Any]: SQLAlchemy 조건 리스트.
+    """
+    conditions = []
+    for filter_data in filters.values():
+        if "." in filter_data["field"]:
+            # 관계를 따라 암묵적으로 연결된 모델의 필드 가져오기
+            related_model_name, field_name = filter_data["field"].split(".")
+            relationship_property = getattr(model, related_model_name)
+            related_model = relationship_property.property.mapper.class_
+            field = getattr(related_model, field_name)
+        else:
+            # 현재 모델의 필드 가져오기
+            field = getattr(model, filter_data["field"])
+
+        # 조건 생성
+        operator = filter_data["operator"]
+        value = filter_data["value"]
+
+        if operator == "like":
+            conditions.append(field.ilike(f"%{value}%"))
+        elif operator == "eq":
+            conditions.append(field == value)
+
+    return conditions
+
+##################
+# 쿼리 실행 #
 ##################
 async def list_entities(
     session: AsyncSession,
@@ -21,12 +191,38 @@ async def list_entities(
     filters: Optional[Dict[str, Any]] = None,
     joins: Optional[List[Any]] = None
 ) -> List[Dict[str, Any]]:
+    """
+    엔터티 리스트를 필터 및 조건에 따라 가져오는 함수.
+
+    Args:
+        session: SQLAlchemy AsyncSession.
+        model: SQLAlchemy 모델.
+        skip: 페이지네이션 시작 위치.
+        limit: 페이지네이션 크기.
+        filters: 필터 조건 딕셔너리.
+            예시:
+            filters = {
+                "search": {"field": "username", "operator": "like", "value": "%admin%"},
+                "name": {"field": "name", "operator": "like", "value": "%John%"},
+                "role_ulid": {"field": "role_ulid", "operator": "eq", "value": "1234"}
+            }
+
+        joins: 조인 옵션.
+            예시:
+            joins = [
+                selectinload(YourModel.related_field),  # 관련된 필드를 함께 로드
+                joinedload(YourModel.another_related_field)  # 다른 관계된 필드를 조인
+            ]
+
+    Returns:
+        List[Dict[str, Any]]: 쿼리 결과 리스트.
+    """
     try:
         query = select(model)
 
         # 필터 조건 적용
         if filters:
-            conditions = [getattr(model, key) == value for key, value in filters.items()]
+            conditions = build_conditions(filters, model)
             query = query.where(and_(*conditions))
 
         # 조인 로딩 적용

aiteamutils/version.py

@@ -1,2 +1,2 @@
 """버전 정보"""
-__version__ = "0.2.64"
+__version__ = "0.2.66"

{aiteamutils-0.2.64.dist-info → aiteamutils-0.2.66.dist-info}/METADATA

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

{aiteamutils-0.2.64.dist-info → aiteamutils-0.2.66.dist-info}/RECORD

@@ -1,15 +1,15 @@
 aiteamutils/__init__.py,sha256=kRBpRjark0M8ZwFfmKiMFol6CbIILN3WE4f6_P6iIq0,1089
 aiteamutils/base_model.py,sha256=ODEnjvUVoxQ1RPCfq8-uZTfTADIA4c7Z3E6G4EVsSX0,2708
-aiteamutils/base_repository.py,sha256=oA91ZtAM8LvdULL0gBB1U-7sj4Up5qUoXh1HJctnTGw,2210
-aiteamutils/base_service.py,sha256=GZY9Xx-nu4EGOQuCissnulc9nGL5DpE2CypX5wj-I-o,2908
+aiteamutils/base_repository.py,sha256=Vbz2_BGT6gSf8fV2Ph4JWalrsNCDZSjLbOdRwCnz3I4,1540
+aiteamutils/base_service.py,sha256=CfNBAgFREqOC1791ex2plKLZiSZ1U5el4GvvkVsN4qU,2901
 aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
 aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
-aiteamutils/database.py,sha256=MtmrX_pDzKFQM-P3OAfm2mALvhRg-v5JWtGBoiegeU0,1484
+aiteamutils/database.py,sha256=CbX7eNFwqz9O4ywVQMLlLrb6hDUJPtsgGg_Hgef-p2I,8126
 aiteamutils/enums.py,sha256=ipZi6k_QD5-3QV7Yzv7bnL0MjDz-vqfO9I5L77biMKs,632
 aiteamutils/exceptions.py,sha256=_lKWXq_ujNj41xN6LDE149PwsecAP7lgYWbOBbLOntg,15368
 aiteamutils/security.py,sha256=xFVrjttxwXB1TTjqgRQQgQJQohQBT28vuW8FVLjvi-M,10103
 aiteamutils/validators.py,sha256=PvI9hbMEAqTawgxPbiWRyx2r9yTUrpNBQs1AD3w4F2U,7726
-aiteamutils/version.py,sha256=Ab2-CQIQ45ZW4Pc2j-7gD_cs2b9qIq_4inLBWtqYLgU,42
-aiteamutils-0.2.64.dist-info/METADATA,sha256=EQlA6VzdmjttNL8PgZftxQevln_ltjDkD7wbiZ6MRvs,1718
-aiteamutils-0.2.64.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.64.dist-info/RECORD,,
+aiteamutils/version.py,sha256=sLTec9HL2qseXAi6mzbn7T-ZwoQOncK22kiRkfVSwH8,42
+aiteamutils-0.2.66.dist-info/METADATA,sha256=SkG0OhfTLO7TiWa1LtvRjPnBNYPqULCb8sb6PllJ21s,1718
+aiteamutils-0.2.66.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.66.dist-info/RECORD,,