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
