def __handle_csvvar(self, word, last_word):
dup_datalist = []
dup_switch = 0
now_switch = 0
if "<지금>" in word:
word.replace("<지금>", "")
now_switch = 1
if self.csvvar_dict.get("dup1_" + word):
self.__csvvar_dup_count += 1
dup_switch = 1
target_list = list(self.csvvar_dict.keys())
else:
target_list = [word]
for var in target_list:
if (var.endswith(word) and var.startswith("dup")) or word == var:
csvvar_data = self.csvvar_dict[var]
csv_name = FileFilter().sep_filename(csvvar_data[0]).upper()
if now_switch:
if csv_name == "EX":
csv_name = "NOWEX"
if self.csvvar_type == 0:
word_withcsv = csv_name + ":" + word.replace("__", " ")
elif self.csvvar_type == 1:
word_withcsv = "{}:{}".format(csv_name, csvvar_data[1])
dup_datalist.append(word_withcsv)
if dup_switch:
result = "!중복변수! 변수명={} {}".format(word, " OR ".join(dup_datalist))
else:
result = word_withcsv
if last_word in self.namedict_situ.values():
result = result.replace(":", ":{}:".format(last_word))
self.__namedict_used_switch = 1
return result
def search_filelist(self, *ext, opt=1):
result = []
for ex in ext:
if not ex.startswith("."):
ex = "." + ex
result.extend(FileFilter(opt).files_ext(self.dirname, ex))
return result
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 __init__(self, csvdict: InfoDict or list, log_set=None):
if isinstance(csvdict, InfoDict):
self.csv_infodict = csvdict
self.csv_fnames = dict()
for filename in list(self.csv_infodict.dict_main.keys()):
csvname = FileFilter().sep_filename(filename).upper()
self.csv_fnames[csvname] = filename
self.csv_head = list(self.csv_fnames.keys())
elif isinstance(csvdict, list):
self.csv_head = csvdict
else:
raise TypeError
csv_all_head = self.csv_head + list(self.extra_dict.keys())
re_varshead = "({})".format("|".join(csv_all_head))
self.csvvar_re = re.compile(re_varshead + self.context_filter)
self.log_set = log_set
def _check_datatype(self, data_1, data_2, text: str = "", isrepeat=False):
result: list(tuple) = []
have_null = {}
if type(data_1) == type(data_2):
if isinstance(data_1, InfoDict):
a_dict: dict = data_1.dict_main
b_dict: dict = data_2.dict_main
sep_name = FileFilter(0).sep_filename
datadict_a = {
sep_name(key): val
for key, val in a_dict.items()
}
datadict_b = {
sep_name(key): val
for key, val in b_dict.items()
}
result, have_null = self._check_datatype(
datadict_a, datadict_b, "InfoDict 내부 ", True)
elif isinstance(data_1, dict):
keys_1 = list(data_1.keys())
keys_2 = list(data_2.keys())
total_keys = DataFilter().dup_filter(keys_1 + keys_2)
for t_key in total_keys:
if t_key not in keys_1:
have_null[t_key] = 1
elif t_key not in keys_2:
have_null[t_key] = 2
elif isrepeat and isinstance(
data_1[t_key],
(dict, list, tuple)): # 재귀중 value에서 또 발견
dat, h_nul = self._check_datatype(
data_1[t_key], data_2[t_key], "dict 안 data ", True)
result.extend(dat)
have_null.update(h_nul)
else:
result.append((data_1[t_key], data_2[t_key]))
elif isinstance(data_1, (list, tuple)):
if len(data_1) != len(data_2):
print("두 자료의 길이가 일치하지 않습니다. 일부 자료가 누락되었습니다.")
f_strip = DataFilter().strip_filter
result = list(zip(f_strip(data_1), f_strip(data_2)))
else:
raise NotImplementedError("지원하지 않는 자료형: " + type(data_1))
else:
raise TypeError("%s두 데이터의 자료형이 같지 않습니다." % text)
return result, have_null
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 search_csvdict(self, encode_type):
csv_filelist = FileFilter(1).files_ext(self.dirname, ".CSV")
CSVinfodict = CSVFunc().import_all_CSV(0b10, csv_filelist, encode_type)
return CSVinfodict
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