Esempio n. 1
0
    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
Esempio n. 2
0
    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
Esempio n. 3
0
 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
Esempio n. 4
0
    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("엔터를 눌러 계속...")
Esempio n. 5
0
    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
Esempio n. 6
0
    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
Esempio n. 7
0
    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
Esempio n. 8
0
 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)
Esempio n. 9
0
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()
Esempio n. 10
0
    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
Esempio n. 11
0
                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")
Esempio n. 12
0
    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
Esempio n. 13
0
    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
Esempio n. 14
0
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()
Esempio n. 15
0
 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()
Esempio n. 16
0
 def __init__(self):
     self.block_data = InfoDict(1)  # {filename:{index:(func,(code_block))}}
     self.files, self.encode_type = CustomInput("ERB").get_filelist()