def _record_as_person_info_from(record: StructRecord) -> str: assert isinstance(record, StructRecord) info = assertion.is_instance(record.note, SceneDataInfo) data = "、".join(info.data) return f"[P: {data}]"
def _record_as_stage_info_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, StageInfo) head = info.index stage = info.stage subject = info.subject outline = info.outline out_subject = '' if StageInfoType.DRAW is info.type: subject = f"({subject})" if subject else '' elif StageInfoType.PUT is info.type: subject = f"[{subject}]" elif StageInfoType.RID is info.type: out_subject = f"[{subject}]" subject = '' elif StageInfoType.NONE is info.type: head = stage = subject = outline = '----' else: return None _head = just_string_of(str(head), 4) _stage = just_string_of(stage, 16) _subject = just_string_of(subject, 16) _outline = just_string_of(outline, 48) _out_subject = just_string_of(out_subject, 16) return f"| {_head} | {_stage} | {_subject} | {_outline} | {_out_subject} |"
def _base_stage_status_data_from(infos_data: InfosData) -> list: assert isinstance(infos_data, InfosData) _PROC = f"{PROC}: base stage data" logger.debug(msg.PROC_START.format(proc=_PROC)) tmp = [] index = 0 stage = 'None' for record in infos_data.get_data(): assert isinstance(record, InfoRecord) if InfoType.ACTION is record.type: ret = _record_as_stage_info_from(index, stage, record) if ret: tmp.append(ret) elif InfoType.TITLE_SCENE is record.type: index += 1 elif InfoType.SCENE_HEAD is record.type: info = assertion.is_instance(record.note, SceneInfo) stage = info.stage else: continue logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return tmp
def _record_as_stage_state_info_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, StageStateInfo) head = info.index stage = info.stage item = info.outline view = '' if StageStateType.ITEM is info.type: item = info.outline view = '' elif StageStateType.VIEW is info.type: item = '' view = info.outline elif StageStateType.NONE is info.type: head = stage = item = view = '----' else: return None _head = just_string_of(str(head), 4) _stage = just_string_of(stage, 16) _item = just_string_of(item, 16) _view = just_string_of(view, 32) return f"| {_head} | {_stage} | {_item} | {_view} |"
def stage_infos_from(infos_data: InfosData) -> InfosData: assert isinstance(infos_data, InfosData) logger.debug(msg.PROC_START.format(proc=PROC)) tmp = [] index = 0 current = None tmp.append(get_record_as_splitter()) tmp.append(get_record_as_data_title('STAGE INFOS')) for record in infos_data.get_data(): assert isinstance(record, InfoRecord) if InfoType.ACTION is record.type: ret = _record_as_stage_info_from(index, current, record) if ret: tmp.append(ret) elif InfoType.TITLE_EPISODE is record.type: tmp.append(_get_record_as_splitter()) elif InfoType.TITLE_SCENE is record.type: index += 1 elif InfoType.SCENE_HEAD is record.type: info = assertion.is_instance(record.note, SceneInfo) current = info.stage else: continue logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return InfosData(tmp)
def _record_as_knowledge_info_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, KnowledgeInfo) head = info.index subject = info.subject outline = info.outline old_know = '' if KnowledgeInfoType.EXPLAIN is info.type: subject = f"{subject}" outline = f"※{outline}" elif KnowledgeInfoType.KNOW is info.type: subject = f"{subject}" elif KnowledgeInfoType.KNOWN is info.type: subject = f"{subject}" old_know = f"({outline})" outline = '' elif KnowledgeInfoType.REMEMBER is info.type: subject = f"{subject}" old_know = f"〜{outline}" outline = '' elif KnowledgeInfoType.NONE is info.type: head = subject = outline = old_know = '----' else: return None _head = just_string_of(str(head), 4) _subject = just_string_of(subject, 16) _outline = just_string_of(outline, 32) _old_know = just_string_of(old_know, 32) return f"| {_head} | {_subject} | {_outline} | {_old_know} |"
def _record_as_flag_info_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, FlagInfo) head = '' subject_a = '' flag = '' subject_b = '' deflag = '' if FlagType.FLAG is info.type: head = info.index subject_a = info.subject flag = info.flag elif FlagType.DEFLAG is info.type: head = info.index subject_b = info.subject deflag = info.flag else: head = subject_a = flag = subject_b = deflag = '----' _head = just_string_of(str(head), 4) _subject_a = just_string_of(subject_a, 16) _flag = just_string_of(flag, 32) _subject_b = just_string_of(subject_b, 16) _deflag = just_string_of(deflag, 32) return f"| {_head} | {_subject_a} | {_flag} | {_subject_b} | {_deflag} |"
def _record_as_item_info_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, ItemInfo) head = info.index subject = info.subject outline = info.outline out_subject = '' if ItemInfoType.HAVE is info.type: subject = f"({subject})[{outline}]" elif ItemInfoType.DISCARD is info.type: out_subject = f"({subject})[{outline}]" subject = '' elif ItemInfoType.NONE is info.type: head = subject = outline = out_subject = '----' else: return None _head = just_string_of(str(head), 4) _subject = just_string_of(subject, 32) _out_subject = just_string_of(out_subject, 32) return f"| {_head} | {_subject} | {_out_subject} |"
def _record_as_person_state_info_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, PersonStateInfo) head = info.index subject = info.subject outline = info.outline skin = state = pinfo = '' if PersonStateType.INFO is info.type: pinfo = outline elif PersonStateType.SKIN is info.type: skin = outline elif PersonStateType.STATE is info.type: state = outline elif PersonStateType.NONE is info.type: head = skin = state = pinfo = '----' else: return None _head = just_string_of(str(head), 4) _subject = just_string_of(subject, 16) _skin = just_string_of(skin, 16) _state = just_string_of(state, 16) _pinfo = just_string_of(pinfo, 32) return f"| {_head} | {_subject} | {_skin} | {_state} | {_pinfo} |"
def _record_as_title_from(record: StoryRecord) -> ActionRecord: assert isinstance(record, StoryRecord) elm = assertion.is_instance(record.type, ElmType) # NOTE: ここは他にも何か情報入れる場合、追加 return ActionRecord( ActType.DATA, DATA_TITLE_TABLE[elm], elm_title_of(record), )
def _record_as_transition_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, SceneInfo) camera = just_string_of(info.camera, 16) stage = just_string_of(info.stage, 16) year = just_string_of(info.year, 8) date = just_string_of(info.date, 8) time = just_string_of(info.time, 8) return f"| {stage} | {time} | {date} | {year} | {camera} |"
def _record_as_scene_data_from(record: StructRecord) -> str: assert isinstance(record, StructRecord) info = assertion.is_instance(record.note, SceneInfo) camera = info.camera stage = info.stage year = info.year date = info.date time = info.time return f"○{stage}({time})- {date}/{year} 【{camera}】"
def _content_record_of(record: StoryRecord, index: int) -> ContentRecord: assert isinstance(record, StoryRecord) assert isinstance(index, int) elm = assertion.is_instance(record.type, ElmType) if not str(TITLE_ELMS[elm]) in record.data: logger.warning( msg.ERR_FAIL_INVALID_DATA.format(data=f"content record in {PROC}")) return None title = record.data[str(TITLE_ELMS[elm])] return ContentRecord(elm, title, index)
def _update_tags_scene_head_record(record: InfoRecord, tags: dict) -> InfoRecord: assert isinstance(record, InfoRecord) assert isinstance(tags, dict) info = assertion.is_instance(record.note, SceneInfo) _info = SceneInfo() _info.camera = translate_tags_str(info.camera, tags, True, None) _info.stage = translate_tags_str(info.stage, tags, True, None) _info.year = translate_tags_str(str(info.year), tags, True, None) _info.date = translate_tags_str(str(info.date), tags, True, None) _info.time = translate_tags_str(str(info.time), tags, True, None) return InfoRecord( record.type, record.act, record.subject, record.outline, _info)
def _update_tags_scene_data_record(record: StructRecord, tags: dict) -> StructRecord: assert isinstance(record, StructRecord) assert isinstance(tags, dict) info = assertion.is_instance(record.note, SceneInfo) updated = SceneInfo() updated.camera = translate_tags_str(info.camera, tags, True, None) updated.stage = translate_tags_str(info.stage, tags, True, None) updated.year = translate_tags_str(str(info.year), tags, True, None) updated.date = translate_tags_str(str(info.date), tags, True, None) updated.time = translate_tags_str(str(info.time), tags, True, None) return StructRecord(record.type, record.act, translate_tags_str(record.subject, tags, True, None), translate_tags_str(record.outline, tags, True, None), updated)
def get_commandline_arguments() -> Namespace: logger.debug(msg.PROC_START.format(proc=PROC)) parser = assertion.is_instance(_init_commandline_parser(), ArgumentParser) if not parser: return None if not _set_parser_options(parser): logger.warning(msg.ERR_FAIL_SET_DATA.format(data='arg parser options')) return None args = parser.parse_args() if not args: return None logger.debug(msg.PROC_DONE.format(proc=PROC)) return args
def _record_as_fashion_info_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, FashionInfo) head = info.index subject = info.subject outline = info.outline if head < 0: head = subject = outline = '----' else: outline = f"[{outline}]" _head = just_string_of(str(head), 4) _subject = just_string_of(subject, 16) _outline = just_string_of(outline, 32) return f"| {_head} | {_subject} | {_outline} |"
def story_data_from(args: Namespace) -> StoryData: assert isinstance(args, Namespace) logger.debug(msg.PROC_START.format(proc=PROC)) order_data = read_yaml_data(read_file(filepath_of(ElmType.ORDER, ''))) if not order_data: logger.error( msg.ERR_FAIL_MISSING_DATA.format(data=f"order data in {PROC}")) return None elmpart = assertion.is_instance( _get_elm_part(args.part if args.part else ""), ElmPart) serialized = assertion.is_list( serialized_filenames_from_order( order_data, elmpart.chapter[0], elmpart.chapter[1], elmpart.episode[0], elmpart.episode[1], elmpart.scene[0], elmpart.scene[1], )) if not serialized: logger.error( msg.ERR_FAIL_MISSING_DATA.format( data=f"serialized data in {PROC}")) return None story_data_base = _conv_story_data_from(serialized) if not story_data_base: logger.error( msg.ERR_FAIL_MISSING_DATA.format( data=f"story data base in {PROC}")) return None updated = update_story_data_if_same_or_next_tag(StoryData(story_data_base)) logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return updated
def _conv_plot_record(record: StoryRecord) -> PlotRecord: assert isinstance(record, StoryRecord) elm = assertion.is_instance(record.type, ElmType) if not is_enable_the_elm(elm, ENABLE_ELMS): logger.warning( msg.ERR_FAIL_INVALID_DATA.format(data=f"element type in {PROC}")) return None title = assertion.is_str(elm_title_of(record)) setup = assertion.is_str(_elm_setup_of(record)) tp1st = assertion.is_str(_elm_tp1st_of(record)) develop = assertion.is_str(_elm_develop_of(record)) tp2nd = assertion.is_str(_elm_tp2nd_of(record)) climax = assertion.is_str(_elm_climax_of(record)) resolve = assertion.is_str(_elm_resolve_of(record)) return PlotRecord(elm, title, setup, tp1st, develop, tp2nd, climax, resolve)
def _record_of_scene_transition_from(record: InfoRecord, cache: SceneInfo) -> InfoRecord: assert isinstance(record, InfoRecord) assert isinstance(cache, SceneInfo) def _diff(a: str, b: str) -> str: if a != b: return '↓' else: return '…' base = assertion.is_instance(record.note, SceneInfo) dif = SceneInfo() dif.camera = _diff(base.camera, cache.camera) dif.stage = _diff(base.stage, cache.stage) dif.year = _diff(base.year, cache.year) dif.date = _diff(base.date, cache.date) dif.time = _diff(base.time, cache.time) return InfoRecord(InfoType.SCENE_TRANSITION, ActType.DATA, '', '', dif)
def _reorder_each_stages(base_data: list) -> list: assert isinstance(base_data, list) _PROC = f"{PROC}: reorder stage data" logger.debug(msg.PROC_START.format(proc=_PROC)) tmp = [] stages = _get_stages_list() tmp.append(get_record_as_splitter()) tmp.append(get_record_as_data_title("STAGE STATUS TRANSITIONS")) for stage in stages: tmp.append(_get_record_as_data_splitter(ElmType.STAGE)) for record in base_data: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, StageStateInfo) if info.stage == stage: tmp.append(record) logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return tmp
def _reorder_each_persons(base_data: list) -> list: assert isinstance(base_data, list) _PROC = f"{PROC}: reorder person data" logger.debug(msg.PROC_START.format(proc=_PROC)) tmp = [] persons = _get_persons_list() tmp.append(get_record_as_splitter()) tmp.append(get_record_as_data_title("PERSON STATUS TRANSITIONS")) for person in persons: tmp.append(_get_record_as_data_splitter(ElmType.PERSON)) for record in base_data: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, PersonStateInfo) if info.subject == person: tmp.append(record) logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return tmp
def _record_as_person_info_from(record: InfoRecord) -> str: assert isinstance(record, InfoRecord) info = assertion.is_instance(record.note, PersonInfo) head = info.index info_sub = '' subject = info.subject outline = info.outline if PersonInfoType.BE is info.type: info_sub = f"[{subject}]" elif PersonInfoType.COME is info.type: info_sub = f"in {subject}" elif PersonInfoType.GO is info.type: info_sub = f"out {subject}" else: head = info_sub = outline = '----' _head = just_string_of(str(head), 4) _subject = just_string_of(info_sub, 16) _outline = just_string_of(outline, 48) return f"| {_head} | {_subject} | {_outline} |"
def test_assertion_is_instance(x, t): assert is_instance(x, t), f"Expected a type {t} value: {x}"
def __init__(self, data: list, record_cls: Any): assert isinstance(data, list) self.data = [assertion.is_instance(r, record_cls) for r in data]