def build_info(story_data: StoryData, tags: dict, callings: dict) -> OutputsData: assert isinstance(story_data, StoryData) assert isinstance(tags, dict) assert isinstance(callings, dict) logger.debug(msg.PROC_START.format(proc=PROC)) infos = Converter.infos_data_from(story_data) if not infos: return None updated_tags = TagConverter.conv_callings_and_tags(infos, tags, callings) if not updated_tags: return None formatted = Formatter.format_data(updated_tags) if not formatted: return None translated = translate_tags_text_list(formatted, tags) logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return OutputsData(translated)
def apply_scene_info_same(data: list) -> list: assert isinstance(data, list) _PROC = f"{PROC}: scene info same conv" logger.debug(msg.PROC_START.format(proc=_PROC)) tmp = [] cache = None for record in data: assert isinstance(record, BaseCode) if isinstance(record, SceneInfo): ret = Converter.conv_same_info(record, cache) if ret: tmp.append(ret) cache = ret else: # nospin tmp.append(record) else: tmp.append(record) logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return tmp
def transitions_data_from(cls, story_data: StoryData) -> list: assert isinstance(story_data, StoryData) tmp = [] indices = [0] tmp.append( InfoRecord(RecordType.DATA_HEAD, 0, 0, 'TRANSITION INFO', '')) for record in story_data.get_data(): assert isinstance(record, BaseCode) if isinstance(record, SceneInfo): if record.level >= len(indices): indices.append(0) indices[record.level] += 1 if 'nospin' in record.flags: continue ret = cls._to_transition_info(indices[record.level], record) if ret: tmp.append(ret) elif isinstance(record, SceneEnd): pass elif isinstance(record, Action): continue else: continue logger.debug( msg.PROC_MESSAGE.format( proc=f"converted transitions data: {PROC}")) return tmp
def flags_data_from(cls, story_data: StoryData) -> list: assert isinstance(story_data, StoryData) tmp = [] indices = [0] cur_level = 0 cur_index = 0 tmp.append(InfoRecord(RecordType.DATA_HEAD, 0, 0, 'FLAG INFO', '')) for record in story_data.get_data(): assert isinstance(record, BaseCode) if isinstance(record, SceneInfo): if record.level <= len(indices): indices.append(0) cur_level = record.level indices[record.level] += 1 cur_index = indices[record.level] elif isinstance(record, SceneEnd): continue elif isinstance(record, Action): ret = cls._to_flag_info(cur_level, cur_index, record) if ret: tmp.append(ret) else: continue logger.debug( msg.PROC_MESSAGE.format(proc=f"converted flags data: {PROC}")) return tmp
def conv_callings_and_tags(cls, data: list, tags: dict, callings: dict) -> list: assert isinstance(data, list) assert isinstance(tags, dict) assert isinstance(callings, dict) tmp = [] for record in data: assert isinstance(record, InfoRecord) if RecordType.TRANSITION is record.type: tmp.append(cls._conv_transition(record, tags)) elif RecordType.PERSON_INFO is record.type: tmp.append(cls._conv_person(record, callings, tags)) elif RecordType.ITEM_INFO is record.type: tmp.append(cls._conv_item(record, callings, tags)) elif RecordType.FLAG_INFO is record.type: tmp.append(cls._conv_flag(record, callings, tags)) else: tmp.append(record) logger.debug( msg.PROC_MESSAGE.format(proc=f"tag converted infos data: {PROC}")) return tmp
def infos_data_from(cls, story_data: StoryData) -> list: assert isinstance(story_data, StoryData) tmp = [] transitions = TransitionInfoConv.transitions_data_from(story_data) if not transitions: return None persons = PersonInfoConv.personinfos_data_from(story_data) if not persons: return None items = ItemInfoConv.iteminfos_data_from(story_data) if not items: return None flags = FlagInfoConv.flags_data_from(story_data) if not flags: return None logger.debug( msg.PROC_MESSAGE.format(proc=f"converted infos data: {PROC}")) tmp = transitions + persons + items + flags return tmp
def build_plot(story_data: StoryData, tags: dict) -> OutputsData: assert isinstance(story_data, StoryData) assert isinstance(tags, dict) logger.debug(msg.PROC_START.format(proc=PROC)) plots = Converter.plots_data_from(story_data) if not plots: logger.error( msg.ERR_FAIL_MISSING_DATA.format(data=f"plots data: {PROC}")) return None reordered = Converter.reorder_plots(plots) if not reordered: logger.error( msg.ERR_FAIL_MISSING_DATA.format(data=f"reordered plots: {PROC}")) return None formatted = Formatter.format_data(reordered) if not formatted: logger.error( msg.ERR_FAIL_MISSING_DATA.format(data=f"formatted plots: {PROC}")) return None translated = translate_tags_text_list(formatted, dict_sorted(tags, True)) logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return OutputsData(translated)
def asset_object_from(data: str) -> SObject: assert isinstance(data, str) logger.debug(msg.PROC_START.format(proc=PROC)) tmp = assertion.is_dict(yaml.safe_load(data)) obj = None if str(AssetType.PERSON) in tmp: obj = Converter.to_person(tmp[str(AssetType.PERSON)]) elif str(AssetType.STAGE) in tmp: obj = Converter.to_stage(tmp[str(AssetType.STAGE)]) elif str(AssetType.ITEM) in tmp: obj = Converter.to_item(tmp[str(AssetType.ITEM)]) elif str(AssetType.MOB) in tmp: obj = Converter.to_nametag(tmp) elif str(AssetType.TIME) in tmp: obj = Converter.to_nametag(tmp) elif str(AssetType.WORD) in tmp: obj = Converter.to_nametag(tmp) elif str(AssetType.RUBI) in tmp: obj = Converter.to_rubi(tmp[str(AssetType.RUBI)]) else: logger.warning( msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format( data=f"asset type: {PROC}"), tmp.keys()) return None logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return obj
def _set_parser_options(parser: ArgumentParser) -> bool: assert isinstance(parser, ArgumentParser) _PROC = f"{PROC}: set parser options" logger.debug(msg.PROC_START.format(proc=_PROC)) parser.add_argument('cmd', metavar='command', type=str, help='builder command') parser.add_argument('-o', '--outline', help='outline output', action='store_true') parser.add_argument('-p', '--plot', help='plot output', action='store_true') parser.add_argument('-i', '--info', help='scene info output', action='store_true') parser.add_argument('-u', '--status', help='status info output', action='store_true') parser.add_argument('-t', '--struct', help='struct output', action='store_true') parser.add_argument('-s', '--script', help='script output', action='store_true') parser.add_argument('-n', '--novel', help='novel output', action='store_true') parser.add_argument('-r', '--rubi', help='output with rubi', action='store_true') parser.add_argument('-v', '--version', help='output app version', action='store_true') parser.add_argument('-e', '--edit', help='add and edit when new file', action='store_true') parser.add_argument('--part', type=str, help='select ouput part') parser.add_argument('--comment', help='show comment', action='store_true') parser.add_argument('--debug', help='set debug flag', action='store_true') parser.add_argument('--debugdetail', help='set detal debug output', action='store_true') logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return True
def raw_src_objects_from(data: str) -> list: assert isinstance(data, str) logger.debug(msg.PROC_START.format(proc=PROC)) srcs = [] tmp = [] current = 'global' for line in data.split('\n'): if line.startswith('#!SMS'): # meta mark continue elif line.startswith('## '): if tmp: srcs.append(Converter.to_src(current, copy.deepcopy(tmp))) current = _get_scene_tag(line) tmp = [] elif line.startswith('# '): # source comment continue elif line: tmp.append(line) else: # break line continue if tmp: srcs.append(Converter.to_src(current, copy.deepcopy(tmp))) logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return srcs
def apply_alias(data: list) -> list: assert isinstance(data, list) # TODO: 現在はそのシーンのみでAlias置換を行っているが、レベルが深くなっても維持するように変更する tmp = [] alias = {} for record in data: assert isinstance(record, BaseCode) if isinstance(record, SceneInfo): tmp.append(record) elif isinstance(record, SceneEnd): tmp.append(record) alias = {} elif isinstance(record, Instruction) and InstType.ALIAS is record.type: tokens = assertion.is_list(record.args) alias[tokens[0]] = tokens[2] elif isinstance(record, Action): ret = TagConv.apply_alias_to_action(record, dict_sorted(alias, True)) tmp.append(ret) else: tmp.append(record) logger.debug( msg.PROC_MESSAGE.format(proc=f"completed apply alias: {PROC}")) return tmp
def build_contents(story_data: StoryData, tags: dict) -> OutputsData: assert isinstance(story_data, StoryData) assert isinstance(tags, dict) logger.debug(msg.PROC_START.format(proc=PROC)) tmp = [] for record in story_data.get_data(): assert isinstance(record, BaseCode) if isinstance(record, SceneInfo): ret = Converter.to_content_record(record) if ret: tmp.append(ret) else: continue formatted = Formatter.format_data(tmp) if not formatted: logger.error( msg.ERR_FAIL_MISSING_DATA.format(data=f"format data: {PROC}")) return None translated = translate_tags_text_list(formatted, tags) logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return OutputsData(translated)
def build_struct(story_data: StoryData, tags: dict, callings: dict, is_comment: bool) -> OutputsData: assert isinstance(story_data, StoryData) assert isinstance(tags, dict) assert isinstance(callings, dict) assert isinstance(is_comment, bool) logger.debug(msg.PROC_START.format(proc=PROC)) structs = Converter.structs_data_from(story_data, _get_person_tags(callings)) if not structs: return None updated_tags = TagConverter.conv_callings_and_tags(structs, tags, callings) if not updated_tags: return None reordered = Reorder.reorder_data_from(updated_tags) if not reordered: return None formatted = Formatter.format_data(reordered, is_comment) if not formatted: return None translated = translate_tags_text_list(formatted, dict_sorted(tags, True)) logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return OutputsData(translated)
def scripts_data_from(cls, story_data: StoryData) -> list: assert isinstance(story_data, StoryData) tmp = [] indices = [0] for record in story_data.get_data(): assert isinstance(record, BaseCode) if isinstance(record, SceneInfo): if record.level >= len(indices): indices.append(0) indices[record.level] += 1 ret = cls._to_scene_head(indices[record.level], record) if ret: tmp.append(ret) ret = cls._to_scene_spin(record) if ret: tmp.append(ret) elif isinstance(record, SceneEnd): tmp.append(cls._get_scene_end()) elif isinstance(record, Action): ret = cls._to_scene_act(record) if ret: tmp.append(ret) elif isinstance(record, Instruction): ret = cls._to_scene_control(record) if ret: tmp.append(ret) else: continue logger.debug( msg.PROC_MESSAGE.format(proc=f"converted script data: {PROC}")) return tmp
def format_data(cls, type: BuildType, data: list) -> list: assert isinstance(type, BuildType) assert isinstance(data, list) tmp = [] current = 0 tmp.append(cls._title_of(type)) tmp.append(get_br(2)) for record in data: assert isinstance(record, CountRecord) if current != record.level: current = record.level tmp.append(get_br()) tmp.append(get_breakline()) tmp.append(cls._conv_count_record(record)) tmp.append(get_br()) tmp.append(get_br(2)) logger.debug( msg.PROC_MESSAGE.format( proc=f"formatted '{type}' char counts data: {PROC}")) return tmp
def char_counts_from(type: BuildType, data: list, columns: int, rows: int) -> list: assert isinstance(type, BuildType) assert isinstance(data, list) assert isinstance(columns, int) assert isinstance(rows, int) logger.debug(msg.PROC_START.format(proc=PROC)) counts = CharCounter.counts_data_from(type, data, columns, rows) if not counts: logger.error( msg.ERR_FAIL_MISSING_DATA.format( data=f"'{type}' char counts data: {PROC}")) return None formatted = Formatter.format_data(type, counts) if not formatted: logger.error( msg.ERR_FAIL_MISSING_DATA.format( data=f"format '{type}' counts data: {PROC}")) return None logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return formatted
def conv_callings_and_tags(cls, data: list, tags: dict, callings: dict) -> list: assert isinstance(data, list) assert isinstance(tags, dict) assert isinstance(callings, dict) tmp = [] _tags = dict_sorted(tags) for record in data: assert isinstance(record, StructRecord) if RecordType.SPIN is record.type: tmp.append(cls._conv_spin(record, _tags)) elif record.type in [ RecordType.ACT, RecordType.OBJECT, RecordType.PERSON ]: tmp.append(cls._conv_act(record, _tags, callings)) else: tmp.append(record) logger.debug( msg.PROC_MESSAGE.format( proc=f"tag converted structs data: {PROC}")) return tmp
def build_base_info(cls, args: Namespace, outputs_data: dict) -> bool: assert isinstance(args, Namespace) assert isinstance(outputs_data, dict) tmp = OutputsData(['BASE INFO\n===\n\n']) columns, rows = _get_columns_and_rows() for type, outputs in outputs_data.items(): if Checker.has(args, type) and outputs: assert isinstance(outputs, OutputsData) ret = char_counts_from(type, outputs.get_data(), columns, rows) if ret: tmp += OutputsData(ret) if not tmp or tmp.is_empty(): logger.error( msg.ERR_FAIL_MISSING_DATA.format( data=f"base info data: {PROC}")) return False if not Outputter.output_data(_get_build_path('base'), tmp): logger.error( msg.ERR_FAIL_CANNOT_WRITE_DATA.format( data=f"base info data: {PROC}")) return False logger.debug( msg.PROC_MESSAGE.format(proc=f"ouputted base infos: {PROC}")) return True
def format_data(cls, data: list) -> list: assert isinstance(data, list) _PROC = f"{PROC}: format" logger.debug(msg.PROC_START.format(proc=_PROC)) tmp = [] indices = [0] for record in data: assert isinstance(record, ContentRecord) ret = None if record.level == 0: ret = cls.conv_main_title(record) else: if record.level >= len(indices): indices.append(0) ret = cls.conv_content_title(indices, record) if ret: tmp.append(ret) tmp.append(get_br()) tmp.append(get_breakline()) logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return tmp
def build_novel(story_data: StoryData, tags: dict, callings: dict, is_comment: bool) -> OutputsData: assert isinstance(story_data, StoryData) assert isinstance(tags, dict) assert isinstance(callings, dict) assert isinstance(is_comment, bool) logger.debug(msg.PROC_START.format(proc=PROC)) novels = Converter.novels_data_from(story_data) if not novels: return None updated_tags = TagConverter.conv_callings_and_tags(novels, tags, callings) if not updated_tags: return None formatted = Formatter.format_data(updated_tags, is_comment) if not formatted: return None translated = translate_tags_text_list(formatted, dict_sorted(tags, True)) logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return OutputsData(translated)
def scene_code_object_from(raw: RawSrc) -> SceneCode: assert isinstance(raw, RawSrc) logger.debug(msg.PROC_START.format(proc=PROC)) code = SceneCode(raw.tag) current_act = None def _store_act(scode: SceneCode, act): assert isinstance(scode, SceneCode) if act: assert isinstance(act, (Action, Instruction)) scode.add(act.cloned()) return None for line in raw.data: assert isinstance(line, str) if line.startswith('<'): ret = Converter.to_call_scene(line) if ret: current_act = _store_act(code, current_act) code.add(ret) elif line.startswith('::'): # member member, val = _get_member_tokens(line) if not member: logger.warning( msg.ERR_FAIL_MISSING_DATA.format( data=f"member:'{member}' and val: '{val}' : {PROC}")) continue if hasattr(code, member): setattr(code, member, val) else: logger.warning( msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format( data=f"scene member: {PROC}"), member) elif line.startswith('!'): # instruction ret = Converter.to_instruction(line) if ret: current_act = _store_act(code, current_act) code.add(ret) elif line.startswith('['): # action current_act = _store_act(code, current_act) current_act = Converter.to_action(line) elif line: # text if current_act: current_act.add(line) else: continue current_act = _store_act(code, current_act) updated_code = Restructor.restruct_dialogue_actions(code) logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return updated_code
def _check_and_create_build_dir() -> bool: build_dir = os.path.join(DIR_PROJECT, DIR_BUILD_NAME) if not is_exists_path(build_dir): os.makedirs(build_dir) logger.debug( msg.PROC_MESSAGE.format(proc=f"created build directory: {PROC}")) return True
def nametags_from(assets: AssetsDB) -> dict: assert isinstance(assets, AssetsDB) logger.debug(msg.PROC_START.format(proc=PROC)) config = yaml.safe_load(read_file(FILE_CONFIG)) if not config: logger.error(msg.ERR_FAIL_MISSING_DATA.format(data=f"config file: {PROC}")) return {} mob_num = config[ELM_CONFIG][ELM_MOBS] tmp = {} for key, val in assets.data.items(): assert isinstance(key, str) assert isinstance(val, SObject) if isinstance(val, Person): if not Converter.person_names_of(tmp, val): logger.warning( msg.ERR_FAIL_INVALID_DATA.format( data=f"person '{val.tag}' name: {PROC}")) elif isinstance(val, Stage): if not Converter.stage_names_of(tmp, val): logger.warning( msg.ERR_FAIL_INVALID_DATA.format( data=f"stage '{val.tag}' name: {PROC}")) elif isinstance(val, Item): if not Converter.item_name_of(tmp, val): logger.warning( msg.ERR_FAIL_INVALID_DATA.format( data=f"item '{val.tag}' name: {PROC}")) elif isinstance(val, NameTag): if NameTagType.MOB is val.type: if not Converter.mob_name_of(tmp, val, mob_num): logger.warning( msg.ERR_FAIL_INVALID_DATA.format( data=f"mob names: {PROC}")) elif NameTagType.TIME is val.type: if not Converter.time_name_of(tmp, val): logger.warning( msg.ERR_FAIL_INVALID_DATA.format( data=f"time names: {PROC}")) elif NameTagType.WORD is val.type: if not Converter.word_name_of(tmp, val): logger.warning( msg.ERR_FAIL_INVALID_DATA.format( data=f"word names: {PROC}")) else: continue elif isinstance(val, Rubi): continue else: continue logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return tmp
def _after_date_from(base: str, data: str) -> str: assert isinstance(base, str) assert isinstance(data, str) logger.debug( msg.MSG_UNIMPLEMENT_PROC.format( proc=f"after date unimplement: {PROC}")) return base
def create_default_files(cls) -> bool: dir_asset = os.path.join(DIR_PROJECT, DEFAULT_ASSET_DIR) dir_src = os.path.join(DIR_PROJECT, DEFAULT_SRC_DIR) dir_temp = os.path.join(DIR_PROJECT, DEFAULT_TEMP_DIR) for fname in SAMPLE_DATA: _fname = add_extention(fname, EXT_YAML) data_path = os.path.join(DIR_EXAMPLE, _fname) data = read_file(data_path) path = os.path.join(dir_asset, _fname) if is_exists_path(path): logger.debug( msg.PROC_MESSAGE.format(proc=f"Already exists {path}")) continue if write_file(path, data): logger.debug(msg.PROC_MESSAGE.format(proc=f"Create {path}")) else: logger.warning( msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"{path}")) return False for fname in SAMPLE_SRC: _fname = add_extention(fname, EXT_MARKDOWN) data_path = os.path.join(DIR_EXAMPLE, _fname) data = read_file(data_path) path = os.path.join(dir_src, _fname) if is_exists_path(path): logger.debug( msg.PROC_MESSAGE.format(proc=f"Already exists {path}")) continue if write_file(path, data): logger.debug(msg.PROC_MESSAGE.format(proc=f"Create {path}")) else: logger.warning( msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"{path}")) return False for fname in TEMP_FILES: data_path = os.path.join(DIR_TEMP, fname) data = read_file(data_path) path = os.path.join(dir_temp, fname) if write_file(path, data): logger.debug(msg.PROC_MESSAGE.format(proc=f"Create {path}")) else: logger.warning( msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"{path}")) return False return True
def reorder_data_from(cls, data: list) -> list: assert isinstance(data, list) tmp = [] cache = [] persons = [] objects = [] is_lighting = False is_int = False is_start_spin = False for record in data: assert isinstance(record, StructRecord) if RecordType.TITLE is record.type: tmp.append(record) elif RecordType.SPIN is record.type: tmp.append(record) info = assertion.is_instance(record.note, SpinInfo) is_int = info.location == 'INT' is_start_spin = True elif RecordType.SCENE_END is record.type: if not is_start_spin: continue oret = cls._conv_object_pack(objects) if oret: tmp.append(oret) pret = cls._conv_person_pack(persons) if pret: tmp.append(pret) if not is_lighting: tmp.append(cls._get_default_light(is_int)) tmp.extend(copy.deepcopy(cache)) tmp.append(record) # reset objects = [] persons = [] cache = [] is_lighting = False is_int = False is_start_spin = False elif RecordType.OBJECT is record.type: objects.append(record) elif RecordType.PERSON is record.type: persons.append(record) elif RecordType.LIGHT is record.type: is_lighting = True cache.append(record) else: cache.append(record) logger.debug( msg.PROC_MESSAGE.format(proc=f"reorder struct data: {PROC}")) return tmp
def _counts_data_from(cls, type: BuildType, data: list, columns: int, rows: int) -> list: assert isinstance(type, BuildType) assert isinstance(data, list) assert isinstance(columns, int) assert isinstance(rows, int) tmp = [] indices = [0] titles = [['']] descs = [['']] for record in data: assert isinstance(record, str) if record.startswith('#'): # scene head level = record.count('#') if len(indices) <= level: indices.append(0) titles.append(['']) descs.append(['']) indices[level] += 1 titles[level].append(cls._title_from(record)) descs[level].append('') elif re.search(r'[0-9]+\.', record): # scene head in outline and plot pass elif record.startswith('<!--'): # comment continue elif record.startswith('----'): # breakline continue elif BuildType.STRUCT is type and record.startswith('['): # spin info continue elif BuildType.STRUCT is type and record.startswith('>>'): # person info continue else: # text for level in range(len(indices)): descs[level][indices[level]] += rid_rn(record) for level in range(len(indices)): tmp.extend( Converter.counts_from(level, titles[level], descs[level], columns, rows)) logger.debug( msg.PROC_MESSAGE.format( proc=f"converted '{type}' char count data: {PROC}")) return tmp
def output_data(path: str, outputs: OutputsData) -> bool: assert isinstance(path, str) assert isinstance(outputs, OutputsData) if not write_file(path, outputs.get_serialized_data()): logger.warning( msg.ERR_FAIL_CANNOT_WRITE_DATA.format( data=f"outputs data to {path}: {PROC}")) return False logger.debug(msg.PROC_MESSAGE.format(proc=f"write {path}")) return True
def _next_time_from(base: str, data: str) -> str: assert isinstance(base, str) assert isinstance(data, str) logger.debug( msg.MSG_UNIMPLEMENT_PROC.format( proc=f"next time unimplement: {PROC}")) if ':' in base: return base else: return base
def _init_commandline_parser() -> ArgumentParser: _PROC = f"{PROC}: init commandline parser" logger.debug(msg.PROC_START.format(proc=_PROC)) parser = ArgumentParser( prog=PROGRAM_NAME, description=DESCRIPTION, ) logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return parser