aiteamutils 0.2.134__py3-none-any.whl → 0.2.136__py3-none-any.whl

aiteamutils/base_model.py

@@ -93,4 +93,43 @@ class BaseSchema(BaseModel):
 
     def to_dict(self) -> Dict[str, Any]:
         """모델을 딕셔너리로 변환"""
-        return self.model_dump()
+        return self.model_dump()
+
+class BaseFileModel(BaseColumn):
+    """파일 관련 기본 모델"""
+    __abstract__ = True
+
+    entity_name: Mapped[str] = mapped_column(
+        String,
+        nullable=False,
+        doc="엔티티 이름"
+    )
+    entity_ulid: Mapped[str] = mapped_column(
+        String,
+        nullable=False,
+        doc="엔티티 ULID"
+    )
+    original_name: Mapped[str] = mapped_column(
+        String,
+        nullable=False,
+        doc="원본 파일명"
+    )
+    storage_path: Mapped[str] = mapped_column(
+        String,
+        nullable=False,
+        doc="저장 경로"
+    )
+    mime_type: Mapped[str] = mapped_column(
+        String,
+        nullable=False,
+        doc="MIME 타입"
+    )
+    size: Mapped[int] = mapped_column(
+        nullable=False,
+        doc="파일 크기(bytes)"
+    )
+    checksum: Mapped[str] = mapped_column(
+        String,
+        nullable=False,
+        doc="파일 체크섬"
+    )

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:
@@ -72,18 +73,53 @@ 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"{self.__class__.__name__}.create"
+                    )
+                
+                # 먼저 엔티티를 생성하여 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:
             # 다른 예외 처리

aiteamutils/database.py

@@ -157,7 +157,6 @@ def process_response(
     
     # Relationship 처리 (이미 로드된 관계만 처리)
     for relationship in entity.__mapper__.relationships:
-        print(f"\n[DEBUG] Processing relationship: {relationship.key}")
         if not relationship.key in entity.__dict__:
             continue
             
@@ -195,7 +194,6 @@ def process_response(
         # response_model에 없는 키 제거
         for key in current_keys:
             if key not in response_model.model_fields:
-                print(f"[DEBUG] Removing key not in response model: {key}")
                 result.pop(key)
         # 모델 검증 및 업데이트
         try:

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.134"
+__version__ = "0.2.136"

{aiteamutils-0.2.134.dist-info → aiteamutils-0.2.136.dist-info}/METADATA

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

{aiteamutils-0.2.134.dist-info → aiteamutils-0.2.136.dist-info}/RECORD

@@ -1,15 +1,16 @@
 aiteamutils/__init__.py,sha256=kRBpRjark0M8ZwFfmKiMFol6CbIILN3WE4f6_P6iIq0,1089
-aiteamutils/base_model.py,sha256=Y__fWJaB8kCyMQLnj88iQVanTdwwJcog13eOdGFlsN8,3129
+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_service.py,sha256=jWN0QTIIe5SkNitA_EP2GF0t1tyrCm1VftQtR3hJMT8,12507
 aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
 aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
-aiteamutils/database.py,sha256=2hrPy_V-n4kKC0I8MkGiS_5-7ZqKypbiYr0nekMVa4Y,20544
+aiteamutils/database.py,sha256=_aiS_akyJHHFSWZCmPcO82_O32xdUnXlNrPW5KhzxaA,20396
 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=egCk8YV5GyRjVbkuh35PwKcfmp7pVNPyW7e2yjO10Gg,43
-aiteamutils-0.2.134.dist-info/METADATA,sha256=-DYgH2SVlCJWygI5qWqZDCt78OPLj_c5YiFOmLg-ziw,1719
-aiteamutils-0.2.134.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.134.dist-info/RECORD,,
+aiteamutils/version.py,sha256=GEzMhIGk9CTUp2zEaaKPPRMurlXlp9MeMYAAzWYudjo,43
+aiteamutils-0.2.136.dist-info/METADATA,sha256=qXiXhvObJ6S8Xlm7NrCwLUMQn6cTLZXnJa-IEDgZ7PY,1719
+aiteamutils-0.2.136.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.136.dist-info/RECORD,,