#!/usr/bin/env python # --!-- coding: utf8 --!-- # Version 1 of file saving format. # Aims at providing a plain-text way of saving a project # (except for some elements), allowing collaborative work # versioning and third-party editing. import os import re import shutil import string import zipfile from collections import OrderedDict from PyQt5.QtCore import Qt, QModelIndex from PyQt5.QtGui import QColor, QStandardItem from PyQt5.QtWidgets import QListWidgetItem from manuskript import settings from manuskript.enums import Character, World, Plot, PlotStep, Outline from manuskript.functions import mainWindow, iconColor, iconFromColorString from manuskript.converters import HTML2PlainText from lxml import etree as ET from manuskript.load_save.version_0 import loadFilesFromZip from manuskript.models.characterModel import CharacterInfo from manuskript.models import outlineItem from manuskript.ui.listDialog import ListDialog import logging LOGGER = logging.getLogger(__name__) try: import zlib # Used with zipfile for compression compression = zipfile.ZIP_DEFLATED except: compression = zipfile.ZIP_STORED cache = {} characterMap = OrderedDict([ (Character.name, "Name"), (Character.ID, "ID"), (Character.importance, "Importance"), (Character.pov, "POV"), (Character.motivation, "Motivation"), (Character.goal, "Goal"), (Character.conflict, "Conflict"), (Character.epiphany, "Epiphany"), (Character.summarySentence, "Phrase Summary"), (Character.summaryPara, "Paragraph Summary"), (Character.summaryFull, "Full Summary"), (Character.notes, "Notes") ]) def formatMetaData(name, value, tabLength=10): # Multiline formatting if len(value.split("\n")) > 1: value = "\n".join([" " * (tabLength + 1) + l for l in value.split("\n")])[tabLength + 1:] # Avoid empty description (don't know how much MMD loves that) if name == "": name = "None" # Escapes ":" in name name = name.replace(":", "_.._") return "{name}:{spaces}{value}\n".format( name=name, spaces=" " * (tabLength - len(name)), value=value ) def slugify(name): """ A basic slug function, that escapes all spaces to "_" and all non letters/digits to "-". @param name: name to slugify (str) @return: str """ valid = string.ascii_letters + string.digits newName = "" for c in name: if c in valid: newName += c elif c in string.whitespace: newName += "_" else: newName += "-" return newName def saveProject(zip=None): """ Saves the project. If zip is False, the project is saved as a multitude of plain-text files for the most parts and some XML or zip? for settings and stuff. If zip is True, everything is saved as a single zipped file. Easier to carry around, but does not allow collaborative work, versioning, or third-party editing. @param zip: if True, saves as a single file. If False, saves as plain-text. If None, tries to determine based on settings. @return: True if successful, False otherwise. """ if zip == None: zip = settings.saveToZip LOGGER.info("Saving to: %s", "zip" if zip else "folder") # List of files to be written files = [] # List of files to be removed removes = [] # List of files to be moved moves = [] # MainWindow interaction things. mw = mainWindow() project = mw.currentProject # Sanity check (see PR-583): make sure we actually have a current project. if project == None: LOGGER.error("Cannot save project because there is no current project in the UI.") return False # File format version files.append(("MANUSKRIPT", "1")) # General infos (book and author) # Saved in plain text, in infos.txt path = "infos.txt" content = "" for name, col in [ ("Title", 0), ("Subtitle", 1), ("Serie", 2), ("Volume", 3), ("Genre", 4), ("License", 5), ("Author", 6), ("Email", 7), ]: item = mw.mdlFlatData.item(0, col) if item: val = item.text().strip() else: val = "" if val: content += "{name}:{spaces}{value}\n".format( name=name, spaces=" " * (15 - len(name)), value=val ) files.append((path, content)) #################################################################################################################### # Summary # In plain text, in summary.txt path = "summary.txt" content = "" for name, col in [ ("Situation", 0), ("Sentence", 1), ("Paragraph", 2), ("Page", 3), ("Full", 4), ]: item = mw.mdlFlatData.item(1, col) if item: val = item.text().strip() else: val = "" if val: content += formatMetaData(name, val, 12) files.append((path, content)) #################################################################################################################### # Label & Status # In plain text for mdl, path in [ (mw.mdlStatus, "status.txt"), (mw.mdlLabels, "labels.txt") ]: content = "" # We skip the first row, which is empty and transparent for i in range(1, mdl.rowCount()): color = "" if mdl.data(mdl.index(i, 0), Qt.DecorationRole) != None: color = iconColor(mdl.data(mdl.index(i, 0), Qt.DecorationRole)).name(QColor.HexRgb) color = color if color != "#ff000000" else "#00000000" text = mdl.data(mdl.index(i, 0)) if text: content += "{name}{color}\n".format( name=text, color="" if color == "" else ":" + " " * (20 - len(text)) + color ) files.append((path, content)) #################################################################################################################### # Characters # In a character folder path = os.path.join("characters", "{name}.txt") mdl = mw.mdlCharacter # Review characters for c in mdl.characters: # Generates file's content content = "" for m in characterMap: val = mdl.data(c.index(m.value)).strip() if val: content += formatMetaData(characterMap[m], val, 20) # Character's color: content += formatMetaData("Color", c.color().name(QColor.HexRgb), 20) # Character's infos for info in c.infos: content += formatMetaData(info.description, info.value, 20) # generate file's path cpath = path.format(name="{ID}-{slugName}".format( ID=c.ID(), slugName=slugify(c.name()) )) # Has the character been renamed? if c.lastPath and cpath != c.lastPath: moves.append((c.lastPath, cpath)) # Update character's path c.lastPath = cpath files.append((cpath, content)) #################################################################################################################### # Texts # In an outline folder mdl = mw.mdlOutline # Go through the tree f, m, r = exportOutlineItem(mdl.rootItem) files += f moves += m removes += r # Writes revisions (if asked for) if settings.revisions["keep"]: files.append(("revisions.xml", mdl.saveToXML())) #################################################################################################################### # World # Either in an XML file, or in lots of plain texts? # More probably text, since there might be writing done in third-party. path = "world.opml" mdl = mw.mdlWorld root = ET.Element("opml") root.attrib["version"] = "1.0" body = ET.SubElement(root, "body") addWorldItem(body, mdl) content = ET.tostring(root, encoding="UTF-8", xml_declaration=True, pretty_print=True) files.append((path, content)) #################################################################################################################### # Plots (mw.mdlPlots) # Either in XML or lots of plain texts? # More probably XML since there is not really a lot if writing to do (third-party) path = "plots.xml" mdl = mw.mdlPlots root = ET.Element("root") addPlotItem(root, mdl) content = ET.tostring(root, encoding="UTF-8", xml_declaration=True, pretty_print=True) files.append((path, content)) #################################################################################################################### # Settings # Saved in readable text (json) for easier versioning. But they mustn't be shared, it seems. # Maybe include them only if zipped? # Well, for now, we keep them here... files.append(("settings.txt", settings.save(protocol=0))) # We check if the file exist and we have write access. If the file does # not exist, we check the parent folder, because it might be a new project. if os.path.exists(project) and not os.access(project, os.W_OK) or \ not os.path.exists(project) and not os.access(os.path.dirname(project), os.W_OK): LOGGER.error("You don't have write access to save this project there.") return False #################################################################################################################### # Save to zip if zip: # project = os.path.join( # os.path.dirname(project), # "_" + os.path.basename(project) # ) zf = zipfile.ZipFile(project, mode="w") for filename, content in files: zf.writestr(filename, content, compress_type=compression) zf.close() return True #################################################################################################################### # Save to plain text else: global cache filesWithPermissionErrors = list() # Project path dir = os.path.dirname(project) # Folder containing file: name of the project file (without .msk extension) folder = os.path.splitext(os.path.basename(project))[0] # Debug LOGGER.debug("Saving to folder %s", folder) # If cache is empty (meaning we haven't loaded from disk), we wipe folder, just to be sure. if not cache: if os.path.exists(os.path.join(dir, folder)): shutil.rmtree(os.path.join(dir, folder)) # Moving files that have been renamed for old, new in moves: # Get full path oldPath = os.path.join(dir, folder, old) newPath = os.path.join(dir, folder, new) # Move the old file to the new place try: os.replace(oldPath, newPath) LOGGER.debug("* Renaming/moving {} to {}".format(old, new)) except FileNotFoundError: # Maybe parent folder has been renamed pass # Update cache cache2 = {} for f in cache: f2 = f.replace(old, new) if f2 != f: LOGGER.debug(" * Updating cache: %s, %s", f, f2) cache2[f2] = cache[f] cache = cache2 # Writing files for path, content in files: filename = os.path.join(dir, folder, path) os.makedirs(os.path.dirname(filename), exist_ok=True) # Check if content is in cache, and write if necessary if path not in cache or cache[path] != content: LOGGER.debug("* Writing file {} ({})".format(path, "not in cache" if path not in cache else "different")) # mode = "w" + ("b" if type(content) == bytes else "") if type(content) == bytes: try: with open(filename, "wb") as f: f.write(content) except PermissionError as e: LOGGER.error("Cannot open file " + filename + " for writing: " + e.strerror) filesWithPermissionErrors.append(filename) else: try: with open(filename, "w", encoding='utf8') as f: f.write(content) except PermissionError as e: LOGGER.error("Cannot open file " + filename + " for writing: " + e.strerror) filesWithPermissionErrors.append(filename) cache[path] = content # Removing phantoms for path in [p for p in cache if p not in [p for p, c in files]]: filename = os.path.join(dir, folder, path) LOGGER.debug("* Removing %s", path) if os.path.isdir(filename): shutil.rmtree(filename) else: # elif os.path.exists(filename) os.remove(filename) # Clear cache cache.pop(path, 0) # Removing empty directories for root, dirs, files in os.walk(os.path.join(dir, folder, "outline")): for dir in dirs: newDir = os.path.join(root, dir) try: os.removedirs(newDir) LOGGER.debug("* Removing empty directory: %s", newDir) except: # Directory not empty, we don't remove. pass # Write the project file's content try: with open(project, "w", encoding='utf8') as f: f.write("1") # Format number except PermissionError as e: LOGGER.error("Cannot open file " + project + " for writing: " + e.strerror) filesWithPermissionErrors.append(project) if len(filesWithPermissionErrors) > 0: dlg = ListDialog(mw) dlg.setModal(True) dlg.setWindowTitle(dlg.tr("Files not saved")) dlg.label.setText(dlg.tr("The following files were not saved and appear to be open in another program")) for f in filesWithPermissionErrors: QListWidgetItem(f, dlg.listWidget) dlg.open() if project in filesWithPermissionErrors: return False return True def addWorldItem(root, mdl, parent=QModelIndex()): """ Lists elements in a world model and create an OPML xml file. @param root: an Etree element @param mdl: a worldModel @param parent: the parent index in the world model @return: root, to which sub element have been added """ # List every row (every world item) for x in range(mdl.rowCount(parent)): # For each row, create an outline item. outline = ET.SubElement(root, "outline") for y in range(mdl.columnCount(parent)): val = mdl.data(mdl.index(x, y, parent)) if not val: continue for w in World: if y == w.value: outline.attrib[w.name] = val if mdl.hasChildren(mdl.index(x, y, parent)): addWorldItem(outline, mdl, mdl.index(x, y, parent)) return root def addPlotItem(root, mdl, parent=QModelIndex()): """ Lists elements in a plot model and create an xml file. @param root: an Etree element @param mdl: a plotModel @param parent: the parent index in the plot model @return: root, to which sub element have been added """ # List every row (every plot item) for x in range(mdl.rowCount(parent)): # For each row, create an outline item. outline = ET.SubElement(root, "plot") for y in range(mdl.columnCount(parent)): index = mdl.index(x, y, parent) val = mdl.data(index) # # if not val: # continue for w in Plot: if y == w.value and val: outline.attrib[w.name] = val # List characters as attrib if y == Plot.characters: if mdl.hasChildren(index): characters = [] for cX in range(mdl.rowCount(index)): for cY in range(mdl.columnCount(index)): cIndex = mdl.index(cX, cY, index) characters.append(mdl.data(cIndex)) outline.attrib[Plot.characters.name] = ",".join(characters) elif Plot.characters.name in outline.attrib: outline.attrib.pop(Plot.characters.name) # List resolution steps as sub items elif y == Plot.steps: if mdl.hasChildren(index): for cX in range(mdl.rowCount(index)): step = ET.SubElement(outline, "step") for cY in range(mdl.columnCount(index)): cIndex = mdl.index(cX, cY, index) # If empty, returns None, which creates trouble later with lxml, so default to "" val = mdl.data(cIndex) or "" for w in PlotStep: if cY == w.value and w.name: step.attrib[w.name] = val elif Plot.steps.name in outline.attrib: outline.attrib.pop(Plot.steps.name) return root def exportOutlineItem(root): """ Takes an outline item, and returns three lists: 1. of (`filename`, `content`), representing the whole tree of files to be written, in multimarkdown. 2. of (`filename`, `filename`) listing files to be moved 3. of `filename`, representing files to be removed. @param root: OutlineItem @return: [(str, str)], [(str, str)], [str] """ files = [] moves = [] removes = [] k = 0 for child in root.children(): spath = os.path.join(*outlineItemPath(child)) k += 1 # Has the item been renamed? lp = child._lastPath if lp and spath != lp: moves.append((lp, spath)) LOGGER.debug("%s has been renamed (%s → %s)", child.title(), lp, spath) LOGGER.debug(" → We mark for moving: %s", lp) # Updates item last's path child._lastPath = spath # Generating content if child.type() == "folder": fpath = os.path.join(spath, "folder.txt") content = outlineToMMD(child) files.append((fpath, content)) elif child.type() == "md": content = outlineToMMD(child) files.append((spath, content)) else: LOGGER.debug("Unknown type: %s", child.type()) f, m, r = exportOutlineItem(child) files += f moves += m removes += r return files, moves, removes def outlineItemPath(item): """ Returns the outlineItem file path (like the path where it will be written on the disk). As a list of folder's name. To be joined by os.path.join. @param item: outlineItem @return: list of folder's names """ # Root item if not item.parent(): return ["outline"] else: # Count the number of siblings for padding '0' siblings = item.parent().childCount() # We check if multiple items have the same name # If so, we add "-ID" to their name siblingsNames = [s.title() for s in item.parent().children()] if siblingsNames.count(item.title()) > 1: title = "{}-{}".format(item.title(), item.ID()) else: title = item.title() name = "{ID}-{name}{ext}".format( ID=str(item.row()).zfill(len(str(siblings))), name=slugify(title), ext="" if item.type() == "folder" else ".md" ) return outlineItemPath(item.parent()) + [name] def outlineToMMD(item): content = "" # We don't want to write some datas (computed) exclude = [Outline.wordCount, Outline.goal, Outline.goalPercentage, Outline.revisions, Outline.text] # We want to force some data even if they're empty force = [Outline.compile] for attrib in Outline: if attrib in exclude: continue val = item.data(attrib.value) if val or attrib in force: content += formatMetaData(attrib.name, str(val), 15) content += "\n\n" content += item.data(Outline.text) return content ######################################################################################################################## # LOAD ######################################################################################################################## def loadProject(project, zip=None): """ Loads a project. @param project: the filename of the project to open. @param zip: whether the project is a zipped or not. @return: an array of errors, empty if None. """ mw = mainWindow() errors = list() filesWithPermissionErrors = list() #################################################################################################################### # Read and store everything in a dict LOGGER.debug("Loading {} ({})".format(project, "zip" if zip else "folder")) if zip: files = loadFilesFromZip(project) # Decode files for f in files: if f[-4:] not in [".xml", "opml"]: files[f] = files[f].decode("utf-8") else: # Project path dir = os.path.dirname(project) # Folder containing file: name of the project file (without .msk extension) folder = os.path.splitext(os.path.basename(project))[0] # The full path towards the folder containing files path = os.path.join(dir, folder, "") files = {} for dirpath, dirnames, filenames in os.walk(path): p = dirpath.replace(path, "") # Skip directories that begin with a period if p[:1] == ".": continue for f in filenames: # Skip filenames that begin with a period if f[:1] == ".": continue # mode = "r" + ("b" if f[-4:] in [".xml", "opml"] else "") if f[-4:] in [".xml", "opml"]: with open(os.path.join(dirpath, f), "rb") as fo: files[os.path.join(p, f)] = fo.read() else: try: filename = os.path.join(dirpath, f) with open(filename, "r", encoding="utf8") as fo: files[os.path.join(p, f)] = fo.read() except PermissionError as e: LOGGER.error("Cannot open file " + filename + ": " + e.strerror) errors.append(fo) filesWithPermissionErrors.append(filename) # Saves to cache (only if we loaded from disk and not zip) global cache cache = files # FIXME: watch directory for changes # Sort files by keys files = OrderedDict(sorted(files.items())) #################################################################################################################### # Settings if "settings.txt" in files: settings.load(files["settings.txt"], fromString=True, protocol=0) else: errors.append("settings.txt") # Just to be sure settings.saveToZip = zip settings.defaultTextType = "md" #################################################################################################################### # Labels mdl = mw.mdlLabels mdl.appendRow(QStandardItem("")) # Empty = No labels if "labels.txt" in files: LOGGER.debug("Reading labels:") for s in files["labels.txt"].split("\n"): if not s: continue m = re.search(r"^(.*?):\s*(.*)$", s) txt = m.group(1) col = m.group(2) LOGGER.debug("* Add status: {} ({})".format(txt, col)) icon = iconFromColorString(col) mdl.appendRow(QStandardItem(icon, txt)) else: errors.append("labels.txt") #################################################################################################################### # Status mdl = mw.mdlStatus mdl.appendRow(QStandardItem("")) # Empty = No status if "status.txt" in files: LOGGER.debug("Reading status:") for s in files["status.txt"].split("\n"): if not s: continue LOGGER.debug("* Add status: %s", s) mdl.appendRow(QStandardItem(s)) else: errors.append("status.txt") #################################################################################################################### # Infos mdl = mw.mdlFlatData if "infos.txt" in files: md, body = parseMMDFile(files["infos.txt"], asDict=True) row = [] for name in ["Title", "Subtitle", "Serie", "Volume", "Genre", "License", "Author", "Email"]: row.append(QStandardItem(md.get(name, ""))) mdl.appendRow(row) else: errors.append("infos.txt") #################################################################################################################### # Summary mdl = mw.mdlFlatData if "summary.txt" in files: md, body = parseMMDFile(files["summary.txt"], asDict=True) row = [] for name in ["Situation", "Sentence", "Paragraph", "Page", "Full"]: row.append(QStandardItem(md.get(name, ""))) mdl.appendRow(row) else: errors.append("summary.txt") #################################################################################################################### # Plots mdl = mw.mdlPlots if "plots.xml" in files: LOGGER.debug("Reading plots:") # xml = bytearray(files["plots.xml"], "utf-8") root = ET.fromstring(files["plots.xml"]) for plot in root: # Create row row = getStandardItemRowFromXMLEnum(plot, Plot) # Log LOGGER.debug("* Add plot: %s", row[0].text()) # Characters if row[Plot.characters].text(): IDs = row[Plot.characters].text().split(",") item = QStandardItem() for ID in IDs: item.appendRow(QStandardItem(ID.strip())) row[Plot.characters] = item # Subplots for step in plot: row[Plot.steps].appendRow( getStandardItemRowFromXMLEnum(step, PlotStep) ) # Add row to the model mdl.appendRow(row) else: errors.append("plots.xml") #################################################################################################################### # World mdl = mw.mdlWorld if "world.opml" in files: LOGGER.debug("Reading World:") # xml = bytearray(files["plots.xml"], "utf-8") root = ET.fromstring(files["world.opml"]) body = root.find("body") for outline in body: row = getOutlineItem(outline, World) mdl.appendRow(row) else: errors.append("world.opml") #################################################################################################################### # Characters mdl = mw.mdlCharacter LOGGER.debug("Reading Characters:") for f in [f for f in files if "characters" in f]: md, body = parseMMDFile(files[f]) c = mdl.addCharacter() c.lastPath = f color = False for desc, val in md: # Base infos if desc in characterMap.values(): key = [key for key, value in characterMap.items() if value == desc][0] index = c.index(key.value) mdl.setData(index, val) # Character color elif desc == "Color" and not color: c.setColor(QColor(val)) # We remember the first time we found "Color": it is the icon color. # If "Color" comes a second time, it is a Character's info. color = True # Character's infos else: c.infos.append(CharacterInfo(c, desc, val)) LOGGER.debug("* Adds {} ({})".format(c.name(), c.ID())) #################################################################################################################### # Texts # We read outline form the outline folder. If revisions are saved, then there's also a revisions.xml which contains # everything, but the outline folder takes precedence (in cases it's been edited outside of manuskript. mdl = mw.mdlOutline LOGGER.debug("Reading outline:") paths = [f for f in files if "outline" in f] outline = OrderedDict() # We create a structure of imbricated OrderedDict to store the whole tree. for f in paths: split = f.split(os.path.sep)[1:] # LOGGER.debug("* %s", split) last = "" parent = outline parentLastPath = "outline" for i in split: if last: parent = parent[last] parentLastPath = os.path.join(parentLastPath, last) last = i if not i in parent: # If not last item, then it is a folder if i != split[-1]: parent[i] = OrderedDict() # If file, we store it else: parent[i] = files[f] # We store f to add it later as lastPath parent[i + ":lastPath"] = os.path.join(parentLastPath, i) # We now just have to recursively add items. addTextItems(mdl, outline) # Adds revisions if "revisions.xml" in files: root = ET.fromstring(files["revisions.xml"]) appendRevisions(mdl, root) # Check IDS mdl.rootItem.checkIDs() if len(filesWithPermissionErrors) > 0: dlg = ListDialog(mw) dlg.setModal(True) dlg.setWindowTitle(dlg.tr("Files not loaded")) dlg.label.setText(dlg.tr("The following files were not loaded and appear to be open in another program")) for f in filesWithPermissionErrors: QListWidgetItem(f, dlg.listWidget) dlg.open() return errors def addTextItems(mdl, odict, parent=None): """ Adds a text / outline items from an OrderedDict. @param mdl: model to add to @param odict: OrderedDict @return: nothing """ if parent is None: parent = mdl.rootItem for k in odict: # In case k is a folder: if (type(odict[k]) == OrderedDict) and ("folder.txt" in odict[k]): # Adds folder LOGGER.debug("{}* Adds {} to {} (folder)".format(" " * parent.level(), k, parent.title())) item = outlineFromMMD(odict[k]["folder.txt"], parent=parent) item._lastPath = odict[k + ":lastPath"] # Read content addTextItems(mdl, odict[k], parent=item) if (":lastPath" in k) or (k == "folder.txt"): continue # k is not a folder if type(odict[k]) == str: try: LOGGER.debug("{}* Adds {} to {} (file)".format(" " * parent.level(), k, parent.title())) item = outlineFromMMD(odict[k], parent=parent) item._lastPath = odict[k + ":lastPath"] except KeyError: LOGGER.error(f"Failed to add file {k}") else: LOGGER.debug(f"Strange things in file {k}") def outlineFromMMD(text, parent): """ Creates outlineItem from multimarkdown file. @param text: content of the file @param parent: appends item to parent (outlineItem) @return: outlineItem """ md, body = parseMMDFile(text, asDict=True) # Assign ID on creation, to avoid generating a new ID for this object item = outlineItem(parent=parent, ID=md.pop('ID')) # Store metadata for k in md: if k in Outline.__members__: item.setData(Outline.__members__[k], str(md[k])) # Store body item.setData(Outline.text, str(body)) # Set file format to "md" # (Old version of manuskript had different file formats: text, t2t, html and md) # If file format is html, convert to plain text: if item.type() == "html": item.setData(Outline.text, HTML2PlainText(body)) if item.type() in ["txt", "t2t", "html"]: item.setData(Outline.type, "md") return item def appendRevisions(mdl, root): """ Parse etree item to find outlineItem's with revisions, and adds them to model `mdl`. @param mdl: outlineModel @param root: etree @return: nothing """ for child in root: # Recursively go through items if child.tag == "outlineItem": appendRevisions(mdl, child) # Revision found. elif child.tag == "revision": # Get root's ID ID = root.attrib["ID"] if not ID: LOGGER.debug("* Serious problem: no ID!") LOGGER.error("Revision has no ID associated!") continue # Find outline item in model item = mdl.getItemByID(ID) if not item: LOGGER.debug("* Error: no item whose ID is %s", ID) LOGGER.error("Could not identify the item matching the revision ID.") continue # Store revision LOGGER.debug("* Appends revision ({}) to {}".format(child.attrib["timestamp"], item.title())) item.appendRevision(child.attrib["timestamp"], child.attrib["text"]) def getOutlineItem(item, enum): """ Reads outline items from an opml file. Returns a row of QStandardItem, easy to add to a QStandardItemModel. @param item: etree item @param enum: enum to read keys from @return: [QStandardItem] """ row = getStandardItemRowFromXMLEnum(item, enum) LOGGER.debug("* Add worldItem: %s", row[0].text()) for child in item: sub = getOutlineItem(child, enum) row[0].appendRow(sub) return row def getStandardItemRowFromXMLEnum(item, enum): """ Reads and etree item and creates a row of QStandardItems by cross-referencing an enum. Returns a list of QStandardItems that can be added to a QStandardItemModel by appendRow. @param item: the etree item @param enum: the enum @return: list of QStandardItems """ row = [] for i in range(len(enum)): row.append(QStandardItem("")) for name in item.attrib: if name in enum.__members__: row[enum[name].value] = QStandardItem(item.attrib[name]) return row def parseMMDFile(text, asDict=False): """ Takes the content of a MultiMarkDown file (str) and returns: 1. A list containing metadatas: (description, value) if asDict is False. If asDict is True, returns metadatas as an OrderedDict. Be aware that if multiple metadatas have the same description (which is stupid, but hey), they will be lost except the last one. 2. The body of the file @param text: the content of the file @return: (list, str) or (OrderedDict, str) """ md = [] mdd = OrderedDict() body = [] descr = "" val = "" inBody = False for s in text.split("\n"): if not inBody: m = re.match(r"^([^\s].*?):\s*(.*)$", s) if m: # Commit last metadata if descr: if descr == "None": descr = "" md.append((descr, val)) mdd[descr] = val descr = "" val = "" # Store new values descr = m.group(1) val = m.group(2) elif s[:4] == " ": val += "\n" + s.strip() elif s == "": # End of metadatas inBody = True # Commit last metadata if descr: if descr == "None": descr = "" md.append((descr, val)) mdd[descr] = val else: body.append(s) # We remove the second empty line (since we save with two empty lines) if body and body[0] == "": body = body[1:] body = "\n".join(body) if not asDict: return md, body else: return mdd, body