pyjallib 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

pyjallib/max/toolManager.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+ToolManager 모듈 - 3DS Max에서 실행되는 도구들을 관리
+도구 인스턴스 생성, 닫기 등을 담당
+"""
+
+from PySide2 import QtWidgets, QtCore
+import gc
+
+class ToolManager:
+    def __init__(self):
+        self.tools = {}  # {tool_class_name: [instances]} 형태로 관리
+    
+    def register_tool(self, tool_instance):
+        """도구 인스턴스를 등록합니다"""
+        class_name = tool_instance.__class__.__name__
+        
+        if class_name not in self.tools:
+            self.tools[class_name] = []
+            
+        self.tools[class_name].append(tool_instance)
+    
+    def close_tool_by_type(self, tool_class):
+        """특정 유형의 도구를 모두 닫습니다"""
+        class_name = tool_class.__name__
+        
+        if class_name not in self.tools:
+            return
+            
+        # 해당 클래스의 모든 인스턴스 정리
+        for tool in self.tools[class_name]:
+            try:
+                if hasattr(tool, 'close'):
+                    tool.close()
+                if hasattr(tool, 'deleteLater'):
+                    tool.deleteLater()
+            except (RuntimeError, AttributeError) as e:
+                print(f"도구 닫기 오류: {e}")
+                
+        # 목록 비우기
+        self.tools[class_name] = []
+        
+        # 추가적으로 QApplication.allWidgets()를 통한 검사
+        try:
+            window_title = None
+            if hasattr(tool_class, 'windowTitle'):
+                window_title = tool_class.windowTitle
+            
+            for widget in QtWidgets.QApplication.allWidgets():
+                if (isinstance(widget, QtWidgets.QDialog) and 
+                    ((window_title and hasattr(widget, 'windowTitle') and widget.windowTitle() == window_title) or
+                     widget.__class__.__name__ == class_name)):
+                    try:
+                        widget.close()
+                        widget.deleteLater()
+                    except:
+                        pass
+        except Exception as e:
+            print(f"위젯 검색 오류: {e}")
+            
+        # 가비지 컬렉션 수행
+        gc.collect()
+    
+    def show_tool(self, tool_class, **kwargs):
+        """
+        도구를 표시합니다. 중복 실행을 방지하고 항상 새 인스턴스를 생성합니다.
+        
+        Args:
+            tool_class: 도구 클래스
+            **kwargs: 도구 클래스 생성자에 전달할 인자들
+            
+        Returns:
+            새로 생성된 도구 인스턴스
+        """
+        # 기존 인스턴스 모두 정리
+        self.close_tool_by_type(tool_class)
+        
+        # 약간의 지연을 두어 정리 완료를 기다림
+        QtCore.QTimer.singleShot(50, lambda: None)
+        
+        # 새 인스턴스 생성
+        tool_instance = tool_class(**kwargs)
+        
+        # 도구 등록
+        self.register_tool(tool_instance)
+        
+        # 도구 표시
+        tool_instance.show()
+        
+        return tool_instance 

pyjallib/max/twistBone.py

@@ -258,6 +258,9 @@ class TwistBone:
         twistBoneRotListController.setActive(twistBoneRotListController.count)
         twistBoneRotListController.weight[0] = 100.0
         
+        # 첫 번째 트위스트 본을 boneChainArray에 추가
+        boneChainArray.append(twistBone)
+        
         if twistNum > 1:
             lastBone = self.bone.create_nub_bone(boneName, 2)
             lastBone.name = self.name.replace_name_part("Index", boneName, str(twistNum))
@@ -320,7 +323,8 @@ class TwistBone:
         if not inBoneChain or inBoneChain.is_empty():
             return None
             
-        # 기존 객체 삭제
+        # 기존 객체 삭제 (delete_all 대신 delete 사용)
+        # delete는 bones와 helpers만 삭제하고 sourceBones와 parameters는 유지함
         inBoneChain.delete()
             
         # BoneChain에서 필요한 정보 추출

pyjallib/max/volumeBone.py

@@ -275,7 +275,8 @@ class VolumeBone:  # Updated class name to match the new file name
         if not inBoneChain or inBoneChain.is_empty():
             return None
             
-        # 기존 객체 삭제
+        # 기존 객체 삭제 (delete_all 대신 delete 사용)
+        # delete는 bones와 helpers만 삭제하고 sourceBones와 parameters는 유지함
         inBoneChain.delete()
             
         # BoneChain에서 필요한 정보 추출

pyjallib/naming.py

@@ -258,6 +258,18 @@ class Naming:
             패딩 숫자
         """
         return self._paddingNum
+    
+    def get_filtering_char(self, inStr):
+        """
+        문자열에서 구분자 문자 가져오기
+        
+        Args:
+            inStr: 확인할 문자열
+            
+        Returns:
+            구분자 문자 (' ' 또는 '_' 또는 '')
+        """
+        return self._get_filtering_char(inStr)
 
     def get_name_part(self, inNamePartName):
         """
@@ -273,6 +285,15 @@ class Naming:
             if part.get_name() == inNamePartName:
                 return part
         return None
+    
+    def get_name_parts(self):
+        """
+        모든 namePart 객체 가져오기
+        
+        Returns:
+            namePart 객체 리스트
+        """
+        return self._nameParts
      
     def get_name_part_index(self, inNamePartName):
         """
@@ -473,7 +494,11 @@ class Naming:
                 
         # 배열을 문자열로 결합
         newName = self._combine(combinedNameArray, inFilChar)
-        newName = self.set_index_padding_num(newName)
+        
+        # "Index"키가 있을 때만 패딩 적용
+        if "Index" in inPartsDict:
+            newName = self.set_index_padding_num(newName)
+        
         return newName
     
     def get_RealName(self, inStr):

pyjallib/namingConfig.py

@@ -388,7 +388,7 @@ class NamingConfig:
         
         return True
     
-    def set_part_value_by_csv(self, part_name: str, csv_file_path: str) -> bool:
+    def set_part_value_by_csv(self, part_name: str, csv_file_path: str, encoding: str = "utf-8") -> bool:
         """
         특정 NamePart의 사전 정의 값을 CSV 파일로 설정
         CSV 파일 형식: value,description,koreanDescription (각 줄당)
@@ -396,6 +396,7 @@ class NamingConfig:
         Args:
             part_name: NamePart 이름
             csv_file_path: CSV 파일 경로
+            encoding: CSV 파일 인코딩 (기본값: "utf-8", "utf-8-sig" 등 사용 가능)
             
         Returns:
             설정 성공 여부 (True/False)
@@ -415,7 +416,7 @@ class NamingConfig:
         descriptions = []
         korean_descriptions = []
         try:
-            with open(csv_file_path, 'r', encoding='utf-8', newline='') as f:
+            with open(csv_file_path, 'r', encoding=encoding, newline='') as f:
                 reader = csv.reader(f)
                 for row in reader:
                     if len(row) >= 3: # Ensure row has at least 3 columns

pyjallib/perforce.py

@@ -195,6 +195,183 @@ class Perforce:
             self._handle_p4_exception(e, f"설명으로 체인지 리스트 조회 ('{description}')")
             return {}
 
+    def get_change_list_by_description_pattern(self, description_pattern: str, exact_match: bool = False) -> list:
+        """설명 패턴과 일치하는 Pending 체인지 리스트들을 가져옵니다.
+
+        Args:
+            description_pattern (str): 검색할 설명 패턴
+            exact_match (bool, optional): True면 정확히 일치하는 설명만, 
+                                        False면 패턴이 포함된 설명도 포함. 기본값 False
+
+        Returns:
+            list: 패턴과 일치하는 체인지 리스트 정보들의 리스트
+        """
+        if not self._is_connected():
+            return []
+        
+        search_type = "정확히 일치" if exact_match else "패턴 포함"
+        logger.debug(f"설명 패턴으로 체인지 리스트 조회 중 ({search_type}): '{description_pattern}'")
+        
+        try:
+            pending_changes = self.p4.run_changes("-l", "-s", "pending", "-u", self.p4.user, "-c", self.p4.client)
+            matching_changes = []
+            
+            for cl in pending_changes:
+                cl_desc = cl.get('Description', b'').decode('utf-8', 'replace').strip()
+                
+                # 패턴 매칭 로직
+                is_match = False
+                if exact_match:
+                    # 정확한 일치
+                    is_match = (cl_desc == description_pattern.strip())
+                else:
+                    # 패턴이 포함되어 있는지 확인 (대소문자 구분 없음)
+                    is_match = (description_pattern.lower().strip() in cl_desc.lower())
+                
+                if is_match:
+                    change_number = int(cl['change'])
+                    change_info = self.get_change_list_by_number(change_number)
+                    if change_info:
+                        matching_changes.append(change_info)
+                        logger.info(f"패턴 '{description_pattern}'에 매칭되는 체인지 리스트 {change_number} 발견: '{cl_desc}'")
+            
+            if matching_changes:
+                logger.info(f"패턴 '{description_pattern}'에 매칭되는 체인지 리스트 {len(matching_changes)}개 조회 완료.")
+            else:
+                logger.info(f"패턴 '{description_pattern}'에 매칭되는 Pending 체인지 리스트를 찾을 수 없습니다.")
+            
+            return matching_changes
+        except P4Exception as e:
+            self._handle_p4_exception(e, f"설명 패턴으로 체인지 리스트 조회 ('{description_pattern}')")
+            return []
+
+    def check_files_checked_out(self, file_paths: list) -> dict:
+        """파일들의 체크아웃 상태를 확인합니다.
+
+        Args:
+            file_paths (list): 확인할 파일 경로 리스트
+
+        Returns:
+            dict: 파일별 체크아웃 상태 정보
+                 {
+                     'file_path': {
+                         'is_checked_out': bool,
+                         'change_list': int or None,
+                         'action': str or None,
+                         'user': str or None,
+                         'workspace': str or None
+                     }
+                 }
+        """
+        if not self._is_connected():
+            return {}
+        if not file_paths:
+            logger.debug("체크아웃 상태 확인할 파일 목록이 비어있습니다.")
+            return {}
+        
+        logger.debug(f"파일 체크아웃 상태 확인 중 (파일 {len(file_paths)}개)")
+        
+        result = {}
+        try:
+            # 각 파일의 상태 확인
+            for file_path in file_paths:
+                file_status = {
+                    'is_checked_out': False,
+                    'change_list': None,
+                    'action': None,
+                    'user': None,
+                    'workspace': None
+                }
+                
+                try:
+                    # p4 opened 명령으로 파일이 열려있는지 확인
+                    opened_files = self.p4.run_opened(file_path)
+                    
+                    if opened_files:
+                        # 파일이 체크아웃되어 있음
+                        file_info = opened_files[0]
+                        file_status['is_checked_out'] = True
+                        file_status['change_list'] = int(file_info.get('change', 0))
+                        file_status['action'] = file_info.get('action', '')
+                        file_status['user'] = file_info.get('user', '')
+                        file_status['workspace'] = file_info.get('client', '')
+                        
+                        logger.debug(f"파일 '{file_path}' 체크아웃됨: CL {file_status['change_list']}, "
+                                   f"액션: {file_status['action']}, 사용자: {file_status['user']}, "
+                                   f"워크스페이스: {file_status['workspace']}")
+                    else:
+                        # 파일이 체크아웃되지 않음
+                        logger.debug(f"파일 '{file_path}' 체크아웃되지 않음")
+                        
+                except P4Exception as e:
+                    # 파일이 perforce에 없거나 접근할 수 없는 경우
+                    if any("not opened" in err.lower() or "no such file" in err.lower() 
+                           for err in self.p4.errors):
+                        logger.debug(f"파일 '{file_path}' 체크아웃되지 않음 (perforce에 없거나 접근 불가)")
+                    else:
+                        self._handle_p4_exception(e, f"파일 '{file_path}' 체크아웃 상태 확인")
+                
+                result[file_path] = file_status
+            
+            checked_out_count = sum(1 for status in result.values() if status['is_checked_out'])
+            logger.info(f"파일 체크아웃 상태 확인 완료: 전체 {len(file_paths)}개 중 {checked_out_count}개 체크아웃됨")
+            
+            return result
+            
+        except P4Exception as e:
+            self._handle_p4_exception(e, f"파일들 체크아웃 상태 확인 ({file_paths})")
+            return {}
+
+    def is_file_checked_out(self, file_path: str) -> bool:
+        """단일 파일의 체크아웃 상태를 간단히 확인합니다.
+
+        Args:
+            file_path (str): 확인할 파일 경로
+
+        Returns:
+            bool: 체크아웃되어 있으면 True, 아니면 False
+        """
+        result = self.check_files_checked_out([file_path])
+        return result.get(file_path, {}).get('is_checked_out', False)
+
+    def is_file_in_pending_changelist(self, file_path: str, change_list_number: int) -> bool:
+        """특정 파일이 지정된 pending 체인지 리스트에 있는지 확인합니다.
+
+        Args:
+            file_path (str): 확인할 파일 경로
+            change_list_number (int): 확인할 체인지 리스트 번호
+
+        Returns:
+            bool: 파일이 해당 체인지 리스트에 있으면 True, 아니면 False
+        """
+        if not self._is_connected():
+            return False
+        
+        logger.debug(f"파일 '{file_path}'가 체인지 리스트 {change_list_number}에 있는지 확인 중...")
+        
+        try:
+            # 해당 체인지 리스트의 파일들 가져오기
+            opened_files = self.p4.run_opened("-c", change_list_number)
+            
+            # 파일 경로 정규화
+            normalized_file_path = os.path.normpath(file_path)
+            
+            for file_info in opened_files:
+                client_file = file_info.get('clientFile', '')
+                normalized_client_file = os.path.normpath(client_file)
+                
+                if normalized_client_file == normalized_file_path:
+                    logger.debug(f"파일 '{file_path}'가 체인지 리스트 {change_list_number}에서 발견됨 "
+                               f"(액션: {file_info.get('action', '')})")
+                    return True
+            
+            logger.debug(f"파일 '{file_path}'가 체인지 리스트 {change_list_number}에 없음")
+            return False
+            
+        except P4Exception as e:
+            self._handle_p4_exception(e, f"파일 '{file_path}' 체인지 리스트 {change_list_number} 포함 여부 확인")
+            return False
+
     def edit_change_list(self, change_list_number: int, description: str = None, add_file_paths: list = None, remove_file_paths: list = None) -> dict:
         """체인지 리스트를 편집합니다.
 
@@ -594,6 +771,40 @@ class Perforce:
             self._handle_p4_exception(e, f"파일/폴더 업데이트 필요 여부 확인 ({processed_paths})")
             return False
 
+    def is_file_in_perforce(self, file_path: str) -> bool:
+        """파일이 Perforce에 속하는지 확인합니다.
+
+        Args:
+            file_path (str): 확인할 파일 경로
+
+        Returns:
+            bool: 파일이 Perforce에 속하면 True, 아니면 False
+        """
+        if not self._is_connected():
+            return False
+            
+        logger.debug(f"파일 '{file_path}'가 Perforce에 속하는지 확인 중...")
+        try:
+            # p4 files 명령으로 파일 정보 조회
+            file_info = self.p4.run_files(file_path)
+            
+            # 파일 정보가 있고, 'no such file(s)' 오류가 없는 경우
+            if file_info and not any("no such file(s)" in str(err).lower() for err in self.p4.errors):
+                logger.info(f"파일 '{file_path}'가 Perforce에 존재합니다.")
+                return True
+            else:
+                logger.info(f"파일 '{file_path}'가 Perforce에 존재하지 않습니다.")
+                return False
+                
+        except P4Exception as e:
+            # 파일이 존재하지 않는 경우는 일반적인 상황이므로 경고 레벨로 로깅
+            if any("no such file(s)" in err.lower() for err in self.p4.errors):
+                logger.info(f"파일 '{file_path}'가 Perforce에 존재하지 않습니다.")
+                return False
+            else:
+                self._handle_p4_exception(e, f"파일 '{file_path}' Perforce 존재 여부 확인")
+                return False
+
     def sync_files(self, file_paths: list) -> bool:
         """파일이나 폴더를 동기화합니다.
 
@@ -644,3 +855,188 @@ class Perforce:
     def __del__(self):
         """객체가 소멸될 때 자동으로 연결을 해제합니다."""
         self.disconnect()
+
+    def check_files_checked_out_all_users(self, file_paths: list) -> dict:
+        """파일들의 체크아웃 상태를 모든 사용자/워크스페이스에서 확인합니다.
+
+        Args:
+            file_paths (list): 확인할 파일 경로 리스트
+
+        Returns:
+            dict: 파일별 체크아웃 상태 정보
+                 {
+                     'file_path': {
+                         'is_checked_out': bool,
+                         'change_list': int or None,
+                         'action': str or None,
+                         'user': str or None,
+                         'client': str or None
+                     }
+                 }
+        """
+        if not self._is_connected():
+            return {}
+        if not file_paths:
+            logger.debug("체크아웃 상태 확인할 파일 목록이 비어있습니다.")
+            return {}
+        
+        logger.debug(f"파일 체크아웃 상태 확인 중 - 모든 사용자 (파일 {len(file_paths)}개)")
+        
+        result = {}
+        try:
+            # 각 파일의 상태 확인
+            for file_path in file_paths:
+                file_status = {
+                    'is_checked_out': False,
+                    'change_list': None,
+                    'action': None,
+                    'user': None,
+                    'client': None
+                }
+                
+                try:
+                    # p4 opened -a 명령으로 모든 사용자의 파일 체크아웃 상태 확인
+                    opened_files = self.p4.run_opened("-a", file_path)
+                    
+                    if opened_files:
+                        # 파일이 체크아웃되어 있음 (첫 번째 결과 사용)
+                        file_info = opened_files[0]
+                        file_status['is_checked_out'] = True
+                        file_status['change_list'] = int(file_info.get('change', 0))
+                        file_status['action'] = file_info.get('action', '')
+                        file_status['user'] = file_info.get('user', '')
+                        file_status['client'] = file_info.get('client', '')
+                        
+                        logger.debug(f"파일 '{file_path}' 체크아웃됨: CL {file_status['change_list']}, "
+                                   f"액션: {file_status['action']}, 사용자: {file_status['user']}, "
+                                   f"클라이언트: {file_status['client']}")
+                    else:
+                        # 파일이 체크아웃되지 않음
+                        logger.debug(f"파일 '{file_path}' 체크아웃되지 않음 (모든 사용자)")
+                        
+                except P4Exception as e:
+                    # 파일이 perforce에 없거나 접근할 수 없는 경우
+                    if any("not opened" in err.lower() or "no such file" in err.lower() 
+                           for err in self.p4.errors):
+                        logger.debug(f"파일 '{file_path}' 체크아웃되지 않음 (perforce에 없거나 접근 불가)")
+                    else:
+                        self._handle_p4_exception(e, f"파일 '{file_path}' 체크아웃 상태 확인 (모든 사용자)")
+                
+                result[file_path] = file_status
+            
+            checked_out_count = sum(1 for status in result.values() if status['is_checked_out'])
+            logger.info(f"파일 체크아웃 상태 확인 완료 (모든 사용자): 전체 {len(file_paths)}개 중 {checked_out_count}개 체크아웃됨")
+            
+            return result
+            
+        except P4Exception as e:
+            self._handle_p4_exception(e, f"파일들 체크아웃 상태 확인 - 모든 사용자 ({file_paths})")
+            return {}
+
+    def is_file_checked_out_by_others(self, file_path: str) -> bool:
+        """단일 파일이 다른 사용자/워크스페이스에 의해 체크아웃되어 있는지 확인합니다.
+
+        Args:
+            file_path (str): 확인할 파일 경로
+
+        Returns:
+            bool: 다른 사용자에 의해 체크아웃되어 있으면 True, 아니면 False
+        """
+        result = self.check_files_checked_out_all_users([file_path])
+        file_status = result.get(file_path, {})
+        
+        if not file_status.get('is_checked_out', False):
+            return False
+        
+        # 현재 사용자와 클라이언트가 아닌 경우 다른 사용자로 간주
+        current_user = self.p4.user
+        current_client = self.p4.client
+        
+        file_user = file_status.get('user', '')
+        file_client = file_status.get('client', '')
+        
+        return (file_user != current_user) or (file_client != current_client)
+
+    def get_file_checkout_info_all_users(self, file_path: str) -> dict:
+        """단일 파일의 상세 체크아웃 정보를 모든 사용자에서 가져옵니다.
+
+        Args:
+            file_path (str): 확인할 파일 경로
+
+        Returns:
+            dict: 체크아웃 정보 또는 빈 딕셔너리
+                 {
+                     'is_checked_out': bool,
+                     'change_list': int or None,
+                     'action': str or None,
+                     'user': str or None,
+                     'client': str or None,
+                     'is_checked_out_by_current_user': bool,
+                     'is_checked_out_by_others': bool
+                 }
+        """
+        result = self.check_files_checked_out_all_users([file_path])
+        file_status = result.get(file_path, {})
+        
+        if file_status.get('is_checked_out', False):
+            # 현재 사용자와 클라이언트인지 확인
+            current_user = self.p4.user
+            current_client = self.p4.client
+            
+            file_user = file_status.get('user', '')
+            file_client = file_status.get('client', '')
+            
+            is_current_user = (file_user == current_user) and (file_client == current_client)
+            
+            file_status['is_checked_out_by_current_user'] = is_current_user
+            file_status['is_checked_out_by_others'] = not is_current_user
+        else:
+            file_status['is_checked_out_by_current_user'] = False
+            file_status['is_checked_out_by_others'] = False
+        
+        return file_status
+
+    def get_files_checked_out_by_others(self, file_paths: list) -> list:
+        """파일 목록에서 다른 사용자/워크스페이스에 의해 체크아웃된 파일들을 찾습니다.
+
+        Args:
+            file_paths (list): 확인할 파일 경로 리스트
+
+        Returns:
+            list: 다른 사용자에 의해 체크아웃된 파일 정보 리스트
+                  [
+                      {
+                          'file_path': str,
+                          'user': str,
+                          'client': str,
+                          'change_list': int,
+                          'action': str
+                      }
+                  ]
+        """
+        if not file_paths:
+            return []
+        
+        result = self.check_files_checked_out_all_users(file_paths)
+        files_by_others = []
+        
+        current_user = self.p4.user
+        current_client = self.p4.client
+        
+        for file_path, status in result.items():
+            if status.get('is_checked_out', False):
+                file_user = status.get('user', '')
+                file_client = status.get('client', '')
+                
+                # 다른 사용자/클라이언트에 의해 체크아웃된 경우
+                if (file_user != current_user) or (file_client != current_client):
+                    files_by_others.append({
+                        'file_path': file_path,
+                        'user': file_user,
+                        'client': file_client,
+                        'change_list': status.get('change_list'),
+                        'action': status.get('action', '')
+                    })
+        
+        logger.info(f"다른 사용자에 의해 체크아웃된 파일: {len(files_by_others)}개")
+        return files_by_others

{pyjallib-0.1.11.dist-info → pyjallib-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjallib
-Version: 0.1.11
+Version: 0.1.13
 Summary: A utility library for 3D game character development pipelines.
 Author-email: Dongseok Kim <jalnagakds@gmail.com>
 Requires-Python: >=3.10