aiteamutils 0.2.135__py3-none-any.whl → 0.2.137__py3-none-any.whl

aiteamutils/base_repository.py

@@ -32,7 +32,7 @@ class BaseRepository(Generic[ModelType]):
             raise CustomException(
                 ErrorCode.DB_CONNECTION_ERROR,
                 detail="Session cannot be None",
-                source_function=f"{self.__class__.__name__}.session"
+                source_function=f"base_repository.{self.__class__.__name__}.session"
             )
         self._session = value
    
@@ -57,7 +57,7 @@ class BaseRepository(Generic[ModelType]):
             raise CustomException(
                 ErrorCode.INTERNAL_ERROR,
                 detail=str(e),
-                source_function=f"{self.__class__.__name__}.create",
+                source_function=f"base_repository.{self.__class__.__name__}.create",
                 original_error=e
             )
         

aiteamutils/base_service.py

@@ -45,7 +45,8 @@ class BaseService(Generic[ModelType]):
         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
+        token_settings: Dict[str, Any] | None = None,
+        storage_dir: str | None = None
     ) -> ModelType:
         
         if role_permission:
@@ -60,7 +61,7 @@ class BaseService(Generic[ModelType]):
                 raise CustomException(
                     ErrorCode.FORBIDDEN,
                     detail=f"{role_permission}",
-                    source_function=f"{self.__class__.__name__}.create"
+                    source_function=f"base_service.{self.__class__.__name__}.create.permission_result"
                 )
         
         try:
@@ -72,25 +73,60 @@ class BaseService(Generic[ModelType]):
                 if fk_check:
                     await validate_unique_fields(self.db_session, fk_check, find_value=False)
                 
+                # _files로 끝나는 키 처리
+                file_keys = [key for key in entity_data.keys() if key.endswith('_files')]
+                file_infos = {}
+                
+                if file_keys and not storage_dir:
+                    raise CustomException(
+                        ErrorCode.INVALID_INPUT,
+                        detail="storage_dir is required for file upload",
+                        source_function=f"base_service.{self.__class__.__name__}.create.file_keys"
+                    )
+                
+                # 먼저 엔티티를 생성하여 ULID를 얻음
                 result = await self.repository.create(
                     entity_data=entity_data,
                     exclude_entities=exclude_entities
                 )
+                
+                # 파일 처리
+                for file_key in file_keys:
+                    files_data = entity_data.pop(file_key)  # 파일 데이터 추출 및 제거
+                    if files_data:
+                        from .files import FileHandler
+                        file_infos[file_key] = await FileHandler.save_files(
+                            files=files_data,
+                            storage_dir=storage_dir,
+                            entity_name=self.model.__tablename__,
+                            entity_ulid=result.ulid,
+                            db_session=self.db_session
+                        )
 
                 # 결과 반환
                 if response_model:
-                    return process_response(result, response_model)
+                    processed_result = process_response(result, response_model)
+                    # 파일 정보 추가
+                    for key, value in file_infos.items():
+                        processed_result[key] = value
+                    return processed_result
                 else:
                     return result
 
         except CustomException as e:
+            # 파일 저장 실패 시 저장된 파일들 삭제
+            if 'file_infos' in locals():
+                for file_list in file_infos.values():
+                    for file_info in file_list:
+                        from .files import FileHandler
+                        await FileHandler.delete_files(file_info["storage_path"])
             raise e
         except Exception as e:
             # 다른 예외 처리
             raise CustomException(
                 ErrorCode.INTERNAL_ERROR,
                 detail=str(e),
-                source_function=f"{self.__class__.__name__}.create",
+                source_function=f"base_service.{self.__class__.__name__}.create",
                 original_error=e
             )
         
@@ -117,7 +153,7 @@ class BaseService(Generic[ModelType]):
                     raise CustomException(
                         ErrorCode.INVALID_INPUT,
                         detail="Either 'ulid' or 'conditions' must be provided.",
-                        source_function="database.update_entity"
+                        source_function=f"base_service.{self.__class__.__name__}.update.ulid_or_conditions"
                     )
 
                 # ulid로 조건 생성
@@ -126,7 +162,7 @@ class BaseService(Generic[ModelType]):
                         raise CustomException(
                             ErrorCode.VALIDATION_ERROR,
                             detail=ulid,
-                            source_function=f"{self.__class__.__name__}.update"
+                            source_function=f"base_service.{self.__class__.__name__}.update.ulid_or_conditions"
                         )
                     
                     conditions = {"ulid": ulid}
@@ -147,7 +183,7 @@ class BaseService(Generic[ModelType]):
             raise CustomException(
                 ErrorCode.INTERNAL_ERROR,
                 detail=str(e),
-                source_function=f"{self.__class__.__name__}.update",
+                source_function=f"base_service.{self.__class__.__name__}.update",
                 original_error=e
             )
 
@@ -165,14 +201,14 @@ class BaseService(Generic[ModelType]):
                 raise CustomException(
                     ErrorCode.VALIDATION_ERROR,
                     detail=ulid,
-                    source_function=f"{self.__class__.__name__}.delete"
+                    source_function=f"base_service.{self.__class__.__name__}.delete.ulid_validation"
                 )
             
             if not ulid and not conditions:
                 raise CustomException(
                     ErrorCode.INVALID_INPUT,
                     detail="Either 'ulid' or 'conditions' must be provided.",
-                    source_function="database.update_entity"
+                    source_function=f"base_service.{self.__class__.__name__}.delete.ulid_or_conditions"
                 )
 
             # ulid로 조건 생성
@@ -190,7 +226,7 @@ class BaseService(Generic[ModelType]):
             raise CustomException(
                 ErrorCode.INTERNAL_ERROR,
                 detail=str(e),
-                source_function=f"{self.__class__.__name__}.delete",
+                source_function=f"base_service.{self.__class__.__name__}.delete",
                 original_error=e
             )
 
@@ -246,7 +282,7 @@ class BaseService(Generic[ModelType]):
         except Exception as e:
             raise CustomException(
                 ErrorCode.INTERNAL_ERROR,
-                source_function=f"{self.__class__.__name__}.list",
+                source_function=f"base_service.{self.__class__.__name__}.list",
                 original_error=e
             )
         
@@ -268,7 +304,7 @@ class BaseService(Generic[ModelType]):
                 raise CustomException(
                     ErrorCode.INVALID_INPUT,
                     detail="Either 'ulid' or 'conditions' must be provided.",
-                    source_function="database.update_entity"
+                    source_function=f"base_service.{self.__class__.__name__}.get.ulid_or_conditions"
                 )
 
             # ulid로 조건 생성
@@ -277,7 +313,7 @@ class BaseService(Generic[ModelType]):
                     raise CustomException(
                         ErrorCode.VALIDATION_ERROR,
                         detail=ulid,
-                        source_function=f"{self.__class__.__name__}.update"
+                        source_function=f"base_service.{self.__class__.__name__}.get.ulid_validation"
                     )
                 
                 conditions = {"ulid": ulid}
@@ -295,7 +331,7 @@ class BaseService(Generic[ModelType]):
             raise CustomException(
                 ErrorCode.INTERNAL_ERROR,
                 detail=str(e),
-                source_function=f"{self.__class__.__name__}.get",
+                source_function=f"base_service.{self.__class__.__name__}.get",
                 original_error=e
             )
 

aiteamutils/database.py

@@ -341,7 +341,7 @@ async def update_entity(
             raise CustomException(
                 ErrorCode.NOT_FOUND,
                 detail=f"{model.__name__}|{conditions}.",
-                source_function="database.update_entity"
+                source_function="database.update_entity.not_entity"
             )
 
         # 기존 데이터를 딕셔너리로 변환
@@ -394,7 +394,7 @@ async def delete_entity(
             raise CustomException(
                 ErrorCode.NOT_FOUND,
                 detail=f"{model.__name__}|{conditions}.",
-                source_function="database.delete_entity"
+                source_function="database.delete_entity.not_entity"
             )
 
         entity.is_deleted = True

aiteamutils/files.py

@@ -0,0 +1,255 @@
+import os
+import hashlib
+import aiofiles
+from datetime import datetime, timezone
+from typing import BinaryIO, Dict, Any, List, Tuple, Union
+from pathlib import Path
+from mimetypes import guess_type
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+from ulid import ULID
+
+from .exceptions import ErrorCode, CustomException
+
+class FileHandler:
+    """파일 처리를 위한 핵심 기능 제공 클래스"""
+    
+    @staticmethod
+    def _create_directory(directory: str) -> None:
+        """디렉토리가 없는 경우 생성
+        
+        Args:
+            directory (str): 생성할 디렉토리 경로
+        """
+        try:
+            os.makedirs(directory, exist_ok=True)
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.FILE_SYSTEM_ERROR,
+                detail=str(directory),
+                source_function="FileHandler._create_directory",
+                original_error=e
+            )
+
+    @staticmethod
+    async def _calculate_checksum(file: BinaryIO) -> str:
+        """파일의 SHA-256 체크섬 계산
+        
+        Args:
+            file (BinaryIO): 체크섬을 계산할 파일 객체
+            
+        Returns:
+            str: 계산된 체크섬 값
+        """
+        try:
+            sha256_hash = hashlib.sha256()
+            current_position = file.tell()
+            file.seek(0)
+            
+            for chunk in iter(lambda: file.read(4096), b""):
+                sha256_hash.update(chunk)
+            
+            file.seek(current_position)
+            return sha256_hash.hexdigest()
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.FILE_SYSTEM_ERROR,
+                detail="checksum calculation failed",
+                source_function="FileHandler._calculate_checksum",
+                original_error=e
+            )
+
+    @staticmethod
+    def _get_mime_type(filename: str) -> str:
+        """파일의 MIME 타입 추측
+        
+        Args:
+            filename (str): MIME 타입을 추측할 파일명
+            
+        Returns:
+            str: 추측된 MIME 타입
+        """
+        mime_type, _ = guess_type(filename)
+        return mime_type or "application/octet-stream"
+
+    @staticmethod
+    async def _save_file(
+        file: BinaryIO,
+        original_name: str,
+        storage_dir: str,
+        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:
+            # 저장 디렉토리 생성
+            FileHandler._create_directory(storage_dir)
+            
+            # 파일 메타데이터 준비
+            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)
+            
+            # 파일 저장
+            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)
+            
+            # 체크섬 계산
+            file.seek(0)
+            checksum = await FileHandler._calculate_checksum(file)
+            
+            # 파일 포인터 복구
+            file.seek(current_position)
+            
+            return {
+                "original_name": original_name,
+                "storage_path": storage_path,
+                "mime_type": FileHandler._get_mime_type(original_name),
+                "size": os.path.getsize(storage_path),
+                "checksum": checksum,
+                "entity_name": entity_name,
+                "entity_ulid": entity_ulid
+            }
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.FILE_SYSTEM_ERROR,
+                detail=str(storage_path),
+                source_function="FileHandler._save_file",
+                original_error=e
+            )
+
+    @staticmethod
+    async def save_files(
+        files: Union[Tuple[BinaryIO, str], List[Tuple[BinaryIO, str]]],
+        storage_dir: str,
+        entity_name: str,
+        entity_ulid: str,
+        db_session: AsyncSession
+    ) -> List[Dict[str, Any]]:
+        """파일(들)을 저장하고 메타데이터 반환
+        
+        Args:
+            files: 단일 파일 튜플 (file, original_name) 또는 파일 튜플 리스트
+            storage_dir (str): 저장 디렉토리 경로
+            entity_name (str): 엔티티 이름
+            entity_ulid (str): 엔티티 ULID
+            db_session (AsyncSession): DB 세션
+            
+        Returns:
+            List[Dict[str, Any]]: 저장된 파일들의 메타데이터 리스트
+        """
+        file_infos = []
+        # 단일 파일인 경우 리스트로 변환
+        files_list = [files] if isinstance(files, tuple) else files
+        
+        for file, original_name in files_list:
+            # 파일 저장 및 메타데이터 생성
+            file_info = await FileHandler._save_file(
+                file=file,
+                original_name=original_name,
+                storage_dir=storage_dir,
+                entity_name=entity_name,
+                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
+                    ) VALUES (
+                        :entity_name, :entity_ulid, :original_name, :storage_path,
+                        :mime_type, :size, :checksum
+                    ) 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"]
+                }
+            )
+            
+            file_info = dict(result.fetchone())
+            file_infos.append(file_info)
+            
+        return file_infos
+
+    @staticmethod
+    async def delete_files(storage_paths: Union[str, List[str]]) -> None:
+        """파일(들) 삭제
+        
+        Args:
+            storage_paths: 단일 파일 경로 또는 파일 경로 리스트
+        """
+        paths_list = [storage_paths] if isinstance(storage_paths, str) else storage_paths
+        for storage_path in paths_list:
+            await FileHandler._delete_file(storage_path)
+
+    @staticmethod
+    async def _delete_file(storage_path: str) -> None:
+        """파일 삭제 (내부 사용)
+        
+        Args:
+            storage_path (str): 삭제할 파일 경로
+        """
+        try:
+            if os.path.exists(storage_path):
+                os.remove(storage_path)
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.FILE_SYSTEM_ERROR,
+                detail=str(storage_path),
+                source_function="FileHandler._delete_file",
+                original_error=e
+            )
+
+    @staticmethod
+    async def read_file(storage_path: str) -> BinaryIO:
+        """파일 읽기
+        
+        Args:
+            storage_path (str): 읽을 파일 경로
+            
+        Returns:
+            BinaryIO: 파일 객체
+        """
+        try:
+            if not os.path.exists(storage_path):
+                raise CustomException(
+                    ErrorCode.FILE_NOT_FOUND,
+                    detail=str(storage_path),
+                    source_function="FileHandler.read_file"
+                )
+            
+            return open(storage_path, 'rb')
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.FILE_SYSTEM_ERROR,
+                detail=str(storage_path),
+                source_function="FileHandler.read_file",
+                original_error=e
+            ) 

aiteamutils/version.py

@@ -1,2 +1,2 @@
 """버전 정보"""
-__version__ = "0.2.135"
+__version__ = "0.2.137"

{aiteamutils-0.2.135.dist-info → aiteamutils-0.2.137.dist-info}/METADATA

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

{aiteamutils-0.2.135.dist-info → aiteamutils-0.2.137.dist-info}/RECORD

@@ -1,15 +1,16 @@
 aiteamutils/__init__.py,sha256=kRBpRjark0M8ZwFfmKiMFol6CbIILN3WE4f6_P6iIq0,1089
 aiteamutils/base_model.py,sha256=0rs4cjnF2ea3Q2vBTj6F64BGk7ZglJsChsS7ne_R_tg,4056
-aiteamutils/base_repository.py,sha256=vzBw3g3jCJetTDblZvZenEGXk89Qu_65_02C7QTcf8Q,4615
-aiteamutils/base_service.py,sha256=nHikjwGp29QrQPr2W8Ye9sKxmVS_8prRG3Nu42TU1Ms,10670
+aiteamutils/base_repository.py,sha256=Oy2zE1i5qx60Xf1tnsaKLyFWapiPqt5JH8NejwNrPWg,4647
+aiteamutils/base_service.py,sha256=LrmntqvNx8SxgNrumkkPMv0vaKMMPVJrHzoXmDdx83M,12839
 aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
 aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
-aiteamutils/database.py,sha256=_aiS_akyJHHFSWZCmPcO82_O32xdUnXlNrPW5KhzxaA,20396
+aiteamutils/database.py,sha256=msvBKtxWeQVOo0v2Q9i2azuTNtnUItuNNar52gdRZTo,20418
 aiteamutils/enums.py,sha256=7WLqlcJqQWtETAga2WAxNp3dJTQIAd2TW-4WzkoHHa8,2498
 aiteamutils/exceptions.py,sha256=pgf3ersezObyl17wAO3I2fb8m9t2OzWDX1mSjwAWm2Y,16035
+aiteamutils/files.py,sha256=tdvivl3XLNv7Al7H1gGFczmrHM8XlQpiZsEc2xQ_UTU,8829
 aiteamutils/security.py,sha256=McUl3t5Z5SyUDVUHymHdDkYyF4YSeg4g9fFMML4W6Kw,11630
 aiteamutils/validators.py,sha256=msOrha36xWsapm4VAh63YmFq1GVyC9tzZcjXYFCEZ_g,11949
-aiteamutils/version.py,sha256=fdwI_s2lFV68CAZnF0FL52Cw9MKy1Mhcfci5r2bWY4o,43
-aiteamutils-0.2.135.dist-info/METADATA,sha256=2erJHJYmx8Vw12QGwfyXEvQC3-z77qtFUxYve85aSvo,1719
-aiteamutils-0.2.135.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.135.dist-info/RECORD,,
+aiteamutils/version.py,sha256=paOXlTEx5pKbXz3iDW_A_JPzLhKBZg6PmXu5SqD_82I,43
+aiteamutils-0.2.137.dist-info/METADATA,sha256=4dfPUZv6C9Xoq8E0HbsY8ToWEx_lsCLpM8qawukEPz0,1719
+aiteamutils-0.2.137.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.137.dist-info/RECORD,,