aiteamutils 0.2.143__py3-none-any.whl → 0.2.145__py3-none-any.whl

aiteamutils/base_service.py

@@ -6,6 +6,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from datetime import datetime
 from ulid import ULID
 from sqlalchemy import text
+import logging
 
 #패키지 라이브러리
 from .exceptions import ErrorCode, CustomException
@@ -17,6 +18,8 @@ from .database import (
 from .security import hash_password, verify_jwt_token, verify_role_permission
 ModelType = TypeVar("ModelType", bound=DeclarativeBase)
 
+logger = logging.getLogger(__name__)
+
 class BaseService(Generic[ModelType]):
     ##################
     # 초기화 영역 #
@@ -55,16 +58,22 @@ class BaseService(Generic[ModelType]):
             Tuple[Dict[str, Any], Dict[str, Any]]: (처리된 엔티티 데이터, 파일 정보)
         """
         try:
+            logger.info(f"[파일 처리 시작] operation: {operation}, storage_dir: {storage_dir}")
+            logger.info(f"[엔티티 데이터] {entity_data}")
+            
             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']}")
                 extra_data = entity_data_copy['extra_data'].copy()
                 file_fields = {k: v for k, v in extra_data.items() if k.endswith('_files')}
+                logger.info(f"[파일 필드 확인] {file_fields}")
                 
                 if file_fields and not storage_dir:
+                    logger.error("[에러] storage_dir이 필요하지만 제공되지 않음")
                     raise CustomException(
                         ErrorCode.INVALID_INPUT,
                         detail="storage_dir is required for file upload",
@@ -74,6 +83,7 @@ class BaseService(Generic[ModelType]):
                 # 파일 필드 분리 및 제거
                 for field_name, files in file_fields.items():
                     if files:
+                        logger.info(f"[파일 처리] 필드: {field_name}, 파일 수: {len(files)}")
                         separated_files[field_name] = files
                         del extra_data[field_name]
                 
@@ -81,6 +91,7 @@ class BaseService(Generic[ModelType]):
 
             # 기존 파일 삭제 (update 또는 delete 작업 시)
             if operation in ["update", "delete"]:
+                logger.info("[기존 파일 삭제 시작]")
                 from .files import FileHandler
                 # files 테이블에서 기존 파일 정보 조회
                 existing_files = await self.db_session.execute(
@@ -96,9 +107,11 @@ class BaseService(Generic[ModelType]):
                     }
                 )
                 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 테이블에서 레코드 삭제
@@ -113,11 +126,14 @@ class BaseService(Generic[ModelType]):
                         "entity_ulid": entity_result.ulid
                     }
                 )
+                logger.info("[기존 파일 DB 레코드 삭제 완료]")
 
             # 새 파일 저장 (create 또는 update 작업 시)
             if operation != "delete" and separated_files:
+                logger.info("[새 파일 저장 시작]")
                 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,
@@ -127,6 +143,7 @@ class BaseService(Generic[ModelType]):
                         column_name=field_name.replace('_files', '')
                     )
                     file_infos[field_name] = saved_files
+                    logger.info(f"[파일 저장 완료] {field_name}: {len(saved_files)}개")
                     
                     # extra_data 업데이트 - 파일 정보 캐싱
                     if not hasattr(entity_result, 'extra_data'):
@@ -144,17 +161,22 @@ class BaseService(Generic[ModelType]):
                             '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
 
         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"])
             raise CustomException(
                 e.error_code,
@@ -163,14 +185,16 @@ class BaseService(Generic[ModelType]):
                 original_error=e
             )
         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"])
             raise CustomException(
                 ErrorCode.FILE_SYSTEM_ERROR,
-                detail=str(e),
+                detail=f"File processing error: {str(e)}",
                 source_function=f"{self.__class__.__name__}._process_files",
                 original_error=e
             )
@@ -248,14 +272,27 @@ class BaseService(Generic[ModelType]):
                     return result
 
         except CustomException as e:
-            raise e
-        except Exception as e:
             raise CustomException(
-                ErrorCode.INTERNAL_ERROR,
-                detail=str(e),
-                source_function=f"base_service.{self.__class__.__name__}.create.exception",
+                e.error_code,
+                detail=f"{e.detail}|{str(e)}",
+                source_function=f"base_service.{self.__class__.__name__}.create",
                 original_error=e
             )
+        except Exception as e:
+            if isinstance(e, str) and "FILE_SYSTEM_ERROR" in str(e):
+                raise CustomException(
+                    ErrorCode.FILE_SYSTEM_ERROR,
+                    detail=f"{str(e)}",
+                    source_function=f"base_service.{self.__class__.__name__}.create",
+                    original_error=e
+                )
+            else:
+                raise CustomException(
+                    ErrorCode.INTERNAL_ERROR,
+                    detail=f"{str(e)}",
+                    source_function=f"base_service.{self.__class__.__name__}.create",
+                    original_error=e
+                )
 
     async def update(
         self,

aiteamutils/files.py

@@ -8,22 +8,38 @@ from mimetypes import guess_type
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
 from ulid import ULID
+import logging
 
 from .exceptions import ErrorCode, CustomException
 
+logger = logging.getLogger(__name__)
+
 class FileHandler:
     """파일 처리를 위한 핵심 기능 제공 클래스"""
     
     @staticmethod
     def _create_directory(directory: str) -> None:
-        """디렉토리가 없는 경우 생성
-        
-        Args:
-            directory (str): 생성할 디렉토리 경로
-        """
+        """디렉토리가 없는 경우 생성"""
         try:
+            logger.info(f"[디렉토리 생성 시도] {directory}")
+            if os.path.exists(directory):
+                logger.info(f"[디렉토리 이미 존재] {directory}")
+                return
+                
             os.makedirs(directory, exist_ok=True)
+            logger.info(f"[디렉토리 생성 완료] {directory}")
+            
+            # 권한 확인
+            if not os.access(directory, os.W_OK):
+                logger.error(f"[권한 에러] 디렉토리에 쓰기 권한 없음: {directory}")
+                raise CustomException(
+                    ErrorCode.FILE_SYSTEM_ERROR,
+                    detail=f"{directory}|No write permission",
+                    source_function="FileHandler._create_directory"
+                )
+                
         except Exception as e:
+            logger.error(f"[디렉토리 생성 실패] {directory}: {str(e)}")
             raise CustomException(
                 ErrorCode.FILE_SYSTEM_ERROR,
                 detail=f"{directory}|{str(e)}",
@@ -80,19 +96,10 @@ class FileHandler:
         entity_name: str,
         entity_ulid: str
     ) -> Dict[str, Any]:
-        """파일을 저장하고 메타데이터 반환 (내부 사용)
-        
-        Args:
-            file (BinaryIO): 저장할 파일 객체
-            original_name (str): 원본 파일명
-            storage_dir (str): 저장 디렉토리 경로
-            entity_name (str): 엔티티 이름
-            entity_ulid (str): 엔티티 ULID
-            
-        Returns:
-            Dict[str, Any]: 저장된 파일의 메타데이터
-        """
+        """파일을 저장하고 메타데이터 반환"""
         try:
+            logger.info(f"[파일 저장 시작] 원본 파일명: {original_name}, 저장 경로: {storage_dir}")
+            
             # 저장 디렉토리 생성
             FileHandler._create_directory(storage_dir)
             
@@ -100,23 +107,30 @@ class FileHandler:
             file_ext = os.path.splitext(original_name)[1]
             storage_filename = f"{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}_{entity_ulid}{file_ext}"
             storage_path = os.path.join(storage_dir, storage_filename)
+            logger.info(f"[저장 파일명] {storage_filename}")
             
             # 파일 저장
             current_position = file.tell()
             file.seek(0)
             
-            async with aiofiles.open(storage_path, 'wb') as f:
-                while chunk := file.read(8192):
-                    await f.write(chunk)
+            try:
+                async with aiofiles.open(storage_path, 'wb') as f:
+                    while chunk := file.read(8192):
+                        await f.write(chunk)
+                logger.info(f"[파일 쓰기 완료] {storage_path}")
+            except Exception as e:
+                logger.error(f"[파일 쓰기 실패] {storage_path}: {str(e)}")
+                raise
             
             # 체크섬 계산
             file.seek(0)
             checksum = await FileHandler._calculate_checksum(file)
+            logger.info(f"[체크섬 계산 완료] {checksum}")
             
             # 파일 포인터 복구
             file.seek(current_position)
             
-            return {
+            file_info = {
                 "original_name": original_name,
                 "storage_path": storage_path,
                 "mime_type": FileHandler._get_mime_type(original_name),
@@ -125,9 +139,14 @@ class FileHandler:
                 "entity_name": entity_name,
                 "entity_ulid": entity_ulid
             }
+            logger.info(f"[파일 정보] {file_info}")
+            return file_info
+            
         except CustomException as e:
+            logger.error(f"[CustomException 발생] {e.error_code}: {e.detail}")
             raise e
         except Exception as e:
+            logger.error(f"[파일 저장 실패] {str(e)}")
             raise CustomException(
                 ErrorCode.FILE_SYSTEM_ERROR,
                 detail=f"{storage_path}|{str(e)}",
@@ -144,24 +163,16 @@ class FileHandler:
         db_session: AsyncSession,
         column_name: str = None
     ) -> List[Dict[str, Any]]:
-        """파일(들)을 저장하고 메타데이터 반환
+        """파일(들)을 저장하고 메타데이터 반환"""
+        logger.info(f"[다중 파일 저장 시작] storage_dir: {storage_dir}, entity_name: {entity_name}")
         
-        Args:
-            files: 단일 파일 튜플 (file, original_name) 또는 파일 튜플 리스트
-            storage_dir (str): 저장 디렉토리 경로
-            entity_name (str): 엔티티 이름
-            entity_ulid (str): 엔티티 ULID
-            db_session (AsyncSession): DB 세션
-            column_name (str): 파일이 속한 컬럼 이름
-            
-        Returns:
-            List[Dict[str, Any]]: 저장된 파일들의 메타데이터 리스트
-        """
         file_infos = []
         # 단일 파일인 경우 리스트로 변환
         files_list = [files] if isinstance(files, tuple) else files
+        logger.info(f"[처리할 파일 수] {len(files_list)}")
         
         for file, original_name in files_list:
+            logger.info(f"[개별 파일 처리] {original_name}")
             # 파일 저장 및 메타데이터 생성
             file_info = await FileHandler._save_file(
                 file=file,
@@ -171,32 +182,39 @@ class FileHandler:
                 entity_ulid=entity_ulid
             )
             
-            # DB에 파일 정보 저장 (트랜잭션은 BaseService에서 관리)
-            result = await db_session.execute(
-                text("""
-                    INSERT INTO files (
-                        entity_name, entity_ulid, original_name, storage_path,
-                        mime_type, size, checksum, column_name
-                    ) VALUES (
-                        :entity_name, :entity_ulid, :original_name, :storage_path,
-                        :mime_type, :size, :checksum, :column_name
-                    ) RETURNING *
-                """),
-                {
-                    "entity_name": entity_name,
-                    "entity_ulid": entity_ulid,
-                    "original_name": file_info["original_name"],
-                    "storage_path": file_info["storage_path"],
-                    "mime_type": file_info["mime_type"],
-                    "size": file_info["size"],
-                    "checksum": file_info["checksum"],
-                    "column_name": column_name
-                }
-            )
-            
-            file_info = dict(result.fetchone())
-            file_infos.append(file_info)
+            # DB에 파일 정보 저장
+            try:
+                logger.info(f"[DB 저장 시작] {original_name}")
+                result = await db_session.execute(
+                    text("""
+                        INSERT INTO files (
+                            entity_name, entity_ulid, original_name, storage_path,
+                            mime_type, size, checksum, column_name
+                        ) VALUES (
+                            :entity_name, :entity_ulid, :original_name, :storage_path,
+                            :mime_type, :size, :checksum, :column_name
+                        ) RETURNING *
+                    """),
+                    {
+                        "entity_name": entity_name,
+                        "entity_ulid": entity_ulid,
+                        "original_name": file_info["original_name"],
+                        "storage_path": file_info["storage_path"],
+                        "mime_type": file_info["mime_type"],
+                        "size": file_info["size"],
+                        "checksum": file_info["checksum"],
+                        "column_name": column_name
+                    }
+                )
+                
+                file_info = dict(result.fetchone())
+                file_infos.append(file_info)
+                logger.info(f"[DB 저장 완료] {original_name}")
+            except Exception as e:
+                logger.error(f"[DB 저장 실패] {original_name}: {str(e)}")
+                raise
             
+        logger.info(f"[다중 파일 저장 완료] 성공: {len(file_infos)}개")
         return file_infos
 
     @staticmethod

aiteamutils/version.py

@@ -1,2 +1,2 @@
 """버전 정보"""
-__version__ = "0.2.143"
+__version__ = "0.2.145"

{aiteamutils-0.2.143.dist-info → aiteamutils-0.2.145.dist-info}/METADATA

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

{aiteamutils-0.2.143.dist-info → aiteamutils-0.2.145.dist-info}/RECORD

@@ -1,16 +1,16 @@
 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=3woNhOtjPc0QNwTcyAH1h6psqDY25sV_4wD-tr3jHk4,20101
+aiteamutils/base_service.py,sha256=dqs0b5xyCdBibgbgHKG9LCyeyQW1MNwiwuOrmSluJHI,22349
 aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
 aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
 aiteamutils/database.py,sha256=msvBKtxWeQVOo0v2Q9i2azuTNtnUItuNNar52gdRZTo,20418
 aiteamutils/enums.py,sha256=7WLqlcJqQWtETAga2WAxNp3dJTQIAd2TW-4WzkoHHa8,2498
 aiteamutils/exceptions.py,sha256=pgf3ersezObyl17wAO3I2fb8m9t2OzWDX1mSjwAWm2Y,16035
-aiteamutils/files.py,sha256=1XuLAvsQbnURHSZ2IyZIXrZH6OWgnC5Tl1vcTDyi1GY,9017
+aiteamutils/files.py,sha256=hBCnXCa8wrBK05aSZAF08tcH_eiYmVQqUaSQqCgib7o,10311
 aiteamutils/security.py,sha256=McUl3t5Z5SyUDVUHymHdDkYyF4YSeg4g9fFMML4W6Kw,11630
 aiteamutils/validators.py,sha256=_WHN6jqJQzKM5uPTg-Da8U2qqevS84XeKMkCCF4C_lY,9591
-aiteamutils/version.py,sha256=9G4P9qltI2Vtwf4PoIM_54O-NL1h1zyzt3BwyK86o58,43
-aiteamutils-0.2.143.dist-info/METADATA,sha256=d9ElwAvXGoaW14-54fZWBRW9rSx8sEzdHCa7j12nO1g,1743
-aiteamutils-0.2.143.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.143.dist-info/RECORD,,
+aiteamutils/version.py,sha256=qTfcWqtaTYCddRCJFGc8bvpJSvvkq6vXGLan238hPT4,43
+aiteamutils-0.2.145.dist-info/METADATA,sha256=SSsB1r0zBl1--1_PNz-nvFAlMP1VFduSYZIwaSrKxZc,1743
+aiteamutils-0.2.145.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.145.dist-info/RECORD,,