def db_erb_finder(self, erb_files=None, encode_type=None, tag=None):
"""데이터베이스형 ERB 자료 추출 함수"""
print("되도록 필요한 파일만 있는 폴더를 만든 후 그곳에서 진행해주세요.",
"추후 복수의 파일을 비교하고자 하는 경우, 각 파일의 파일명은 같아야 합니다.",
sep="\n")
if not erb_files or not encode_type:
erb_files, encode_type = CustomInput("ERB").get_filelist()
while True:
if not tag:
tag = input("필요한 데이터 형식의 앞말을 붙여넣어주세요.: ")
adj_yn = MenuPreset().yesno(
"AAA/BBB/CCC 꼴의 데이터인 경우, 각 요소별 분할이 가능합니다.", "분할을 시도하시겠습니까?")
case_yn = MenuPreset().yesno(
"CASE XXX ~ tag AAA 꼴의 데이터인 경우 CASE를 활용한 좀 더 정확한 계산이 가능합니다.",
"해당 작업을 시도하시겠습니까?")
adj_res = "Yes" if adj_yn else "No"
case_res = "Yes" if case_yn else "No"
if not MenuPreset().yesno(
"tag: %s, 분할 시도: %s, CASE 사용: %s가 맞습니까?" %
(tag, adj_res, case_res)):
if MenuPreset().yesno("작업을 취소할까요?"):
return None
continue
break
for erbname in erb_files:
erb_load = ERBLoad(erbname, encode_type)
erblines = erb_load.make_erblines()
self.result_infodict.add_dict(
erbname,
DataBaseERB().collect_adj(erblines, tag, adj_yn, case_yn))
return self.result_infodict
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 create(self):
dir_ori, *_ = CustomInput("원본 에라").input_option(0b001)
enc_ori: str = MenuPreset().encode()
self.set_dict["csv_A"] = BringFiles(dir_ori).search_csvdict(enc_ori)
self.set_dict["dir_A"] = dir_ori
self.set_dict["enc_A"] = enc_ori
dir_tns, *_ = CustomInput("번역본 에라").input_option(0b001)
enc_tns: str = MenuPreset().encode()
self.set_dict["csv_B"] = BringFiles(dir_tns).search_csvdict(enc_tns)
self.set_dict["dir_B"] = dir_tns
self.set_dict["enc_B"] = enc_tns
return self.set_dict
def make_result(self, target_name, target_data, result_type=0):
"""입력받은 정보를 ExportData에 전달하는 함수.
Factors:
target_name
출력될 파일의 이름
target_data
출력될 데이터
result_type
출력될 파일의 확장자 타입. 0:txt, 1:erb, 2:srs, 3:xlsx 이고 미입력시 txt가 출력됨.
"""
done_success = None
dirname = DirFilter("ResultFiles").dir_exist()
result_file = ExportData(dirname, target_name, target_data)
typename = ("TXT", "ERB", "srs", "xlsx")[result_type]
print("지정된 데이터의 %s 파일화를 진행합니다." % typename)
if result_type == 0: # TXT
writelines_yn = MenuPreset().yesno(
"데이터에 줄바꿈이 되어있던 경우, 줄바꿈 출력이 가능합니다. 시도하시겠습니까?")
done_success = result_file.to_TXT(option_num=writelines_yn)
elif result_type == 1: # ERB
done_success = result_file.to_TXT(typename, 1, "UTF-8-sig")
elif result_type == 2: # srs
print("csv 변수로 작성시 chara 폴더가 제외되어있어야 합니다.",
"ERB 데이터로 시도시 두 자료의 행 위치가 일치해야 합니다.",
"작성 또는 수정할 srs 파일명을 입력해주세요.",
sep="\n")
srs_name = input("공란일 시 autobuild.simplesrs로 진행합니다. :")
optimize_mod_dict = {
1: "미번역(영어 포함) 단어 제외",
2: "짧은 단어(1글자) 제외",
3: "CSV 표적화 기능(ERB 내 CSV 변수만 변환할 수 있음)",
4: "CSV 표적화 기능(Chara CSV 내 NAME, CALLNAME만)",
5: '필터용 글자 추가 (", /)',
6: "srs 파일에 제외항목 기록"
}
srs_option = MenuPreset().select_mod(
optimize_mod_dict, 0b1,
"활성화할 기능을 선택해주세요.\n * CSV 표적화는 하나만 선택해주세요.")
done_success = ExportSRS(dirname, target_name,
target_data).to_SRS(srs_option, srs_name)
elif result_type == 3: # xlsx
xlsx_name = input("작성할 xlsx 파일명을 입력해주세요. : ")
done_success = result_file.to_xlsx(xlsx_name)
if not done_success:
print("파일 처리를 진행하지 못했습니다.")
else:
print("처리가 완료되었습니다.")
input("엔터를 눌러 계속...")
def userdict_to_srs(self):
print("이지트랜스용 UserDic 파일을 srs 형태로 변환할 수 있게 합니다.")
print("빈 칸 입력시 전으로 돌아갑니다.")
while True:
filename = input("변환할 UserDic 파일의 경로를 입력해주세요.(파일명, 확장자 포함)")
if not filename:
return False
elif not filename.find(".json"):
print("확장자명을 포함해 입력해주세요.")
else:
break
transdict = TransUserDict(filename)
result = None
print("\n\n적어도 하나의 데이터는 .sav 파일로 저장해두셔아 srs화가 가능합니다.")
for data in transdict.convert_to_infodict():
print("처리된 데이터 분류: %s" % data.db_name)
if not MenuPreset().shall_save_data(data, "infodict"):
result = data
if not result:
result = data
return result
def to_xlsx(self, xlsxname=None):
"""입력받은 데이터를 xlsx로 출력하는 함수. 현재 SheetInfo형만 지원함."""
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
if not xlsxname:
xlsxname = "basic_sheet"
_, data = self.__data_type_check(self.target_data,
max_data=1)[0] # 최대 1개만
if not isinstance(data, SheetInfo):
print("차트화 기능은 현재 특정 기능에서만 지원합니다. 다른 처리방법을 시도해주세요.")
return False
xlsx_data = openpyxl.Workbook()
for count, o_sheetname in enumerate(data.sheetdict):
sheetname = FileFilter(2).sep_filename(o_sheetname)
if not count:
sheet = xlsx_data.active
sheet.title = sheetname
else:
xlsx_data.create_sheet(sheetname)
sheet = xlsx_data.get_sheet_by_name(sheetname)
main_data = data.sheetdict[o_sheetname].copy()
sheet_info = main_data.pop(0)
datatags = sheet_info["tags"]
sheet.append(datatags)
tags_dict = dict(zip(datatags, range(1, len(datatags) + 1)))
for context in main_data:
apnd_dict = dict()
for key, value in context.items():
apnd_dict[tags_dict[key]] = value
sheet.append(apnd_dict)
xlsx_data.save("%s%s.xlsx" % (self.dest_dir, xlsxname))
return True
def srsdict_to_sheet(self, srs_data=None):
if not srs_data:
filename = input("작업할 srs/simplesrs 파일의 경로를 입력해주세요.")
encoding = MenuPreset().encode()
srs_data, _ = SRSFile(filename, encoding).make_dict()
sheetname = FileFilter().sep_filename(filename)
else:
sheetname = 'srs-sheet'
result, _ = SRSConvert().make_srs_to_sheet(srs_data, sheetname)
return result
def __multi_data_input(self, data_count=2):
"""입력받는 데이터가 2개인 경우 사용. sav 디랙토리의 저장 파일을 불러옴."""
result_input = []
if self.target_data:
result_input.append(self.target_data)
print("직전에 실행한 데이터를 목록에 추가합니다.")
data_count -= 1
inputed_count = 1
for _ in range(data_count):
result_input.append(MenuPreset().load_saved_data(
1, "{}개 중 {}번째 파일을 불러옵니다.".format(data_count, inputed_count)))
inputed_count += 1
return tuple(result_input)
class ERBBlkFinder:
"""디렉토리 대응 코드 블럭 인식 클래스"""
def __init__(self):
self.block_data = InfoDict(1) # {filename:{index:(func,(code_block))}}
self.files, self.encode_type = CustomInput("ERB").get_filelist()
def block_maker(self):
for filename in self.files:
opened_erbs = ERBLoad(filename, self.encode_type)
chk_stk = CheckStack(opened_erbs.make_erblines()).line_divider()
self.block_data.add_dict(filename, chk_stk)
return self.block_data
def block_checker(self):
# TODO 파일별/ 블럭별 분리 및 공통점(구문 위치) 확인해 변경사항 체크
pass
def block_showdiff(self):
while not isinstance(self.block_data, InfoDict):
self.block_data = MenuPreset().load_saved_data()
if self.block_data is None:
print("특정 디렉토리의 ERB 데이터를 불러옵니다.")
self.block_maker()
def csv_infodict_maker(self, mod_num=0, debug_log=None):
"""infodict을 필요로하는 함수나 클래스에 사용함. debug_log은 LogPreset 타입을 요구함."""
infodict_csv = MenuPreset().load_saved_data(
0, "{}\n{}".format("CSV 변수 목록 추출 데이터를 불러오실 수 있습니다.",
"불러오실 경우 선택하신 모드와 다르게 작동할 수 있습니다."))
if not infodict_csv:
if mod_num in (0, 1): # {csv파일명:{숫자:csv변수명}}
infodict_csv = CSVFunc().import_all_CSV(0b010)
elif mod_num == 2: # {csv파일명:{csv변수명:숫자}}
infodict_csv = CSVFunc().import_all_CSV(0b011)
else:
raise NotImplementedError(mod_num)
if debug_log:
if mod_num == 0:
log_text = "작업을 위해 csv infodict 불러옴"
elif mod_num in (1, 2): # log_text 추가작성하는 경우
if mod_num == 1:
log_text = "숫자를 index 변수로 변환"
else:
log_text = "index 변수를 숫자로 변환"
log_text = "ERB 내부 {}\n".format(log_text)
debug_log.write_log(log_text)
return infodict_csv
func_name = line.split("(")[0]
total_strs = []
# dim_dict = dict()
# elif line.startswith("#DIM"):
# dim_dict.update(HandleDIM(dim_dict).dim_search(line))
elif line.find('"') > -1:
str_list = search_str.findall(line)
for string in str_list:
if string.find("/") > -1:
# string_list = string.split("/")
# total_strs.extend(string_list)
total_strs.append(string)
else:
total_strs.append(string)
else:
pass
func_dict.add_dict(func_name, total_strs, erb_file) # 마지막 함수용
return func_dict
with open("dimtest.log", "w", encoding="UTF-8") as log:
funcinfo = erb_translate_check()
for key, value in funcinfo.func_dict.items():
if isinstance(value, dict):
org = list(value.items())
elif isinstance(value, list):
org = value
text = "%s\n" % key + ", ".join(org) + "\n\n"
print(text, file=log)
MenuPreset().shall_save_data(funcinfo, "FuncInfo")
def to_SRS(self, srs_opt=0, srsname=None):
"""입력받은 데이터를 updateera의 simplesrs 양식으로 출력
Variables:
srs_opt: bit 기반 모드 설정 - 짧은 단어, srs 내부 중복 문자열 필터링 등 체크.
srsname: 저장될 simplesrs 파일명
"""
flags = 0b000000
h_opt = 0b0000
done_count = 0
failed_count = 0
self.log_file.workclass = "SRSWrite"
while True:
dataset = self.__multi_data_input()
print("처음 선택한 두 데이터만으로 진행합니다.\n")
print("SRS 자료 입력시 첫번째를 원문, 두번째를 번역문으로 인식합니다.\n")
o_dataset, t_dataset = self.__data_type_check(*dataset, max_data=2)
orig_data, trans_data = o_dataset[1], t_dataset[1]
if orig_data and trans_data:
if MenuPreset().yesno(
"선택하신 두 자료가",
"원본: " + str(o_dataset[0]),
"번역본: " + str(t_dataset[0]),
"입니까?",
):
break
else:
print("공란인 데이터가 있습니다. 다시 시도해주세요.")
if srs_opt & 0b100000: # srs 내 제외사항 기록
exp_opt_dict = {1: "미번역 단어", 2: "한글자 단어", 3: "원문 누락", 4: "번역문 누락"}
exp_opt = MenuPreset().select_mod(exp_opt_dict, 0b1010,
"srs 내 작성할 항목을 선택해주세요.")
flags |= exp_opt
# SRS type 설정부
ext_str = "simplesrs"
if not srsname:
srsname = "autobuild"
self.res_filename = "{}.{}".format(self.dest_dir + srsname, ext_str)
# 데이터가 InfoDict형이라면 데이터 목록 호출
if isinstance(orig_data, InfoDict) and isinstance(
trans_data, InfoDict):
sep_name = FileFilter(0).sep_filename
orig_data = {
sep_name(key): val
for key, val in orig_data.dict_main.items()
}
trans_data = {
sep_name(key): val
for key, val in trans_data.dict_main.items()
}
orig_infokeys = list(orig_data.keys())
trans_infokeys = list(trans_data.keys())
flags |= 0b010000 # isInfoDict
else:
orig_infokeys = [o_dataset[0]]
trans_infokeys = [t_dataset[0]]
# SRS 가필 유무 검사
if not os.path.isfile(self.res_filename):
print("SRS 파일을 새로 작성합니다.")
flags |= 0b100000 # isFirst
srs_headdict = {
1: "[-WORDWRAP-]",
2: "[-TRIM-]",
3: "[-REGEX-]",
4: "[-SORT-]"
}
h_opt = MenuPreset().select_mod(
srs_headdict, 0b1010,
"srs에 사용할 필터를 선택해주세요.\nREGEX와 SORT 옵션은 동시 사용이 불가합니다")
dup_chk = DupItemCheck()
else:
_, dup_chk = SRSFunc().exist_srsdict(self.res_filename)
print("SRS 입력을 시작합니다...")
for num in range(len(orig_infokeys)):
try:
self.orig_key = orig_infokeys[num]
self.trans_key = trans_infokeys[num]
if isinstance(orig_data, dict) and isinstance(
trans_data, dict):
self.trans_key = self.orig_key
except IndexError as error:
comment = "두 자료의 항목 수 또는 행이 같지 않습니다."
self.log_file.write_error_log(error, self.orig_key, comment)
failed_count += 1
continue
if self.orig_key in list(self.single_namedict.values()):
keyname = "단독파일"
elif self.orig_key.startswith("ex: "): # FuncInfo 대응용 임시
keyname = "단독파일"
else:
keyname = FileFilter().sep_filename(self.orig_key)
if isinstance(orig_data, dict) and isinstance(trans_data, dict):
target_couple = orig_data.get(self.orig_key), trans_data.get(
self.trans_key)
elif isinstance(orig_data, FuncInfo) and isinstance(
trans_data, FuncInfo):
# TODO 함수별 또는 파일별 나눠 분류 가능하도록
target_couple = orig_data.func_dict, trans_data.func_dict
else:
target_couple = orig_data, trans_data
multiwrite = self.__SRS_multi_write(*target_couple, keyname, flags,
dup_chk, h_opt, srs_opt)
if not multiwrite:
failed_count += 1
else:
if multiwrite[0]: #is_worked
flags &= flags ^ 0b100000 # remove isFirst Flag when first write finished
h_opt = 0
done_count += 1
if multiwrite[1] & 0b100 or multiwrite[1] & 0b001:
failed_count += 1
if done_count and failed_count == 0:
pass
else:
if not done_count:
print(
"입력된 정보로 이전에 만들어진 SRS 파일이거나 오류로 인해 SRS의 가필이 이루어지지 않았습니다.")
elif failed_count != 0:
print("{}쌍의 데이터가 정확히 작성되지 못했습니다.".format(failed_count))
print("{}를 확인해주세요.".format(self.log_file.NameDir))
self.log_file.sucessful_done()
return True
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 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()
def block_showdiff(self):
while not isinstance(self.block_data, InfoDict):
self.block_data = MenuPreset().load_saved_data()
if self.block_data is None:
print("특정 디렉토리의 ERB 데이터를 불러옵니다.")
self.block_maker()
def __init__(self):
self.block_data = InfoDict(1) # {filename:{index:(func,(code_block))}}
self.files, self.encode_type = CustomInput("ERB").get_filelist()