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 _reject_file(elm: ElmType, fname: str) -> bool:
assert isinstance(elm, ElmType)
assert isinstance(fname, str)
updated = remove_item_order_data(orderitem_of(elm), fname)
if not write_order_data(updated):
logger.error(
msg.ERR_FAIL_SUBPROCESS.format(proc=f"write order data in {PROC}"))
return False
return True
def _get_new_editorname(name: str) -> str:
assert isinstance(name, str)
_name = input(f"> Please Enter changing new editor name from '{name}': ")
if not _name:
logger.error(
msg.ERR_FAIL_MISSING_DATA.format(
data=f"new editor name in {PROC}"))
return ""
return _name
def write_order_data(orderdata: dict) -> bool:
assert isinstance(orderdata, dict)
assert str(OrderItem.BOOK) in orderdata
if not write_file(filepath_of(ElmType.ORDER, ''),
yaml.safe_dump(orderdata)):
logger.error(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(
data=f"order data in {PROC}"))
return False
return True
def _edit_file(elm: ElmType, fname: str) -> bool:
assert isinstance(elm, ElmType)
assert isinstance(fname, str)
editor = _get_editor()
path = filepath_of(elm, fname)
proc = subprocess.run([editor, path])
if proc.returncode != 0:
logger.error(msg.ERR_FAIL_SUBPROCESS.format(proc=f"edit file in {PROC}"))
return True
def check_and_create_directories() -> bool:
_PROC = f"{PROC}: check and create dirs"
logger.debug(msg.PROC_START.format(proc=_PROC))
for elm, dirpath in DIRS_TABLE.items():
if dirpath:
if not _safe_create_directory(dirpath_of(elm)):
logger.error(msg.ERR_FAIL_CANNOT_CREATE_DATA.format(data=f"{dirpath} in {_PROC}"))
return False
logger.debug(msg.PROC_SUCCESS.format(proc=_PROC))
return True
def _is_valid_args(args: Namespace) -> bool:
assert isinstance(args, Namespace)
if not args.cmd:
logger.error(msg.ERR_FAIL_MISSING_DATA.format(data=f"command in {PROC}"))
return False
if not args.elm:
logger.error(msg.ERR_FAIL_MISSING_DATA.format(data=f"command args in {PROC}"))
return False
return True
def write_project_data(item: ProjectItem, val: str) -> bool:
assert isinstance(item, ProjectItem)
assert isinstance(val, str)
data = _get_project_raw_data()
if str(item) in data[PROJECT]:
data[PROJECT][str(item)] = val
if not write_file(filepath_of(ElmType.PROJECT, ''), yaml.safe_dump(data)):
logger.error(msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"project data in {PROC}"))
return False
return True
def push_story_source(args: Namespace) -> bool:
assert isinstance(args, Namespace)
assert has_cmd_of(args, CmdType.PUSH)
logger.debug(msg.PROC_START.format(proc=PROC))
if not is_enable_elm_in(args, ENABLE_ELMS):
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"element type in {PROC}"))
return False
elm = elm_from(args)
fname = _get_push_filename(elm, args.option)
if not fname:
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"push filename in {PROC}"))
return False
parent = 'book'
if ElmType.CHAPTER is not elm:
parent = _get_push_parent_filename(elm)
if not parent:
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"push parent filename in {PROC}"))
return False
if not _push_file(elm, fname, parent):
logger.error(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(data=f"push file in {PROC}"))
return False
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return True
def rename_story_source(args: Namespace) -> bool:
assert isinstance(args, Namespace)
assert has_cmd_of(args, CmdType.RENAME)
logger.debug(msg.PROC_START.format(proc=PROC))
if not is_enable_elm_in(args, ENABLE_ELMS):
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"element type in {PROC}"))
return False
elm = elm_from(args)
fname = _get_rename_filename(elm, args.option)
if not fname:
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"delete filename in {PROC}"))
return False
newname = _get_renamed_name(elm)
if not newname:
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"rename name in {PROC}"))
return False
if not _rename_file(elm, fname, newname):
logger.error(
msg.ERR_FAIL_CANNOT_REMOVE_DATA.format(
data=f"rename file in {PROC}"))
return False
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return True
def serialized_filenames_from_order(order_data: dict, ch_start: int,
ch_end: int, ep_start: int, ep_end: int,
sc_start: int, sc_end: int) -> list:
assert isinstance(order_data, dict)
assert isinstance(ch_start, int)
assert isinstance(ch_end, int)
assert isinstance(ep_start, int)
assert isinstance(ep_end, int)
assert isinstance(sc_start, int)
assert isinstance(sc_end, int)
logger.debug(msg.PROC_START.format(proc=PROC))
if not _is_valid_order_data(order_data):
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(proc=f"order data: {PROC}"))
return []
tmp = []
ch_idx, ep_idx, sc_idx = 0, 0, 0
for ch_record in assertion.is_list(order_data[str(OrderItem.BOOK)]):
# in Chapter
if ch_idx >= ch_start and (ch_idx <= ch_end or ch_end < 0):
assert isinstance(ch_record, dict)
for key in ch_record.keys():
tmp.append(key)
# in Episode
for ch_data in ch_record.values():
assert isinstance(ch_data, list)
for ep_record in ch_data:
if ep_idx >= ep_start and (ep_idx <= ep_end or ep_end < 0):
assert isinstance(ep_record, dict)
for key in ep_record.keys():
tmp.append(key)
# in Scene
for ep_data in ep_record.values():
assert isinstance(ep_data, list)
for sc_record in ep_data:
if sc_idx >= sc_start and (sc_idx <= sc_end
or sc_end < 0):
assert isinstance(sc_record, str)
tmp.append(sc_record)
sc_idx += 1
ep_idx += 1
ch_idx += 1
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return tmp
def set_editor() -> bool:
name = project_item_of(ProjectItem.EDITOR)
newname = _get_new_editorname(name)
if not newname:
logger.error(msg.ERR_FAIL_INVALID_DATA.format(data=f"in {PROC}"))
return False
if not write_project_data(ProjectItem.EDITOR, newname):
logger.error(
msg.ERR_FAIL_CANNOT_WRITE_DATA.format(
data=f"new editor name in {PROC}"))
return False
return True
def init_project(args: Namespace) -> bool:
assert isinstance(args, Namespace)
assert has_cmd_of(args, CmdType.INIT)
logger.debug(msg.PROC_START.format(proc=PROC))
if not check_and_create_directories():
logger.error(msg.ERR_FAIL_SUBPROCESS.format(proc=f"check and create dirs in {PROC}"))
return False
if not check_and_create_default_files():
logger.error(msg.ERR_FAIL_SUBPROCESS.format(proc=f"check and create files in {PROC}"))
return False
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return True
def _rename_file(elm: ElmType, fname: str, newname: str) -> bool:
assert isinstance(elm, ElmType)
assert isinstance(fname, str)
assert isinstance(newname, str)
path = filepath_of(elm, fname)
newpath = filepath_of(elm, newname)
if newpath != path:
os.rename(path, newpath)
return True
else:
logger.error(
msg.ERR_FAIL_INVALID_DATA_WITH_DATA.format(
data=f"rename file in {PROC}"), newpath)
return False
def outputs_data_from_plots_data(plots_data: PlotsData,
tags: dict) -> OutputsData:
assert isinstance(plots_data, PlotsData)
assert isinstance(tags, dict)
_PROC = f"{PROC}: convert outputs data"
logger.debug(msg.PROC_START.format(proc=_PROC))
formatted = format_plots_data(plots_data)
if not formatted:
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"outputs data in {PROC}"))
return None
translated = translate_tags_text_list(formatted, tags)
logger.debug(msg.PROC_SUCCESS.format(proc=_PROC))
return OutputsData(translated)
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"commandline args in {PROC}"))
return os.EX_NOINPUT
if has_cmd_of(args, CmdType.INIT):
if not init_project(args):
logger.error(msg.ERR_FAIL_CANNOT_INITIALIZE.format(data='project'))
return os.EX_SOFTWARE
return os.EX_OK
is_succeeded = False
if has_cmd_of(args, CmdType.BUILD):
is_succeeded = build_project(args)
elif has_cmd_of(args, CmdType.NONE) or has_cmd_of(args, CmdType.INIT):
is_succeeded = True
else:
if not _is_valid_args(args):
return os.EX_NOINPUT
if has_cmd_of(args, CmdType.ADD):
is_succeeded = add_story_source(args)
elif has_cmd_of(args, CmdType.COPY):
is_succeeded = copy_story_source(args)
elif has_cmd_of(args, CmdType.DELETE):
is_succeeded = delete_story_source(args)
elif has_cmd_of(args, CmdType.EDIT):
is_succeeded = edit_story_source(args)
elif has_cmd_of(args, CmdType.LIST):
is_succeeded = show_list_of_story_sources(args)
elif has_cmd_of(args, CmdType.PUSH):
is_succeeded = push_story_source(args)
elif has_cmd_of(args, CmdType.REJECT):
is_succeeded = reject_story_source(args)
elif has_cmd_of(args, CmdType.RENAME):
is_succeeded = rename_story_source(args)
elif has_cmd_of(args, CmdType.SET):
is_succeeded = set_project_data(args)
else:
logger.error(msg.ERR_FAIL_INVALID_DATA.format(data=f"command type in {PROC}"))
if not is_succeeded:
logger.error(msg.ERR_FAILED_PROC.format(proc=PROC))
return os.EX_SOFTWARE
logger.debug(msg.PROC_DONE.format(proc=PROC))
return os.EX_OK
def contents_data_from(story_data: StoryData, tags: dict) -> ContentsData:
assert isinstance(story_data, StoryData)
assert isinstance(tags, dict)
logger.debug(msg.PROC_START.format(proc=PROC))
contents = _contents_data_from(story_data)
if not contents or not contents.has_data():
logger.error(
msg.ERR_FAIL_SUBPROCESS.format(proc=f"contents data in {PROC}"))
return None
translated = _translate_contents_data(contents, tags)
if not translated or not translated.has_data():
logger.error(
msg.ERR_FAIL_SUBPROCESS.format(proc=f"translate data in {PROC}"))
return None
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return translated
def add_story_source(args: Namespace) -> bool:
assert isinstance(args, Namespace)
assert has_cmd_of(args, CmdType.ADD)
logger.debug(msg.PROC_START.format(proc=PROC))
if not is_enable_elm_in(args, ENABLE_ELMS):
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"element type in {PROC}"))
return False
elm = elm_from(args)
fname = _get_new_filename(elm, args.option)
if not fname:
logger.error(msg.ERR_FAIL_INVALID_DATA)
return False
path = filepath_of(elm, fname)
data = get_template_data(elm)
if not write_file(path, data):
logger.error(
msg.ERR_FAIL_CANNOT_CREATE_DATA.format(
data=f"new {elm} file in {PROC}"))
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return True
def actions_data_from(story_data: StoryData, tags: dict) -> ActionsData:
assert isinstance(story_data, StoryData)
assert isinstance(tags, dict)
logger.debug(msg.PROC_START.format(proc=PROC))
actions = conv_base_action_data_from(story_data)
if not actions:
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"base action data in {PROC}"))
return None
updated = update_actions_data_if_same(actions)
if not updated or not updated.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"update action data in {PROC}"))
return None
applied = actions_data_apply_instructions(updated, tags)
if not applied or not isinstance(applied,
ActionsData) or not applied.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"apply action data in {PROC}"))
return None
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return applied
def plots_data_from(story_data: StoryData) -> PlotsData:
assert isinstance(story_data, StoryData)
tmp = []
for record in story_data.get_data():
assert isinstance(record, StoryRecord)
ret = _conv_plot_record(record)
if ret:
tmp.append(ret)
if not tmp:
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"plots data in {PROC}"))
return None
reordered = _reorder_plots_data(PlotsData(tmp))
if not reordered or not reordered.has_data():
logger.error(
msg.ERR_FAILED_PROC.format(proc=f"reorder data in {PROC}"))
return None
return reordered
def _conv_plot_char_counts(story_data: StoryData, tags: dict, columns: int,
rows: int) -> OutputsData:
assert isinstance(story_data, StoryData)
assert isinstance(tags, dict)
assert isinstance(columns, int)
assert isinstance(rows, int)
plots = plots_data_from(story_data)
formatted = outputs_data_from_plots_data(plots, tags)
plot_counts = counts_data_from(BuildType.PLOT, formatted, columns, rows)
if not plot_counts or not plot_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"plots count in {PROC}"))
return None
char_counts = OutputsData(format_plots_charcounts_data(plot_counts))
if not char_counts or not char_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"plots char count in {PROC}"))
return None
return char_counts
def _conv_novel_char_counts(actions_data: ActionsData, tags: dict,
columns: int, rows: int) -> OutputsData:
assert isinstance(actions_data, ActionsData)
assert isinstance(tags, dict)
assert isinstance(columns, int)
assert isinstance(rows, int)
novels = novels_data_from(actions_data, tags)
formatted = outputs_data_from_novels_data(novels, tags)
novel_counts = counts_data_from(BuildType.NOVEL, formatted, columns, rows)
if not novel_counts or not novel_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(data=f"novels count in {PROC}"))
return None
char_counts = OutputsData(format_novels_charcounts_data(novel_counts))
if not char_counts or not char_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"novels char count in {PROC}"))
return None
return char_counts
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 edit_story_source(args: Namespace) -> bool:
assert isinstance(args, Namespace)
assert has_cmd_of(args, CmdType.EDIT)
logger.debug(msg.PROC_START.format(proc=PROC))
if not is_enable_elm_in(args, ENABLE_ELMS):
logger.error(msg.ERR_FAIL_INVALID_DATA.format(data=f"element type in {PROC}"))
return False
elm = elm_from(args)
fname = _get_edit_filename(elm, args.option)
if not fname:
logger.error(msg.ERR_FAIL_INVALID_DATA.format(data=f"copy filename in {PROC}"))
return False
if not _edit_file(elm, fname):
logger.error(msg.ERR_FAIL_SUBPROCESS.format(proc=f"edit {elm} file in {PROC}"))
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return True
def remove_item_order_data(item: OrderItem, fname: str) -> dict:
assert isinstance(item, OrderItem)
assert isinstance(fname, str)
data = assertion.is_dict(_get_order_raw_data())
_fname = ordername_of(item, fname)
if OrderItem.CHAPTER is item:
if not _reject_chapter_from_order(data, _fname):
logger.error(
msg.ERR_FAIL_CANNOT_REMOVE_DATA.format(data=f"in {PROC}"))
return data
elif OrderItem.EPISODE is item:
if not _reject_episode_from_order(data, _fname):
logger.error(
msg.ERR_FAIL_CANNOT_REMOVE_DATA.format(data=f"in {PROC}"))
return data
elif OrderItem.SCENE is item:
if not _reject_scene_from_order(data, _fname):
logger.error(
msg.ERR_FAIL_CANNOT_REMOVE_DATA.format(data=f"in {PROC}"))
return data
else:
return data
def base_info_outputs_data_from(args: Namespace, story_data: StoryData,
actions_data: ActionsData,
tags: dict) -> OutputsData:
assert isinstance(args, Namespace)
assert isinstance(story_data, StoryData)
assert isinstance(actions_data, ActionsData)
logger.debug(msg.PROC_START.format(proc=PROC))
tmp = _get_base_info_title()
columns, rows = _get_columns_rows()
if has_build_of(args, BuildType.OUTLINE):
char_counts = _conv_outline_char_counts(story_data, tags, columns,
rows)
if not char_counts or not char_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"outlines char count in {PROC}"))
return None
tmp += char_counts
if has_build_of(args, BuildType.PLOT):
char_counts = _conv_plot_char_counts(story_data, tags, columns, rows)
if not char_counts or not char_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"plots char count in {PROC}"))
return None
tmp += char_counts
if has_build_of(args, BuildType.STRUCT):
char_counts = _conv_struct_char_counts(actions_data, tags, columns,
rows)
if not char_counts or not char_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"structs char count in {PROC}"))
return None
tmp += char_counts
if has_build_of(args, BuildType.SCRIPT):
char_counts = _conv_script_char_counts(actions_data, tags, columns,
rows)
if not char_counts or not char_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"scripts char count in {PROC}"))
return None
tmp += char_counts
if has_build_of(args, BuildType.NOVEL):
char_counts = _conv_novel_char_counts(actions_data, tags, columns,
rows)
if not char_counts or not char_counts.has_data():
logger.error(
msg.ERR_FAIL_INVALID_DATA.format(
data=f"novels char count in {PROC}"))
return None
tmp += char_counts
logger.debug(msg.PROC_SUCCESS.format(proc=PROC))
return tmp
