aiteamutils 0.2.157__py3-none-any.whl → 0.2.159__py3-none-any.whl

aiteamutils/base_service.py

@@ -39,181 +39,191 @@ class BaseService(Generic[ModelType]):
     #######################
     # 입력 및 수정, 삭제 #
     #######################
-    async def _process_files(
+    async def _separate_file_data(
         self,
-        entity_data: Dict[str, Any],
-        entity_result: Any,
-        storage_dir: str,
-        operation: Literal["create", "update", "delete"] = "create"
+        entity_data: Dict[str, Any]
     ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-        """파일 처리를 위한 내부 메서드
+        """파일 데이터를 엔티티 데이터에서 분리하는 함수
         
         Args:
             entity_data (Dict[str, Any]): 엔티티 데이터
-            entity_result (Any): 생성/수정된 엔티티 결과
-            storage_dir (str): 저장 디렉토리 경로
-            operation (str): 수행할 작업 유형 ("create", "update", "delete")
             
         Returns:
-            Tuple[Dict[str, Any], Dict[str, Any]]: (처리된 엔티티 데이터, 파일 정보)
+            Tuple[Dict[str, Any], Dict[str, Any]]: (파일 제외된 엔티티 데이터, 분리된 파일 데이터)
         """
         try:
-            logger.info(f"[파일 처리 시작] operation: {operation}, storage_dir: {storage_dir}")
-            logger.info(f"[엔티티 데이터] {entity_data}")
-            
+            logger.info("[파일 데이터 분리 시작]")
             entity_data_copy = entity_data.copy()
-            file_infos = {}
-            
-            # 파일 데이터 분리
             separated_files = {}
-            if operation != "delete" and 'extra_data' in entity_data_copy and isinstance(entity_data_copy['extra_data'], dict):
-                logger.info(f"[extra_data 확인] {entity_data_copy['extra_data']}")
+            
+            if 'extra_data' in entity_data_copy and isinstance(entity_data_copy['extra_data'], dict):
                 extra_data = entity_data_copy['extra_data'].copy()
-                # 파일 필드 체크 로직 수정
-                file_fields = {}
-                for k, v in extra_data.items():
-                    logger.info(f"[필드 검사] 필드명: {k}, 타입: {type(v)}, 값: {v}")
-                    if v and isinstance(v, (list, tuple)):
-                        logger.info(f"[리스트/튜플 검사] 필드명: {k}, 첫 번째 항목 타입: {type(v[0]) if v else 'None'}")
-                        # 파일 객체를 포함하는 튜플/리스트인 경우만 처리
-                        if any(isinstance(item, (tuple, list)) and len(item) == 2 and hasattr(item[0], 'read') for item in v):
-                            logger.info(f"[파일 객체 포함 필드 발견] {k}")
-                            file_fields[k] = v
-                
-                logger.info(f"[파일 필드 확인] {file_fields}")
-                logger.info(f"[파일 필드 타입] {[(k, type(v), type(v[0]) if isinstance(v, list) and v else None) for k, v in file_fields.items()]}")
+                fields_to_remove = []
                 
-                if file_fields and not storage_dir:
-                    logger.error("[에러] storage_dir이 필요하지만 제공되지 않음")
-                    raise CustomException(
-                        ErrorCode.INVALID_INPUT,
-                        detail="storage_dir is required for file upload",
-                        source_function=f"{self.__class__.__name__}._process_files"
-                    )
+                # 파일 필드 체크 및 분리 (딕셔너리 수정 없이)
+                for field_name, files in extra_data.items():
+                    logger.info(f"[필드 검사] 필드명: {field_name}, 타입: {type(files)}")
+                    if files and isinstance(files, (list, tuple)):
+                        # 파일 객체를 포함하는 튜플/리스트인 경우만 처리
+                        if any(isinstance(item, (tuple, list)) and len(item) == 2 and hasattr(item[0], 'read') for item in files):
+                            logger.info(f"[파일 필드 발견] {field_name}")
+                            separated_files[field_name] = files
+                            fields_to_remove.append(field_name)
                 
-                # 파일 필드 분리 및 제거
-                for field_name, files in file_fields.items():
-                    logger.info(f"[파일 처리] 필드: {field_name}, 파일 수: {len(files)}")
-                    logger.info(f"[파일 상세] 필드: {field_name}, 파일 내용: {files}")
-                    separated_files[field_name] = files
+                # 파일 필드 제거 (별도 단계로 분리)
+                for field_name in fields_to_remove:
                     del extra_data[field_name]
                 
                 entity_data_copy['extra_data'] = extra_data
-                logger.info(f"[파일 분리 후 extra_data] {entity_data_copy['extra_data']}")
-
-            # 기존 파일 삭제 (update 또는 delete 작업 시)
-            if operation in ["update", "delete"]:
-                logger.info("[기존 파일 삭제 시작]")
-                from .files import FileHandler
-                # files 테이블에서 기존 파일 정보 조회
-                existing_files = await self.db_session.execute(
-                    text("""
-                        SELECT storage_path 
-                        FROM files 
-                        WHERE entity_name = :entity_name 
-                        AND entity_ulid = :entity_ulid
-                    """),
-                    {
-                        "entity_name": self.model.__tablename__,
-                        "entity_ulid": entity_result.ulid
-                    }
+            
+            logger.info("[파일 데이터 분리 완료]")
+            return entity_data_copy, separated_files
+            
+        except Exception as e:
+            logger.error(f"[파일 분리 중 에러 발생] {str(e)}")
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}._separate_file_data",
+                original_error=e
+            )
+
+    async def _save_files(
+        self,
+        separated_files: Dict[str, Any],
+        entity_result: Any,
+        storage_dir: str
+    ) -> Dict[str, Any]:
+        """분리된 파일 데이터를 저장하는 함수
+        
+        Args:
+            separated_files (Dict[str, Any]): 분리된 파일 데이터
+            entity_result (Any): 생성/수정된 엔티티
+            storage_dir (str): 저장 디렉토리
+            
+        Returns:
+            Dict[str, Any]: 저장된 파일 정보
+        """
+        try:
+            if not storage_dir:
+                raise CustomException(
+                    ErrorCode.INVALID_INPUT,
+                    detail="storage_dir is required for file upload",
+                    source_function=f"{self.__class__.__name__}._save_files"
                 )
-                existing_files = existing_files.fetchall()
-                logger.info(f"[기존 파일 조회 결과] {existing_files}")
-                
-                # 기존 파일 삭제
-                for file_info in existing_files:
-                    logger.info(f"[파일 삭제] {file_info[0]}")
-                    await FileHandler.delete_files(file_info[0])
-                
-                # files 테이블에서 레코드 삭제
-                await self.db_session.execute(
-                    text("""
-                        DELETE FROM files 
-                        WHERE entity_name = :entity_name 
-                        AND entity_ulid = :entity_ulid
-                    """),
-                    {
-                        "entity_name": self.model.__tablename__,
-                        "entity_ulid": entity_result.ulid
-                    }
+            
+            logger.info("[파일 저장 시작]")
+            file_infos = {}
+            from .files import FileHandler
+            
+            for field_name, files in separated_files.items():
+                logger.info(f"[필드 처리] {field_name}, 파일 수: {len(files)}")
+                saved_files = await FileHandler.save_files(
+                    files=files,
+                    storage_dir=storage_dir,
+                    entity_name=self.model.__tablename__,
+                    entity_ulid=entity_result.ulid,
+                    db_session=self.db_session,
+                    column_name=field_name
                 )
-                logger.info("[기존 파일 DB 레코드 삭제 완료]")
-
-            # 새 파일 저장 (create 또는 update 작업 시)
-            if operation != "delete" and separated_files:
-                logger.info("[새 파일 저장 시작]")
-                from .files import FileHandler
+                file_infos[field_name] = saved_files
                 
-                # 임시 엔티티인 경우 파일 저장 건너뛰기
-                if isinstance(entity_result, type('TempEntity', (), {})):
-                    logger.info("[임시 엔티티 감지] 파일 저장 건너뛰기")
-                    return entity_data_copy, {}
+                # extra_data 업데이트
+                if not hasattr(entity_result, 'extra_data') or not entity_result.extra_data:
+                    entity_result.extra_data = {}
                 
-                for field_name, files in separated_files.items():
-                    logger.info(f"[필드 처리] {field_name}, 파일 수: {len(files)}")
-                    saved_files = await FileHandler.save_files(
-                        files=files,
-                        storage_dir=storage_dir,
-                        entity_name=self.model.__tablename__,
-                        entity_ulid=entity_result.ulid,
-                        db_session=self.db_session,
-                        column_name=field_name
-                    )
-                    file_infos[field_name] = saved_files
-                    logger.info(f"[파일 저장 완료] {field_name}: {len(saved_files)}개")
-                    
-                    # extra_data 업데이트 - 파일 정보 캐싱
-                    if not hasattr(entity_result, 'extra_data'):
-                        entity_result.extra_data = {}
-                    if not entity_result.extra_data:
-                        entity_result.extra_data = {}
-                        
-                    entity_result.extra_data[field_name] = [
-                        {
-                            'original_name': f['original_name'],
-                            'storage_path': f['storage_path'],
-                            'mime_type': f['mime_type'],
-                            'size': f['size'],
-                            'checksum': f['checksum'],
-                            'column_name': f['column_name']
-                        } for f in saved_files
-                    ]
-                    logger.info(f"[extra_data 업데이트 완료] {field_name}")
-                
-                # extra_data 업데이트된 엔티티 저장
-                await self.db_session.flush()
-                logger.info("[DB flush 완료]")
-
-            logger.info("[파일 처리 완료]")
-            return entity_data_copy, file_infos
-
+                entity_result.extra_data[field_name] = [
+                    {
+                        'original_name': f['original_name'],
+                        'storage_path': f['storage_path'],
+                        'mime_type': f['mime_type'],
+                        'size': f['size'],
+                        'checksum': f['checksum'],
+                        'column_name': f['column_name']
+                    } for f in saved_files
+                ]
+            
+            await self.db_session.flush()
+            logger.info("[파일 저장 완료]")
+            return file_infos
+            
         except CustomException as e:
-            logger.error(f"[CustomException 발생] {e.error_code}: {e.detail}")
-            if file_infos:
-                from .files import FileHandler
-                for file_list in file_infos.values():
-                    for file_info in file_list:
-                        logger.info(f"[에러 복구] 파일 삭제: {file_info['storage_path']}")
-                        await FileHandler.delete_files(file_info["storage_path"])
+            logger.error(f"[파일 저장 중 CustomException 발생] {e.error_code}: {e.detail}")
+            await self._cleanup_saved_files(file_infos)
+            raise e
+        except Exception as e:
+            logger.error(f"[파일 저장 중 에러 발생] {str(e)}")
+            await self._cleanup_saved_files(file_infos)
             raise CustomException(
-                e.error_code,
-                detail=e.detail,
-                source_function=f"{self.__class__.__name__}._process_files",
+                ErrorCode.FILE_SYSTEM_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}._save_files",
                 original_error=e
             )
+
+    async def _cleanup_saved_files(self, file_infos: Dict[str, Any]):
+        """저장된 파일들을 정리(삭제)하는 함수"""
+        if file_infos:
+            from .files import FileHandler
+            for file_list in file_infos.values():
+                for file_info in file_list:
+                    logger.info(f"[에러 복구] 파일 삭제: {file_info['storage_path']}")
+                    await FileHandler.delete_files(file_info["storage_path"])
+
+    async def _delete_files(
+        self,
+        entity_result: Any
+    ) -> None:
+        """엔티티와 관련된 파일들을 삭제하는 함수
+        
+        Args:
+            entity_result (Any): 삭제할 파일이 있는 엔티티
+        """
+        try:
+            logger.info("[파일 삭제 시작]")
+            from .files import FileHandler
+            
+            # files 테이블에서 기존 파일 정보 조회
+            existing_files = await self.db_session.execute(
+                text("""
+                    SELECT storage_path 
+                    FROM files 
+                    WHERE entity_name = :entity_name 
+                    AND entity_ulid = :entity_ulid
+                """),
+                {
+                    "entity_name": self.model.__tablename__,
+                    "entity_ulid": entity_result.ulid
+                }
+            )
+            existing_files = existing_files.fetchall()
+            logger.info(f"[기존 파일 조회 결과] {existing_files}")
+            
+            # 기존 파일 삭제
+            for file_info in existing_files:
+                logger.info(f"[파일 삭제] {file_info[0]}")
+                await FileHandler.delete_files(file_info[0])
+            
+            # files 테이블에서 레코드 삭제
+            await self.db_session.execute(
+                text("""
+                    DELETE FROM files 
+                    WHERE entity_name = :entity_name 
+                    AND entity_ulid = :entity_ulid
+                """),
+                {
+                    "entity_name": self.model.__tablename__,
+                    "entity_ulid": entity_result.ulid
+                }
+            )
+            logger.info("[파일 DB 레코드 삭제 완료]")
+            
         except Exception as e:
-            logger.error(f"[예외 발생] {str(e)}")
-            if file_infos:
-                from .files import FileHandler
-                for file_list in file_infos.values():
-                    for file_info in file_list:
-                        logger.info(f"[에러 복구] 파일 삭제: {file_info['storage_path']}")
-                        await FileHandler.delete_files(file_info["storage_path"])
+            logger.error(f"[파일 삭제 중 에러 발생] {str(e)}")
             raise CustomException(
                 ErrorCode.FILE_SYSTEM_ERROR,
-                detail=f"File processing error: {str(e)}",
-                source_function=f"{self.__class__.__name__}._process_files",
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}._delete_files",
                 original_error=e
             )
 
@@ -254,16 +264,8 @@ class BaseService(Generic[ModelType]):
                 if fk_check:
                     await validate_unique_fields(self.db_session, fk_check, find_value=False)
                 
-                # 파일 데이터 분리를 위한 임시 엔티티 생성
-                temp_entity = type('TempEntity', (), {'ulid': str(ULID())})()
-                
                 # 파일 데이터 분리
-                entity_data_copy, _ = await self._process_files(
-                    entity_data=entity_data,
-                    entity_result=temp_entity,
-                    storage_dir=storage_dir,
-                    operation="create"
-                )
+                entity_data_copy, separated_files = await self._separate_file_data(entity_data)
                 
                 # 엔티티 생성 (파일 데이터가 제거된 상태)
                 result = await self.repository.create(
@@ -271,20 +273,19 @@ class BaseService(Generic[ModelType]):
                     exclude_entities=exclude_entities
                 )
                 
-                # 실제 파일 저장 및 엔티티 업데이트
-                if storage_dir:
-                    _, file_infos = await self._process_files(
-                        entity_data=entity_data,  # 원본 데이터 사용
-                        entity_result=result,     # 실제 엔티티 사용
-                        storage_dir=storage_dir,
-                        operation="create"
+                # 파일 저장
+                file_infos = {}
+                if storage_dir and separated_files:
+                    file_infos = await self._save_files(
+                        separated_files=separated_files,
+                        entity_result=result,
+                        storage_dir=storage_dir
                     )
 
                 # 결과 반환
                 if response_model:
                     processed_result = process_response(result, response_model)
-                    # 파일 정보 추가
-                    if storage_dir and 'file_infos' in locals():
+                    if file_infos:
                         for key, value in file_infos.items():
                             processed_result[key] = value
                     return processed_result
@@ -362,12 +363,7 @@ class BaseService(Generic[ModelType]):
                     )
 
                 # 파일 데이터 분리
-                entity_data_copy, _ = await self._process_files(
-                    entity_data=entity_data,
-                    entity_result=existing_entity,
-                    storage_dir=storage_dir,
-                    operation="update"
-                )
+                entity_data_copy, separated_files = await self._separate_file_data(entity_data)
 
                 # 엔티티 수정 (파일 데이터가 제거된 상태)
                 result = await self.repository.update(
@@ -376,19 +372,21 @@ class BaseService(Generic[ModelType]):
                     exclude_entities=exclude_entities
                 )
 
-                # 실제 파일 처리
-                _, file_infos = await self._process_files(
-                    entity_data=entity_data,
-                    entity_result=result,
-                    storage_dir=storage_dir,
-                    operation="update"
-                )
+                # 기존 파일 삭제 후 새 파일 저장
+                file_infos = {}
+                if storage_dir and separated_files:
+                    await self._delete_files(result)
+                    file_infos = await self._save_files(
+                        separated_files=separated_files,
+                        entity_result=result,
+                        storage_dir=storage_dir
+                    )
 
                 if response_model:
                     processed_result = process_response(result, response_model)
-                    # 파일 정보 추가
-                    for key, value in file_infos.items():
-                        processed_result[key] = value
+                    if file_infos:
+                        for key, value in file_infos.items():
+                            processed_result[key] = value
                     return processed_result
                 else:
                     return result
@@ -439,13 +437,9 @@ class BaseService(Generic[ModelType]):
             if not entity:
                 return False
 
-            # 파일 처리 (삭제)
-            _, _ = await self._process_files(
-                entity_data={},
-                entity_result=entity,
-                storage_dir=storage_dir,
-                operation="delete"
-            )
+            # 파일 삭제
+            if storage_dir:
+                await self._delete_files(entity)
 
             return await self.repository.delete(
                 conditions=conditions

aiteamutils/version.py

@@ -1,2 +1,2 @@
 """버전 정보"""
-__version__ = "0.2.157"
+__version__ = "0.2.159"

{aiteamutils-0.2.157.dist-info → aiteamutils-0.2.159.dist-info}/METADATA

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

{aiteamutils-0.2.157.dist-info → aiteamutils-0.2.159.dist-info}/RECORD

@@ -1,7 +1,7 @@
 aiteamutils/__init__.py,sha256=kRBpRjark0M8ZwFfmKiMFol6CbIILN3WE4f6_P6iIq0,1089
 aiteamutils/base_model.py,sha256=yBZqzTDF9PA4wCAvmYfG12FdVwLtxOEUCcA3z2i6fXU,4176
 aiteamutils/base_repository.py,sha256=Oy2zE1i5qx60Xf1tnsaKLyFWapiPqt5JH8NejwNrPWg,4647
-aiteamutils/base_service.py,sha256=uoeeYUr-TAm2CaGUvjO74U2_nAAQdC6ZTSv8hiVsrcg,23866
+aiteamutils/base_service.py,sha256=uYEym6Cp2prK_ZbzAtrQaYLZRqn-AolTwoso_ASEqCk,22043
 aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
 aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
 aiteamutils/database.py,sha256=msvBKtxWeQVOo0v2Q9i2azuTNtnUItuNNar52gdRZTo,20418
@@ -11,7 +11,7 @@ aiteamutils/files.py,sha256=Qq2w3VAEOzvsDirYtxRTN48LnIzf4TPUH2LftmyYtQk,12831
 aiteamutils/models.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 aiteamutils/security.py,sha256=McUl3t5Z5SyUDVUHymHdDkYyF4YSeg4g9fFMML4W6Kw,11630
 aiteamutils/validators.py,sha256=_WHN6jqJQzKM5uPTg-Da8U2qqevS84XeKMkCCF4C_lY,9591
-aiteamutils/version.py,sha256=zzhDPxUCDTkincSRtbo_y2fTIxFwm8eppgXa_Unb-L0,43
-aiteamutils-0.2.157.dist-info/METADATA,sha256=g7aZN3zbtNOAnu07UJSQWePUB-o10qRpBuiJmXj_6FQ,1743
-aiteamutils-0.2.157.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.157.dist-info/RECORD,,
+aiteamutils/version.py,sha256=xr1O2ZYSzlPjLr1SLG4IBRNdFzNlMV4GLn1gHFE6Kd8,43
+aiteamutils-0.2.159.dist-info/METADATA,sha256=gmkHCBPBGe1kRWjRwOBNlhg8lywLG2N0EG4IXLNP-D0,1743
+aiteamutils-0.2.159.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.159.dist-info/RECORD,,