def remodel_equation(self, metainfo_option_num=2, metalineinfo=None):
mod_dict = {1: "중첩 PRNTDATA 변환"}
if metalineinfo == None:
print("불완전한 수식을 교정해주는 유틸리티입니다.")
erb_files, encode_type = CustomInput("ERB").get_filelist()
file_count_check = StatusNum(erb_files, "파일")
file_count_check.how_much_there()
mod_no = MenuPreset().select_mod(mod_dict)
for filename in erb_files:
erb_bulk = ERBLoad(filename, encode_type).make_erblines()
lines = (ERBUtil().make_metainfo_lines(erb_bulk,
metainfo_option_num,
filename).linelist)
lines.insert(0, [0, 0, 0, ";{}에서 불러옴\n".format(filename)])
temp_metainfo = ERBMetaInfo()
temp_metainfo.linelist = lines
self.result_infodict.add_dict(
filename,
ERBUtil().grammar_corrector(temp_metainfo, mod_no))
file_count_check.how_much_done()
result_dataset = self.result_infodict # InfoDict 클래스 {파일명:ERBMetaInfo 클래스 메소드}
else:
mod_no = MenuPreset().select_mod(mod_dict, 0b1)
result_dataset = ERBUtil().grammar_corrector(
metalineinfo, mod_no) # ERBMetaInfo 클래스 메소드
CommonSent.extract_finished()
self.func_log.sucessful_done()
return result_dataset
def extract_printfunc(self, erb_files=None, encode_type=None, opt=0):
"""ERB 파일 내 출력문 데이터를 추출하는 함수
opt bit 1 : 차트 내 중복 context 제거, 2: 파일당 차트 할당, 3: 공백 출력안함
"""
print("PRINT/DATAFORM 구문의 추출을 시작합니다.")
if not erb_files or not encode_type:
erb_files, encode_type = CustomInput("ERB").get_filelist()
file_count_check = StatusNum(erb_files, "파일")
file_count_check.how_much_there()
result_sheet = SheetInfo()
sheet_tags = ["COM_type", "context"]
if not opt & 0b10: # 파일당 차트 할당 아님
sheet_tags.insert(0, "file")
sheetname = "print_sent"
result_sheet.add_sheet(sheetname, sheet_tags)
if opt & 0b1: # 중복 후처리
dup_list = list()
for filename in erb_files:
bulk_lines = ERBLoad(filename, encode_type)
if opt & 0b10: # 파일당 차트 할당
sheetname = filename
result_sheet.add_sheet(sheetname, sheet_tags)
if opt & 0b1000: # 주석처리 모드
printfunc_list = [
line for line in bulk_lines.make_erblines()
if line.find(";")
]
else:
printfunc_list = bulk_lines.search_line(
"PRINT",
"DATA",
except_args=["PRINTDATA", "DATALIST"],
opt=0b1)
for line in printfunc_list:
comtype = line.split()[0]
context = " ".join(line.split()[1:])
if opt & 0b1: # 중복 후처리
if dup_list.count(context):
continue
else:
dup_list.append(context)
if opt & 0b100: # 공백 처리안함
if not context:
continue
result_sheet.add_row(sheetname,
file=filename,
COM_type=comtype,
context=context)
file_count_check.how_much_done()
CommonSent.extract_finished()
self.func_log.sucessful_done()
if opt & 0b1 and dup_list:
print("중복으로 발견되어 누락 처리한 문장이 한 개 이상 존재합니다. 이후 처리에 유의해주세요.")
return result_sheet # SheetInfo
def remodel_indent(self, metainfo_option_num=0, metalineinfo=None):
if metalineinfo == None:
print("들여쓰기를 자동 교정하는 유틸리티입니다.")
erb_files, encode_type = CustomInput("ERB").get_filelist()
file_count_check = StatusNum(erb_files, "파일")
file_count_check.how_much_there()
for filename in erb_files:
erb_bulk = ERBLoad(filename, encode_type).make_erblines()
lines = (ERBUtil().make_metainfo_lines(erb_bulk,
metainfo_option_num,
filename).linelist)
lines.insert(0, [0, 0, 0, ";{}에서 불러옴\n".format(filename)])
temp_metainfo = ERBMetaInfo()
temp_metainfo.linelist = lines
self.result_infodict.add_dict(
filename,
ERBUtil().indent_maker(temp_metainfo))
file_count_check.how_much_done()
result_dataset = self.result_infodict # InfoDict 클래스 {파일명:[들여쓰기 처리된 lines]}
else:
if isinstance(metalineinfo, list): # metaline 없는 순수 lines 일 때
metalineinfo = ERBUtil().make_metainfo_lines(
metalineinfo, metainfo_option_num)
result_dataset = ERBUtil().indent_maker(
metalineinfo) # [들여쓰기 처리된 lines]
CommonSent.extract_finished()
self.func_log.sucessful_done()
return result_dataset
def first_log(self, file_info=None):
"""작업 시작 절차를 logfile에 기록함. 입력받은 인자가 없으면 시작 시간만을 입력함."""
with self.addwrite() as log_open:
if file_info == None:
log_open.write("[{}] Util Started\n".format(
CommonSent.put_time()))
else:
log_open.write("[{}] {} Loaded\n".format(
CommonSent.put_time(), file_info))
def search_csv_var(self, erb_files=None, encode_type=None, opt=0):
"""ERB 파일 내 사용된 csv 변수 목록 출력
opt bit 1: 참이면 CSV별 차트, 아니면 ERB별 차트
"""
print("ERB 파일에서 사용된 CSV 변수목록을 추출합니다.")
if not erb_files or not encode_type:
erb_files, encode_type = CustomInput("ERB").get_filelist()
csvvar_list = ERBUtil().csv_infodict_maker()
if csvvar_list == None:
try:
csvvar_list = CSVFunc().single_csv_read("CSVfnclist.csv",
opt=2)
except:
print("설정 정보가 없어 실행이 불가합니다.")
return None
vfinder = ERBVFinder(csvvar_list)
file_count_check = StatusNum(erb_files, "파일")
file_count_check.how_much_there()
result_sheet = SheetInfo()
sheet_tags = ["file", "var_name", "orig_word"]
for filename in erb_files:
erb_bulk = ERBLoad(filename, encode_type).make_erblines()
self.func_log.write_loaded_log(filename)
if not opt & 0b1: # ERB별 차트
result_sheet.add_sheet(filename, sheet_tags)
sheet_name = filename
file_results = []
for line in erb_bulk:
vars_list = vfinder.find_csvfnc_line(line)
if vars_list:
file_results.extend(vars_list)
dup_res_list = DataFilter().dup_filter(file_results)
for var_info in dup_res_list:
varhead, varname, _, _ = var_info
context = vfinder.print_csvfnc([
var_info,
])[0]
if opt & 0b1:
sheet_name = varhead
if sheet_name not in result_sheet.sheetdict.keys():
result_sheet.add_sheet(sheet_name, sheet_tags)
f_name = filename
else:
f_name = varhead
result_sheet.add_row(sheet_name,
file=f_name,
var_name=varname,
orig_word=context)
file_count_check.how_much_done()
CommonSent.extract_finished()
self.func_log.sucessful_done()
return result_sheet # SheetInfo
def run_paged_menu(self):
while True:
selected_num = self.__print_paged_menu()
try:
selected_num = int(selected_num)
if self.menu_dict.get(selected_num):
self.selected_menu = self.menu_dict[selected_num]
return selected_num
else:
CommonSent.not_ok()
except ValueError:
CommonSent.not_ok()
def make_csv_var_dict(self, csv_files=None, encode_type=None):
"""{csv변수명:[파일명,번호]} 형태 딕셔너리 제작"""
print("csv 변수 대응 딕셔너리를 제작합니다.")
if not csv_files or not encode_type:
csv_files, encode_type = CustomInput("CSV").get_filelist()
count_check = StatusNum(csv_files, "파일", self.debug_log.NameDir)
count_check.how_much_there()
csvvar_dict = {}
all_var_list = []
dup_count = 0
for csvname in csv_files:
csvdata_dict = self.single_csv_read(csvname, encode_type,
1) # {변수명:숫자}
if csvdata_dict == None:
count_check.error_num += 1
continue
for var in csvdata_dict.keys():
if var == "":
continue
core_var = var
var = var.split(";")[0]
nospace_var = var.replace(" ", "__")
all_var_list.append(var)
try:
if csvvar_dict.get(nospace_var):
dup_count = all_var_list.count(var) - 1
csvvar_dict["dup{}_{}".format(
dup_count, nospace_var)] = [
csvname,
int(csvdata_dict[core_var]),
]
else:
csvvar_dict[nospace_var] = [
csvname, int(csvdata_dict[core_var])
]
except ValueError:
continue
count_check.how_much_done()
total_dup = len(all_var_list) - len(set(all_var_list))
if dup_count != 0:
print("{}건의 중복변수가 존재합니다. 추후 유의해주세요.".format(total_dup))
if count_check.error_num > 0:
self.debug_log.if_decode_error()
CommonSent.extract_finished()
CommonSent.print_line()
self.debug_log.sucessful_done()
return csvvar_dict
def __no_void_str(self, opt):
if opt & 0b010:
text = "명칭"
elif opt & 0b100:
text = "타입"
else:
return False
while True:
inputed = input("%s의 %s을 입력해주세요. : " % (text, self.target))
if len(inputed) == 0:
CommonSent.no_void()
continue
break
return inputed
def memory_optimizer(self, erb_files=None, encode_type=None):
print("현재 기능이 완성되지 않았습니다. 되도록 백업 후 이용해주시고, 구상 파일에만 사용해주세요.")
if not erb_files or not encode_type:
erb_files, encode_type = CustomInput("ERB").get_filelist()
file_count_check = StatusNum(erb_files, "파일")
file_count_check.how_much_there()
for filename in erb_files:
erblines = ERBLoad(filename, encode_type).make_erblines()
optmized_lines = ERBRemodel(erblines).memory_optimize()
self.result_infodict.add_dict(filename, optmized_lines)
file_count_check.how_much_done()
CommonSent.extract_finished()
self.func_log.sucessful_done()
return self.result_infodict # {파일명:lines} 형태가 포함된 infodict
def replace_num_or_name(self, mod_num=0, erb_files=None, encode_type=None):
"""0:숫자 > 변수, 1: 변수 > 숫자"""
if not erb_files or not encode_type:
erb_files, encode_type = CustomInput("ERB").get_filelist()
file_count_check = StatusNum(erb_files, "ERB 파일")
file_count_check.how_much_there()
csv_infodict = ERBUtil().csv_infodict_maker(mod_num + 1, self.func_log)
print("ERB내 index 변환작업을 시작합니다.")
for filename in erb_files:
erblines = ERBLoad(filename, encode_type).make_erblines()
replaced_lines = ERBRemodel(erblines).replace_csvvars(
csv_infodict, mod_num)
self.result_infodict.add_dict(filename, replaced_lines)
file_count_check.how_much_done()
CommonSent.extract_finished()
self.func_log.sucessful_done()
return self.result_infodict # {파일명:[바뀐줄]}
def run_menu(self):
"""입력 정보를 int로 변환 후 해당하는 선택지가 있을 때 해당 숫자 반환함. 다른 경우 루프."""
menu_numlist = tuple(self.menu_dict.keys())
while True:
selected_num = self.__print_menu()
try:
selected_num = int(selected_num)
if menu_numlist.count(selected_num) == True:
self.selected_menu = self.menu_dict[selected_num]
return selected_num
# EasterEgg
elif selected_num in (4, 99, 127, 255, 999, 32767, 65535,
2147483647):
print("디버그 기능 없습니다!")
time.sleep(0.5)
elif selected_num == 10:
input("지켜보고 있다" * 500)
else:
CommonSent.not_ok()
except ValueError:
CommonSent.not_ok()
def import_all_CSV(self, mode_num=0, csv_files=None, encode_type=None):
"""InfoDict 클래스를 받아 CSV 변수 자료형 생성
{csv파일명:{csv변수명:숫자}} 또는 {csv파일명:{숫자:csv변수명}}
mode_num:
bit 기반 모드 필터링
0 = 필터링 없음
0b1 = 숫자/변수명 반전
0b10 = chara 등 미포함
0b100 = srs용 chara 처리
"""
print("추출을 시작합니다.")
if not csv_files or not encode_type:
csv_files, encode_type = CustomInput("CSV").get_filelist()
self.dic_assemble = InfoDict(0)
count_check = StatusNum(csv_files, "파일", self.debug_log.NameDir)
count_check.how_much_there()
arg_list = [0, None] # 구별없이 전부
name_filter = [] # 리스트에 포함된 파일명 제외(소문자만 지원)
if mode_num:
# 만들어도 의미없는 파일 제외
name_filter.extend(("gamebase", "_replace", "variablesize"))
if mode_num & 0b1: # 숫자/변수명 반전 있음
name_filter.append("chara")
arg_list[0] = 1
if mode_num & 0b10: # chara 미포함
name_filter.extend(("chara", "_rename"))
if mode_num & 0b100: # SRS용 인명 처리
arg_list[1] = ["NAME", "名前", "CALLNAME", "呼び名"]
# 중복 필터 제거
name_filter = DataFilter().dup_filter(name_filter)
for filename in csv_files:
if mode_num:
if mode_num & 0b100 and "chara" not in filename.lower():
continue
else:
is_filtered = 0
for name in name_filter:
if name in filename.lower():
is_filtered = 1
break
if is_filtered:
continue
csvdata_dict = self.single_csv_read(filename, encode_type,
*arg_list)
if csvdata_dict == None: # 인식되지 않은 경우 infodict에 추가되지 않음
count_check.error_num += 1
continue
self.dic_assemble.add_dict(filename, csvdata_dict)
count_check.how_much_done()
if count_check.error_num > 0:
self.debug_log.if_decode_error()
CommonSent.extract_finished()
CommonSent.print_line()
self.debug_log.sucessful_done()
return self.dic_assemble
def to_TXT(self, filetype="TXT", option_num=0, encode_type="UTF-8"):
"""입력받은 데이터를 텍스트 파일 형태로 출력하는 함수.
Vairables:
filetype: 확장자 구분
option_num: 1이면 출력시 줄바꿈 관련 절차 진행
encode_type: 저장되는 파일의 인코딩
"""
# txt, erb 공용
# erb metaline은 ERBUtil.indent_maker에서 텍스트.readlines형으로 양식화됨
self.log_file.workclass = "TXTwrite"
self.encoding = encode_type
if self.target_data == None:
print_data = MenuPreset()
self.target_data = print_data.load_saved_data(
0, "미리 실행된 자료가 없습니다.")
if self.target_data == None:
print("데이터가 선택되지 않았습니다.")
return False
else:
self.target_name = print_data.selected_name
else:
print("이번 구동 중 실행된 {} 자료를 {}화 합니다.".format(self.target_name,
filetype))
target_data = self.__data_type_check(
self.target_data) # ((자료명,알수 없는 자료형),...)
menu_dict_sel_dest = {0: "원본 위치에 저장", 1: "결과물 폴더에 저장"}
menu_sel_dest = Menu(menu_dict_sel_dest)
menu_sel_dest.title(
"변환된 파일을 어떤 위치에 저장할까요?",
"원본 폴더에 저장시 원본 데이터가 손상될 수 있습니다.",
"결과물 데이터에 원본 위치 정보가 없다면 오류가 발생합니다.",
)
dest_mod = menu_sel_dest.run_menu()
que_list = []
for data in target_data:
tag, content = data
if isinstance(content, InfoDict):
infodict = content.dict_main
sel_data = list(
map(lambda x: {x: infodict[x]}, infodict.keys()))
elif isinstance(content, ERBMetaInfo):
sel_data = [{tag: content}]
elif isinstance(content, (list, dict)):
sel_data = [{tag: content}]
else:
print("상정되지 않은 자료형이나 일단 진행합니다.")
sel_data = [data]
que_list.extend(sel_data) # [{tag:content}]
numstat = StatusNum(que_list, filetype + " 파일자료")
numstat.how_much_there()
for que in que_list:
que_key = list(que.keys())[0]
if dest_mod == 1: # 결과물 디렉토리에 저장
if len(que_list) == 1 and que_key in list(
self.single_namedict.values()):
data_filename = "({}){}".format(CommonSent.put_time(1),
self.target_name)
else:
data_filename = que_key
result_filename = "{}.{}".format(
FileFilter().sep_filename(data_filename), filetype)
self.res_filename = self.dest_dir + result_filename
elif dest_mod == 0: # 원본 디렉토리에 저장
self.res_filename = que_key
self.log_file.which_type_loaded(filetype)
result_lines = []
if filetype == "TXT":
result_lines.append("{}에서 불러옴\n".format(self.target_name))
context = que[que_key]
if type(context) == dict:
for key, value in list(context.items()):
result_lines.append("{}:{}\n".format(key, value))
elif type(context) == FuncInfo:
for key, value in list(context.func_dict.items()):
if isinstance(value, (str, int)):
value = value
result_lines.append("{}:{}".format(key, ",\n".join(value)))
elif option_num == 0:
result_lines.append("{}\n".format(context))
elif option_num == 1:
if type(context) == list:
result_lines = context
elif isinstance(context, ERBMetaInfo):
result_lines = ERBFunc().remodel_indent(
metalineinfo=context.printable_lines())
else:
print("텍스트화 할 수 없는 데이터입니다. 옵션을 바꿔 다시 시도해주세요.")
self.log_file.write_log("Can not write text by {}".format(
type(context)))
if result_lines:
self.__output_txt(result_lines)
numstat.how_much_done()
self.log_file.sucessful_done()
return True
def title(self, *title_names):
"""메뉴 제목용 함수. 메뉴 내 문장 출력에도 사용 가능"""
CommonSent.print_line()
for title_name in title_names:
print(title_name.center(self.window_size, " "))
CommonSent.print_line()
def __print_menu(self):
for key in self.menu_dict:
print("[{}]. {}".format(key, self.menu_dict[key]))
CommonSent.print_line()
return input("번호를 입력하세요. 클릭은 지원하지 않습니다. :")
def end_log(self, workname=""):
with self.addwrite() as log_open:
log_open.write("[{}] {} done\n\n".format(CommonSent.put_time(),
workname))
def run_main():
global last_work
global last_work_name
global version_no
while True:
print("작업 후 버튼을 눌러 프로그램을 종료하셔야 작업파일이 손실되지 않습니다.")
CommonSent.print_line()
menu_main.run_menu()
# [0] 프로그램 종료
if menu_main.selected_menu == "프로그램 종료":
break
# [1] CSV 파일의 분석
elif menu_main.selected_menu == "CSV 파일 분석":
CommonSent.print_line()
menu_dict_csv = {
0: "이전으로",
1: "CSV 변수 목록 추출",
2: "CSV 변수 명칭 사전",
}
menu_csv = Menu(menu_dict_csv)
menu_csv.title("CSV 파일 분석 메뉴입니다.", "따로 표기해놓지 않았다면 숫자:변수명 꼴입니다.")
no_csvmenu = menu_csv.run_menu()
if not no_csvmenu: # 이전으로
continue
elif no_csvmenu == 1:
menu_dict_import_all_csv = {
0: "처음으로",
1: "필터 설정",
2: "구별없이 모두",
3: "SRS 작성용 - 인명",
4: "SRS 작성용 - 변수명",
}
menu_import_all_csv = Menu(menu_dict_import_all_csv)
menu_import_all_csv.title("CSV를 추출할 내용/파일명 조건을 선택해주세요.")
no_impcsv_menu = menu_import_all_csv.run_menu()
if not no_impcsv_menu: # csv 변수추출 중 처음으로 이동
continue
elif no_impcsv_menu == 1:
mod_dict = {1: "1열/2열 반전", 2: "특수형식 csv 미포함"}
mod_no = MenuPreset().select_mod(
mod_dict,
title_txt="1열/2열 반전시 특수형식 csv는 포함하지 않는 것을 권장합니다.")
elif no_impcsv_menu == 2:
mod_no = 0
elif no_impcsv_menu == 3: # 인명 SRS용 특수 항목처리
mod_no = 0b100
elif no_impcsv_menu == 4: # 변수 SRS용 프리셋 - 특수형식 csv 미포함만
mod_no = 0b10
import_all_csv_infodict = CSVFunc().import_all_CSV(mod_no)
MenuPreset().shall_save_data(import_all_csv_infodict,
"infodict")
last_work = import_all_csv_infodict # 마지막 작업 저장
elif no_csvmenu == 2:
csvvar_dict = CSVFunc().make_csv_var_dict()
MenuPreset().shall_save_data(csvvar_dict, "dict")
last_work = csvvar_dict
last_work_name = menu_csv.selected_menu # 마지막 작업 명칭 저장
# [2] ERB 파일의 분석
elif menu_main.selected_menu == "ERB 파일 분석":
menu_dict_anal_erb = {
0: "이전으로",
1: "ERB 내 CSV 변수 추출",
2: "구상추출",
3: "ERB형 데이터베이스 추출"
}
menu_anal_erb = Menu(menu_dict_anal_erb)
menu_anal_erb.title("ERB 파일 분석 메뉴입니다.")
no_erbmenu = menu_anal_erb.run_menu()
if not no_erbmenu: # 이전으로
continue
elif no_erbmenu == 1:
csvvar_mod_dict = {1: "CSV당 차트 생성(비활성화시 ERB당 생성됨)"}
csvvar_opt = MenuPreset().select_mod(csvvar_mod_dict)
last_work = ERBFunc().search_csv_var(opt=csvvar_opt)
sav_datatype = "sheetinfo"
elif no_erbmenu == 2:
ext_print_mod_dict = {
1: "차트 내 중복 자료 제거",
2: "ERB파일당 차트 할당(비활성화시 차트 하나에 전부 포함)",
3: "공백을 포함하지 않음",
4: "주석추출 모드"
}
ext_print_opt = MenuPreset().select_mod(ext_print_mod_dict)
last_work = ERBFunc().extract_printfunc(opt=ext_print_opt)
sav_datatype = "sheetinfo"
elif no_erbmenu == 3:
last_work = ERBFunc().db_erb_finder()
sav_datatype = "erblines"
if last_work != None:
MenuPreset().shall_save_data(last_work, sav_datatype)
last_work_name = menu_anal_erb.selected_menu # 마지막 작업 명칭 저장
# [3] ERB 파일의 처리
elif menu_main.selected_menu == "ERB 파일 처리":
menu_dict_erb = {
0: "이전으로",
1: "들여쓰기 교정",
2: "구상 번역기",
3: "ERB 내 CSV 인덱스 변환",
4: "불완전 수식 정리",
5: "구상 메모리 최적화",
}
menu_erb = Menu(menu_dict_erb)
menu_erb.title("ERB 파일 처리 메뉴입니다.",
"현재 TW 파일 이외의 정상 구동을 보장하지 않습니다.")
no_erbmenu = menu_erb.run_menu()
if not no_erbmenu: # 이전으로
continue
last_work = None
if menu_erb.selected_menu == "들여쓰기 교정":
last_work = ERBFunc().remodel_indent()
sav_datatype = "erblines"
elif menu_erb.selected_menu == "구상 번역기": # v3.7.0 현재 알파버전
print("양식에 맞는 txt 파일을 erb 문법 파일로 바꾸어주는 유틸리티입니다.")
menu_list_eratype = ["TW"]
menu_eratype = Menu(menu_list_eratype)
menu_eratype.title("어느 종류의 에라인지 선택해주세요.")
menu_eratype.run_menu()
if menu_eratype.selected_menu in menu_list_eratype:
sent_load_dis = "csvvar 딕셔너리를 불러와주세요. 미선택시 추후 생성 단계로 넘어갑니다."
csvvar_dict = MenuPreset().load_saved_data(
0, sent_load_dis)
last_work = ERBFunc().translate_txt_to_erb(
menu_eratype.selected_menu, csvvar_dict)
sav_datatype = "metaerb"
elif menu_erb.selected_menu == "ERB 내 CSV 인덱스 변환":
menu_dict_erb_rep = {0: "숫자를 변수로", 1: "변수를 숫자로"}
menu_erb_rep = Menu(menu_dict_erb_rep)
mod_num = menu_erb_rep.run_menu()
last_work = ERBFunc().replace_num_or_name(mod_num)
sav_datatype = "erblines"
elif menu_erb.selected_menu == "불완전 수식 정리":
last_work = ERBFunc().remodel_equation()
sav_datatype = "metainfoline"
elif menu_erb.selected_menu == "구상 메모리 최적화": # 3.7.0 현재 베타버전
last_work = ERBFunc().memory_optimizer()
sav_datatype = "erblines"
if last_work != None:
MenuPreset().shall_save_data(last_work, sav_datatype)
print("결과물을 ERB로 출력하시고 싶은 경우 추가 절차를 진행해주세요.")
if MenuPreset().yesno("지금 바로 데이터를 erb화 할까요?"):
ResultFunc().make_result(menu_erb.selected_menu, last_work,
1)
last_work_name = menu_erb.selected_menu # 마지막 작업 명칭 저장
# [4] ERH 파일의 분석
elif menu_main.selected_menu == "ERH 파일 분석 (미실장)":
print("미실장입니다")
# [5] 외부 데이터 처리
elif menu_main.selected_menu == "외부 데이터 처리":
menu_dict_other_data = {
0: "이전으로",
1: "UserDic.json srs화",
2: "웹 게시글 txt화",
3: "srs 병합",
}
menu_other_data = Menu(menu_dict_other_data)
menu_other_data.title("에라 파일과 관련성이 적은 데이터의 처리 메뉴입니다.")
no_othermenu = menu_other_data.run_menu()
if not no_othermenu: # 이전으로
continue
last_work_name = menu_other_data.selected_menu
if "srs" in last_work_name:
if last_work_name == "UserDic.json srs화":
last_work = EXTFunc().userdict_to_srs()
elif last_work_name == "srs 병합":
last_work = SRSFunc().merge_srs()
if not last_work:
input("작업한 내용이 없습니다.")
continue
elif MenuPreset().yesno("바로 srs화를 진행할까요?"):
ResultFunc().make_result(last_work_name, last_work, 2)
else:
input(
"저장된 infodict 데이터를 기반으로 '결과물 srs화'를 해주셔야 srs화가 되니 참고해주세요."
)
elif last_work_name == "웹 게시글 txt화":
last_work = CrawlFunc().crawl_text()
if last_work == None:
input("작업한 내용이 없습니다.")
continue
print("바로 txt화를 진행합니다.")
ResultFunc().make_result(last_work_name, last_work)
# [6] 결과물 처리
elif menu_main.selected_menu == "결과물 처리":
menu_dict_result = {
0: "이전으로",
1: "결과물 TXT화",
2: "결과물 ERB화",
3: "결과물 srs화",
4: "결과물 xlsx화",
}
menu_result = Menu(menu_dict_result)
menu_result.title("추출 결과물에 대한 제어 메뉴입니다.")
no_resultmenu = menu_result.run_menu()
if not no_resultmenu:
continue
ResultFunc().make_result(last_work_name, last_work,
no_resultmenu - 1)
# 결과물 처리 이후 last_work, last_work_name 은 초기화되지 않음
# [7] 프로그램 정보
elif menu_main.selected_menu == "프로그램 정보":
xml_settings = SettingXML()
menu_dict_prginfo = {0: "이전으로", 1: "버전명", 2: "오류보고 관련", 3: "유의사항"}
menu_prginfo = Menu(menu_dict_prginfo)
menu_prginfo.title("EZworkEra 정보")
no_proginfo = menu_prginfo.run_menu()
if no_proginfo == 1:
print("버전명: " + version_no)
elif no_proginfo == 2:
print("{}/issues 으로 연락주세요.".format(
xml_settings.show_info("github")))
elif no_proginfo == 3:
print(xml_settings.show_info("caution"))
CommonSent.end_comment()