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

pyjallib/__init__.py

@@ -6,14 +6,15 @@ pyjallib Package
 Python library for game character development pipeline.
 """
 
-__version__ = '0.1.17'
+__version__ = '0.1.19'
 
 # reload_modules 함수를 패키지 레벨에서 사용 가능하게 함
+from pyjallib.logger import Logger
+from pyjallib.progressEvent import ProgressEvent
+from pyjallib.exceptions import PyJalLibError, PerforceError, ValidationError, FileOperationError, NamingConfigError, MaxError, UE5Error
 from pyjallib.namePart import NamePart, NamePartType
 from pyjallib.naming import Naming
 from pyjallib.namingConfig import NamingConfig
 from pyjallib.nameToPath import NameToPath
 from pyjallib.perforce import Perforce
-from pyjallib.reloadModules import reload_modules
-from pyjallib.logger import Logger
-from pyjallib.progressEvent import ProgressEvent
+from pyjallib.reloadModules import reload_modules

pyjallib/exceptions.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+PyJalLib 커스텀 예외 클래스들
+라이브러리에서 발생할 수 있는 다양한 예외 상황을 명확히 구분하기 위한 예외 클래스 정의
+"""
+
+import inspect
+from typing import Optional
+
+
+class PyJalLibError(Exception):
+    """PyJalLib 기본 예외 클래스"""
+    
+    def __init__(self, inMessage: str, inFunctionName: Optional[str] = None):
+        """
+        Args:
+            inMessage (str): 에러 메시지
+            inFunctionName (str, optional): 에러가 발생한 함수명. None인 경우 자동으로 감지 시도
+        """
+        self.function_name = inFunctionName or self._get_caller_function_name()
+        super().__init__(inMessage)
+    
+    def _get_caller_function_name(self) -> Optional[str]:
+        """호출자 함수명을 자동으로 감지"""
+        try:
+            # 현재 스택에서 호출자 함수명 찾기
+            frame = inspect.currentframe()
+            if frame and frame.f_back and frame.f_back.f_back:
+                return frame.f_back.f_back.f_code.co_name
+        except Exception:
+            pass
+        return None
+    
+    def get_function_name(self) -> Optional[str]:
+        """에러가 발생한 함수명 반환"""
+        return self.function_name
+    
+    def __str__(self) -> str:
+        """에러 메시지 반환 (함수명 포함)"""
+        message = super().__str__()
+        if self.function_name:
+            return f"[{self.function_name}] {message}"
+        return message
+
+
+class PerforceError(PyJalLibError):
+    """Perforce 관련 예외"""
+    pass
+
+
+class ValidationError(PyJalLibError):
+    """입력값 검증 실패 예외"""
+    pass
+
+
+class FileOperationError(PyJalLibError):
+    """파일 작업 실패 예외"""
+    pass
+
+
+class NamingConfigError(PyJalLibError):
+    """NamingConfig 관련 예외"""
+    pass
+
+
+class MaxError(PyJalLibError):
+    """3ds Max 관련 예외"""
+    pass
+
+
+class UE5Error(PyJalLibError):
+    """UE5 관련 예외"""
+    pass 

pyjallib/logger.py

@@ -7,15 +7,20 @@ PyJalLib 중앙 집중식 로깅 모듈
 """
 
 import logging
+import inspect
+import sys
 from pathlib import Path
 from typing import Optional
 from datetime import datetime
 
+from pyjallib.exceptions import PyJalLibError
+
 
 class Logger:
     """PyJalLib 간단한 로깅 클래스"""
     
-    def __init__(self, inLogPath: Optional[str] = None, inLogFileName: Optional[str] = None, inEnableConsole: bool = True, inEnableUE5: bool = False):
+    def __init__(self, inLogPath: Optional[str] = None, inLogFileName: Optional[str] = None, 
+                 inEnableConsole: bool = True, inLogLevel: str = "debug"):
         """로거 인스턴스 초기화
         
         Args:
@@ -25,7 +30,7 @@ class Logger:
                                          None인 경우 기본값 "pyjallib" 사용
                                          실제 파일명은 "YYYYMMDD_파일명.log" 형식으로 생성
             inEnableConsole (bool): 콘솔 출력 활성화 여부 (기본값: True)
-            inEnableUE5 (bool): UE5 출력 활성화 여부 (기본값: False)
+            inLogLevel (str): 로깅 레벨 (debug, info, warning, error, critical). 기본값: "debug"
         """
         # 기본 로그 경로 설정
         if inLogPath is None:
@@ -42,33 +47,122 @@ class Logger:
         
         # 출력 옵션 설정
         self._enableConsole = inEnableConsole
-        self._enableUE5 = inEnableUE5
         self._sessionName = None  # 초기에는 세션 없음
         
+        # 로깅 레벨 설정
+        self._logLevel = self._parse_log_level(inLogLevel)
+        
         # 로거 생성 및 설정
         self._logger = logging.getLogger(f"pyjallib_{id(self)}")
-        self._logger.setLevel(logging.DEBUG)
+        self._logger.setLevel(self._logLevel)
         self._logger.handlers.clear()  # 기존 핸들러 제거
         self._setup_handlers()
     
-    def debug(self, inMessage: str) -> None:
-        """디버그 레벨 로그 메시지"""
+    def _parse_log_level(self, inLogLevel: str) -> int:
+        """문자열 로깅 레벨을 logging 상수로 변환
+        
+        Args:
+            inLogLevel (str): 로깅 레벨 문자열
+            
+        Returns:
+            int: logging 모듈의 레벨 상수
+        """
+        level_map = {
+            "debug": logging.DEBUG,
+            "info": logging.INFO,
+            "warning": logging.WARNING,
+            "error": logging.ERROR,
+            "critical": logging.CRITICAL
+        }
+        
+        level_str = inLogLevel.lower().strip()
+        if level_str in level_map:
+            return level_map[level_str]
+        else:
+            # 잘못된 레벨이 입력된 경우 기본값으로 DEBUG 사용
+            return logging.DEBUG
+    
+    def _generate_auto_message(self, inLevel: str) -> str:
+        """자동 메시지 생성
+        
+        Args:
+            inLevel (str): 로깅 레벨 문자열
+            
+        Returns:
+            str: 자동 생성된 메시지
+        """
+        # 호출자 함수명 감지 (2단계 위: _generate_auto_message <- debug/info/etc <- 실제 호출자)
+        try:
+            caller_frame = inspect.currentframe().f_back.f_back
+            function_name = caller_frame.f_code.co_name
+            filename = caller_frame.f_code.co_filename
+            line_number = caller_frame.f_lineno
+            
+            # 파일명에서 경로 제거하고 확장자만 유지
+            file_basename = Path(filename).name
+        except (AttributeError, TypeError):
+            function_name = "unknown"
+            file_basename = "unknown"
+            line_number = 0
+        
+        # 현재 예외 정보 확인
+        exc_type, exc_value, exc_tb = sys.exc_info()
+        
+        if exc_value:
+            # 예외가 활성화된 상태라면 예외 정보 포함
+            return f"[{file_basename}:{line_number}:{function_name}] {exc_type.__name__}: {exc_value}"
+        else:
+            # 예외가 없다면 기본 메시지
+            return f"[{file_basename}:{line_number}:{function_name}] {inLevel.upper()} 로그"
+    
+    def debug(self, inMessage: Optional[str] = None) -> None:
+        """디버그 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("debug")
         self._logger.debug(inMessage)
         
-    def info(self, inMessage: str) -> None:
-        """정보 레벨 로그 메시지"""
+    def info(self, inMessage: Optional[str] = None) -> None:
+        """정보 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("info")
         self._logger.info(inMessage)
         
-    def warning(self, inMessage: str) -> None:
-        """경고 레벨 로그 메시지"""
+    def warning(self, inMessage: Optional[str] = None) -> None:
+        """경고 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("warning")
         self._logger.warning(inMessage)
         
-    def error(self, inMessage: str) -> None:
-        """에러 레벨 로그 메시지"""
+    def error(self, inMessage: Optional[str] = None) -> None:
+        """에러 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("error")
         self._logger.error(inMessage)
         
-    def critical(self, inMessage: str) -> None:
-        """치명적 에러 레벨 로그 메시지"""
+    def critical(self, inMessage: Optional[str] = None) -> None:
+        """치명적 에러 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("critical")
         self._logger.critical(inMessage)
         
     def set_session(self, inSessionName: str) -> None:
@@ -101,7 +195,46 @@ class Logger:
                 self._logger.removeHandler(handler)
             except Exception:
                 pass
-            
+    
+    def log_exception(self, inException: Exception, inCustomMessage: Optional[str] = None) -> None:
+        """예외 정보를 로그에 기록
+        
+        Args:
+            inException (Exception): 기록할 예외 객체
+            inCustomMessage (str, optional): 사용자 정의 메시지. None인 경우 예외 메시지만 기록
+        """
+        if inCustomMessage:
+            message = f"{inCustomMessage}: {inException}"
+        else:
+            message = str(inException)
+        
+        self._logger.error(message)
+    
+    def log_pyjallib_error(self, inError: PyJalLibError, inCustomMessage: Optional[str] = None) -> None:
+        """PyJalLib 예외를 로그에 기록 (함수명 포함)
+        
+        Args:
+            inError (PyJalLibError): PyJalLib 예외 객체
+            inCustomMessage (str, optional): 사용자 정의 메시지
+        """
+        # PyJalLibError는 이미 함수명이 포함된 메시지를 반환
+        if inCustomMessage:
+            message = f"{inCustomMessage}: {inError}"
+        else:
+            message = str(inError)
+        
+        self._logger.error(message)
+    
+    def log_function_error(self, inFunctionName: str, inMessage: str) -> None:
+        """함수명을 포함한 에러 메시지를 로그에 기록
+        
+        Args:
+            inFunctionName (str): 함수명
+            inMessage (str): 에러 메시지
+        """
+        message = f"[{inFunctionName}] {inMessage}"
+        self._logger.error(message)
+        
     def _log_separator(self, inMessage: str) -> None:
         """구분선 메시지를 모든 핸들러에 직접 출력"""
         # 구분선은 INFO 레벨로 출력하되, 특별한 포맷 사용
@@ -125,9 +258,6 @@ class Logger:
                         handler.stream.write(inMessage + "\n")
                         if hasattr(handler, 'flush'):
                             handler.flush()
-                    elif isinstance(handler, _UE5LogHandler):
-                        # UE5 핸들러의 경우 직접 emit 호출
-                        handler.emit(separator_record)
             except Exception:
                 # 핸들러 오류 시 무시
                 pass
@@ -136,66 +266,23 @@ class Logger:
         """로거에 핸들러 설정"""
         # 파일 핸들러 (항상 활성화) - 날짜 기반 파일명
         current_date = datetime.now().strftime("%Y%m%d")
-        log_filename = f"{current_date}_{self._logFileName}.log"
+        log_filename = f"{self._logFileName}_{current_date}.log"
         log_file = self._logPath / log_filename
         file_handler = logging.FileHandler(log_file, encoding='utf-8')
+        file_handler.setLevel(self._logLevel)  # 파일 핸들러도 동일한 레벨 적용
         file_handler.setFormatter(self._get_formatter())
         self._logger.addHandler(file_handler)
         
         # 콘솔 핸들러 (선택사항)
         if self._enableConsole:
             console_handler = logging.StreamHandler()
+            console_handler.setLevel(self._logLevel)  # 콘솔 핸들러도 동일한 레벨 적용
             console_handler.setFormatter(self._get_formatter())
             self._logger.addHandler(console_handler)
             
-        # UE5 핸들러 (선택사항)
-        if self._enableUE5:
-            ue5_handler = self._create_ue5_handler()
-            if ue5_handler:
-                self._logger.addHandler(ue5_handler)
-            
     def _get_formatter(self) -> logging.Formatter:
         """표준 포맷터 반환"""
         return logging.Formatter(
             '%(asctime)s - %(levelname)s - %(message)s',
             datefmt='%Y-%m-%d %H:%M:%S'
-        )
-        
-    def _create_ue5_handler(self) -> Optional[logging.Handler]:
-        """UE5 핸들러 생성 (기존 UE5LogHandler 코드 활용)"""
-        try:
-            return _UE5LogHandler()
-        except Exception:
-            # UE5 핸들러 생성 실패 시 None 반환
-            return None
-
-
-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 
+        ) 

pyjallib/max/__init__.py

@@ -32,7 +32,11 @@ from pyjallib.max.boneChain import BoneChain
 from pyjallib.max.twistBone import TwistBone
 from pyjallib.max.groinBone import GroinBone
 from pyjallib.max.autoClavicle import AutoClavicle
+from pyjallib.max.shoulder import Shoulder
 from pyjallib.max.volumeBone import VolumeBone
+from pyjallib.max.elbow import Elbow
+from pyjallib.max.wrist import Wrist
+from pyjallib.max.inguinal import Inguinal
 from pyjallib.max.kneeBone import KneeBone
 from pyjallib.max.hip import Hip
 
@@ -65,7 +69,11 @@ __all__ = [
     'TwistBone',
     'GroinBone',
     'AutoClavicle',
+    'Shoulder',
     'VolumeBone',
+    'Elbow',
+    'Wrist',
+    'Inguinal',
     'KneeBone',
     'Hip',
     'RootMotion',

pyjallib/max/autoClavicle.py

@@ -48,6 +48,10 @@ class AutoClavicle:
         self.bip = bipService if bipService else Bip(nameService=self.name, animService=self.anim)
         
         self.boneSize = 2.0
+        self.rotTargetUpperArmPosConstExpression = ""
+        self.rotTargetUpperArmPosConstExpression += "local clavicleDistance = distance clavicle upperArm\n"
+        self.rotTargetUpperArmPosConstExpression += "local xPos = (clavicleDistance/2.0) * distanceDir * liftScale\n"
+        self.rotTargetUpperArmPosConstExpression += "[xPos, 0.0, 0.0]\n"
         
         # 초기화된 결과를 저장할 변수들
         self.genBones = []
@@ -106,37 +110,43 @@ class AutoClavicle:
         autoClavicleBone = self.bone.create_nub_bone(autoClavicleName, 2)
         autoClavicleBone.name = self.name.remove_name_part("Nub", autoClavicleBone.name)
         autoClavicleBone.transform = inClavicle.transform
-        self.anim.move_local(autoClavicleBone, clavicleLength/2.0, 0.0, 0.0)
         autoClavicleBone.parent = inClavicle
+        autoClvaiclePosConst = self.const.assign_pos_const_multi(autoClavicleBone, [inClavicle, inUpperArm])
         genBones.append(autoClavicleBone)
         
         # 타겟 헬퍼 포인트 생성 (쇄골과 상완용)
         rotTargetClavicle = self.helper.create_point(self.name.replace_name_part("Type", autoClavicleName, self.name.get_name_part_value_by_description("Type", "Target")))
         rotTargetClavicle.name = self.name.replace_name_part("Index", rotTargetClavicle.name, "0")
         rotTargetClavicle.transform = inClavicle.transform
-        self.anim.move_local(rotTargetClavicle, clavicleLength, 0.0, 0.0)
-        
         rotTargetClavicle.parent = inClavicle
+        rotTargetClaviclePosConst = self.const.assign_pos_const(rotTargetClavicle, inUpperArm)
         genHelpers.append(rotTargetClavicle)
         
         rotTargetUpperArm = self.helper.create_point(self.name.replace_name_part("Type", autoClavicleName, self.name.get_name_part_value_by_description("Type", "Target")))
         rotTargetUpperArm.name = self.name.add_suffix_to_real_name(rotTargetUpperArm.name, self.name._get_filtering_char(inClavicle.name) + "arm")
         rotTargetUpperArm.transform = inUpperArm.transform
-        self.anim.move_local(rotTargetUpperArm, (clavicleLength/2.0)*liftScale, 0.0, 0.0)
-        
         rotTargetUpperArm.parent = inUpperArm
+        rotTargetUpperArmPosConst = self.const.assign_pos_script_controller(rotTargetUpperArm)
+        rotTargetUpperArmPosConst.addConstant("distanceDir", distanceDir)
+        rotTargetUpperArmPosConst.addConstant("liftScale", liftScale)
+        rotTargetUpperArmPosConst.addNode("clavicle", inClavicle)
+        rotTargetUpperArmPosConst.addNode("upperArm", inUpperArm)
+        rotTargetUpperArmPosConst.setExpression(self.rotTargetUpperArmPosConstExpression)
         genHelpers.append(rotTargetUpperArm)
         
         # 회전 헬퍼 포인트 생성
         autoClavicleRotHelper = self.helper.create_point(self.name.replace_name_part("Type", autoClavicleName, self.name.get_name_part_value_by_description("Type", "Rotation")))
         autoClavicleRotHelper.transform = autoClavicleBone.transform
         autoClavicleRotHelper.parent = inClavicle
+        autoClavicleRotHelperPosConst = self.const.assign_pos_const_multi(autoClavicleRotHelper, [inClavicle, inUpperArm])
         
         lookAtConst = self.const.assign_lookat_multi(autoClavicleRotHelper, [rotTargetClavicle, rotTargetUpperArm])
         
         lookAtConst.upnode_world = False
         lookAtConst.pickUpNode = inClavicle
         lookAtConst.lookat_vector_length = 0.0
+        if distanceDir < 0:
+            lookAtConst.target_axisFlip = True
         
         genHelpers.append(autoClavicleRotHelper)
         
@@ -175,6 +185,8 @@ class AutoClavicle:
         # 메소드 호출 후 데이터 초기화
         self.reset()
         
+        rt.redrawViews()
+        
         return BoneChain.from_result(result)
     
     def create_bones_from_chain(self, inBoneChain: BoneChain):

pyjallib/max/bone.py

@@ -976,8 +976,16 @@ class Bone:
         spineDistance = rt.distance(spine3, neck)/3.0
         rt.setProperty(spine4, "transform", spine3.transform)
         rt.setProperty(spine5, "transform", spine3.transform)
+        
         self.anim.move_local(spine4, spineDistance, 0, 0)
+        spine4PosConst = self.const.assign_pos_const_multi(spine4, [spine3, neck])
+        spine4PosConst.setWeight(1, 100.0*(2.0/3.0))
+        spine4PosConst.setWeight(2, 100.0 - (100.0*(2.0/3.0)))
+        
         self.anim.move_local(spine5, spineDistance * 2, 0, 0)
+        spine5PosConst = self.const.assign_pos_const_multi(spine5, [spine3, neck])
+        spine5PosConst.setWeight(1, 100.0*(1.0/3.0))
+        spine5PosConst.setWeight(2, 100.0 - (100.0*(1.0/3.0)))
         
         returnBones.append(spine4)
         returnBones.append(spine5)
@@ -995,6 +1003,7 @@ class Bone:
         neckDistance = rt.distance(neck, head)/2.0
         rt.setProperty(nekc2, "transform", neck.transform)
         self.anim.move_local(nekc2, neckDistance, 0, 0)
+        neck2PosConst = self.const.assign_pos_const_multi(nekc2, [neck, head])
         
         returnBones.append(nekc2)
         
@@ -1338,4 +1347,15 @@ class Bone:
         """
         selArray = list(rt.getCurrentSelection())
         for item in selArray:
-            self.set_freeze_length_off(item)
+            self.set_freeze_length_off(item)
+            
+    def turn_bone(self, inBone, inAngle):
+        """
+        입력된 각도만큼 입력된 본의 로컬 X 축을 회전 합니다.
+        
+        Args:
+            inBone: 회전할 뼈대 객체
+            inAngle: 회전할 각도
+        """
+        if rt.classOf(inBone) == rt.BoneGeometry:
+            self.anim.rotate_local(inBone, inAngle, 0, 0, dontAffectChildren=True)

pyjallib/max/boneChain.py

@@ -92,6 +92,8 @@ class BoneChain:
             self.bones = []
             self.helpers = []
             
+            rt.redrawViews()
+            
             return True
         except:
             return False

pyjallib/max/constraint.py

@@ -32,7 +32,7 @@ class Constraint:
         self.name = nameService if nameService else Name()
         self.helper = helperService if helperService else Helper(nameService=self.name) # Pass the potentially newly created nameService
     
-    def collapse(self, inObj):
+    def collapse(self, inObj, inUseTCBRot=False):
         """
         비 Biped 객체의 트랜스폼 컨트롤러를 기본 컨트롤러로 초기화하고 현재 변환 상태 유지.
         
@@ -48,7 +48,10 @@ class Constraint:
             
             # 기본 컨트롤러로 위치, 회전, 스케일 초기화
             rt.setPropertyController(inObj.controller, "Position", rt.Position_XYZ())
-            rt.setPropertyController(inObj.controller, "Rotation", rt.Euler_XYZ())
+            if inUseTCBRot:
+                rt.setPropertyController(inObj.controller, "Rotation", rt.TCB_Rotation())
+            else:
+                rt.setPropertyController(inObj.controller, "Rotation", rt.Euler_XYZ())
             rt.setPropertyController(inObj.controller, "Scale", rt.Bezier_Scale())
             
             # 백업한 변환 상태 복원
@@ -473,6 +476,28 @@ class Constraint:
         
         return eulerXYZ
     
+    def assign_tcb_rot(self, inObj):
+        """
+        객체에 TCB 회전 컨트롤러를 할당.
+        
+        Args:
+            inObj: 컨트롤러를 할당할 객체
+        """
+        # 회전 컨트롤러가 리스트 형태가 아니면 변환
+        rot_controller = rt.getPropertyController(inObj.controller, "Rotation")
+        if rt.classOf(rot_controller) != rt.Rotation_list:
+            rt.setPropertyController(inObj.controller, "Rotation", rt.Rotation_list())
+            
+        # 회전 리스트 컨트롤러 가져오기
+        rotList = self.assign_rot_list(inObj)
+        
+        # TCB 회전 컨트롤러 할당
+        tcbRot = rt.TCB_Rotation()
+        rt.setPropertyController(rotList, "Available", tcbRot)
+        rotList.setActive(rotList.count)
+        
+        return tcbRot
+    
     def get_lookat(self, inObj):
         """
         객체의 LookAt 제약 컨트롤러를 찾아 반환.