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