Module pyjallib.naming

Naming 모듈 - 이름 규칙 관리 및 적용 기능 제공 NamePart 객체를 기반으로 조직화된 이름 생성 및 분석 기능 구현

Classes

class Naming (configPath=None)
Expand source code
class Naming:
    """
    노드 이름을 관리하기 위한 기본 클래스.
    기본적인 이름 구성 요소를 정의하고 관리합니다.
    이 클래스는 하위 클래스에서 확장하여 특정 목적에 맞게 사용할 수 있습니다.
    """
    
    def __init__(self, configPath=None):
        """
        클래스 초기화 및 기본 설정값 정의
        
        Args:
            configPath: 설정 파일 경로 (기본값: None)
                        설정 파일이 제공되면 해당 파일에서 설정을 로드함
        """
        # 기본 설정값
        self._paddingNum = 2
        self._configPath = configPath
        
        # 기본 namePart 초기화 (각 부분에 사전 정의 값 직접 설정)
        self._nameParts = []
        
        # Prefix 부분 (PREFIX 타입)
        prefixPart = NamePart("Prefix", NamePartType.PREFIX, ["Pr"], ["Prefix"])
        
        # RealName 부분 (REALNAME 타입)
        realNamePart = NamePart("RealName", NamePartType.REALNAME, [], [])
        
        # Index 부분 (INDEX 타입)
        indexPart = NamePart("Index", NamePartType.INDEX, [], [])
        
        # Suffix 부분 (SUFFIX 타입)
        suffixPart = NamePart("Suffix", NamePartType.SUFFIX, ["Su"], ["Suffix"])
        
        # 기본 순서대로 설정
        self._nameParts = [prefixPart, realNamePart, indexPart, suffixPart]
        
        # 설정 파일이 제공된 경우 로드
        if configPath:
            self.load_from_config_file(configPath)
        else:
            # 기본 JSON 설정 파일 로드 시도
            self.load_default_config()

    # ---- String 관련 메소드들 (내부 사용 헬퍼 메소드) ----
    
    def _split_into_string_and_digit(self, inStr):
        """
        문자열을 문자부분과 숫자부분으로 분리
        
        Args:
            inStr: 분리할 문자열
            
        Returns:
            튜플 (문자부분, 숫자부분)
        """
        match = re.match(r'^(.*?)(\d*)$', inStr)
        if match:
            return match.group(1), match.group(2)
        return inStr, ""

    def _compare_string(self, inStr1, inStr2):
        """
        대소문자 구분 없이 문자열 비교
        
        Args:
            inStr1: 첫 번째 문자열
            inStr2: 두 번째 문자열
            
        Returns:
            비교 결과 (inStr1 < inStr2: 음수, inStr1 == inStr2: 0, inStr1 > inStr2: 양수)
        """
        # Python에서는 대소문자 구분 없는 비교를 위해 lower() 메서드 사용
        if inStr1.lower() < inStr2.lower():
            return -1
        elif inStr1.lower() > inStr2.lower():
            return 1
        return 0

    def _sort_by_alphabet(self, inArray):
        """
        배열 내 문자열을 알파벳 순으로 정렬
        
        Args:
            inArray: 정렬할 배열
            
        Returns:
            정렬된 배열
        """
        # Python의 sorted 함수와 lambda를 사용하여 대소문자 구분 없이 정렬
        return sorted(inArray, key=lambda x: x.lower())

    def _get_filtering_char(self, inStr):
        """
        문자열에서 사용된 구분자 문자 찾기
        
        Args:
            inStr: 확인할 문자열
            
        Returns:
            구분자 문자 (' ' 또는 '_' 또는 '')
        """
        if ' ' in inStr:
            return ' '
        if '_' in inStr:
            return '_'
        return ''

    def _filter_by_filtering_char(self, inStr):
        """
        구분자 문자로 문자열 분할
        
        Args:
            inStr: 분할할 문자열
            
        Returns:
            분할된 문자열 리스트
        """
        filChar = self._get_filtering_char(inStr)
        
        if not filChar:
            return [inStr]
            
        # 빈 문자열 제거하며 분할
        return [part for part in inStr.split(filChar) if part]

    def _filter_by_upper_case(self, inStr):
        """
        대문자로 시작하는 부분을 기준으로 문자열 분할
        
        Args:
            inStr: 분할할 문자열
            
        Returns:
            분할된 문자열 리스트
        """
        if not inStr:
            return []
            
        result = []
        currentPart = inStr[0]
        
        for i in range(1, len(inStr)):
            if inStr[i].isupper():
                result.append(currentPart)
                currentPart = inStr[i]
            else:
                currentPart += inStr[i]
                
        if currentPart:
            result.append(currentPart)
            
        return result

    def _has_digit(self, inStr):
        """
        문자열에 숫자가 포함되어 있는지 확인
        
        Args:
            inStr: 확인할 문자열
            
        Returns:
            숫자가 포함되어 있으면 True, 아니면 False
        """
        return any(char.isdigit() for char in inStr)

    def _split_to_array(self, inStr):
        """
        문자열을 구분자 또는 대문자로 분할하고 숫자 부분도 분리
        
        Args:
            inStr: 분할할 문자열
            
        Returns:
            분할된 문자열 리스트
        """
        filChar = self._get_filtering_char(inStr)
        
        if not filChar:
            # 구분자가 없을 경우 대문자로 분할
            resultArray = self._filter_by_upper_case(inStr)
            tempArray = []
            
            for item in resultArray:
                if self._has_digit(item):
                    stringPart, digitPart = self._split_into_string_and_digit(item)
                    if stringPart:
                        tempArray.append(stringPart)
                    if digitPart:
                        tempArray.append(digitPart)
                else:
                    tempArray.append(item)
                    
            return tempArray
        else:
            # 구분자가 있을 경우 구분자로 분할
            return self._filter_by_filtering_char(inStr)

    def _remove_empty_string_in_array(self, inArray):
        """
        배열에서 빈 문자열 제거
        
        Args:
            inArray: 처리할 배열
            
        Returns:
            빈 문자열이 제거된 배열
        """
        return [item for item in inArray if item]

    def _combine(self, inArray, inFilChar=" "):
        """
        문자열 배열을 하나의 문자열로 결합
        
        Args:
            inArray: 결합할 문자열 배열
            filChar: 구분자 (기본값: 공백)
            
        Returns:
            결합된 문자열
        """
        refinedArray = self._remove_empty_string_in_array(inArray)
        
        if not refinedArray:
            return ""
            
        if len(refinedArray) == 1:
            return refinedArray[0]
            
        return inFilChar.join(refinedArray)

    # ---- Name 관련 메서드들 ----
    
    # 사전 정의 값 편집 메서드 제거 (namingConfig를 통해서만 변경 가능)

    def get_padding_num(self):
        """
        패딩 숫자 가져오기
        
        Returns:
            패딩 숫자
        """
        return self._paddingNum

    def get_name_part(self, inNamePartName):
        """
        namePart 이름으로 NamePart 객체 가져오기
        
        Args:
            namePart: 가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)
            
        Returns:
            해당 NamePart 객체, 존재하지 않으면 None
        """
        for part in self._nameParts:
            if part.get_name() == inNamePartName:
                return part
        return None
     
    def get_name_part_index(self, inNamePartName):
        """
        namePart 이름으로 인덱스 가져오기
        
        Args:
            namePart: 가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)
            
        Returns:
            해당 NamePart의 인덱스, 존재하지 않으면 -1
        """
        for i, part in enumerate(self._nameParts):
            if part.get_name() == inNamePartName:
                return i
        return -1

    def get_name_part_predefined_values(self, inNamePartName):
        """
        namePart의 사전 정의 값 가져오기
        
        Args:
            namePart: 가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)
            
        Returns:
            해당 NamePart의 사전 정의 값 리스트, 존재하지 않으면 빈 리스트
        """
        partObj = self.get_name_part(inNamePartName)
        if partObj:
            return partObj.get_predefined_values()
        return []
    
    def is_in_name_part_predefined_values(self, inNamePartName, inStr):
        """
        지정된 namePart에 해당하는 부분이 문자열에 포함되어 있는지 확인
        
        Args:
            namePart: 확인할 namePart 이름 ("Base", "Type", "Side" 등)
            inStr: 확인할 문자열
            
        Returns:
            포함되어 있으면 True, 아니면 False
        """
        partObj = self.get_name_part(inNamePartName)
        if not partObj:
            return False
        
        partType = partObj.get_type()
        if not partType:
            return False
            
        partValues = partObj.get_predefined_values()
        
        if partType == NamePartType.PREFIX or partType == NamePartType.SUFFIX:
            return any(item in inStr for item in partValues)
        
        return False

    def get_name_part_value_by_description(self, inNamePartName, inDescription):
        """
        지정된 namePart에 해당하는 부분을 문자열에서 추출
        
        Args:
            namePart: 추출할 namePart 이름 ("Base", "Type", "Side" 등)
            inDescription: predefined value에서 찾기위한 description 문자열
            
        Returns:
            지정된 namePart에 해당하는 문자열
        """
        partObj = self.get_name_part(inNamePartName)
        if not partObj:
            return ""
        
        partType = partObj.get_type()
        if not partType:
            return ""
            
        partValues = partObj.get_predefined_values()
        
        if partType == NamePartType.PREFIX or partType == NamePartType.SUFFIX:
            foundIndex = partObj._descriptions.index(inDescription)
            if foundIndex >= 0:
                return partValues[foundIndex]
        
        return ""

    def pick_name(self, inNamePartName, inStr):
        nameArray = self._split_to_array(inStr)
        returnStr = ""
        
        # namePart 문자열 목록 가져오기
        partObj = self.get_name_part(inNamePartName)
        if not partObj:
            return returnStr
        
        partType = partObj.get_type()
        if not partType:
            return returnStr
            
        partValues = partObj.get_predefined_values()
        if partType != NamePartType.INDEX and partType != NamePartType.REALNAME and not partValues:
            return returnStr
        
        if partType == NamePartType.PREFIX:
            for item in nameArray:
                if item in partValues:
                    returnStr = item
                    break
        
        if partType == NamePartType.SUFFIX:
            for i in range(len(nameArray) - 1, -1, -1):
                if nameArray[i] in partValues:
                    returnStr = nameArray[i]
                    break
                
        if partType == NamePartType.INDEX:
            if self.get_name_part_index("Index") > self.get_name_part_index("RealName"):
                for i in range(len(nameArray) - 1, -1, -1):
                    if nameArray[i].isdigit():
                        returnStr = nameArray[i]
                        break
            else:
                for item in nameArray:
                    if item.isdigit():
                        returnStr = item
                        break
        
        return returnStr
        
    def get_name(self, inNamePartName, inStr):
        """
        지정된 namePart에 해당하는 부분을 문자열에서 추출
        
        Args:
            namePart: 추출할 namePart 이름 ("Base", "Type", "Side" 등)
            inStr: 처리할 문자열
            
        Returns:
            지정된 namePart에 해당하는 문자열
        """
        nameArray = self._split_to_array(inStr)
        returnStr = ""
        
        partType = self.get_name_part(inNamePartName).get_type()
        
        foundName = self.pick_name(inNamePartName, inStr)
        if foundName == "":
            return returnStr
        partIndex = self.get_name_part_index(inNamePartName)
        foundIndex = nameArray.index(foundName)
        
        if partType == NamePartType.PREFIX:
            if foundIndex >= 0:
                prevNameParts = self._nameParts[:partIndex]
                prevNames = [self.pick_name(part.get_name(), inStr) for part in prevNameParts]
                prevNamesInNameArray = nameArray[:foundIndex]
                for prevName in prevNames:
                    if prevName in prevNamesInNameArray:
                        prevNamesInNameArray.remove(prevName)
                if len(prevNamesInNameArray) == 0 :
                    returnStr = foundName
        
        if partType == NamePartType.SUFFIX:
            if foundIndex >= 0:
                nextNameParts = self._nameParts[partIndex + 1:]
                nextNames = [self.pick_name(part.get_name(), inStr) for part in nextNameParts]
                nextNamesInNameArray = nameArray[foundIndex + 1:]
                for nextName in nextNames:
                    if nextName in nextNamesInNameArray:
                        nextNamesInNameArray.remove(nextName)
                if len(nextNamesInNameArray) == 0 :
                    returnStr = foundName
        
        if partType == NamePartType.INDEX:
            returnStr = self.pick_name(inNamePartName, inStr)
                
        return returnStr
    
    def combine(self, inPartsDict={}, inFilChar=" "):
        """
        namingConfig에서 정의된 nameParts와 그 순서에 따라 이름 부분들을 조합하여 완전한 이름 생성
        
        Args:
            parts_dict: namePart 이름과 값의 딕셔너리 (예: {"Base": "b", "Type": "P", "Side": "L"})
            inFilChar: 구분자 문자 (기본값: " ")
            
        Returns:
            조합된 이름 문자열
        """
        # 결과 배열 초기화 (빈 문자열로)
        combinedNameArray = [""] * len(self._nameParts)
        
        # 각 namePart에 대해
        for i, part in enumerate(self._nameParts):
            partName = part.get_name()
            # 딕셔너리에서 해당 부분의 값 가져오기 (없으면 빈 문자열 사용)
            if partName in inPartsDict:
                combinedNameArray[i] = inPartsDict[partName]
                
        # 배열을 문자열로 결합
        newName = self._combine(combinedNameArray, inFilChar)
        newName = self.set_index_padding_num(newName)
        return newName
    
    def get_RealName(self, inStr):
        """
        문자열에서 실제 이름 부분 추출
        
        Args:
            inStr: 처리할 문자열
            
        Returns:
            실제 이름 부분 문자열
        """
        filChar = self._get_filtering_char(inStr)
        nameArray = self._split_to_array(inStr)
        
        # 모든 nameParts 중 RealName이 아닌 것들의 값을 수집
        nonRealNameArray = []
        for part in self._nameParts:
            partName = part.get_name()
            partType = part.get_type()
            if partType != NamePartType.REALNAME:
                foundName = self.get_name(partName, inStr)
                nonRealNameArray.append(foundName)
        
        for item in nonRealNameArray:
            if item in nameArray:
                nameArray.remove(item)
                
        # 구분자로 결합
        return self._combine(nameArray, filChar)

    def get_non_RealName(self, inStr):
        """
        실제 이름 부분을 제외한 이름 가져오기
        
        Args:
            inStr: 처리할 이름 문자열
            
        Returns:
            실제 이름이 제외된 이름 문자열
        """
        filChar = self._get_filtering_char(inStr)
        
        # 모든 nameParts 중 RealName이 아닌 것들의 값을 수집
        nonRealNameArray = []
        for part in self._nameParts:
            partName = part.get_name()
            partType = part.get_type()
            if partType != NamePartType.REALNAME:
                foundName = self.get_name(partName, inStr)
                nonRealNameArray.append(foundName)
        
        return self._combine(nonRealNameArray, filChar)
                
    def convert_name_to_array(self, inStr):
        """
        문자열 이름을 이름 부분 배열로 변환
        
        Args:
            inStr: 변환할 이름 문자열
            
        Returns:
            이름 부분 배열 (Base, Type, Side, FrontBack, RealName, Index, Nub 등)
        """
        returnArray = [""] * len(self._nameParts)
        
        # 각 namePart에 대해 처리
        for i, part in enumerate(self._nameParts):
            partName = part.get_name()
            
            # 특수 케이스인 RealName은 마지막에 처리하기 위해 저장
            if partName == "RealName":
                realNameIndex = i
                continue
                
            # get_name 메소드를 사용하여 해당 부분 추출
            partValue = self.get_name(partName, inStr)
            returnArray[i] = partValue
        
        # 마지막으로 RealName 처리 (다른 모든 부분을 찾은 후에 수행해야 함)
        if 'realNameIndex' in locals():
            realNameStr = self.get_RealName(inStr)
            returnArray[realNameIndex] = realNameStr
        
        return returnArray
    
    def convert_to_dictionary(self, inStr):
        """
        문자열 이름을 이름 부분 딕셔너리로 변환
        
        Args:
            inStr: 변환할 이름 문자열
            
        Returns:
            이름 부분 딕셔너리 (키: namePart 이름, 값: 추출된 값)
            예: {"Base": "b", "Type": "P", "Side": "L", "RealName": "Arm", ...}
        """
        returnDict = {}
        
        # 각 namePart에 대해 처리
        for part in self._nameParts:
            partName = part.get_name()
            
            # 특수 케이스인 RealName은 마지막에 처리하기 위해 저장
            if partName == "RealName":
                continue
                
            # get_name 메소드를 사용하여 해당 부분 추출
            partValue = self.get_name(partName, inStr)
            returnDict[partName] = partValue
        
        # 마지막으로 RealName 처리 (다른 모든 부분을 찾은 후에 수행해야 함)
        realNameStr = self.get_RealName(inStr)
        returnDict["RealName"] = realNameStr
        
        return returnDict
    
    def convert_to_description(self, inStr):
        """
        문자열 이름을 설명으로 변환
        
        Args:
            inStr: 변환할 이름 문자열
            
        Returns:
            설명 문자열 (예: "b_P_L_Arm")
        """
        nameDic = self.convert_to_dictionary(inStr)
        descriptionDic = {}
        filteringChar = self._get_filtering_char(inStr)
        descName = inStr
        if nameDic:
            for namePartName, value in nameDic.items():
                namePart = self.get_name_part(namePartName)
                desc = namePart.get_description_by_value(value)

                if desc == "" and value != "":
                    desc = value

                descriptionDic[namePartName] = desc # Store in dictionary for later use

            descName = self.combine(descriptionDic, filteringChar)
        
        return descName
    
    def convert_to_korean_description(self, inStr):
        """
        문자열 이름을 한국어 설명으로 변환
        
        Args:
            inStr: 변환할 이름 문자열
            
        Returns:
            한국어 설명 문자열 (예: "팔_왼쪽_팔")
        """
        nameDic = self.convert_to_dictionary(inStr)
        korDescDic = {}
        filteringChar = self._get_filtering_char(inStr)
        korDescName = inStr
        if nameDic:
            for namePartName, value in nameDic.items():
                namePart = self.get_name_part(namePartName)
                desc = namePart.get_description_by_value(value)
                korDesc = namePart.get_korean_description_by_value(value)

                if korDesc == "" and desc != "":
                    korDesc = desc

                korDescDic[namePartName] = korDesc # Store in dictionary for later use

            korDescName = self.combine(korDescDic, filteringChar)
        
        return korDescName
    
    def has_name_part(self, inPart, inStr):
        """
        문자열에 특정 namePart가 포함되어 있는지 확인
        
        Args:
            inPart: 확인할 namePart 이름 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
            inStr: 확인할 문자열
            
        Returns:
            포함되어 있으면 True, 아니면 False
        """
        return self.get_name(inPart, inStr) != ""
    
    def add_prefix_to_name_part(self, inPart, inStr, inPrefix):
        """
        이름의 특정 부분에 접두사 추가
        
        Args:
            inPart: 수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
            inStr: 처리할 이름 문자열
            inPrefix: 추가할 접두사
            
        Returns:
            수정된 이름 문자열
        """
        returnStr = inStr
        
        if inPrefix:
            filChar = self._get_filtering_char(inStr)
            nameArray = self.convert_name_to_array(inStr)
            partIndex = self.get_name_part_index(inPart)
                
            nameArray[partIndex] = inPrefix + nameArray[partIndex]
                    
            returnStr = self._combine(nameArray, filChar)
                
        return returnStr
    
    def add_suffix_to_name_part(self, inPart, inStr, inSuffix):
        """
        이름의 특정 부분에 접미사 추가
        
        Args:
            inPart: 수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
            inStr: 처리할 이름 문자열
            inSuffix: 추가할 접미사
            
        Returns:
            수정된 이름 문자열
        """
        returnStr = inStr
        
        if inSuffix:
            filChar = self._get_filtering_char(inStr)
            nameArray = self.convert_name_to_array(inStr)
            partIndex = self.get_name_part_index(inPart)
                
            nameArray[partIndex] = nameArray[partIndex] + inSuffix
                    
            returnStr = self._combine(nameArray, filChar)
                
        return returnStr

    def add_prefix_to_real_name(self, inStr, inPrefix):
        """
        실제 이름 부분에 접두사 추가
        
        Args:
            inStr: 처리할 이름 문자열
            inPrefix: 추가할 접두사
            
        Returns:
            수정된 이름 문자열
        """
        return self.add_prefix_to_name_part("RealName", inStr, inPrefix)

    def add_suffix_to_real_name(self, inStr, inSuffix):
        """
        실제 이름 부분에 접미사 추가
        
        Args:
            inStr: 처리할 이름 문자열
            inSuffix: 추가할 접미사
            
        Returns:
            수정된 이름 문자열
        """
        return self.add_suffix_to_name_part("RealName", inStr, inSuffix)
    
    def convert_digit_into_padding_string(self, inDigit, inPaddingNum=None):
        """
        숫자를 패딩된 문자열로 변환
        
        Args:
            inDigit: 변환할 숫자 또는 숫자 문자열
            inPaddingNum: 패딩 자릿수 (기본값: 클래스의 _paddingNum)
            
        Returns:
            패딩된 문자열
        """
        if inPaddingNum is None:
            inPaddingNum = self._paddingNum
            
        digitNum = 0
        
        if isinstance(inDigit, int):
            digitNum = inDigit
        elif isinstance(inDigit, str):
            if inDigit.isdigit():
                digitNum = int(inDigit)
                
        # Python의 문자열 포맷팅을 사용하여 패딩
        return f"{digitNum:0{inPaddingNum}d}"

    def set_index_padding_num(self, inStr, inPaddingNum=None):
        """
        이름의 인덱스 부분 패딩 설정
        
        Args:
            inStr: 처리할 이름 문자열
            inPaddingNum: 설정할 패딩 자릿수 (기본값: 클래스의 _paddingNum)
            
        Returns:
            패딩이 적용된 이름 문자열
        """
        if inPaddingNum is None:
            inPaddingNum = self._paddingNum
            
        filChar = self._get_filtering_char(inStr)
        nameArray = self.convert_name_to_array(inStr)
        indexIndex = self.get_name_part_index("Index")
        indexStr = self.get_name("Index", inStr)
        
        if indexStr:
            indexStr = self.convert_digit_into_padding_string(indexStr, inPaddingNum)
            nameArray[indexIndex] = indexStr
            
        return self._combine(nameArray, filChar)

    def get_index_padding_num(self, inStr):
        """
        이름의 인덱스 부분 패딩 자릿수 가져오기
        
        Args:
            inStr: 처리할 이름 문자열
            
        Returns:
            인덱스 패딩 자릿수
        """
        indexVal = self.get_name("Index", inStr)
        
        if indexVal:
            return len(indexVal)
            
        return 1

    def increase_index(self, inStr, inAmount):
        """
        이름의 인덱스 부분 값 증가
        
        Args:
            inStr: 처리할 이름 문자열
            inAmount: 증가시킬 값
            
        Returns:
            인덱스가 증가된 이름 문자열
        """
        newName = inStr
        filChar = self._get_filtering_char(inStr)
        nameArray = self.convert_name_to_array(inStr)
        indexIndex = self.get_name_part_index("Index")
        
        if indexIndex >= 0:
            indexStr = ""
            indexPaddingNum = self._paddingNum
            indexNum = -99999
            
            if not nameArray[indexIndex]:
                indexNum = -1
            else:
                try:
                    indexNum = int(nameArray[indexIndex])
                    indexPaddingNum = len(nameArray[indexIndex])
                except ValueError:
                    pass
            
            indexNum += inAmount
            
            if indexNum < 0:
                indexNum = 0
            
            # Python의 문자열 포맷팅을 사용하여 패딩
            indexStr = f"{indexNum:0{indexPaddingNum}d}"
            nameArray[indexIndex] = indexStr
            newName = self._combine(nameArray, filChar)
            newName = self.set_index_padding_num(newName)
            
        return newName

    def get_index_as_digit(self, inStr):
        """
        이름의 인덱스를 숫자로 변환
        
        Args:
            inStr: 변환할 이름 문자열
            
        Returns:
            숫자로 변환된 인덱스 (넙이 있으면 -1, 인덱스가 없으면 False)
        """
        indexStr = self.get_name("Index", inStr)
            
        if indexStr:
            try:
                return int(indexStr)
            except ValueError:
                pass
                
        return False

    def sort_by_index(self, inNameArray):
        """
        이름 배열을 인덱스 기준으로 정렬
        
        Args:
            inNameArray: 정렬할 이름 배열
            
        Returns:
            인덱스 기준으로 정렬된 이름 배열
        """
        if not inNameArray:
            return []
            
        # 정렬을 위한 보조 클래스 정의
        @dataclass
        class IndexSorting:
            oriIndex: int
            newIndex: int
                
        # 각 이름의 인덱스를 추출하여 정렬 정보 생성
        structArray = []
        
        for i, name in enumerate(inNameArray):
            tempIndex = self.get_index_as_digit(name)
            
            if tempIndex is False:
                structArray.append(IndexSorting(i, 0))
            else:
                structArray.append(IndexSorting(i, tempIndex))
                
        # 인덱스 기준으로 정렬
        structArray.sort(key=lambda x: x.newIndex)
        
        # 정렬된 순서로 결과 배열 생성
        sortedNameArray = []
        for struct in structArray:
            sortedNameArray.append(inNameArray[struct.oriIndex])
            
        return sortedNameArray
    
    def get_string(self, inStr):
        """
        인덱스 부분을 제외한 이름 문자열 가져오기
        
        Args:
            inStr: 처리할 이름 문자열
            
        Returns:
            인덱스가 제외된 이름 문자열
        """
        filChar = self._get_filtering_char(inStr)
        nameArray = self.convert_name_to_array(inStr)
        indexOrder = self.get_name_part_index("Index")
        
        # 인덱스 부분 제거
        returnNameArray = nameArray.copy()
        returnNameArray[indexOrder] = ""
        
        return self._combine(returnNameArray, filChar)

    def gen_mirroring_name(self, inStr):
        """
        미러링된 이름 생성 (측면 또는 앞/뒤 변경)
        
        이름에서 Side와 FrontBack namePart를 자동으로 검색하고,
        발견된 값의 semanticmapping weight와 가장 차이가 큰 값으로 교체합니다.
        
        Args:
            inStr: 처리할 이름 문자열
            
        Returns:
            미러링된 이름 문자열
        """
        nameArray = self.convert_name_to_array(inStr)
            
        for part in self._nameParts:
            partName = part.get_name()
            partType = part.get_type()
            if (partType != NamePartType.REALNAME or partType != NamePartType.INDEX) and part.is_direction():
                partIndex = self.get_name_part_index(partName)
                foundName = self.get_name(partName, inStr)
                opositeName = part.get_most_different_weight_value(foundName)
                if opositeName and foundName != opositeName:
                    nameArray[partIndex] = opositeName
        
        returnName = self._combine(nameArray, self._get_filtering_char(inStr))
        
        return returnName

    def replace_filtering_char(self, inStr, inNewFilChar):
        """
        이름의 구분자 문자 변경
        
        Args:
            inStr: 처리할 이름 문자열
            inNewFilChar: 새 구분자 문자
            
        Returns:
            구분자가 변경된 이름 문자열
        """
        nameArray = self.convert_name_to_array(inStr)
        return self._combine(nameArray, inNewFilChar)

    def replace_name_part(self, inPart, inStr, inNewName):
        """
        이름의 특정 부분을 새 이름으로 변경
        
        Args:
            inPart: 수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
            inStr: 처리할 이름 문자열
            inNewName: 새 이름
        
        Returns:
            수정된 이름 문자열
        """
        nameArray = self.convert_name_to_array(inStr)
        partIndex = self.get_name_part_index(inPart)
        
        if partIndex >= 0:
            nameArray[partIndex] = inNewName
        
        newName = self._combine(nameArray, self._get_filtering_char(inStr))
        newName = self.set_index_padding_num(newName)
        
        return newName

    def remove_name_part(self, inPart, inStr):
        """
        이름의 특정 부분 제거
        
        Args:
            inPart: 제거할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
            inStr: 처리할 이름 문자열
            
        Returns:
            수정된 이름 문자열
        """
        nameArray = self.convert_name_to_array(inStr)
        partIndex = self.get_name_part_index(inPart)
        
        if partIndex >= 0:
            nameArray[partIndex] = ""
            
        newName = self._combine(nameArray, self._get_filtering_char(inStr))
        newName = self.set_index_padding_num(newName)
        
        return newName

    def load_from_config_file(self, configPath=None):
        """
        설정 파일에서 설정 로드
        
        Args:
            configPath: 설정 파일 경로 (기본값: self._configPath)
            
        Returns:
            로드 성공 여부 (True/False)
        """
        # 경로가 없으면 인스턴스 생성 시 설정된 경로 사용
        if not configPath:
            configPath = self._configPath
            
        if not configPath:
            print("설정 파일 경로가 제공되지 않았습니다.")
            return False
            
        # NamingConfig 인스턴스 생성 및 설정 로드
        config = NamingConfig()
        if config.load(configPath):
            # 설정을 Naming 인스턴스에 적용
            result = config.apply_to_naming(self)
            if result:
                self._configPath = configPath  # 성공적으로 로드한 경로 저장
            return result
        else:
            print(f"설정 파일 로드 실패: {configPath}")
            return False
    
    def load_default_config(self):
        """
        기본 설정 로드 (현재는 아무 작업도 수행하지 않음)
        
        Returns:
            항상 True 반환 (기본 설정은 __init__에서 이미 설정됨)
        """
        # 이 메소드는 현재 __init__에서 설정한 기본값을 그대로 사용하므로
        # 아무 작업도 수행하지 않습니다.
        return True

    def get_config_path(self):
        """
        현재 설정 파일 경로 가져오기
        
        Returns:
            설정 파일 경로 (없으면 빈 문자열)
        """
        return self._configPath or ""

노드 이름을 관리하기 위한 기본 클래스. 기본적인 이름 구성 요소를 정의하고 관리합니다. 이 클래스는 하위 클래스에서 확장하여 특정 목적에 맞게 사용할 수 있습니다.

클래스 초기화 및 기본 설정값 정의

Args

configPath
설정 파일 경로 (기본값: None) 설정 파일이 제공되면 해당 파일에서 설정을 로드함

Subclasses

Methods

def add_prefix_to_name_part(self, inPart, inStr, inPrefix)
Expand source code
def add_prefix_to_name_part(self, inPart, inStr, inPrefix):
    """
    이름의 특정 부분에 접두사 추가
    
    Args:
        inPart: 수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
        inStr: 처리할 이름 문자열
        inPrefix: 추가할 접두사
        
    Returns:
        수정된 이름 문자열
    """
    returnStr = inStr
    
    if inPrefix:
        filChar = self._get_filtering_char(inStr)
        nameArray = self.convert_name_to_array(inStr)
        partIndex = self.get_name_part_index(inPart)
            
        nameArray[partIndex] = inPrefix + nameArray[partIndex]
                
        returnStr = self._combine(nameArray, filChar)
            
    return returnStr

이름의 특정 부분에 접두사 추가

Args

inPart
수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
inStr
처리할 이름 문자열
inPrefix
추가할 접두사

Returns

수정된 이름 문자열

def add_prefix_to_real_name(self, inStr, inPrefix)
Expand source code
def add_prefix_to_real_name(self, inStr, inPrefix):
    """
    실제 이름 부분에 접두사 추가
    
    Args:
        inStr: 처리할 이름 문자열
        inPrefix: 추가할 접두사
        
    Returns:
        수정된 이름 문자열
    """
    return self.add_prefix_to_name_part("RealName", inStr, inPrefix)

실제 이름 부분에 접두사 추가

Args

inStr
처리할 이름 문자열
inPrefix
추가할 접두사

Returns

수정된 이름 문자열

def add_suffix_to_name_part(self, inPart, inStr, inSuffix)
Expand source code
def add_suffix_to_name_part(self, inPart, inStr, inSuffix):
    """
    이름의 특정 부분에 접미사 추가
    
    Args:
        inPart: 수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
        inStr: 처리할 이름 문자열
        inSuffix: 추가할 접미사
        
    Returns:
        수정된 이름 문자열
    """
    returnStr = inStr
    
    if inSuffix:
        filChar = self._get_filtering_char(inStr)
        nameArray = self.convert_name_to_array(inStr)
        partIndex = self.get_name_part_index(inPart)
            
        nameArray[partIndex] = nameArray[partIndex] + inSuffix
                
        returnStr = self._combine(nameArray, filChar)
            
    return returnStr

이름의 특정 부분에 접미사 추가

Args

inPart
수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
inStr
처리할 이름 문자열
inSuffix
추가할 접미사

Returns

수정된 이름 문자열

def add_suffix_to_real_name(self, inStr, inSuffix)
Expand source code
def add_suffix_to_real_name(self, inStr, inSuffix):
    """
    실제 이름 부분에 접미사 추가
    
    Args:
        inStr: 처리할 이름 문자열
        inSuffix: 추가할 접미사
        
    Returns:
        수정된 이름 문자열
    """
    return self.add_suffix_to_name_part("RealName", inStr, inSuffix)

실제 이름 부분에 접미사 추가

Args

inStr
처리할 이름 문자열
inSuffix
추가할 접미사

Returns

수정된 이름 문자열

def combine(self, inPartsDict={}, inFilChar=' ')
Expand source code
def combine(self, inPartsDict={}, inFilChar=" "):
    """
    namingConfig에서 정의된 nameParts와 그 순서에 따라 이름 부분들을 조합하여 완전한 이름 생성
    
    Args:
        parts_dict: namePart 이름과 값의 딕셔너리 (예: {"Base": "b", "Type": "P", "Side": "L"})
        inFilChar: 구분자 문자 (기본값: " ")
        
    Returns:
        조합된 이름 문자열
    """
    # 결과 배열 초기화 (빈 문자열로)
    combinedNameArray = [""] * len(self._nameParts)
    
    # 각 namePart에 대해
    for i, part in enumerate(self._nameParts):
        partName = part.get_name()
        # 딕셔너리에서 해당 부분의 값 가져오기 (없으면 빈 문자열 사용)
        if partName in inPartsDict:
            combinedNameArray[i] = inPartsDict[partName]
            
    # 배열을 문자열로 결합
    newName = self._combine(combinedNameArray, inFilChar)
    newName = self.set_index_padding_num(newName)
    return newName

namingConfig에서 정의된 nameParts와 그 순서에 따라 이름 부분들을 조합하여 완전한 이름 생성

Args

parts_dict
namePart 이름과 값의 딕셔너리 (예: {"Base": "b", "Type": "P", "Side": "L"})
inFilChar
구분자 문자 (기본값: " ")

Returns

조합된 이름 문자열

def convert_digit_into_padding_string(self, inDigit, inPaddingNum=None)
Expand source code
def convert_digit_into_padding_string(self, inDigit, inPaddingNum=None):
    """
    숫자를 패딩된 문자열로 변환
    
    Args:
        inDigit: 변환할 숫자 또는 숫자 문자열
        inPaddingNum: 패딩 자릿수 (기본값: 클래스의 _paddingNum)
        
    Returns:
        패딩된 문자열
    """
    if inPaddingNum is None:
        inPaddingNum = self._paddingNum
        
    digitNum = 0
    
    if isinstance(inDigit, int):
        digitNum = inDigit
    elif isinstance(inDigit, str):
        if inDigit.isdigit():
            digitNum = int(inDigit)
            
    # Python의 문자열 포맷팅을 사용하여 패딩
    return f"{digitNum:0{inPaddingNum}d}"

숫자를 패딩된 문자열로 변환

Args

inDigit
변환할 숫자 또는 숫자 문자열
inPaddingNum
패딩 자릿수 (기본값: 클래스의 _paddingNum)

Returns

패딩된 문자열

def convert_name_to_array(self, inStr)
Expand source code
def convert_name_to_array(self, inStr):
    """
    문자열 이름을 이름 부분 배열로 변환
    
    Args:
        inStr: 변환할 이름 문자열
        
    Returns:
        이름 부분 배열 (Base, Type, Side, FrontBack, RealName, Index, Nub 등)
    """
    returnArray = [""] * len(self._nameParts)
    
    # 각 namePart에 대해 처리
    for i, part in enumerate(self._nameParts):
        partName = part.get_name()
        
        # 특수 케이스인 RealName은 마지막에 처리하기 위해 저장
        if partName == "RealName":
            realNameIndex = i
            continue
            
        # get_name 메소드를 사용하여 해당 부분 추출
        partValue = self.get_name(partName, inStr)
        returnArray[i] = partValue
    
    # 마지막으로 RealName 처리 (다른 모든 부분을 찾은 후에 수행해야 함)
    if 'realNameIndex' in locals():
        realNameStr = self.get_RealName(inStr)
        returnArray[realNameIndex] = realNameStr
    
    return returnArray

문자열 이름을 이름 부분 배열로 변환

Args

inStr
변환할 이름 문자열

Returns

이름 부분 배열 (Base, Type, Side, FrontBack, RealName, Index, Nub 등)

def convert_to_description(self, inStr)
Expand source code
def convert_to_description(self, inStr):
    """
    문자열 이름을 설명으로 변환
    
    Args:
        inStr: 변환할 이름 문자열
        
    Returns:
        설명 문자열 (예: "b_P_L_Arm")
    """
    nameDic = self.convert_to_dictionary(inStr)
    descriptionDic = {}
    filteringChar = self._get_filtering_char(inStr)
    descName = inStr
    if nameDic:
        for namePartName, value in nameDic.items():
            namePart = self.get_name_part(namePartName)
            desc = namePart.get_description_by_value(value)

            if desc == "" and value != "":
                desc = value

            descriptionDic[namePartName] = desc # Store in dictionary for later use

        descName = self.combine(descriptionDic, filteringChar)
    
    return descName

문자열 이름을 설명으로 변환

Args

inStr
변환할 이름 문자열

Returns

설명 문자열 (예: "b_P_L_Arm")

def convert_to_dictionary(self, inStr)
Expand source code
def convert_to_dictionary(self, inStr):
    """
    문자열 이름을 이름 부분 딕셔너리로 변환
    
    Args:
        inStr: 변환할 이름 문자열
        
    Returns:
        이름 부분 딕셔너리 (키: namePart 이름, 값: 추출된 값)
        예: {"Base": "b", "Type": "P", "Side": "L", "RealName": "Arm", ...}
    """
    returnDict = {}
    
    # 각 namePart에 대해 처리
    for part in self._nameParts:
        partName = part.get_name()
        
        # 특수 케이스인 RealName은 마지막에 처리하기 위해 저장
        if partName == "RealName":
            continue
            
        # get_name 메소드를 사용하여 해당 부분 추출
        partValue = self.get_name(partName, inStr)
        returnDict[partName] = partValue
    
    # 마지막으로 RealName 처리 (다른 모든 부분을 찾은 후에 수행해야 함)
    realNameStr = self.get_RealName(inStr)
    returnDict["RealName"] = realNameStr
    
    return returnDict

문자열 이름을 이름 부분 딕셔너리로 변환

Args

inStr
변환할 이름 문자열

Returns

이름 부분 딕셔너리 (키: namePart 이름, 값: 추출된 값)
{"Base": "b", "Type": "P", "Side": "L", "RealName": "Arm", …}
def convert_to_korean_description(self, inStr)
Expand source code
def convert_to_korean_description(self, inStr):
    """
    문자열 이름을 한국어 설명으로 변환
    
    Args:
        inStr: 변환할 이름 문자열
        
    Returns:
        한국어 설명 문자열 (예: "팔_왼쪽_팔")
    """
    nameDic = self.convert_to_dictionary(inStr)
    korDescDic = {}
    filteringChar = self._get_filtering_char(inStr)
    korDescName = inStr
    if nameDic:
        for namePartName, value in nameDic.items():
            namePart = self.get_name_part(namePartName)
            desc = namePart.get_description_by_value(value)
            korDesc = namePart.get_korean_description_by_value(value)

            if korDesc == "" and desc != "":
                korDesc = desc

            korDescDic[namePartName] = korDesc # Store in dictionary for later use

        korDescName = self.combine(korDescDic, filteringChar)
    
    return korDescName

문자열 이름을 한국어 설명으로 변환

Args

inStr
변환할 이름 문자열

Returns

한국어 설명 문자열 (예: "팔_왼쪽_팔")

def gen_mirroring_name(self, inStr)
Expand source code
def gen_mirroring_name(self, inStr):
    """
    미러링된 이름 생성 (측면 또는 앞/뒤 변경)
    
    이름에서 Side와 FrontBack namePart를 자동으로 검색하고,
    발견된 값의 semanticmapping weight와 가장 차이가 큰 값으로 교체합니다.
    
    Args:
        inStr: 처리할 이름 문자열
        
    Returns:
        미러링된 이름 문자열
    """
    nameArray = self.convert_name_to_array(inStr)
        
    for part in self._nameParts:
        partName = part.get_name()
        partType = part.get_type()
        if (partType != NamePartType.REALNAME or partType != NamePartType.INDEX) and part.is_direction():
            partIndex = self.get_name_part_index(partName)
            foundName = self.get_name(partName, inStr)
            opositeName = part.get_most_different_weight_value(foundName)
            if opositeName and foundName != opositeName:
                nameArray[partIndex] = opositeName
    
    returnName = self._combine(nameArray, self._get_filtering_char(inStr))
    
    return returnName

미러링된 이름 생성 (측면 또는 앞/뒤 변경)

이름에서 Side와 FrontBack namePart를 자동으로 검색하고, 발견된 값의 semanticmapping weight와 가장 차이가 큰 값으로 교체합니다.

Args

inStr
처리할 이름 문자열

Returns

미러링된 이름 문자열

def get_RealName(self, inStr)
Expand source code
def get_RealName(self, inStr):
    """
    문자열에서 실제 이름 부분 추출
    
    Args:
        inStr: 처리할 문자열
        
    Returns:
        실제 이름 부분 문자열
    """
    filChar = self._get_filtering_char(inStr)
    nameArray = self._split_to_array(inStr)
    
    # 모든 nameParts 중 RealName이 아닌 것들의 값을 수집
    nonRealNameArray = []
    for part in self._nameParts:
        partName = part.get_name()
        partType = part.get_type()
        if partType != NamePartType.REALNAME:
            foundName = self.get_name(partName, inStr)
            nonRealNameArray.append(foundName)
    
    for item in nonRealNameArray:
        if item in nameArray:
            nameArray.remove(item)
            
    # 구분자로 결합
    return self._combine(nameArray, filChar)

문자열에서 실제 이름 부분 추출

Args

inStr
처리할 문자열

Returns

실제 이름 부분 문자열

def get_config_path(self)
Expand source code
def get_config_path(self):
    """
    현재 설정 파일 경로 가져오기
    
    Returns:
        설정 파일 경로 (없으면 빈 문자열)
    """
    return self._configPath or ""

현재 설정 파일 경로 가져오기

Returns

설정 파일 경로 (없으면 빈 문자열)

def get_index_as_digit(self, inStr)
Expand source code
def get_index_as_digit(self, inStr):
    """
    이름의 인덱스를 숫자로 변환
    
    Args:
        inStr: 변환할 이름 문자열
        
    Returns:
        숫자로 변환된 인덱스 (넙이 있으면 -1, 인덱스가 없으면 False)
    """
    indexStr = self.get_name("Index", inStr)
        
    if indexStr:
        try:
            return int(indexStr)
        except ValueError:
            pass
            
    return False

이름의 인덱스를 숫자로 변환

Args

inStr
변환할 이름 문자열

Returns

숫자로 변환된 인덱스 (넙이 있으면 -1, 인덱스가 없으면 False)

def get_index_padding_num(self, inStr)
Expand source code
def get_index_padding_num(self, inStr):
    """
    이름의 인덱스 부분 패딩 자릿수 가져오기
    
    Args:
        inStr: 처리할 이름 문자열
        
    Returns:
        인덱스 패딩 자릿수
    """
    indexVal = self.get_name("Index", inStr)
    
    if indexVal:
        return len(indexVal)
        
    return 1

이름의 인덱스 부분 패딩 자릿수 가져오기

Args

inStr
처리할 이름 문자열

Returns

인덱스 패딩 자릿수

def get_name(self, inNamePartName, inStr)
Expand source code
def get_name(self, inNamePartName, inStr):
    """
    지정된 namePart에 해당하는 부분을 문자열에서 추출
    
    Args:
        namePart: 추출할 namePart 이름 ("Base", "Type", "Side" 등)
        inStr: 처리할 문자열
        
    Returns:
        지정된 namePart에 해당하는 문자열
    """
    nameArray = self._split_to_array(inStr)
    returnStr = ""
    
    partType = self.get_name_part(inNamePartName).get_type()
    
    foundName = self.pick_name(inNamePartName, inStr)
    if foundName == "":
        return returnStr
    partIndex = self.get_name_part_index(inNamePartName)
    foundIndex = nameArray.index(foundName)
    
    if partType == NamePartType.PREFIX:
        if foundIndex >= 0:
            prevNameParts = self._nameParts[:partIndex]
            prevNames = [self.pick_name(part.get_name(), inStr) for part in prevNameParts]
            prevNamesInNameArray = nameArray[:foundIndex]
            for prevName in prevNames:
                if prevName in prevNamesInNameArray:
                    prevNamesInNameArray.remove(prevName)
            if len(prevNamesInNameArray) == 0 :
                returnStr = foundName
    
    if partType == NamePartType.SUFFIX:
        if foundIndex >= 0:
            nextNameParts = self._nameParts[partIndex + 1:]
            nextNames = [self.pick_name(part.get_name(), inStr) for part in nextNameParts]
            nextNamesInNameArray = nameArray[foundIndex + 1:]
            for nextName in nextNames:
                if nextName in nextNamesInNameArray:
                    nextNamesInNameArray.remove(nextName)
            if len(nextNamesInNameArray) == 0 :
                returnStr = foundName
    
    if partType == NamePartType.INDEX:
        returnStr = self.pick_name(inNamePartName, inStr)
            
    return returnStr

지정된 namePart에 해당하는 부분을 문자열에서 추출

Args

namePart
추출할 namePart 이름 ("Base", "Type", "Side" 등)
inStr
처리할 문자열

Returns

지정된 namePart에 해당하는 문자열

def get_name_part(self, inNamePartName)
Expand source code
def get_name_part(self, inNamePartName):
    """
    namePart 이름으로 NamePart 객체 가져오기
    
    Args:
        namePart: 가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)
        
    Returns:
        해당 NamePart 객체, 존재하지 않으면 None
    """
    for part in self._nameParts:
        if part.get_name() == inNamePartName:
            return part
    return None

namePart 이름으로 NamePart 객체 가져오기

Args

namePart
가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)

Returns

해당 NamePart 객체, 존재하지 않으면 None

def get_name_part_index(self, inNamePartName)
Expand source code
def get_name_part_index(self, inNamePartName):
    """
    namePart 이름으로 인덱스 가져오기
    
    Args:
        namePart: 가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)
        
    Returns:
        해당 NamePart의 인덱스, 존재하지 않으면 -1
    """
    for i, part in enumerate(self._nameParts):
        if part.get_name() == inNamePartName:
            return i
    return -1

namePart 이름으로 인덱스 가져오기

Args

namePart
가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)

Returns

해당 NamePart의 인덱스, 존재하지 않으면 -1

def get_name_part_predefined_values(self, inNamePartName)
Expand source code
def get_name_part_predefined_values(self, inNamePartName):
    """
    namePart의 사전 정의 값 가져오기
    
    Args:
        namePart: 가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)
        
    Returns:
        해당 NamePart의 사전 정의 값 리스트, 존재하지 않으면 빈 리스트
    """
    partObj = self.get_name_part(inNamePartName)
    if partObj:
        return partObj.get_predefined_values()
    return []

namePart의 사전 정의 값 가져오기

Args

namePart
가져올 NamePart의 이름 ("Prefix", "RealName", "Suffix", "Index" 등)

Returns

해당 NamePart의 사전 정의 값 리스트, 존재하지 않으면 빈 리스트

def get_name_part_value_by_description(self, inNamePartName, inDescription)
Expand source code
def get_name_part_value_by_description(self, inNamePartName, inDescription):
    """
    지정된 namePart에 해당하는 부분을 문자열에서 추출
    
    Args:
        namePart: 추출할 namePart 이름 ("Base", "Type", "Side" 등)
        inDescription: predefined value에서 찾기위한 description 문자열
        
    Returns:
        지정된 namePart에 해당하는 문자열
    """
    partObj = self.get_name_part(inNamePartName)
    if not partObj:
        return ""
    
    partType = partObj.get_type()
    if not partType:
        return ""
        
    partValues = partObj.get_predefined_values()
    
    if partType == NamePartType.PREFIX or partType == NamePartType.SUFFIX:
        foundIndex = partObj._descriptions.index(inDescription)
        if foundIndex >= 0:
            return partValues[foundIndex]
    
    return ""

지정된 namePart에 해당하는 부분을 문자열에서 추출

Args

namePart
추출할 namePart 이름 ("Base", "Type", "Side" 등)
inDescription
predefined value에서 찾기위한 description 문자열

Returns

지정된 namePart에 해당하는 문자열

def get_non_RealName(self, inStr)
Expand source code
def get_non_RealName(self, inStr):
    """
    실제 이름 부분을 제외한 이름 가져오기
    
    Args:
        inStr: 처리할 이름 문자열
        
    Returns:
        실제 이름이 제외된 이름 문자열
    """
    filChar = self._get_filtering_char(inStr)
    
    # 모든 nameParts 중 RealName이 아닌 것들의 값을 수집
    nonRealNameArray = []
    for part in self._nameParts:
        partName = part.get_name()
        partType = part.get_type()
        if partType != NamePartType.REALNAME:
            foundName = self.get_name(partName, inStr)
            nonRealNameArray.append(foundName)
    
    return self._combine(nonRealNameArray, filChar)

실제 이름 부분을 제외한 이름 가져오기

Args

inStr
처리할 이름 문자열

Returns

실제 이름이 제외된 이름 문자열

def get_padding_num(self)
Expand source code
def get_padding_num(self):
    """
    패딩 숫자 가져오기
    
    Returns:
        패딩 숫자
    """
    return self._paddingNum

패딩 숫자 가져오기

Returns

패딩 숫자

def get_string(self, inStr)
Expand source code
def get_string(self, inStr):
    """
    인덱스 부분을 제외한 이름 문자열 가져오기
    
    Args:
        inStr: 처리할 이름 문자열
        
    Returns:
        인덱스가 제외된 이름 문자열
    """
    filChar = self._get_filtering_char(inStr)
    nameArray = self.convert_name_to_array(inStr)
    indexOrder = self.get_name_part_index("Index")
    
    # 인덱스 부분 제거
    returnNameArray = nameArray.copy()
    returnNameArray[indexOrder] = ""
    
    return self._combine(returnNameArray, filChar)

인덱스 부분을 제외한 이름 문자열 가져오기

Args

inStr
처리할 이름 문자열

Returns

인덱스가 제외된 이름 문자열

def has_name_part(self, inPart, inStr)
Expand source code
def has_name_part(self, inPart, inStr):
    """
    문자열에 특정 namePart가 포함되어 있는지 확인
    
    Args:
        inPart: 확인할 namePart 이름 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
        inStr: 확인할 문자열
        
    Returns:
        포함되어 있으면 True, 아니면 False
    """
    return self.get_name(inPart, inStr) != ""

문자열에 특정 namePart가 포함되어 있는지 확인

Args

inPart
확인할 namePart 이름 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
inStr
확인할 문자열

Returns

포함되어 있으면 True, 아니면 False

def increase_index(self, inStr, inAmount)
Expand source code
def increase_index(self, inStr, inAmount):
    """
    이름의 인덱스 부분 값 증가
    
    Args:
        inStr: 처리할 이름 문자열
        inAmount: 증가시킬 값
        
    Returns:
        인덱스가 증가된 이름 문자열
    """
    newName = inStr
    filChar = self._get_filtering_char(inStr)
    nameArray = self.convert_name_to_array(inStr)
    indexIndex = self.get_name_part_index("Index")
    
    if indexIndex >= 0:
        indexStr = ""
        indexPaddingNum = self._paddingNum
        indexNum = -99999
        
        if not nameArray[indexIndex]:
            indexNum = -1
        else:
            try:
                indexNum = int(nameArray[indexIndex])
                indexPaddingNum = len(nameArray[indexIndex])
            except ValueError:
                pass
        
        indexNum += inAmount
        
        if indexNum < 0:
            indexNum = 0
        
        # Python의 문자열 포맷팅을 사용하여 패딩
        indexStr = f"{indexNum:0{indexPaddingNum}d}"
        nameArray[indexIndex] = indexStr
        newName = self._combine(nameArray, filChar)
        newName = self.set_index_padding_num(newName)
        
    return newName

이름의 인덱스 부분 값 증가

Args

inStr
처리할 이름 문자열
inAmount
증가시킬 값

Returns

인덱스가 증가된 이름 문자열

def is_in_name_part_predefined_values(self, inNamePartName, inStr)
Expand source code
def is_in_name_part_predefined_values(self, inNamePartName, inStr):
    """
    지정된 namePart에 해당하는 부분이 문자열에 포함되어 있는지 확인
    
    Args:
        namePart: 확인할 namePart 이름 ("Base", "Type", "Side" 등)
        inStr: 확인할 문자열
        
    Returns:
        포함되어 있으면 True, 아니면 False
    """
    partObj = self.get_name_part(inNamePartName)
    if not partObj:
        return False
    
    partType = partObj.get_type()
    if not partType:
        return False
        
    partValues = partObj.get_predefined_values()
    
    if partType == NamePartType.PREFIX or partType == NamePartType.SUFFIX:
        return any(item in inStr for item in partValues)
    
    return False

지정된 namePart에 해당하는 부분이 문자열에 포함되어 있는지 확인

Args

namePart
확인할 namePart 이름 ("Base", "Type", "Side" 등)
inStr
확인할 문자열

Returns

포함되어 있으면 True, 아니면 False

def load_default_config(self)
Expand source code
def load_default_config(self):
    """
    기본 설정 로드 (현재는 아무 작업도 수행하지 않음)
    
    Returns:
        항상 True 반환 (기본 설정은 __init__에서 이미 설정됨)
    """
    # 이 메소드는 현재 __init__에서 설정한 기본값을 그대로 사용하므로
    # 아무 작업도 수행하지 않습니다.
    return True

기본 설정 로드 (현재는 아무 작업도 수행하지 않음)

Returns

항상 True 반환 (기본 설정은 __init__에서 이미 설정됨)

def load_from_config_file(self, configPath=None)
Expand source code
def load_from_config_file(self, configPath=None):
    """
    설정 파일에서 설정 로드
    
    Args:
        configPath: 설정 파일 경로 (기본값: self._configPath)
        
    Returns:
        로드 성공 여부 (True/False)
    """
    # 경로가 없으면 인스턴스 생성 시 설정된 경로 사용
    if not configPath:
        configPath = self._configPath
        
    if not configPath:
        print("설정 파일 경로가 제공되지 않았습니다.")
        return False
        
    # NamingConfig 인스턴스 생성 및 설정 로드
    config = NamingConfig()
    if config.load(configPath):
        # 설정을 Naming 인스턴스에 적용
        result = config.apply_to_naming(self)
        if result:
            self._configPath = configPath  # 성공적으로 로드한 경로 저장
        return result
    else:
        print(f"설정 파일 로드 실패: {configPath}")
        return False

설정 파일에서 설정 로드

Args

configPath
설정 파일 경로 (기본값: self._configPath)

Returns

로드 성공 여부 (True/False)

def pick_name(self, inNamePartName, inStr)
Expand source code
def pick_name(self, inNamePartName, inStr):
    nameArray = self._split_to_array(inStr)
    returnStr = ""
    
    # namePart 문자열 목록 가져오기
    partObj = self.get_name_part(inNamePartName)
    if not partObj:
        return returnStr
    
    partType = partObj.get_type()
    if not partType:
        return returnStr
        
    partValues = partObj.get_predefined_values()
    if partType != NamePartType.INDEX and partType != NamePartType.REALNAME and not partValues:
        return returnStr
    
    if partType == NamePartType.PREFIX:
        for item in nameArray:
            if item in partValues:
                returnStr = item
                break
    
    if partType == NamePartType.SUFFIX:
        for i in range(len(nameArray) - 1, -1, -1):
            if nameArray[i] in partValues:
                returnStr = nameArray[i]
                break
            
    if partType == NamePartType.INDEX:
        if self.get_name_part_index("Index") > self.get_name_part_index("RealName"):
            for i in range(len(nameArray) - 1, -1, -1):
                if nameArray[i].isdigit():
                    returnStr = nameArray[i]
                    break
        else:
            for item in nameArray:
                if item.isdigit():
                    returnStr = item
                    break
    
    return returnStr
def remove_name_part(self, inPart, inStr)
Expand source code
def remove_name_part(self, inPart, inStr):
    """
    이름의 특정 부분 제거
    
    Args:
        inPart: 제거할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
        inStr: 처리할 이름 문자열
        
    Returns:
        수정된 이름 문자열
    """
    nameArray = self.convert_name_to_array(inStr)
    partIndex = self.get_name_part_index(inPart)
    
    if partIndex >= 0:
        nameArray[partIndex] = ""
        
    newName = self._combine(nameArray, self._get_filtering_char(inStr))
    newName = self.set_index_padding_num(newName)
    
    return newName

이름의 특정 부분 제거

Args

inPart
제거할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
inStr
처리할 이름 문자열

Returns

수정된 이름 문자열

def replace_filtering_char(self, inStr, inNewFilChar)
Expand source code
def replace_filtering_char(self, inStr, inNewFilChar):
    """
    이름의 구분자 문자 변경
    
    Args:
        inStr: 처리할 이름 문자열
        inNewFilChar: 새 구분자 문자
        
    Returns:
        구분자가 변경된 이름 문자열
    """
    nameArray = self.convert_name_to_array(inStr)
    return self._combine(nameArray, inNewFilChar)

이름의 구분자 문자 변경

Args

inStr
처리할 이름 문자열
inNewFilChar
새 구분자 문자

Returns

구분자가 변경된 이름 문자열

def replace_name_part(self, inPart, inStr, inNewName)
Expand source code
def replace_name_part(self, inPart, inStr, inNewName):
    """
    이름의 특정 부분을 새 이름으로 변경
    
    Args:
        inPart: 수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
        inStr: 처리할 이름 문자열
        inNewName: 새 이름
    
    Returns:
        수정된 이름 문자열
    """
    nameArray = self.convert_name_to_array(inStr)
    partIndex = self.get_name_part_index(inPart)
    
    if partIndex >= 0:
        nameArray[partIndex] = inNewName
    
    newName = self._combine(nameArray, self._get_filtering_char(inStr))
    newName = self.set_index_padding_num(newName)
    
    return newName

이름의 특정 부분을 새 이름으로 변경

Args

inPart
수정할 부분 ("Base", "Type", "Side", "FrontBack", "RealName", "Index")
inStr
처리할 이름 문자열
inNewName
새 이름

Returns

수정된 이름 문자열

def set_index_padding_num(self, inStr, inPaddingNum=None)
Expand source code
def set_index_padding_num(self, inStr, inPaddingNum=None):
    """
    이름의 인덱스 부분 패딩 설정
    
    Args:
        inStr: 처리할 이름 문자열
        inPaddingNum: 설정할 패딩 자릿수 (기본값: 클래스의 _paddingNum)
        
    Returns:
        패딩이 적용된 이름 문자열
    """
    if inPaddingNum is None:
        inPaddingNum = self._paddingNum
        
    filChar = self._get_filtering_char(inStr)
    nameArray = self.convert_name_to_array(inStr)
    indexIndex = self.get_name_part_index("Index")
    indexStr = self.get_name("Index", inStr)
    
    if indexStr:
        indexStr = self.convert_digit_into_padding_string(indexStr, inPaddingNum)
        nameArray[indexIndex] = indexStr
        
    return self._combine(nameArray, filChar)

이름의 인덱스 부분 패딩 설정

Args

inStr
처리할 이름 문자열
inPaddingNum
설정할 패딩 자릿수 (기본값: 클래스의 _paddingNum)

Returns

패딩이 적용된 이름 문자열

def sort_by_index(self, inNameArray)
Expand source code
def sort_by_index(self, inNameArray):
    """
    이름 배열을 인덱스 기준으로 정렬
    
    Args:
        inNameArray: 정렬할 이름 배열
        
    Returns:
        인덱스 기준으로 정렬된 이름 배열
    """
    if not inNameArray:
        return []
        
    # 정렬을 위한 보조 클래스 정의
    @dataclass
    class IndexSorting:
        oriIndex: int
        newIndex: int
            
    # 각 이름의 인덱스를 추출하여 정렬 정보 생성
    structArray = []
    
    for i, name in enumerate(inNameArray):
        tempIndex = self.get_index_as_digit(name)
        
        if tempIndex is False:
            structArray.append(IndexSorting(i, 0))
        else:
            structArray.append(IndexSorting(i, tempIndex))
            
    # 인덱스 기준으로 정렬
    structArray.sort(key=lambda x: x.newIndex)
    
    # 정렬된 순서로 결과 배열 생성
    sortedNameArray = []
    for struct in structArray:
        sortedNameArray.append(inNameArray[struct.oriIndex])
        
    return sortedNameArray

이름 배열을 인덱스 기준으로 정렬

Args

inNameArray
정렬할 이름 배열

Returns

인덱스 기준으로 정렬된 이름 배열