def process_save_file(self, save_file_name):
save_data = SaveFile.load(save_file_name)
if not ret.success(save_data):
self.log("ERROR: unable to open save file: " + save_file_name)
return ret.ERROR
#try/catch here for checking data translation?
self.save_file = save_data.name
self.library_file = save_data.library_file
self.book_file = save_data.book_file
self.universe_name = save_data.universe_name
self.series_name = save_data.series_name
self.book_name = save_data.book_name
self.page_start = save_data.page_start
self.library = Library.load(self.library_file)
if not ret.success(self.library):
self.library = Library()
self.library.save(self.library_file)
return ret.SUCCESS
def save_library(self, new_page_start):
self.library.save(self.library_file)
save_file = SaveFile.load(self.save_file)
if not ret.success(save_file):
self.log("Unable to load save file: " + self.save_file)
return ret.ERROR
save_file.page_start = new_page_start
save_file.save()
self.log("Successfully updated library and save file with new scene!")
return ret.SUCCESS
def new_cmd_in():
save_str = request.form['save_box']
cmd_str = request.form['cmd_box']
action, importer = process_cmd(cmd_str, save_str)
if action == ret.HOME:
resp = importer.print_log()
return render_template('index_home.html', cmd_out=resp, cmd_in=cmd_str)
elif action == ret.EDIT_CHAR:
#not supported in modern paradigm yet!
resp = "Not yet supported in modern paradigm!"
return render_template('index_home.html', cmd_out=resp)
"""
character = Character.match_character(series.characters, data)
if character == ret.ERROR:
error_msg = "INTERNAL ERROR:\nValid character name not found after processing"
return render_template('index_home.html', cmd_out=error_msg)
return render_template('index_char_form.html', \
action="edit", \
char_name=character.name, \
char_aliases=character.print_aliases(), \
char_tier=character.tier, \
char_gender=character.gender, \
char_tags=character.print_tags(), \
char_r=character.color["r"], \
char_g=character.color["g"], \
char_b=character.color["b"])
"""
elif action == ret.ADD_CHAR:
#not supported in modern paradigm yet!
resp = "Not yet supported in modern paradigm!"
return render_template('index_home.html', cmd_out=resp)
"""
if Character.match_character(series.characters, data, True) != ret.ERROR:
error_msg = "INTERNAL ERROR:\nCharacter '" + data + "' matched after processing"
return render_template('index_home.html', cmd_out=error_msg)
return render_template('index_char_form.html', action="add", char_name=data)
"""
elif action == ret.GRAPH_TOOL:
return render_template('index_graph_tool.html', x_val='', y_val='')
elif action == ret.TEXT_TOOL:
return render_template('index_text_tool.html', \
save_file=importer.save_file, \
book_file=importer.book_file, \
page_start=importer.page_start, \
known_names=util.join(importer.known_names, "\n"))
elif not ret.success(action):
return render_template('index_home.html',
cmd_out=importer.print_log(),
cmd_in=cmd_str)
error_msg = "INTERNAL ERROR:\nInvalid return from processing"
return render_template('index_home.html', cmd_out=error_msg)
def print_info(self):
out = "<b>(Scene) " + self.name + "</b>\n"
per_str = ""
for p in self.perspectives:
per_str += p.name + ", "
per_str = per_str.rstrip(", ")
#NOTE: not using locations until universe update
loc_str = ""
for l in self.locations:
loc_str += l.name + ", "
loc_str = loc_str.rstrip(", ")
out += "Perspectives: " + per_str + "; Words: " + str(self.wordcount) + "\n"
out += "Description: " + self.description + "\n"
featured_char_strs = []
mentioned_char_strs = []
for i in self.included:
inc_str = ""
character = i["character"]
new_str = "(New) " if ret.success(character.intro_scene()) and character.intro_scene() == self else ""
inc_str += new_str + character.name + "; Words: " + str(i["quotes"]) + ", Calls: " + str(i["mentions"]) + "\n"
for a in character.aliases:
if a[1] == self:
inc_str += "--New Alias: " + a[0] + "\n"
for j in character.joins:
if j[1] == self:
inc_str += "--New Join: " + j[0].name + "\n"
for t in character.tags:
if t[1] == self:
inc_str += "--New Tag: " + t[0] + "\n"
if i["featured"]:
featured_char_strs.append(inc_str)
else:
mentioned_char_strs.append(inc_str)
if len(featured_char_strs) > 0:
out += "<u>Featured:</u>\n"
for fcs in featured_char_strs:
out += fcs
if len(mentioned_char_strs) > 0:
out += "<u>Mentioned:</u>\n"
for mcs in mentioned_char_strs:
out += mcs
return out
def get_book(self, bo_name):
book = Book.match(self.books, bo_name)
if not ret.success(book):
book = Book(bo_name, len(self.books)+1)
self.books.append(book)
return book
def process_cmd(cmd_str, save_str):
importer = SceneImporter()
cmd_parts = util.split(cmd_str, '=')
if len(cmd_parts) < 1:
importer.log("No command entry in: " + cmd_str)
return ret.ERROR, importer
status = importer.process_save_file(save_str)
if not ret.success(status):
importer.log("Unable to import save file: " + save_str)
return ret.ERROR, importer
#disp_char
if cmd_parts[0] == 'disp_char':
if len(cmd_parts) < 2:
importer.log("No character name provided in: " + cmd_str)
return ret.BAD_INPUT, importer
universe = importer.library.get_universe(importer.universe_name)
if cmd_parts[1] == "all":
for c in universe.characters:
importer.log(c.print_info())
return ret.HOME, importer
character = Character.match(universe.characters, cmd_parts[1])
#and now this is where loose is needed (future TODO)
if not ret.success(character):
importer.log("Unable to match character: " + cmd_parts[1])
return ret.ERROR, importer
importer.log(character.print_info())
return ret.HOME, importer
#disp_chapter
if cmd_parts[0] == 'disp_chapter':
if len(cmd_parts) < 2:
importer.log("No chapter name provided in: " + cmd_str)
return ret.BAD_INPUT, importer
book = importer.library.get_universe(
importer.universe_name).get_series(importer.series_name).get_book(
importer.book_name)
if cmd_parts[1] == "all":
for c in book.chapters:
importer.log(c.print_info())
for s in c.scenes:
importer.log(s.print_info())
return ret.HOME, importer
chapter = Chapter.match(book.chapters, cmd_parts[1], False)
if not ret.success(chapter):
importer.log("Unable to find chapter: " + cmd_parts[1])
return ret.ERROR, importer
importer.log(chapter.print_info())
for s in chapter.scenes:
importer.log(s.print_info())
return ret.HOME, importer
#disp_book
if cmd_parts[0] == 'disp_book':
book = importer.library.get_universe(
importer.universe_name).get_series(importer.series_name).get_book(
importer.book_name)
importer.log(book.print_info())
return ret.HOME, importer
#disp_save
if cmd_parts[0] == 'disp_save':
save_data = SaveFile.load(importer.save_file)
if not ret.success(save_data):
importer.log("ERROR: unable to open save file: " +
importer.save_file)
return ret.HOME, importer
importer.log(save_data.print_info())
return ret.HOME, importer
#text_tool
if cmd_parts[0] == 'text_tool':
status = importer.generate_known_names()
return ret.TEXT_TOOL, importer
#find_pos
if cmd_parts[0] == 'find_pos':
if len(cmd_parts) < 2:
importer.log("No valid search text provided in: " + cmd_str)
return ret.BAD_INPUT, importer
try:
input = open(importer.book_file, 'r')
book_text = input.read()
except:
importer.log("Failed to read input file")
return ret.BAD_INPUT, importer
position = book_text.find(cmd_parts[1])
if position >= 0:
importer.log("Text Position: " + str(position))
importer.log("Next 100 chars:\n" +
book_text[position:position + 100])
else:
importer.log("Unable to find input string: " + cmd_parts[1])
return ret.HOME, importer
#set_pos
if cmd_parts[0] == "set_pos":
if len(cmd_parts) < 2:
importer.log("No position provided in: " + cmd_str)
return ret.BAD_INPUT, importer
position = int(cmd_parts[1])
save_data = SaveFile.load(importer.save_file)
save_data.page_start = position
save_data.save()
importer.log("Set new save position to: " + str(position))
importer.log(save_data.print_info())
return ret.HOME, importer
#script
if cmd_parts[0] == "script":
importer.script()
return ret.HOME, importer
importer.log("Unsupported command entry: " + cmd_str)
return ret.ERROR, importer
"""
def load(load_file):
save_file = ds.load_pickle(load_file)
if not ret.success(save_file):
return ret.ERROR
return save_file
def process_scene_data(self, ch_form: str, pe_form: str, lo_form: str, de_form: str, \
wo_form: str, me_form: str, qu_form: str, fe_form: str, ce_form: str):
#finding universe, series, book, chapter
universe = self.library.get_universe(self.universe_name)
series = universe.get_series(self.series_name)
book = series.get_book(self.book_name)
chapter = book.get_chapter(ch_form)
#making new scene
scene_placement = len(chapter.scenes) + 1
scene_name = chapter.name.lower().replace(
" ", "_") + "_" + str(scene_placement)
scene = Scene(scene_name, scene_placement, wo_form, de_form)
'''
Removing location tracking for now, until we add universe + locations
scene_locations = util.split(lo_form, "\\n")
for sl in scene_locations:
scene.add_location(Location(sl.strip()))
'''
if chapter.add_scene(scene) == ret.DUPLICATE:
self.log(
"NOTE: Duplicate Information in Chapter. Will not add scene.")
return ret.DUPLICATE
#updating characters with character events
char_events = util.split(ce_form, "\\n")
for ce in char_events:
ce_fields = ce.split(";")
if len(ce_fields) != 4:
self.log("Invalid CE: " + ce)
continue
ce_name = ce_fields[0]
ce_aliases = ce_fields[1].split(",")
ce_joins = ce_fields[2].split(",")
ce_tags = ce_fields[3].split(",")
ce_char = series.get_character(ce_name, scene)
if not ret.success(ce_char):
self.log("Failed to match or make character: " + ce_name)
continue
for ce_a in ce_aliases:
if ce_a == "": continue
ce_char.add_alias(ce_a, scene)
for ce_j in ce_joins:
if ce_j == "": continue
join_character = Character.match(series.characters, ce_j)
if not ret.success(join_character):
self.log("Cannot find Join for CE: " + ce)
continue
ce_char.add_join(ce_j, scene)
for ce_t in ce_tags:
if ce_t == "": continue
ce_char.add_tag(ce_t, scene)
#adding perspectives
perspectives = util.split(pe_form, "\\n")
for p in perspectives:
pe_char = Character.match(series.characters, p)
if not ret.success(pe_char):
self.log("Cannot find character for perspective: " + p)
continue
scene.add_perspective(pe_char)
#populating scene included
#scene quotes
scene_quotes = util.split(qu_form, "\\n")
for sq in scene_quotes:
sq_fields = sq.split(",")
if len(sq_fields) != 2:
self.log("Invalid SQ: " + sq)
continue
sq_name = sq_fields[0]
sq_count = int(sq_fields[1])
sq_char = series.get_character(sq_name, scene)
if not ret.success(sq_char):
self.log("Failed to match or make character: " + sq_name)
continue
found_in_included = False
for i in scene.included:
if i["character"] == sq_char:
i["quotes"] += sq_count
i["featured"] = True
found_in_included = True
if not found_in_included:
scene.included.append({
"character": sq_char,
"featured": True,
"mentions": 0,
"quotes": sq_count
})
#scene features
scene_features = util.split(fe_form, "\\n")
for sf in scene_features:
sf_char = series.get_character(sf, scene)
if not ret.success(sf_char):
self.log("Failed to match or make character: " + sf)
continue
found_in_included = False
for i in scene.included:
if i["character"] == sf_char:
i["featured"] = True
found_in_included = True
if not found_in_included:
scene.included.append({
"character": sf_char,
"featured": True,
"mentions": 0,
"quotes": 0
})
#scene mentions
scene_mentions = util.split(me_form, "\\n")
for sm in scene_mentions:
sm_fields = sm.split(",")
if len(sm_fields) != 2:
self.log("Invalid SM: " + sm)
continue
sm_name = sm_fields[0]
sm_count = int(sm_fields[1])
sm_char = series.get_character(sm_name, scene)
if not ret.success(sm_char):
self.log("Failed to match or make character: " + sm_name)
continue
found_in_included = False
for i in scene.included:
if i["character"] == sm_char:
i["mentions"] += sm_count
found_in_included = True
if not found_in_included:
scene.included.append({
"character": sm_char,
"featured": False,
"mentions": sm_count,
"quotes": 0
})
return ret.SUCCESS
def get_series(self, se_name):
series = Series.match(self.series, se_name)
if not ret.success(series):
series = Series(se_name, len(self.series) + 1)
self.series.append(series)
return series
def get_chapter(self, ch_name):
chapter = Chapter.match(self.chapters, ch_name)
if not ret.success(chapter):
chapter = Chapter(ch_name, len(self.chapters) + 1)
self.chapters.append(chapter)
return chapter
def get_universe(self, uni_name):
universe = Universe.match(self.universes, uni_name)
if not ret.success(universe):
universe = Universe(uni_name)
self.universes.append(universe)
return universe
def load(load_file):
library = ds.load_pickle(load_file)
if not ret.success(library):
return ret.ERROR
return library
