novelWriter 2.2.1__py3-none-any.whl → 2.3b1__py3-none-any.whl

novelwriter/core/index.py

@@ -32,8 +32,9 @@ import json
 import logging
 
 from time import time
-from typing import TYPE_CHECKING, ItemsView, Iterable, Iterator
+from typing import TYPE_CHECKING
 from pathlib import Path
+from collections.abc import ItemsView, Iterable, Iterator
 
 from novelwriter import SHARED
 from novelwriter.enum import nwComment, nwItemClass, nwItemType, nwItemLayout
@@ -122,8 +123,8 @@ class NWIndex:
         for nwItem in self._project.tree:
             if nwItem.isFileType():
                 tHandle = nwItem.itemHandle
-                theDoc = self._project.storage.getDocument(tHandle)
-                self.scanText(tHandle, theDoc.readDocument() or "", blockSignal=True)
+                doc = self._project.storage.getDocument(tHandle)
+                self.scanText(tHandle, doc.readDocument() or "", blockSignal=True)
         self._indexBroken = False
         SHARED.indexSignalProxy({"event": "buildIndex"})
         return
@@ -148,8 +149,8 @@ class NWIndex:
         """
         if tHandle and self._project.tree.checkType(tHandle, nwItemType.FILE):
             logger.debug("Re-indexing item '%s'", tHandle)
-            theDoc = self._project.storage.getDocument(tHandle)
-            self.scanText(tHandle, theDoc.readDocument() or "")
+            doc = self._project.storage.getDocument(tHandle)
+            self.scanText(tHandle, doc.readDocument() or "")
             return True
         return False
 
@@ -420,10 +421,10 @@ class NWIndex:
             return
 
         if tBits[0] == nwKeyWords.TAG_KEY:
-            tagName = tBits[1]
-            self._tagsIndex.add(tagName, tHandle, sTitle, itemClass)
-            self._itemIndex.setHeadingTag(tHandle, sTitle, tagName)
-            tags[tagName.lower()] = True
+            tagKey, displayName = self.parseValue(tBits[1])
+            self._tagsIndex.add(tagKey, displayName, tHandle, sTitle, itemClass.name)
+            self._itemIndex.setHeadingTag(tHandle, sTitle, tagKey)
+            tags[tagKey.lower()] = True
         else:
             self._itemIndex.addHeadingRef(tHandle, sTitle, tBits[1:], tBits[0])
 
@@ -471,10 +472,8 @@ class NWIndex:
 
         return True, tBits, tPos
 
-    def checkThese(self, tBits: list[str], nwItem: NWItem) -> list[bool]:
-        """Check the tags against the index to see if they are valid
-        tags. This is needed for syntax highlighting.
-        """
+    def checkThese(self, tBits: list[str], tHandle: str) -> list[bool]:
+        """Check tags against the index to see if they are valid."""
         nBits = len(tBits)
         isGood = [False]*nBits
         if nBits == 0:
@@ -487,20 +486,27 @@ class NWIndex:
 
         # For a tag, only the first value is accepted, the rest are ignored
         if tBits[0] == nwKeyWords.TAG_KEY and nBits > 1:
-            if tBits[1] in self._tagsIndex:
-                isGood[1] = self._tagsIndex.tagHandle(tBits[1]) == nwItem.itemHandle
+            check, _ = self.parseValue(tBits[1])
+            if check in self._tagsIndex:
+                isGood[1] = self._tagsIndex.tagHandle(check) == tHandle
             else:
                 isGood[1] = True
             return isGood
 
         # If we're still here, we check that the references exist
+        # Class references cannot have the | symbol in them
         refKey = nwKeyWords.KEY_CLASS[tBits[0]].name
         for n in range(1, nBits):
-            if tBits[n] in self._tagsIndex:
-                isGood[n] = self._tagsIndex.tagClass(tBits[n]) == refKey
+            if (aBit := tBits[n]) in self._tagsIndex:
+                isGood[n] = self._tagsIndex.tagClass(aBit) == refKey and "|" not in aBit
 
         return isGood
 
+    def parseValue(self, text: str) -> tuple[str, str]:
+        """Parse a single value into a name and display part."""
+        name, _, display = text.partition("|")
+        return name.rstrip(), display.lstrip()
+
     ##
     #  Extract Data
     ##
@@ -517,28 +523,31 @@ class NWIndex:
         return None
 
     def novelStructure(
-        self, rootHandle: str | None = None, skipExcl: bool = True
+        self, rootHandle: str | None = None, activeOnly: bool = True
     ) -> Iterator[tuple[str, str, str, IndexHeading]]:
         """Iterate over all titles in the novel, in the correct order as
         they appear in the tree view and in the respective document
         files, but skipping all note files.
         """
-        structure = self._itemIndex.iterNovelStructure(rHandle=rootHandle, skipExcl=skipExcl)
+        structure = self._itemIndex.iterNovelStructure(rHandle=rootHandle, activeOnly=activeOnly)
         for tHandle, sTitle, hItem in structure:
             yield f"{tHandle}:{sTitle}", tHandle, sTitle, hItem
         return
 
-    def getNovelWordCount(self, skipExcl: bool = True) -> int:
-        """Count the number of words in the novel project."""
-        wCount = 0
-        for _, _, hItem in self._itemIndex.iterNovelStructure(skipExcl=skipExcl):
-            wCount += hItem.wordCount
-        return wCount
+    def getNovelWordCount(self, rootHandle: str | None = None, activeOnly: bool = True) -> int:
+        """Count the number of words in one or all novel roots."""
+        return sum(hItem.wordCount for _, _, hItem in self._itemIndex.iterNovelStructure(
+            rHandle=rootHandle, activeOnly=activeOnly
+        ))
 
-    def getNovelTitleCounts(self, skipExcl: bool = True) -> list[int]:
-        """Count the number of titles in the novel project."""
+    def getNovelTitleCounts(
+        self, rootHandle: str | None = None, activeOnly: bool = True
+    ) -> list[int]:
+        """Count the number of titles in one or all novel roots."""
         hCount = [0, 0, 0, 0, 0]
-        for _, _, hItem in self._itemIndex.iterNovelStructure(skipExcl=skipExcl):
+        for _, _, hItem in self._itemIndex.iterNovelStructure(
+            rHandle=rootHandle, activeOnly=activeOnly
+        ):
             iLevel = nwHeaders.H_LEVEL.get(hItem.level, 0)
             hCount[iLevel] += 1
         return hCount
@@ -551,14 +560,14 @@ class NWIndex:
         return 0
 
     def getTableOfContents(
-        self, rHandle: str | None, maxDepth: int, skipExcl: bool = True
+        self, rHandle: str | None, maxDepth: int, activeOnly: bool = True
     ) -> list[tuple[str, int, str, int]]:
         """Generate a table of contents up to a maximum depth."""
         tOrder = []
         tData = {}
         pKey = None
         for tHandle, sTitle, hItem in self._itemIndex.iterNovelStructure(
-            rHandle=rHandle, skipExcl=skipExcl
+            rHandle=rHandle, activeOnly=activeOnly
         ):
             tKey = f"{tHandle}:{sTitle}"
             iLevel = nwHeaders.H_LEVEL.get(hItem.level, 0)
@@ -612,9 +621,18 @@ class NWIndex:
                     for refType in refTypes:
                         if refType in tRefs:
                             tRefs[refType].append(self._tagsIndex.tagName(aTag))
-
         return tRefs
 
+    def getReferenceForHeader(self, tHandle: str, nHead: int, keyClass: str) -> list[str]:
+        """Get the display names for a tags class for insertion into a
+        heading by one of the build classes.
+        """
+        if iItem := self._itemIndex[tHandle]:
+            if hItem := iItem[f"T{nHead:04d}"]:
+                hRefs = [k for k, v in hItem.references.items() if keyClass in v]
+                return [self._tagsIndex.tagDisplay(k) for k in hRefs]
+        return []
+
     def getBackReferenceList(self, tHandle: str) -> dict[str, tuple[str, IndexHeading]]:
         """Build a dict of files referring back to our file."""
         if tHandle is None or tHandle not in self._itemIndex:
@@ -646,12 +664,15 @@ class NWIndex:
         """Return all tags based on itemClass."""
         return self._tagsIndex.filterTagNames(itemClass.name)
 
-    def getTagsData(self) -> Iterator[tuple[str, str, str, IndexItem | None, IndexHeading | None]]:
+    def getTagsData(
+        self, activeOnly: bool = True
+    ) -> Iterator[tuple[str, str, str, IndexItem | None, IndexHeading | None]]:
         """Return all known tags."""
         for tag, data in self._tagsIndex.items():
             iItem = self._itemIndex[data.get("handle")]
             hItem = None if iItem is None else iItem[data.get("heading")]
-            yield tag, data.get("name", ""), data.get("class", ""), iItem, hItem
+            if not activeOnly or (iItem and iItem.item.isActive):
+                yield tag, data.get("name", ""), data.get("class", ""), iItem, hItem
         return
 
     def getSingleTag(self, tagKey: str) -> tuple[str, str, IndexItem | None, IndexHeading | None]:
@@ -709,17 +730,26 @@ class TagsIndex:
         """Return a dictionary view of all tags."""
         return self._tags.items()
 
-    def add(self, tagKey: str, tHandle: str, sTitle: str, itemClass: nwItemClass) -> None:
+    def add(self, tagKey: str, displayName: str, tHandle: str,
+            sTitle: str, className: str) -> None:
         """Add a key to the index and set all values."""
         self._tags[tagKey.lower()] = {
-            "name": tagKey, "handle": tHandle, "heading": sTitle, "class": itemClass.name
+            "name": tagKey,
+            "display": displayName or tagKey,
+            "handle": tHandle,
+            "heading": sTitle,
+            "class": className,
         }
         return
 
     def tagName(self, tagKey: str) -> str:
-        """Get the display name of a given tag."""
+        """Get the name of a given tag."""
         return self._tags.get(tagKey.lower(), {}).get("name", "")
 
+    def tagDisplay(self, tagKey: str) -> str:
+        """Get the display name of a given tag."""
+        return self._tags.get(tagKey.lower(), {}).get("display", "")
+
     def tagHandle(self, tagKey: str) -> str | None:
         """Get the handle of a given tag."""
         return self._tags.get(tagKey.lower(), {}).get("handle", None)
@@ -754,27 +784,30 @@ class TagsIndex:
         if not isinstance(data, dict):
             raise ValueError("tagsIndex is not a dict")
 
-        for tagKey, tagData in data.items():
-            if not isinstance(tagKey, str):
-                raise ValueError("tagsIndex keys must be a strings")
-            if "name" not in tagData:
-                raise KeyError("A tagIndex item is missing a name entry")
-            if "handle" not in tagData:
-                raise KeyError("A tagIndex item is missing a handle entry")
-            if "heading" not in tagData:
-                raise KeyError("A tagIndex item is missing a heading entry")
-            if "class" not in tagData:
-                raise KeyError("A tagIndex item is missing a class entry")
-            if tagData["name"].lower() != tagKey:
-                raise ValueError("tagsIndex name must match key")
-            if not isHandle(tagData["handle"]):
+        for key, entry in data.items():
+            if not isinstance(key, str):
+                raise ValueError("tagsIndex keys must be a string")
+            if not isinstance(entry, dict):
+                raise ValueError("tagsIndex entry is not a dict")
+
+            name = entry.get("name")
+            display = entry.get("display")
+            handle = entry.get("handle")
+            heading = entry.get("heading")
+            className = entry.get("class")
+
+            if not isinstance(name, str):
+                raise ValueError("tagsIndex name is not a string")
+            if not isinstance(display, str):
+                raise ValueError("tagsIndex display is not a string")
+            if not isHandle(handle):
                 raise ValueError("tagsIndex handle must be a handle")
-            if not isTitleTag(tagData["heading"]):
+            if not isTitleTag(heading):
                 raise ValueError("tagsIndex heading must be a title tag")
-            if not isItemClass(tagData["class"]):
+            if not isItemClass(className):
                 raise ValueError("tagsIndex handle must be an nwItemClass")
 
-        self._tags = data
+            self.add(name, display, handle, heading, className)
 
         return
 
@@ -848,7 +881,7 @@ class ItemIndex:
         return
 
     def iterNovelStructure(
-        self, rHandle: str | None = None, skipExcl: bool = False
+        self, rHandle: str | None = None, activeOnly: bool = False
     ) -> Iterable[tuple[str, str, IndexHeading]]:
         """Iterate over all items and headers in the novel structure for
         a given root handle, or for all if root handle is None.
@@ -856,7 +889,7 @@ class ItemIndex:
         for tItem in self._project.tree:
             if tItem.isNoteLayout():
                 continue
-            if skipExcl and not tItem.isActive:
+            if activeOnly and not tItem.isActive:
                 continue
 
             tHandle = tItem.itemHandle
@@ -1159,7 +1192,7 @@ class IndexHeading:
         return self._tag
 
     @property
-    def references(self) -> dict:
+    def references(self) -> dict[str, set[str]]:
         return self._refs
 
     ##

novelwriter/core/item.py

@@ -334,15 +334,33 @@ class NWItem:
 
     def isNovelLike(self) -> bool:
         """Check if the item is of a novel-like class."""
-        return self._class in (nwItemClass.NOVEL, nwItemClass.ARCHIVE)
+        return self._class in (
+            nwItemClass.NOVEL,
+            nwItemClass.ARCHIVE,
+            nwItemClass.TEMPLATE,
+        )
+
+    def isTemplateFile(self) -> bool:
+        """Check if the item is a template file."""
+        return self._type == nwItemType.FILE and self._class == nwItemClass.TEMPLATE
 
     def documentAllowed(self) -> bool:
         """Check if the item is allowed to be of document layout."""
-        return self._class in (nwItemClass.NOVEL, nwItemClass.ARCHIVE, nwItemClass.TRASH)
+        return self._class in (
+            nwItemClass.NOVEL,
+            nwItemClass.ARCHIVE,
+            nwItemClass.TEMPLATE,
+            nwItemClass.TRASH,
+        )
 
     def isInactiveClass(self) -> bool:
         """Check if the item is in an inactive class."""
-        return self._class in (nwItemClass.NO_CLASS, nwItemClass.ARCHIVE, nwItemClass.TRASH)
+        return self._class in (
+            nwItemClass.NO_CLASS,
+            nwItemClass.ARCHIVE,
+            nwItemClass.TEMPLATE,
+            nwItemClass.TRASH,
+        )
 
     def isRootType(self) -> bool:
         """Check if item is a root item."""

novelwriter/core/options.py

@@ -42,7 +42,7 @@ logger = logging.getLogger(__name__)
 
 NWEnum = TypeVar("NWEnum", bound=Enum)
 
-VALID_MAP = {
+VALID_MAP: dict[str, set[str]] = {
     "GuiWritingStats": {
         "winWidth", "winHeight", "widthCol0", "widthCol1", "widthCol2",
         "widthCol3", "sortCol", "sortOrder", "incNovel", "incNotes",
@@ -53,10 +53,6 @@ VALID_MAP = {
     "GuiProjectSettings": {
         "winWidth", "winHeight", "replaceColW", "statusColW", "importColW",
     },
-    "GuiProjectDetails": {
-        "winWidth", "winHeight", "widthCol0", "widthCol1", "widthCol2",
-        "widthCol3", "widthCol4", "wordsPerPage", "countFrom", "clearDouble",
-    },
     "GuiWordList": {"winWidth", "winHeight"},
     "GuiNovelView": {"lastCol", "lastColSize"},
     "GuiBuildSettings": {
@@ -70,8 +66,13 @@ VALID_MAP = {
         "winWidth", "winHeight", "fmtWidth", "sumWidth",
     },
     "GuiDocViewerPanel": {
-        "colWidths",
-    }
+        "colWidths", "hideInactive",
+    },
+    "GuiNovelDetails": {
+        "winWidth", "winHeight", "widthCol0", "widthCol1", "widthCol2",
+        "widthCol3", "widthCol4", "wordsPerPage", "countFrom", "clearDouble",
+        "novelRoot",
+    },
 }
 
 

novelwriter/core/project.py

@@ -26,10 +26,12 @@ from __future__ import annotations
 import json
 import logging
 
+from enum import Enum
 from time import time
-from typing import TYPE_CHECKING, Iterator
+from typing import TYPE_CHECKING
 from pathlib import Path
 from functools import partial
+from collections.abc import Iterator
 
 from PyQt5.QtCore import QCoreApplication
 
@@ -40,7 +42,7 @@ from novelwriter.constants import trConst, nwLabels
 from novelwriter.core.tree import NWTree
 from novelwriter.core.index import NWIndex
 from novelwriter.core.options import OptionState
-from novelwriter.core.storage import NWStorage
+from novelwriter.core.storage import NWStorage, NWStorageOpen
 from novelwriter.core.sessions import NWSessionLog
 from novelwriter.core.projectxml import ProjectXMLReader, ProjectXMLWriter, XMLReadState
 from novelwriter.core.projectdata import NWProjectData
@@ -55,6 +57,16 @@ if TYPE_CHECKING:  # pragma: no cover
 logger = logging.getLogger(__name__)
 
 
+class NWProjectState(Enum):
+
+    UNKNOWN  = 0
+    LOCKED   = 1
+    RECOVERY = 2
+    READY    = 3
+
+# END Enum NWProjectState
+
+
 class NWProject:
 
     def __init__(self) -> None:
@@ -69,9 +81,9 @@ class NWProject:
 
         # Project Status
         self._langData = {}     # Localisation data
-        self._lockedBy = None   # Data on which computer has the project open
         self._changed  = False  # The project has unsaved changes
         self._valid    = False  # The project was successfully loaded
+        self._state    = NWProjectState.UNKNOWN
 
         # Internal Mapping
         self.tr = partial(QCoreApplication.translate, "NWProject")
@@ -125,12 +137,15 @@ class NWProject:
         """Return True if a project is loaded."""
         return self._valid
 
+    @property
+    def state(self) -> NWProjectState:
+        """Return the current project state."""
+        return self._state
+
     @property
     def lockStatus(self) -> list | None:
         """Return the project lock information."""
-        if isinstance(self._lockedBy, list) and len(self._lockedBy) == 4:
-            return self._lockedBy
-        return None
+        return self._storage.lockStatus
 
     @property
     def currentEditTime(self) -> int:
@@ -161,24 +176,47 @@ class NWProject:
         will not run if the file exists and is not empty.
         """
         tItem = self._tree[tHandle]
-        if tItem is None:
-            return False
-        if not tItem.isFileType():
+        if not (tItem and tItem.isFileType()):
             return False
 
         newDoc = self._storage.getDocument(tHandle)
         if (newDoc.readDocument() or "").strip():
             return False
 
-        hshText = "#"*minmax(hLevel, 1, 4)
-        newText = f"{hshText} {tItem.itemName}\n\n{text}"
+        indent = "#"*minmax(hLevel, 1, 4)
+        text = f"{indent} {tItem.itemName}\n\n{text}"
+
         if tItem.isNovelLike() and isDocument:
             tItem.setLayout(nwItemLayout.DOCUMENT)
         else:
             tItem.setLayout(nwItemLayout.NOTE)
 
-        newDoc.writeDocument(newText)
-        self._index.scanText(tHandle, newText)
+        newDoc.writeDocument(text)
+        self._index.scanText(tHandle, text)
+
+        return True
+
+    def copyFileContent(self, tHandle: str, sHandle: str) -> bool:
+        """Copy content to a new document after it is created. This
+        will not run if the file exists and is not empty.
+        """
+        tItem = self._tree[tHandle]
+        if not (tItem and tItem.isFileType()):
+            return False
+
+        sItem = self._tree[sHandle]
+        if not (sItem and sItem.isFileType()):
+            return False
+
+        newDoc = self._storage.getDocument(tHandle)
+        if (newDoc.readDocument() or "").strip():
+            return False
+
+        logger.debug("Populating '%s' with text from '%s'", tHandle, sHandle)
+        text = self._storage.getDocument(sHandle).readDocument() or ""
+        newDoc.writeDocument(text)
+        sItem.setLayout(tItem.itemLayout)
+        self._index.scanText(tHandle, text)
 
         return True
 
@@ -219,29 +257,21 @@ class NWProject:
         build the tree of project items.
         """
         logger.info("Opening project: %s", projPath)
-        if not self._storage.openProjectInPlace(projPath):
-            SHARED.error(self.tr("Could not open project with path: {0}").format(projPath))
-            return False
-
-        # Project Lock
-        # ============
 
-        if clearLock:
-            self._storage.clearLockFile()
-
-        lockStatus = self._storage.readLockFile()
-        if len(lockStatus) > 0:
-            if lockStatus[0] == "ERROR":
-                logger.warning("Failed to check lock file")
-            else:
-                logger.error("Project is locked, so not opening")
-                self._lockedBy = lockStatus
-                return False
-        else:
-            logger.debug("Project is not locked")
+        status = self._storage.initProjectStorage(projPath, clearLock)
+        if status != NWStorageOpen.READY:
+            if status == NWStorageOpen.UNKOWN:
+                SHARED.error(self.tr("Not a known project file format."))
+            elif status == NWStorageOpen.NOT_FOUND:
+                SHARED.error(self.tr("Project file not found."))
+            elif status == NWStorageOpen.LOCKED:
+                self._state = NWProjectState.LOCKED
+            elif status == NWStorageOpen.FAILED:
+                SHARED.error(self.tr("Failed to open project."), exc=self._storage.exc)
+            return False
 
-        # Open The Project XML File
-        # =========================
+        # Read Project XML
+        # ================
 
         xmlReader = self._storage.getXmlReader()
         if not isinstance(xmlReader, ProjectXMLReader):
@@ -250,9 +280,7 @@ class NWProject:
         self._data = NWProjectData(self)
         projContent = []
         xmlParsed = xmlReader.read(self._data, projContent)
-
         appVersion = xmlReader.appVersion or self.tr("Unknown")
-
         if not xmlParsed:
             if xmlReader.state == XMLReadState.NOT_NWX_FILE:
                 SHARED.error(self.tr(
@@ -302,8 +330,7 @@ class NWProject:
         self._loadProjectLocalisation()
 
         # Update recent projects
-        storePath = self._storage.storagePath
-        if storePath:
+        if storePath := self._storage.storagePath:
             CONFIG.recentProjects.update(
                 storePath, self._data.name, sum(self._data.initCounts), time()
             )
@@ -323,9 +350,9 @@ class NWProject:
 
         self.updateWordCounts()
         self._session.startSession()
-        self._storage.writeLockFile()
         self.setProjectChanged(False)
         self._valid = True
+        self._state = NWProjectState.READY
 
         SHARED.newStatusMessage(self.tr("Opened Project: {0}").format(self._data.name))
 
@@ -370,13 +397,11 @@ class NWProject:
         self._storage.runPostSaveTasks(autoSave=autoSave)
 
         # Update recent projects
-        storePath = self._storage.storagePath
-        if storePath:
+        if storagePath := self._storage.storagePath:
             CONFIG.recentProjects.update(
-                storePath, self._data.name, sum(self._data.currCounts), saveTime
+                storagePath, self._data.name, sum(self._data.currCounts), saveTime
             )
 
-        self._storage.writeLockFile()
         SHARED.newStatusMessage(self.tr("Saved Project: {0}").format(self._data.name))
         self.setProjectChanged(False)
 
@@ -420,8 +445,8 @@ class NWProject:
         timeStamp = formatTimeStamp(time(), fileSafe=True)
         archName = baseDir / f"{cleanName} {timeStamp}.zip"
         if self._storage.zipIt(archName, compression=2):
-            size = formatInt(getFileSize(archName))
             if doNotify:
+                size = formatInt(getFileSize(archName))
                 SHARED.info(
                     self.tr("Created a backup of your project of size {0}B.").format(size),
                     info=self.tr("Path: {0}").format(str(backupPath))

novelwriter/core/projectdata.py

@@ -53,7 +53,6 @@ class NWProjectData:
         # Project Meta
         self._uuid = ""
         self._name = ""
-        self._title = ""
         self._author = ""
         self._saveCount = 0
         self._autoCount = 0
@@ -102,11 +101,6 @@ class NWProjectData:
         """Return the project name."""
         return self._name
 
-    @property
-    def title(self) -> str:
-        """Return the project title."""
-        return self._title
-
     @property
     def author(self) -> str:
         """Return the project author."""
@@ -228,16 +222,9 @@ class NWProjectData:
             self._project.setProjectChanged(True)
         return
 
-    def setTitle(self, value: str | None) -> None:
-        """Set a new novel title."""
-        if value != self._title:
-            self._title = simplified(str(value or ""))
-            self._project.setProjectChanged(True)
-        return
-
     def setAuthor(self, value: str | None) -> None:
         """Set the author value."""
-        if value != self._title:
+        if value != self._author:
             self._author = simplified(str(value or ""))
             self._project.setProjectChanged(True)
         return