def check_and_create_default_files() -> bool:
_PROC = f"{PROC}: check and create files"
logger.debug(msg.PROC_START.format(proc=_PROC))
for elm in BASE_FILES:
path = filepath_of(elm, BASE_FILE_TABLE[elm])
if not is_exists_path(path):
data = get_template_data(elm)
if not write_file(path, data):
logger.warning(msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"{str(elm)} in {_PROC}"))
return False
else:
logger.debug(msg.PROC_MESSAGE.format(proc=f"Already exists {str(elm)} file in {PROC}"))
continue
for elm in DEFAULT_FILES:
path = filepath_of(elm, 'main')
if not is_exists_path(path):
data = get_template_data(elm)
if not write_file(path, data):
logger.warning(msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"{str(elm)} in {_PROC}"))
return False
else:
logger.debug(msg.PROC_MESSAGE.format(proc=f"Already exists {str(elm)} file in {PROC}"))
continue
logger.debug(msg.PROC_SUCCESS.format(proc=_PROC))
return True
def set_project_data(args: Namespace) -> bool:
assert isinstance(args, Namespace)
assert has_cmd_of(args, CmdType.SET)
logger.debug(msg.PROC_START.format(proc=PROC))
if not _is_enable_setelm(args):
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"set element type in {PROC}"))
return False
elm = _setelm_from(args)
is_succeeded = False
if SetElmType.EDITOR is elm:
is_succeeded = set_editor()
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"set element type in {PROC}"))
if not is_succeeded:
logger.error(msg.ERR_FAIL_SUBPROCESS.format(proc=f"in {PROC}"))
return False
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return True
def scene_item_of(record: StoryRecord, item: SceneItem) -> str:
assert isinstance(record, StoryRecord)
assert isinstance(item, SceneItem)
if str(item) in record.data:
return record.data[str(item)]
else:
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"scene item in {PROC}"))
return ""
def _base_data_from(actions_data: ActionsData) -> list:
assert isinstance(actions_data, ActionsData)
_PROC = f"{PROC}: base data"
logger.debug(msg.PROC_START.format(proc=_PROC))
tmp = []
cache = SceneInfo()
for record in actions_data.get_data():
assert isinstance(record, ActionRecord)
if ActType.DATA is record.type:
if record.subtype in TITLE_ACTIONS:
tmp.append(_record_as_title_from(record))
elif ActDataType.SCENE_CAMERA is record.subtype:
cache.camera = record.subject
elif ActDataType.SCENE_STAGE is record.subtype:
cache.stage = record.subject
elif ActDataType.SCENE_YEAR is record.subtype:
cache.year = record.subject
elif ActDataType.SCENE_DATE is record.subtype:
cache.date = record.subject
elif ActDataType.SCENE_TIME is record.subtype:
cache.time = record.subject
elif ActDataType.SCENE_START is record.subtype:
tmp.append(_record_as_scene_head_from(cache.cloned()))
elif ActDataType.SCENE_END is record.subtype:
tmp.append(_get_record_as_scene_end())
cache.reset()
elif ActDataType.COMMENT is record.subtype:
tmp.append(_record_as_comment_from(record))
elif ActDataType.FORESHADOW is record.subtype:
tmp.append(_record_as_foreshadow_from(record))
elif ActDataType.PAYOFF is record.subtype:
tmp.append(_record_as_payoff_from(record))
elif record.subtype in [ActDataType.BR,
ActDataType.PARAGRAPH_START,
ActDataType.PARAGRAPH_END,
ActDataType.INSTRUCTION]:
continue
elif ActDataType.TEXT is record.subtype:
continue
else:
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"act data type in {PROC}"))
continue
elif record.type in NORMAL_ACTIONS:
tmp.append(_record_as_action_from(record))
elif ActType.NONE is record.type:
continue
elif ActType.SAME is record.type:
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"same act type in {PROC}"))
continue
else:
continue
logger.debug(msg.PROC_SUCCESS.format(proc=_PROC))
return tmp
def _safe_get_elm_item_of(record: StoryRecord, item_table: dict) -> Any:
assert isinstance(record, StoryRecord)
assert isinstance(item_table, dict)
key = str(item_table[record.type])
if key in record.data:
return record.data[key]
else:
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"{key} data in {PROC}"))
return ""
def _base_structs_data_from(actions_data: ActionsData) -> list:
assert isinstance(actions_data, ActionsData)
tmp = []
cache = SceneInfo()
for record in actions_data.get_data():
assert isinstance(record, ActionRecord)
if record.type is ActType.DATA:
if record.subtype in TITLE_ACTIONS:
tmp.append(_record_as_title_from(record))
elif ActDataType.SCENE_START is record.subtype:
tmp.append(_record_as_scene_data_from(cache))
elif ActDataType.SCENE_END is record.subtype:
tmp.append(_get_record_as_scene_end())
cache.reset()
elif ActDataType.SCENE_CAMERA is record.subtype:
cache.camera = record.subject
elif ActDataType.SCENE_STAGE is record.subtype:
cache.stage = record.subject
elif ActDataType.SCENE_YEAR is record.subtype:
cache.year = record.subject
elif ActDataType.SCENE_DATE is record.subtype:
cache.date = record.subject
elif ActDataType.SCENE_TIME is record.subtype:
cache.time = record.subject
elif ActDataType.COMMENT is record.subtype:
tmp.append(_record_as_comment_from(record))
elif ActDataType.TEXT is record.subtype:
tmp.append(_record_as_text_from(record))
elif record.subtype in [
ActDataType.BR,
ActDataType.FORESHADOW,
ActDataType.PAYOFF,
ActDataType.PARAGRAPH_START,
ActDataType.PARAGRAPH_END,
]:
continue
else:
logger.warning(
msg.ERR_FAIL_UNKNOWN_DATA.format(
data=f"act data sub type in {PROC}"))
continue
elif record.type in NORMAL_ACTIONS:
tmp.append(_record_as_action_from(record))
elif record.type in [ActType.NONE, ActType.SAME]:
# NOTE: SE?
continue
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(data=f"act type in {PROC}"))
continue
return tmp
def _get_renamed_name(elm: ElmType) -> str:
assert isinstance(elm, ElmType)
_fname = new_filename_by_input(str(elm))
if is_duplicated_path_in_dir(elm, _fname):
logger.warning(
msg.ERR_FAIL_DUPLICATED_DATA.format(
data=f"new name for renaming in {PROC}"))
return ""
return _fname
def person_item_of(fname: str, item: PersonItem) -> Any:
assert isinstance(fname, str)
assert isinstance(item, PersonItem)
data = read_markdown_data_as_yaml(
read_file(filepath_of(ElmType.PERSON, fname)))
if str(item) in data:
return data[str(item)]
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(data=f"{item} in {PROC}"))
return ""
def _get_new_filename(elm: ElmType, fname: str) -> str:
assert isinstance(elm, ElmType)
_fname = assertion.is_str(fname) if fname else new_filename_by_input(
str(elm))
if is_duplicated_path_in_dir(elm, _fname):
logger.warning(
msg.ERR_FAIL_DUPLICATED_DATA_WITH_DATA.format(
data=f"new filename in {PROC}"), _fname)
return ""
return _fname
def _get_edit_filename(elm: ElmType, fname: str) -> str:
assert isinstance(elm, ElmType)
filenames = filepaths_by_elm(elm)
_fname = assertion.is_str(fname) if fname else get_target_filename_from_list(f"edit {str(elm)}", filenames)
if not is_duplicated_path_in_dir(elm, _fname):
logger.warning(
msg.ERR_FAIL_MISSING_DATA_WITH_DATA.format(data=f"edit filename in {PROC}"),
_fname)
return ""
return _fname
def get_basefile_data(elm: ElmType) -> dict:
assert isinstance(elm, ElmType)
if not elm in BASE_FILES:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(data=f"element type in {PROC}"))
return {}
data = read_file(filepath_of(elm, ''))
if EXT_TABLE[elm] is MARKDOWN_EXT:
return read_markdown_data_as_yaml(data)
else:
return read_yaml_data(data)
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 elm_from_ordername(ordername: str) -> ElmType:
assert isinstance(ordername, str)
if str(OrderItem.BOOK) in ordername:
return ElmType.BOOK
elif str(OrderItem.CHAPTER) in ordername:
return ElmType.CHAPTER
elif str(OrderItem.EPISODE) in ordername:
return ElmType.EPISODE
elif str(OrderItem.SCENE) in ordername:
return ElmType.SCENE
else:
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"in {PROC}"))
return ElmType.NONE
def _base_novels_data_from(actions_data: ActionsData) -> list:
assert isinstance(actions_data, ActionsData)
tmp = []
for record in actions_data.get_data():
assert isinstance(record, ActionRecord)
if ActType.DATA is record.type:
if record.subtype in TITLE_ACTIONS:
tmp.append(_record_as_title_from(record))
elif ActDataType.SCENE_START is record.subtype:
tmp.append(_get_record_as_br())
elif ActDataType.SCENE_END is record.subtype:
tmp.append(_get_record_as_br())
elif ActDataType.COMMENT is record.subtype:
tmp.append(_record_as_comment_from(record))
elif ActDataType.BR is record.subtype:
tmp.append(_get_record_as_br())
elif ActDataType.PARAGRAPH_START is record.subtype:
tmp.append(_get_record_as_paragraph_start())
elif ActDataType.PARAGRAPH_END is record.subtype:
tmp.append(_get_record_as_paragraph_end())
elif ActDataType.TEXT is record.subtype:
tmp.append(_record_as_description_from(record))
elif record.subtype in SCENE_DATAS:
# NOTE: 何か利用する場合はここでキャッシュ
continue
elif record.subtype in [
ActDataType.FORESHADOW, ActDataType.PAYOFF
]:
continue
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format(
data=f"act data type in {PROC}"), record.subtype)
continue
elif record.type in NORMAL_ACTIONS:
if ActType.TALK is record.type:
tmp.append(_record_as_dialogue_from(record))
else:
tmp.append(_record_as_description_from(record))
elif record.type in [ActType.NONE, ActType.SAME]:
continue
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(data=f"act type in {PROC}"))
continue
return tmp
def _title_from(record: ActionRecord) -> InfoType:
assert isinstance(record, ActionRecord)
if ActDataType.BOOK_TITLE is record.subtype:
return InfoType.TITLE_BOOK
elif ActDataType.CHAPTER_TITLE is record.subtype:
return InfoType.TITLE_CHAPTER
elif ActDataType.EPISODE_TITLE is record.subtype:
return InfoType.TITLE_EPISODE
elif ActDataType.SCENE_TITLE is record.subtype:
return InfoType.TITLE_SCENE
elif ActDataType.SCENE_HEAD is record.subtype:
return InfoType.TITLE_TEXT
else:
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"title data type in {PROC}"))
return InfoType.NONE
def _get_push_parent_filename(elm: ElmType) -> str:
assert isinstance(elm, ElmType)
parent_elm = get_elm_from_order(get_parent_item_of(orderitem_of(elm)))
ordernames = [
rid_prefix(orderitem_of(parent_elm), name)
for name in get_filenames_in_order_by_elm(parent_elm)
]
_fname = get_target_filename_from_list("parent name", ordernames)
if not is_duplicated_path_in_dir(parent_elm, _fname):
logger.warning(
msg.ERR_FAIL_MISSING_DATA_WITH_DATA.format(
data=f"parent filename in {PROC}"), _fname)
return ""
return _fname
def _get_reject_filename(elm: ElmType, fname: str) -> str:
assert isinstance(elm, ElmType)
ordernames = [
rid_prefix(orderitem_of(elm), name)
for name in get_filenames_in_order_by_elm(elm)
]
_fname = assertion.is_str(
fname) if fname else get_target_filename_from_list(
f"reject {str(elm)}", ordernames)
if not is_duplicated_path_in_dir(elm, _fname):
logger.warning(
msg.ERR_FAIL_CANNOT_WRITE_DATA_WITH_DATA.format(
data=f"reject filename in {PROC}"), _fname)
return ""
return _fname
def conv_base_action_data_from(story_data: StoryData) -> ActionsData:
assert isinstance(story_data, StoryData)
tmp = []
for record in story_data.get_data():
assert isinstance(record, StoryRecord)
if record.type in TOP_LEVEL_ELMS:
tmp.append(_record_as_title_from(record))
elif record.type is ElmType.SCENE:
tmp.extend(_conv_action_records_on_scene_from(record))
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"element type in {PROC}"))
continue
return ActionsData(tmp)
def _record_as_title_from(record: ScriptRecord) -> str:
assert isinstance(record, ScriptRecord)
if ScriptType.TITLE_BOOK is record.type:
return f"# {record.subject}"
elif ScriptType.TITLE_CHAPTER is record.type:
return f"## {record.subject}"
elif ScriptType.TITLE_EPISODE is record.type:
return f"### {record.subject}"
elif ScriptType.TITLE_SCENE is record.type:
return f"** {record.subject} **"
elif ScriptType.TITLE_TEXT is record.type:
return f"[{record.subject}]"
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"script type title in {PROC}"))
return ""
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 _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 _get_plot_item_of(record: StoryRecord, item: PlotItem) -> str:
assert isinstance(record, StoryRecord)
assert isinstance(item, PlotItem)
data = assertion.is_dict(elm_plot_of(record))
if not data:
logger.warning(
msg.ERR_FAIL_MISSING_DATA.format(data=f"plot data in {PROC}"))
return ""
key = str(item)
if key not in data:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"{key} of record in {PROC}"))
return ""
return data[key]
def _get_push_filename(elm: ElmType, fname: str) -> str:
assert isinstance(elm, ElmType)
filenames = [basename_of(name) for name in filepaths_by_elm(elm)]
ordernames = [
rid_prefix(orderitem_of(elm), name)
for name in get_filenames_in_order_by_elm(elm)
]
_fname = assertion.is_str(
fname) if fname else get_target_filename_from_list(
f"push {str(elm)}", list(set(filenames) - set(ordernames)))
if not is_duplicated_path_in_dir(elm, _fname):
logger.warning(
msg.ERR_FAIL_MISSING_DATA_WITH_DATA.format(
data=f"push filename in {PROC}"), _fname)
return ""
return _fname
def _record_as_title_from(record: StructRecord, index: HeadIndex) -> str:
assert isinstance(record, StructRecord)
assert isinstance(index, HeadIndex)
if StructType.TITLE_BOOK is record.type:
return f"# {record.subject}"
elif StructType.TITLE_CHAPTER is record.type:
return f"## {record.subject}"
elif StructType.TITLE_EPISODE is record.type:
return f"### {record.subject}"
elif StructType.TITLE_SCENE is record.type:
return f"#### {index.chapter}.{index.episode}.{index.scene} {record.subject}"
elif StructType.TITLE_TEXT is record.type:
return f"[{record.subject}]"
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"struct type title in {PROC}"))
return ""
def actions_data_apply_instructions(actions_data: ActionsData,
tags: dict) -> ActionsData:
assert isinstance(actions_data, ActionsData)
assert isinstance(tags, dict)
logger.debug(msg.PROC_START.format(proc=PROC))
tmp = []
alias = {}
# TODO: パラグラフはパラグラフのActDataTypeで制御し、インデントやBRはここでは命令分以外は入れない
for record in actions_data.get_data():
assert isinstance(record, ActionRecord)
if ActDataType.INSTRUCTION is record.subtype:
if record.subject in INST_PARAGRAPH_START:
tmp.append(_get_record_as_paragraph_start())
elif record.subject in INST_PARAGRAPH_END:
tmp.append(_get_record_as_paragraph_end())
elif record.subject in INST_BREAK:
tmp.append(_get_record_as_br())
elif record.subject in INST_ALIAS:
short, origin = record.outline.split('=')
alias[short] = origin
elif record.subject in INST_FORESHADOW:
tmp.append(_record_as_foreshadow_from(record, tags))
elif record.subject in INST_PAYOFF:
tmp.append(_record_as_payoff_from(record, tags))
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"instruction type in {PROC}"))
continue
elif ActDataType.SCENE_START is record.subtype:
alias = {}
tmp.append(record)
elif record.type in NORMAL_ACTIONS:
tmp.append(_conv_shorter_by_alias(record, alias))
else:
tmp.append(record)
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return ActionsData(tmp)
def infos_data_from(actions_data: ActionsData, tags: dict) -> InfosData:
assert isinstance(actions_data, ActionsData)
assert isinstance(tags, dict)
logger.debug(msg.PROC_START.format(proc=PROC))
base_data = _base_data_from(actions_data)
updated = update_data_tags(base_data, tags)
data_set = _get_info_data_set(updated)
if not data_set or not data_set.has_data():
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"data set in {PROC}"))
return None
eliminated = _eliminate_empty_records(data_set)
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return eliminated
def _get_status_info_data_set(infos_data: InfosData) -> InfosData:
assert isinstance(infos_data, InfosData)
_PROC = f"{PROC}: status info set"
logger.debug(msg.PROC_START.format(proc=_PROC))
persons = person_status_info_from(infos_data)
if not persons or not persons.has_data():
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"persons status data in {_PROC}"))
return None
stages = stage_status_info_from(infos_data)
if not stages or not stages.has_data():
logger.warning(msg.ERR_FAIL_INVALID_DATA.format(data=f"stages status data in {_PROC}"))
return None
data_set = persons + stages
logger.debug(msg.PROC_SUCCESS.format(proc=_PROC))
return data_set
def update_story_data_if_same_or_next_tag(story_data: StoryData) -> StoryData:
assert isinstance(story_data, StoryData)
tmp = []
cache = None
for record in story_data.get_data():
assert isinstance(record, StoryRecord)
if record.type in TOP_LEVEL_ELMS:
tmp.append(record)
elif record.type is ElmType.SCENE:
ret = _copy_and_change_scene_data_if_same_or_next(record, cache)
tmp.append(ret)
cache = ret
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"element type in {PROC}"))
continue
return StoryData(tmp)
def _conv_action_record_from(line: str) -> ActionRecord:
assert isinstance(line, str)
record = rid_rn(line)
if record in LINE_EMPTY:
return None
elif record.startswith(LINE_COMMENT):
return _record_as_comment_from(record)
elif record.startswith(LINE_HEAD):
return _record_as_head_from(record)
elif record.startswith(LINE_INSTRUCTION):
return _record_as_instruction_from(record)
elif record.startswith(LINE_ACTION):
return _record_as_action_from(record)
elif record:
return _record_as_text_from(record)
else:
logger.warning(
msg.ERR_FAIL_INVALID_DATA.format(data=f"action line in {PROC}"))
return None
def update_actions_data_if_same(actions_data: ActionsData) -> ActionsData:
assert isinstance(actions_data, ActionsData)
tmp = []
cache = None
for record in actions_data.get_data():
assert isinstance(record, ActionRecord)
if record.type in [ActType.DATA, ActType.NONE]:
tmp.append(record)
elif record.type in NORMAL_ACTIONS + [
ActType.SAME,
]:
ret = _copy_action_record_if_same(record, cache)
if ret:
tmp.append(ret)
cache = ret
else:
logger.warning(
msg.ERR_FAIL_UNKNOWN_DATA.format(data=f"act type in {PROC}"))
continue
return ActionsData(tmp)
