pyjallib 0.1.16__py3-none-any.whl → 0.1.19__py3-none-any.whl

pyjallib/ue5/logger.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+UE5 모듈 로깅 설정 모듈
+메인 Logger 클래스를 상속하여 UE5 전용 기능을 추가합니다.
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+
+from pyjallib.logger import Logger
+
+
+class UE5LogHandler(logging.Handler):
+    """UE5 전용 로그 핸들러 - UE5의 로그 시스템과 호환되도록 설계"""
+    
+    def emit(self, record):
+        """로그 레코드를 UE5 로그 시스템으로 전송"""
+        try:
+            # UE5의 unreal.log 함수 사용
+            import unreal
+            
+            # 메시지 포맷팅
+            message = self.format(record) if self.formatter else record.getMessage()
+            
+            # 로그 레벨에 따라 적절한 UE5 로그 함수 호출
+            if record.levelno >= logging.ERROR:
+                unreal.log_error(f"[PyJalLib] {message}")
+            elif record.levelno >= logging.WARNING:
+                unreal.log_warning(f"[PyJalLib] {message}")
+            elif record.levelno >= logging.INFO:
+                unreal.log(f"[PyJalLib] {message}")
+            else:  # DEBUG
+                unreal.log(f"[PyJalLib-DEBUG] {message}")
+                
+        except ImportError:
+            # unreal 모듈이 없는 경우 표준 출력 사용
+            message = self.format(record) if self.formatter else record.getMessage()
+            print(f"[PyJalLib] {message}")
+        except Exception:
+            # 모든 예외를 무시하여 로깅 실패가 애플리케이션을 중단하지 않도록 함
+            pass
+
+
+class UE5Logger(Logger):
+    """UE5 전용 로거 클래스 - 메인 Logger 클래스를 상속하여 UE5 기능을 추가"""
+    
+    def __init__(self, inLogPath: Optional[str] = None, inLogFileName: Optional[str] = None, 
+                 inEnableConsole: bool = True, inEnableUE5: bool = True):
+        """UE5 로거 인스턴스 초기화
+        
+        Args:
+            inLogPath (str, optional): 로그 파일 저장 경로. 
+                                     None인 경우 기본 경로 사용 (Documents/PyJalLib/logs)
+            inLogFileName (str, optional): 로그 파일명 (확장자 제외). 
+                                         None인 경우 기본값 "ue5_module" 사용
+                                         실제 파일명은 "YYYYMMDD_파일명.log" 형식으로 생성
+            inEnableConsole (bool): 콘솔 출력 활성화 여부 (기본값: True)
+            inEnableUE5 (bool): UE5 출력 활성화 여부 (기본값: True)
+        """
+        # UE5 기본 파일명 설정
+        if inLogFileName is None:
+            inLogFileName = "ue5_module"
+            
+        # 부모 클래스 초기화
+        super().__init__(inLogPath, inLogFileName, inEnableConsole)
+        
+        # UE5 핸들러 설정
+        self._enableUE5 = inEnableUE5
+        if self._enableUE5:
+            self._add_ue5_handler()
+    
+    def set_ue5_log_level(self, inLevel: str):
+        """
+        UE5 출력의 로깅 레벨을 설정합니다.
+        
+        Args:
+            inLevel (str): 로깅 레벨 ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
+        """
+        level_map = {
+            'DEBUG': logging.DEBUG,
+            'INFO': logging.INFO,
+            'WARNING': logging.WARNING,
+            'ERROR': logging.ERROR,
+            'CRITICAL': logging.CRITICAL
+        }
+        
+        if inLevel.upper() not in level_map:
+            self.warning(f"잘못된 로깅 레벨: {inLevel}. 기본값 INFO로 설정합니다.")
+            inLevel = 'INFO'
+        
+        # UE5 핸들러 찾기
+        for handler in self._logger.handlers:
+            if isinstance(handler, UE5LogHandler):
+                handler.setLevel(level_map[inLevel.upper()])
+                self.info(f"UE5 로깅 레벨이 {inLevel.upper()}로 설정되었습니다.")
+                return
+        
+        self.warning("UE5 핸들러를 찾을 수 없습니다.")
+    
+    def enable_ue5_output(self, inEnable: bool = True):
+        """
+        UE5 출력을 활성화/비활성화합니다.
+        
+        Args:
+            inEnable (bool): UE5 출력 활성화 여부
+        """
+        if inEnable and not self._enableUE5:
+            # UE5 핸들러 추가
+            self._add_ue5_handler()
+            self._enableUE5 = True
+            self.info("UE5 출력이 활성화되었습니다.")
+        elif not inEnable and self._enableUE5:
+            # UE5 핸들러 제거
+            self._remove_ue5_handler()
+            self._enableUE5 = False
+            self.info("UE5 출력이 비활성화되었습니다.")
+    
+    def _add_ue5_handler(self):
+        """UE5 핸들러를 로거에 추가"""
+        try:
+            ue5_handler = UE5LogHandler()
+            ue5_handler.setLevel(logging.INFO)  # UE5에서는 INFO 이상만 표시
+            ue5_handler.setFormatter(self._get_formatter())
+            self._logger.addHandler(ue5_handler)
+        except Exception:
+            # UE5 핸들러 생성 실패 시 무시
+            pass
+    
+    def _remove_ue5_handler(self):
+        """UE5 핸들러를 로거에서 제거"""
+        for handler in self._logger.handlers[:]:
+            if isinstance(handler, UE5LogHandler):
+                self._logger.removeHandler(handler)
+                try:
+                    handler.close()
+                except Exception:
+                    pass
+    
+    def _log_separator(self, inMessage: str) -> None:
+        """구분선 메시지를 모든 핸들러에 직접 출력 (UE5 핸들러 포함)"""
+        # 구분선은 INFO 레벨로 출력하되, 특별한 포맷 사용
+        separator_record = logging.LogRecord(
+            name=self._logger.name,
+            level=logging.INFO,
+            pathname="",
+            lineno=0,
+            msg=inMessage,
+            args=(),
+            exc_info=None
+        )
+        
+        # 각 핸들러에 직접 전송 (포맷터 우회)
+        for handler in self._logger.handlers:
+            try:
+                # 핸들러 레벨 확인
+                if handler.level <= logging.INFO:
+                    if isinstance(handler, UE5LogHandler):
+                        # UE5 핸들러의 경우 직접 emit 호출
+                        handler.emit(separator_record)
+                    elif hasattr(handler, 'stream'):
+                        # 구분선만 특별한 포맷으로 출력
+                        handler.stream.write(inMessage + "\n")
+                        if hasattr(handler, 'flush'):
+                            handler.flush()
+            except Exception:
+                # 핸들러 오류 시 무시
+                pass
+
+
+# 편의를 위한 전역 UE5 로거 인스턴스
+ue5_logger = UE5Logger()
+
+# 호환성을 위한 기존 함수들
+def set_log_level(inLevel: str):
+    """
+    UE5 모듈의 로깅 레벨을 설정합니다.
+    
+    Args:
+        inLevel (str): 로깅 레벨 ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
+    """
+    level_map = {
+        'DEBUG': logging.DEBUG,
+        'INFO': logging.INFO,
+        'WARNING': logging.WARNING,
+        'ERROR': logging.ERROR,
+        'CRITICAL': logging.CRITICAL
+    }
+    
+    if inLevel.upper() not in level_map:
+        ue5_logger.warning(f"잘못된 로깅 레벨: {inLevel}. 기본값 INFO로 설정합니다.")
+        inLevel = 'INFO'
+    
+    ue5_logger._logger.setLevel(level_map[inLevel.upper()])
+    ue5_logger.info(f"로깅 레벨이 {inLevel.upper()}로 설정되었습니다.")
+
+def set_ue5_log_level(inLevel: str):
+    """
+    UE5 출력의 로깅 레벨을 설정합니다.
+    
+    Args:
+        inLevel (str): 로깅 레벨 ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
+    """
+    ue5_logger.set_ue5_log_level(inLevel)
+
+def get_log_file_path():
+    """
+    현재 로그 파일의 경로를 반환합니다.
+    
+    Returns:
+        str: 로그 파일의 절대 경로
+    """
+    documents_path = Path.home() / "Documents"
+    log_folder = documents_path / "PyJalLib" / "logs"
+    current_date = datetime.now().strftime("%Y%m%d")
+    log_filename = f"{current_date}_ue5_module.log"
+    return str(log_folder / log_filename)
+
+def set_log_file_path(inLogFolder: str = None, inLogFilename: str = None):
+    """
+    로그 파일의 경로를 동적으로 변경합니다.
+    
+    Args:
+        inLogFolder (str, optional): 로그 폴더 경로. None인 경우 기본 Documents/PyJalLib/logs 사용
+        inLogFilename (str, optional): 로그 파일명. None인 경우 기본 날짜 기반 파일명 사용
+    """
+    # 새로운 UE5Logger 인스턴스 생성
+    global ue5_logger
+    
+    # 기존 로거 정리
+    ue5_logger.close()
+    
+    # 새로운 로거 생성
+    ue5_logger = UE5Logger(inLogPath=inLogFolder, inLogFileName=inLogFilename)
+    ue5_logger.info(f"로그 파일 경로가 변경되었습니다.")
+
+# 로깅 설정 완료 메시지
+ue5_logger.info("UE5 모듈 로깅 시스템 초기화 완료") 

pyjallib/ue5/templateProcessor.py

@@ -0,0 +1,287 @@
+"""
+템플릿 처리를 위한 유틸리티 모듈
+UE5 익스포트 시 파이썬 스크립트 템플릿을 실제 코드로 변환하는 기능을 제공합니다.
+"""
+
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+from .logger import ue5_logger
+from .templates import (
+    get_template_path, 
+    get_all_template_paths, 
+    get_available_templates,
+    ANIM_IMPORT_TEMPLATE,
+    SKELETON_IMPORT_TEMPLATE,
+    SKELETAL_MESH_IMPORT_TEMPLATE,
+    BATCH_ANIM_IMPORT_TEMPLATE
+)
+
+
+class TemplateProcessor:
+    """템플릿 처리를 위한 확장된 클래스"""
+    
+    def __init__(self):
+        """TemplateProcessor 초기화"""
+        ue5_logger.debug("TemplateProcessor 초기화")
+        self._default_output_dir = Path.cwd() / "temp_scripts"
+    
+    def process_template(self, inTemplatePath: str, inTemplateOutPath: str, inTemplateData: Dict[str, Any]) -> str:
+        """
+        템플릿을 처리하여 실제 코드로 변환 (기존 메서드 유지)
+        
+        Args:
+            inTemplatePath (str): 템플릿 파일 경로
+            inTemplateOutPath (str): 출력 파일 경로
+            inTemplateData (Dict[str, Any]): 템플릿에서 치환할 데이터
+            
+        Returns:
+            str: 처리된 템플릿 내용
+            
+        Raises:
+            FileNotFoundError: 템플릿 파일이 존재하지 않는 경우
+            PermissionError: 파일 읽기/쓰기 권한이 없는 경우
+            OSError: 디렉토리 생성 실패 등 파일 시스템 오류
+            UnicodeDecodeError: 파일 인코딩 오류
+        """
+        # 템플릿 파일 존재 확인
+        templatePath = Path(inTemplatePath)
+        if not templatePath.exists():
+            ue5_logger.error(f"템플릿 파일을 찾을 수 없습니다: {inTemplatePath}")
+            raise FileNotFoundError(f"템플릿 파일을 찾을 수 없습니다: {inTemplatePath}")
+        
+        # 템플릿 파일 읽기 권한 확인
+        if not os.access(templatePath, os.R_OK):
+            ue5_logger.error(f"템플릿 파일 읽기 권한이 없습니다: {inTemplatePath}")
+            raise PermissionError(f"템플릿 파일 읽기 권한이 없습니다: {inTemplatePath}")
+        
+        # 템플릿 파일 읽기
+        with open(templatePath, 'r', encoding='utf-8') as file:
+            templateContent = file.read()
+        
+        # 템플릿 데이터로 플레이스홀더 치환
+        processedContent = templateContent
+        for key, value in inTemplateData.items():
+            placeholder = f'{{{key}}}'
+            if placeholder in processedContent:
+                processedContent = processedContent.replace(placeholder, str(value))
+        
+        # 출력 디렉토리 생성 (존재하지 않는 경우)
+        outputPath = Path(inTemplateOutPath)
+        outputPath.parent.mkdir(parents=True, exist_ok=True)
+        
+        # 출력 파일 쓰기 권한 확인 (기존 파일이 있는 경우)
+        if outputPath.exists() and not os.access(outputPath, os.W_OK):
+            ue5_logger.error(f"출력 파일 쓰기 권한이 없습니다: {inTemplateOutPath}")
+            raise PermissionError(f"출력 파일 쓰기 권한이 없습니다: {inTemplateOutPath}")
+        
+        # 처리된 내용을 파일로 출력
+        with open(outputPath, 'w', encoding='utf-8') as file:
+            file.write(processedContent)
+        
+        ue5_logger.info(f"템플릿 처리 완료: {inTemplatePath} -> {inTemplateOutPath}")
+        return processedContent
+
+    # === 새로운 템플릿 경로 관리 메서드 ===
+    def get_template_path(self, template_name: str) -> str:
+        """
+        템플릿 파일 경로를 간단하게 가져오기
+        
+        Args:
+            template_name (str): 'animImport', 'skeletonImport', 'skeletalMeshImport' 중 하나
+            
+        Returns:
+            str: 템플릿 파일의 절대 경로
+        """
+        return get_template_path(template_name)
+        
+    def get_all_template_paths(self) -> Dict[str, str]:
+        """모든 템플릿 경로를 딕셔너리로 반환"""
+        return get_all_template_paths()
+    
+    def get_available_templates(self) -> list:
+        """사용 가능한 템플릿 목록 반환"""
+        return get_available_templates()
+
+    # === 타입별 특화 처리 메서드 ===
+    def process_animation_import_template(self, 
+                                        inTemplateData: Dict[str, Any], 
+                                        inOutputPath: Optional[str] = None) -> str:
+        """
+        애니메이션 임포트 전용 템플릿 처리
+        
+        Args:
+            inTemplateData (Dict[str, Any]): 템플릿 데이터
+                필수 키:
+                - inExtPackagePath: 외부 패키지 경로
+                - inAnimFbxPath: 애니메이션 FBX 경로
+                - inSkeletonFbxPath: 스켈레톤 FBX 경로  
+                - inContentRootPrefix: Content 루트 경로
+                - inFbxRootPrefix: FBX 루트 경로
+            inOutputPath (Optional[str]): 출력 파일 경로. None인 경우 기본 경로 사용
+            
+        Returns:
+            str: 처리된 템플릿 내용
+        """
+        # 필수 키 검증
+        required_keys = ['inExtPackagePath', 'inAnimFbxPath', 'inSkeletonFbxPath', 
+                        'inContentRootPrefix', 'inFbxRootPrefix']
+        if not self.validate_template_data(ANIM_IMPORT_TEMPLATE, inTemplateData, required_keys):
+            raise ValueError(f"애니메이션 템플릿에 필요한 키가 누락되었습니다: {required_keys}")
+        
+        template_path = get_template_path(ANIM_IMPORT_TEMPLATE)
+        
+        if inOutputPath is None:
+            inOutputPath = self.get_default_output_path(ANIM_IMPORT_TEMPLATE, "animImportScript")
+        
+        return self.process_template(template_path, inOutputPath, inTemplateData)
+        
+    def process_skeleton_import_template(self, 
+                                       inTemplateData: Dict[str, Any], 
+                                       inOutputPath: Optional[str] = None) -> str:
+        """
+        스켈레톤 임포트 전용 템플릿 처리
+        
+        Args:
+            inTemplateData (Dict[str, Any]): 템플릿 데이터
+                필수 키:
+                - inExtPackagePath: 외부 패키지 경로
+                - inSkeletonFbxPath: 스켈레톤 FBX 경로
+                - inContentRootPrefix: Content 루트 경로
+                - inFbxRootPrefix: FBX 루트 경로
+            inOutputPath (Optional[str]): 출력 파일 경로. None인 경우 기본 경로 사용
+            
+        Returns:
+            str: 처리된 템플릿 내용
+        """
+        # 필수 키 검증
+        required_keys = ['inExtPackagePath', 'inSkeletonFbxPath', 
+                        'inContentRootPrefix', 'inFbxRootPrefix']
+        if not self.validate_template_data(SKELETON_IMPORT_TEMPLATE, inTemplateData, required_keys):
+            raise ValueError(f"스켈레톤 템플릿에 필요한 키가 누락되었습니다: {required_keys}")
+        
+        template_path = get_template_path(SKELETON_IMPORT_TEMPLATE)
+        
+        if inOutputPath is None:
+            inOutputPath = self.get_default_output_path(SKELETON_IMPORT_TEMPLATE, "skeletonImportScript")
+        
+        return self.process_template(template_path, inOutputPath, inTemplateData)
+        
+    def process_skeletal_mesh_import_template(self, 
+                                            inTemplateData: Dict[str, Any], 
+                                            inOutputPath: Optional[str] = None) -> str:
+        """
+        스켈레탈 메시 임포트 전용 템플릿 처리
+        
+        Args:
+            inTemplateData (Dict[str, Any]): 템플릿 데이터
+                필수 키:
+                - inExtPackagePath: 외부 패키지 경로
+                - inSkeletalMeshFbxPath: 스켈레탈 메시 FBX 경로
+                - inSkeletonFbxPath: 스켈레톤 FBX 경로
+                - inContentRootPrefix: Content 루트 경로
+                - inFbxRootPrefix: FBX 루트 경로
+            inOutputPath (Optional[str]): 출력 파일 경로. None인 경우 기본 경로 사용
+            
+        Returns:
+            str: 처리된 템플릿 내용
+        """
+        # 필수 키 검증
+        required_keys = ['inExtPackagePath', 'inSkeletalMeshFbxPath', 'inSkeletonFbxPath', 
+                        'inContentRootPrefix', 'inFbxRootPrefix']
+        if not self.validate_template_data(SKELETAL_MESH_IMPORT_TEMPLATE, inTemplateData, required_keys):
+            raise ValueError(f"스켈레탈 메시 템플릿에 필요한 키가 누락되었습니다: {required_keys}")
+        
+        template_path = get_template_path(SKELETAL_MESH_IMPORT_TEMPLATE)
+        
+        if inOutputPath is None:
+            inOutputPath = self.get_default_output_path(SKELETAL_MESH_IMPORT_TEMPLATE, "skeletalMeshImportScript")
+        
+        return self.process_template(template_path, inOutputPath, inTemplateData)
+    
+    def process_batch_anim_import_template(self, 
+                                        inTemplateData: Dict[str, Any], 
+                                        inOutputPath: Optional[str] = None) -> str:
+        """
+        배치 애니메이션 임포트 전용 템플릿 처리
+        
+        Args:
+            inTemplateData (Dict[str, Any]): 템플릿 데이터
+                필수 키:
+                - inExtPackagePath: 외부 패키지 경로
+                - inAnimFbxPaths: 애니메이션 FBX 경로들 (리스트)
+                - inSkeletonFbxPaths: 스켈레톤 FBX 경로들 (리스트)
+                - inContentRootPrefix: Content 루트 경로
+                - inFbxRootPrefix: FBX 루트 경로
+            inOutputPath (Optional[str]): 출력 파일 경로. None인 경우 기본 경로 사용
+            
+        Returns:
+            str: 처리된 템플릿 내용
+        """
+        # 필수 키 검증
+        required_keys = ['inExtPackagePath', 'inAnimFbxPaths', 'inSkeletonFbxPaths', 
+                        'inContentRootPrefix', 'inFbxRootPrefix']
+        if not self.validate_template_data(BATCH_ANIM_IMPORT_TEMPLATE, inTemplateData, required_keys):
+            raise ValueError(f"배치 애니메이션 템플릿에 필요한 키가 누락되었습니다: {required_keys}")
+        
+        template_path = get_template_path(BATCH_ANIM_IMPORT_TEMPLATE)
+        
+        if inOutputPath is None:
+            inOutputPath = self.get_default_output_path(BATCH_ANIM_IMPORT_TEMPLATE, "batchAnimImportScript")
+        
+        return self.process_template(template_path, inOutputPath, inTemplateData)
+    
+    # === 유틸리티 메서드 ===
+    def validate_template_data(self, template_type: str, template_data: Dict[str, Any], required_keys: list = None) -> bool:
+        """
+        템플릿 데이터 유효성 검사
+        
+        Args:
+            template_type (str): 템플릿 타입
+            template_data (Dict[str, Any]): 검사할 템플릿 데이터
+            required_keys (list, optional): 필수 키 목록. None인 경우 기본 검사만 수행
+            
+        Returns:
+            bool: 유효한 데이터면 True, 그렇지 않으면 False
+        """
+        if not isinstance(template_data, dict):
+            ue5_logger.error(f"템플릿 데이터가 딕셔너리가 아닙니다: {type(template_data)}")
+            return False
+        
+        if required_keys:
+            missing_keys = [key for key in required_keys if key not in template_data]
+            if missing_keys:
+                ue5_logger.error(f"템플릿 데이터에 필수 키가 누락되었습니다: {missing_keys}")
+                return False
+        
+        return True
+        
+    def get_default_output_path(self, template_type: str, base_name: str = None) -> str:
+        """
+        기본 출력 경로 생성
+        
+        Args:
+            template_type (str): 템플릿 타입
+            base_name (str, optional): 기본 파일명. None인 경우 템플릿 타입으로 생성
+            
+        Returns:
+            str: 기본 출력 파일 경로
+        """
+        if base_name is None:
+            base_name = f"{template_type}Script"
+        
+        # 기본 출력 디렉토리 생성
+        self._default_output_dir.mkdir(parents=True, exist_ok=True)
+        
+        output_path = self._default_output_dir / f"{base_name}.py"
+        return str(output_path)
+    
+    def set_default_output_directory(self, directory_path: str):
+        """
+        기본 출력 디렉토리 설정
+        
+        Args:
+            directory_path (str): 새로운 기본 출력 디렉토리 경로
+        """
+        self._default_output_dir = Path(directory_path)
+        ue5_logger.info(f"기본 출력 디렉토리가 변경되었습니다: {directory_path}")

pyjallib/ue5/templates/__init__.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+UE5 템플릿 관리 모듈
+템플릿 파일 경로를 쉽게 가져올 수 있는 기능 제공
+"""
+
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+# 템플릿 이름 상수
+ANIM_IMPORT_TEMPLATE = "animImport"
+SKELETON_IMPORT_TEMPLATE = "skeletonImport" 
+SKELETAL_MESH_IMPORT_TEMPLATE = "skeletalMeshImport"
+BATCH_ANIM_IMPORT_TEMPLATE = "batchAnimImport"
+
+# 템플릿 파일 매핑
+_TEMPLATE_FILE_MAP = {
+    ANIM_IMPORT_TEMPLATE: "animImportTemplate.py",
+    SKELETON_IMPORT_TEMPLATE: "skeletonImportTemplate.py",
+    SKELETAL_MESH_IMPORT_TEMPLATE: "skeletalMeshImportTemplate.py",
+    BATCH_ANIM_IMPORT_TEMPLATE: "batchAnimImportTemplate.py"
+}
+
+def get_template_path(template_name: str) -> str:
+    """
+    템플릿 이름으로 템플릿 파일 경로 반환
+    
+    Args:
+        template_name (str): 'animImport', 'skeletonImport', 'skeletalMeshImport', 'batchAnimImport' 중 하나
+    
+    Returns:
+        str: 템플릿 파일의 절대 경로
+        
+    Raises:
+        ValueError: 지원하지 않는 템플릿 이름인 경우
+        FileNotFoundError: 템플릿 파일이 존재하지 않는 경우
+    """
+    if template_name not in _TEMPLATE_FILE_MAP:
+        supported_templates = list(_TEMPLATE_FILE_MAP.keys())
+        raise ValueError(f"지원하지 않는 템플릿 이름: {template_name}. 지원되는 템플릿: {supported_templates}")
+    
+    template_filename = _TEMPLATE_FILE_MAP[template_name]
+    templates_dir = Path(__file__).parent
+    template_path = templates_dir / template_filename
+    
+    if not template_path.exists():
+        raise FileNotFoundError(f"템플릿 파일을 찾을 수 없습니다: {template_path}")
+    
+    return str(template_path.resolve())
+
+def get_all_template_paths() -> Dict[str, str]:
+    """
+    모든 템플릿 경로를 딕셔너리로 반환
+    
+    Returns:
+        Dict[str, str]: 템플릿 이름을 키로 하고 파일 경로를 값으로 하는 딕셔너리
+    """
+    template_paths = {}
+    for template_name in _TEMPLATE_FILE_MAP.keys():
+        try:
+            template_paths[template_name] = get_template_path(template_name)
+        except (ValueError, FileNotFoundError):
+            # 존재하지 않는 템플릿은 건너뛰기
+            continue
+    
+    return template_paths
+
+def get_available_templates() -> list:
+    """
+    사용 가능한 템플릿 목록 반환
+    
+    Returns:
+        list: 사용 가능한 템플릿 이름 목록
+    """
+    available = []
+    templates_dir = Path(__file__).parent
+    
+    for template_name, filename in _TEMPLATE_FILE_MAP.items():
+        template_path = templates_dir / filename
+        if template_path.exists():
+            available.append(template_name)
+    
+    return available
+
+def validate_template_name(template_name: str) -> bool:
+    """
+    템플릿 이름이 유효한지 확인
+    
+    Args:
+        template_name (str): 확인할 템플릿 이름
+        
+    Returns:
+        bool: 유효한 템플릿 이름이면 True, 그렇지 않으면 False
+    """
+    return template_name in _TEMPLATE_FILE_MAP
+
+__all__ = [
+    'get_template_path',
+    'get_all_template_paths',
+    'get_available_templates',
+    'validate_template_name',
+    'ANIM_IMPORT_TEMPLATE',
+    'SKELETON_IMPORT_TEMPLATE',
+    'SKELETAL_MESH_IMPORT_TEMPLATE',
+    'BATCH_ANIM_IMPORT_TEMPLATE'
+] 

pyjallib/ue5/templates/animImportTemplate.py

@@ -0,0 +1,22 @@
+import sys
+import os
+from pathlib import Path
+
+# 프로젝트 루트 디렉토리 추가 (PyJalLib 디렉토리)
+extPackagePath = r'{inExtPackagePath}'
+
+if extPackagePath not in sys.path:
+    sys.path.insert(0, extPackagePath)
+
+import pyjallib
+from pyjallib.ue5.inUnreal.animationImporter import AnimationImporter
+
+fbxPath = r'{inAnimFbxPath}'
+skeletonPath = r'{inSkeletonFbxPath}'
+
+contentRootPrefix = r'{inContentRootPrefix}'
+fbxRootPrefix = r'{inFbxRootPrefix}'
+
+animImporter = AnimationImporter(inContentRootPrefix=contentRootPrefix, inFbxRootPrefix=fbxRootPrefix)
+
+result = animImporter.import_animation(fbxPath, skeletonPath)

pyjallib/ue5/templates/batchAnimImportTemplate.py

@@ -0,0 +1,21 @@
+import sys
+import os
+from pathlib import Path
+
+# 프로젝트 루트 디렉토리 추가 (PyJalLib 디렉토리)
+extPackagePath = r'{inExtPackagePath}'
+
+if extPackagePath not in sys.path:
+    sys.path.insert(0, extPackagePath)
+
+from pyjallib.ue5.inUnreal.animationImporter import AnimationImporter
+
+fbxPaths = {inAnimFbxPaths}
+skeletonPaths = {inSkeletonFbxPaths}
+
+contentRootPrefix = r'{inContentRootPrefix}'
+fbxRootPrefix = r'{inFbxRootPrefix}'
+
+animImporter = AnimationImporter(inContentRootPrefix=contentRootPrefix, inFbxRootPrefix=fbxRootPrefix)
+
+result = animImporter.import_animations(fbxPaths, skeletonPaths)