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
인덱스 기준으로 정렬된 이름 배열