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 get_assets_db() -> AssetsDB: _PROC = f"{PROC}: get assets db" logger.debug(msg.PROC_START.format(proc=_PROC)) db = AssetsDB() paths = get_filepaths_in(PM.get_asset_dir_path(), EXT_YAML, True) for path in paths: if not is_exists_path(path): logger.warning( msg.ERR_FAIL_MISSING_DATA.format( data=f"asset data of {path}: {PROC}")) continue data = read_file(path) # NOTE: file validate? obj = asset_object_from(data) if obj: assert isinstance(obj, SObject) db.add(obj.tag, obj) logger.debug( msg.PROC_MESSAGE.format(proc=f"Add '{obj.tag}' to asset db")) logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return db
def _conv_person(level: str, index: str, subject: str, type: PersonInOut, outline: str) -> str: assert isinstance(level, str) assert isinstance(index, str) assert isinstance(subject, str) assert isinstance(type, PersonInOut) assert isinstance(outline, str) be = into = outto = wear = '' if PersonInOut.BE is type: be = 'BE' elif PersonInOut.IN is type: into = 'IN' elif PersonInOut.OUT is type: outto = 'OUT' elif PersonInOut.WEAR is type: wear = 'WEAR' else: logger.warning( msg.ERR_FAIL_UNKNOWN_DATA_WITH_DATA.format( data=f"format person info: {PROC}"), type) _level = just_string_of(level, 4) _index = just_string_of(index, 4) _subject = just_string_of(subject, 16) _be = just_string_of(be, 4) _in = just_string_of(into, 4) _out = just_string_of(outto, 4) _wear = just_string_of(wear, 4) _outline = just_string_of(outline, 16) return f"| {_level} | {_index} | {_subject} | {_be} | {_in} | {_out} | {_wear} | {_outline} |"
def run(self) -> int: logger.debug(msg.PROC_START.format(proc=PROC)) args = get_commandline_arguments() if not args: logger.error( msg.ERR_FAIL_MISSING_DATA.format( data=f"command line args: {PROC}")) return os.EX_NOINPUT if BuildChecker.has_build_cmd_of(args, BuildType.BUILD): if not build_project(args): logger.debug( msg.ERR_FAIL_SUBPROCESS.format( proc=f"build project: {PROC}")) return os.EX_SOFTWARE elif BuildChecker.has_build_cmd_of(args, BuildType.INIT): if not init_project(): logger.debug( msg.ERR_FAIL_SUBPROCESS.format( proc=f"init project: {PROC}")) return os.EX_SOFTWARE else: logger.warning( msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format( data=f"build command: {PROC}"), args.cmd) return os.EX_NOINPUT logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return os.EX_OK
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 create_default_dirs(cls) -> bool: for dirname in DEF_DIRS: _dirname = os.path.join(DIR_PROJECT, dirname) if not cls._safe_create_dir(_dirname): logger.warning( msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"{_dirname}")) return False return True
def _set_data_attr(obj: SObject, data: dict) -> bool: assert isinstance(obj, SObject) assert isinstance(data, dict) for key, val in data.items(): if key in [ELM_TAG, ELM_NAME]: continue if not _safe_set_attr(obj, key, val): logger.warning( msg.ERR_FAIL_CANNOT_WRITE_DATA_WITH_DATA.format( data=f"set '{key}'|'{val}': {PROC}"), obj) return True
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 _act_type_of(tag: str) -> ActType: assert isinstance(tag, str) for act in ActType: if tag in act.to_checker(): return act if tag: logger.warning( msg.ERR_FAIL_UNKNOWN_DATA_WITH_DATA.format( data=f"act type string: {PROC}"), tag) return ActType.NONE else: return ActType.SAME
def to_nametag(data: dict) -> NameTag: assert isinstance(data, dict) if str(AssetType.MOB) in data: return NameTag(NameTagType.MOB, data[str(AssetType.MOB)]) elif str(AssetType.TIME) in data: return NameTag(NameTagType.TIME, data[str(AssetType.TIME)]) elif str(AssetType.WORD) in data: return NameTag(NameTagType.WORD, data[str(AssetType.WORD)]) else: logger.warning( msg.ERR_FAIL_UNKNOWN_DATA.format( data=f"tag type {data.keys()}: {PROC}")) return None
def call_scene(level: int, tag: str, scenes: ScenesDB) -> list: assert isinstance(level, int) assert isinstance(tag, str) assert isinstance(scenes, ScenesDB) if not scenes.has(tag): logger.warning( msg.ERR_FAIL_MISSING_DATA_WITH_DATA.format( data=f"call tag: {PROC}"), tag) return [] tmp = [] scode = assertion.is_instance(scenes.get(tag), SceneCode) tmp.append(Converter.conv_scene_info_from(level, scode)) for obj in scode.data: if isinstance(obj, Action): tmp.append(obj) elif isinstance(obj, Instruction): if InstType.CALL is obj.type: call_tag = obj.args[0] # TODO: 親タグも取得して相互呼び出しを禁止する if tag == call_tag: logger.error( msg.ERR_FAIL_MUSTBE_WITH_DATA.format( data=f"not self calling: {PROC}"), tag) raise ValueError('invalid self calling', tag) ret = call_scene(level + 1, obj.args[0], scenes) if ret: tmp.extend(ret) else: tmp.append(obj) else: logger.warning( msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format( data=f"scene code object: {PROC}"), obj) continue tmp.append(_get_scene_end(scode)) return tmp
def callingtags_from(assets: AssetsDB) -> dict: assert isinstance(assets, AssetsDB) _PROC = f"{PROC}: calling tags" logger.debug(msg.PROC_START.format(proc=_PROC)) tmp = {} for key, val in assets.data.items(): assert isinstance(key, str) assert isinstance(val, SObject) if isinstance(val, Person): if not Converter.person_callings_of(tmp, val): logger.warning( msg.ERR_FAIL_INVALID_DATA.format( data=f"person '{val.tag} calling: {_PROC}'")) else: continue logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return tmp
def _to_act(record: StructRecord) -> str: assert isinstance(record, StructRecord) act = assertion.is_instance(record.act, ActType) subject = record.subject if record.subject else '――' category = act.to_category() outline = record.outline if record.outline else '――' indent = get_indent(2) if act in DIALOGUE_ACTS: _outline = f"「{outline}」" if ActType.VOICE is act: _outline = f"({category})『{outline}』" return f"{subject}{_outline}" elif act in DOING_ACTS: return f"{indent}〔{category}〕[{subject}]{outline}" elif act in DRAW_ACTS: return f"{indent}@({category})[{subject}]{outline}" elif act in FLAG_ACTS: return f"{indent}!({category})[{subject}]{outline}" elif act in STATE_ACTS: return f"{indent}%({category})[{subject}]={outline}" elif act in THINKING_ACTS: return f"{indent}({category})[{subject}]{outline}" elif act in SELECT_ACTS: if ActType.CHOICE is act: return f"{indent}!({category})[{subject}]={outline}" else: assert ActType.SELECTION is act selects = outline.replace(' ', '').split(',') _selects = '/'.join(selects) return f'{indent}?({category})[{subject}]={_selects}' elif act in TIME_ACTS: return f"[XII] {outline}" else: logger.warning( msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format( data=f"act type in format: {PROC}"), act) return None
def create_base_project_files(cls) -> bool: for path in BASE_FILES: if is_exists_path(path): logger.debug( msg.PROC_MESSAGE.format(proc=f"Already exists {path}")) continue data_path = os.path.join(DIR_DATA, basename_of(path, False)) data = read_file(data_path) if path == FILE_PROJECT: data = cls._replace_project_file_data(data) 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 get_srcs_db() -> SrcsDB: _PROC = f"{PROC}: get sources db" logger.debug(msg.PROC_START.format(proc=_PROC)) db = SrcsDB() key_cache = [] paths = get_filepaths_in(PM.get_src_dir_path(), EXT_MARKDOWN, True) for path in paths: if not is_exists_path(path): logger.warning( msg.ERR_FAIL_MISSING_DATA.format( data=f"source data of {path}: {PROC}")) continue data = read_file(path) raws = assertion.is_list(raw_src_objects_from(data)) for raw in raws: if raw: assert isinstance(raw, RawSrc) if raw.tag in key_cache: logger.warning( msg.ERR_FAIL_DUPLICATED_DATA_WITH_DATA.format( data=f"tag name: {_PROC}"), raw.tag) continue db.add(raw.tag, raw) key_cache.append(raw.tag) logger.debug( msg.PROC_MESSAGE.format( proc=f"Add '{raw.tag}' to srcs db")) logger.debug(msg.PROC_SUCCESS.format(proc=_PROC)) return db
def get_commandline_arguments() -> Namespace: logger.debug(msg.PROC_START.format(proc=PROC)) parser = assertion.is_instance(_init_commandline_parser(), ArgumentParser) if not parser: logger.error(msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"parser: {PROC}")) return None if not _set_parser_options(parser): logger.warning(msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"arg parser options: {PROC}")) return None args = parser.parse_args() if not args: logger.error(msg.ERR_FAIL_MISSING_DATA.format(data=f"args: {PROC}")) return None logger.debug(msg.PROC_SUCCESS.format(proc=PROC)) return args
def create_common_files(cls) -> bool: dir_asset = os.path.join(DIR_PROJECT, DEFAULT_ASSET_DIR) dir_common = os.path.join(dir_asset, DEFAULT_COMMON) for fname in COMMON_FILES: _fname = add_extention(fname, EXT_YAML) data_path = os.path.join(DIR_COMMON, _fname) data = read_file(data_path) path = os.path.join(dir_common, _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 return True
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 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