novelWriter 2.6.2__py3-none-any.whl → 2.7b1__py3-none-any.whl

novelwriter/core/indexdata.py

@@ -0,0 +1,403 @@
+"""
+novelWriter – Project Index Data
+================================
+
+File History:
+Created: 2022-05-28 [2.0rc1] IndexNode
+Created: 2022-05-28 [2.0rc1] IndexHeading
+Moved:   2025-02-22 [2.7b1]  IndexNode
+Moved:   2025-02-22 [2.7b1]  IndexHeading
+
+This file is a part of novelWriter
+Copyright (C) 2025 Veronica Berglyd Olsen and novelWriter contributors
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import logging
+
+from typing import TYPE_CHECKING, Literal
+
+from novelwriter import CONFIG
+from novelwriter.common import checkInt, compact, isListInstance, isTitleTag
+from novelwriter.constants import nwKeyWords, nwStyles
+
+if TYPE_CHECKING:
+    from collections.abc import ItemsView, Sequence
+
+    from novelwriter.core.index import IndexCache
+    from novelwriter.core.item import NWItem
+    from novelwriter.enum import nwComment
+
+logger = logging.getLogger(__name__)
+
+T_NoteTypes = Literal["footnotes", "comments"]
+
+TT_NONE = "T0000"  # Default title key
+NOTE_TYPES: list[T_NoteTypes] = ["footnotes", "comments"]
+
+
+class IndexNode:
+    """Core: Single Index Item Node Class
+
+    This object represents the index data of a project item (NWItem).
+    It holds a record of all the headings in the text, and the meta data
+    associated with each heading. It also holds a pointer to the project
+    item. The main heading level of the item is also held here since it
+    must be reset each time the item is re-indexed.
+    """
+
+    __slots__ = ("_cache", "_count", "_handle", "_headings", "_item", "_notes")
+
+    def __init__(self, cache: IndexCache, tHandle: str, nwItem: NWItem) -> None:
+        self._cache = cache
+        self._handle = tHandle
+        self._item = nwItem
+        self._headings: dict[str, IndexHeading] = {TT_NONE: IndexHeading(self._cache, TT_NONE)}
+        self._notes: dict[str, set[str]] = {}
+        self._count = 0
+        return
+
+    def __repr__(self) -> str:
+        return f"<IndexNode handle='{self._handle}'>"
+
+    def __len__(self) -> int:
+        return len(self._headings)
+
+    def __getitem__(self, sTitle: str) -> IndexHeading | None:
+        return self._headings.get(sTitle, None)
+
+    def __contains__(self, sTitle: str) -> bool:
+        return sTitle in self._headings
+
+    ##
+    # Properties
+    ##
+
+    @property
+    def handle(self) -> str:
+        """Return the item handle of the index item."""
+        return self._handle
+
+    @property
+    def item(self) -> NWItem:
+        """Return the project item of the index item."""
+        return self._item
+
+    ##
+    #  Setters
+    ##
+
+    def addHeading(self, tHeading: IndexHeading) -> None:
+        """Add a heading to the item. Also remove the placeholder entry
+        if it exists.
+        """
+        if TT_NONE in self._headings:
+            self._headings.pop(TT_NONE)
+        self._headings[tHeading.key] = tHeading
+        return
+
+    def setHeadingCounts(self, sTitle: str, cCount: int, wCount: int, pCount: int) -> None:
+        """Set the character, word and paragraph count of a heading."""
+        if sTitle in self._headings:
+            self._headings[sTitle].setCounts([cCount, wCount, pCount])
+        return
+
+    def setHeadingComment(self, sTitle: str, comment: nwComment, key: str, text: str) -> None:
+        """Set the comment text of a heading."""
+        if sTitle in self._headings:
+            self._headings[sTitle].setComment(comment.name, key, text)
+        return
+
+    def setHeadingTag(self, sTitle: str, tag: str) -> None:
+        """Set the tag of a heading."""
+        if sTitle in self._headings:
+            self._headings[sTitle].setTag(tag)
+        return
+
+    def addHeadingRef(self, sTitle: str, tags: list[str], keyword: str) -> None:
+        """Add a reference key and all its types to a heading."""
+        if sTitle in self._headings:
+            for tag in tags:
+                self._headings[sTitle].addReference(tag, keyword)
+        return
+
+    def addNoteKey(self, style: T_NoteTypes, key: str) -> None:
+        """Add a note key to the index."""
+        if style not in self._notes:
+            self._notes[style] = set()
+        self._notes[style].add(key)
+        return
+
+    ##
+    #  Data Methods
+    ##
+
+    def items(self) -> ItemsView[str, IndexHeading]:
+        """Return IndexHeading items."""
+        return self._headings.items()
+
+    def headings(self) -> list[str]:
+        """Return heading keys in sorted order."""
+        return sorted(self._headings.keys())
+
+    def allTags(self) -> list[str]:
+        """Return a list of all tags in the current item."""
+        return [h.tag for h in self._headings.values() if h.tag]
+
+    def nextHeading(self) -> str:
+        """Return the next heading key to be used."""
+        self._count += 1
+        return f"T{self._count:04d}"
+
+    def noteKeys(self, style: T_NoteTypes) -> set[str]:
+        """Return a set of all note keys."""
+        return self._notes.get(style, set())
+
+    ##
+    #  Pack/Unpack
+    ##
+
+    def packData(self) -> dict:
+        """Pack the indexed item's data into a dictionary."""
+        data = {}
+        for sTitle, hItem in self._headings.items():
+            data[sTitle]  = hItem.packData()
+        if self._notes:
+            data["document"] = {style: list(keys) for style, keys in self._notes.items()}
+        return data
+
+    def unpackData(self, data: dict) -> None:
+        """Unpack an item entry from the data."""
+        for key, entry in data.items():
+            if isTitleTag(key):
+                heading = IndexHeading(self._cache, key)
+                heading.unpackData(entry)
+                self.addHeading(heading)
+            elif key == "document":
+                for style, keys in entry.items():
+                    if style not in NOTE_TYPES:
+                        raise ValueError("The notes style is invalid")
+                    if not isListInstance(keys, str):
+                        raise ValueError("The notes keys must be a list of strings")
+                    self._notes[style] = set(keys)
+            else:
+                raise KeyError("Index node contains an invalid key")
+        return
+
+
+class IndexHeading:
+    """Core: Single Index Heading Class
+
+    This object represents a section of text in a project item
+    associated with a single (valid) heading. It holds a separate record
+    of all references made under the heading.
+    """
+
+    __slots__ = (
+        "_cache", "_comments", "_counts", "_key", "_level", "_line", "_refs",
+        "_tag", "_title",
+    )
+
+    def __init__(
+        self, cache: IndexCache, key: str, line: int = 0,
+        level: str = "H0", title: str = "",
+    ) -> None:
+        self._cache = cache
+        self._key = key
+        self._line = line
+        self._level = level
+        self._title = title
+        self._counts: tuple[int, int, int] = (0, 0, 0)
+        self._tag = ""
+        self._refs: dict[str, set[str]] = {}
+        self._comments: dict[str, str] = {}
+        return
+
+    def __repr__(self) -> str:
+        return f"<IndexHeading key='{self._key}'>"
+
+    ##
+    #  Properties
+    ##
+
+    @property
+    def key(self) -> str:
+        return self._key
+
+    @property
+    def line(self) -> int:
+        return self._line
+
+    @property
+    def level(self) -> str:
+        return self._level
+
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @property
+    def mainCount(self) -> int:
+        return self._counts[0 if CONFIG.useCharCount else 1]
+
+    @property
+    def charCount(self) -> int:
+        return self._counts[0]
+
+    @property
+    def wordCount(self) -> int:
+        return self._counts[1]
+
+    @property
+    def paraCount(self) -> int:
+        return self._counts[2]
+
+    @property
+    def synopsis(self) -> str:
+        return self._comments.get("summary", "")
+
+    @property
+    def comments(self) -> dict[str, str]:
+        return self._comments
+
+    @property
+    def tag(self) -> str:
+        return self._tag
+
+    @property
+    def references(self) -> dict[str, set[str]]:
+        return self._refs
+
+    ##
+    #  Setters
+    ##
+
+    def setLevel(self, level: str) -> None:
+        """Set the level of the heading if it's a valid value."""
+        if level in nwStyles.H_VALID:
+            self._level = level
+        return
+
+    def setLine(self, line: int) -> None:
+        """Set the line number of a heading."""
+        self._line = max(0, checkInt(line, 0))
+        return
+
+    def setCounts(self, counts: Sequence[int]) -> None:
+        """Set the character, word and paragraph count. Make sure the
+        value is an integer and is not smaller than 0.
+        """
+        if len(counts) == 3:
+            self._counts = (
+                max(0, checkInt(counts[0], 0)),
+                max(0, checkInt(counts[1], 0)),
+                max(0, checkInt(counts[2], 0)),
+            )
+        return
+
+    def setComment(self, comment: str, key: str, text: str) -> None:
+        """Set the text for a comment and make sure it is a string."""
+        match comment.lower():
+            case "short" | "synopsis" | "summary":
+                self._comments["summary"] = str(text)
+            case "story" if key:
+                self._cache.story.add(key)
+                self._comments[f"story.{key}"] = str(text)
+        return
+
+    def setTag(self, tag: str) -> None:
+        """Set the tag for references, and make sure it is a string."""
+        self._tag = str(tag).lower()
+        return
+
+    def addReference(self, tag: str, keyword: str) -> None:
+        """Add a record of a reference tag, and what keyword types it is
+        associated with.
+        """
+        if keyword in nwKeyWords.VALID_KEYS:
+            tag = tag.lower()
+            if tag not in self._refs:
+                self._refs[tag] = set()
+            self._refs[tag].add(keyword)
+        return
+
+    ##
+    #  Getters
+    ##
+
+    def getReferences(self) -> dict[str, list[str]]:
+        """Extract all references for this heading."""
+        refs = {x: [] for x in nwKeyWords.VALID_KEYS}
+        for tag, types in self._refs.items():
+            for keyword in types:
+                if keyword in refs and (name := self._cache.tags.tagName(tag)):
+                    refs[keyword].append(name)
+        return refs
+
+    def getReferencesByKeyword(self, keyword: str) -> list[str]:
+        """Extract all references for this heading."""
+        refs = []
+        for tag, types in self._refs.items():
+            if keyword in types and (name := self._cache.tags.tagName(tag)):
+                refs.append(name)
+        return refs
+
+    ##
+    #  Data Methods
+    ##
+
+    def packData(self) -> dict:
+        """Pack the values into a dictionary for saving to cache."""
+        data = {}
+        data["meta"] = {
+            "level": self._level,
+            "title": self._title,
+            "line": self._line,
+            "tag": self._tag,
+            "counts": self._counts,
+        }
+        if self._refs:
+            data["refs"] = {k: ",".join(sorted(list(v))) for k, v in self._refs.items()}
+        if self._comments:
+            data.update(self._comments)
+        return data
+
+    def unpackData(self, data: dict) -> None:
+        """Unpack a heading entry from a dictionary."""
+        for key, entry in data.items():
+            if key == "meta":
+                self.setLevel(entry.get("level", "H0"))
+                self._title = str(entry.get("title", ""))
+                self._tag = str(entry.get("tag", ""))
+                self.setLine(entry.get("line", 0))
+                self.setCounts(entry.get("counts", [0, 0, 0]))
+            elif key == "refs":
+                for tag, value in entry.items():
+                    if not isinstance(tag, str):
+                        raise ValueError("Heading reference key must be a string")
+                    if not isinstance(value, str):
+                        raise ValueError("Heading reference value must be a string")
+                    for keyword in value.split(","):
+                        if keyword in nwKeyWords.VALID_KEYS:
+                            self.addReference(tag, keyword)
+                        else:
+                            raise ValueError("Heading reference contains an invalid keyword")
+            elif key == "summary" or key.startswith("story"):
+                comment, _, kind = str(key).partition(".")
+                self.setComment(comment, compact(kind), str(entry))
+            else:
+                raise KeyError("Unknown key in heading entry")
+        return

novelwriter/core/item.py

@@ -27,8 +27,6 @@ import logging
 
 from typing import TYPE_CHECKING, Any
 
-from PyQt5.QtGui import QFont, QIcon
-
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import (
     checkInt, isHandle, isItemClass, isItemLayout, isItemType, simplified,
@@ -37,7 +35,9 @@ from novelwriter.common import (
 from novelwriter.constants import nwLabels, nwStyles, trConst
 from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
+    from PyQt6.QtGui import QFont, QIcon
+
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)
@@ -53,10 +53,10 @@ class NWItem:
     """
 
     __slots__ = (
-        "_project", "_name", "_handle", "_parent", "_root", "_order",
-        "_type", "_class", "_layout", "_status", "_import", "_active",
-        "_expanded", "_heading", "_charCount", "_wordCount",
-        "_paraCount", "_cursorPos", "_initCount",
+        "_active", "_charCount", "_class", "_cursorPos", "_expanded",
+        "_handle", "_heading", "_import", "_initCount", "_layout", "_name",
+        "_order", "_paraCount", "_parent", "_project", "_root", "_status",
+        "_type", "_wordCount",
     )
 
     def __init__(self, project: NWProject, handle: str) -> None:
@@ -264,25 +264,25 @@ class NWItem:
     @classmethod
     def duplicate(cls, source: NWItem, handle: str) -> NWItem:
         """Make a copy of an item."""
-        cls = NWItem(source._project, handle)
-        cls._name      = source._name
-        cls._parent    = source._parent
-        cls._root      = source._root
-        cls._order     = source._order
-        cls._type      = source._type
-        cls._class     = source._class
-        cls._layout    = source._layout
-        cls._status    = source._status
-        cls._import    = source._import
-        cls._active    = source._active
-        cls._expanded  = source._expanded
-        cls._heading   = source._heading
-        cls._charCount = source._charCount
-        cls._wordCount = source._wordCount
-        cls._paraCount = source._paraCount
-        cls._cursorPos = source._cursorPos
-        cls._initCount = source._initCount
-        return cls
+        new = cls(source._project, handle)
+        new._name      = source._name
+        new._parent    = source._parent
+        new._root      = source._root
+        new._order     = source._order
+        new._type      = source._type
+        new._class     = source._class
+        new._layout    = source._layout
+        new._status    = source._status
+        new._import    = source._import
+        new._active    = source._active
+        new._expanded  = source._expanded
+        new._heading   = source._heading
+        new._charCount = source._charCount
+        new._wordCount = source._wordCount
+        new._paraCount = source._paraCount
+        new._cursorPos = source._cursorPos
+        new._initCount = source._initCount
+        return new
 
     ##
     #  Action Methods
@@ -293,6 +293,12 @@ class NWItem:
         self._project.tree.refreshItems([self._handle])
         return
 
+    def notifyNovelStructureChange(self) -> None:
+        """Notify that the structure of a novel has changed."""
+        if self._root and self._class == nwItemClass.NOVEL:
+            self._project.tree.novelStructureChanged(self._root)
+        return
+
     ##
     #  Lookup Methods
     ##
@@ -350,11 +356,12 @@ class NWItem:
         """
         if self.isFileType():
             key = "checked" if self._active else "unchecked"
+            color = "green" if self._active else "red"
             text = trConst(nwLabels.ACTIVE_NAME[key])
-            icon = SHARED.theme.getIcon(key)
+            icon = SHARED.theme.getIcon(key, color)
         else:
             text = ""
-            icon = SHARED.theme.getIcon("noncheckable")
+            icon = SHARED.theme.getIcon("noncheckable", "faded")
         return text, icon
 
     ##

novelwriter/core/itemmodel.py

@@ -28,8 +28,8 @@ import logging
 
 from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import QAbstractItemModel, QMimeData, QModelIndex, Qt
-from PyQt5.QtGui import QFont, QIcon
+from PyQt6.QtCore import QAbstractItemModel, QMimeData, QModelIndex, Qt
+from PyQt6.QtGui import QFont, QIcon
 
 from novelwriter.common import decodeMimeHandles, encodeMimeHandles, minmax
 from novelwriter.constants import nwConst
@@ -37,7 +37,7 @@ from novelwriter.core.item import NWItem
 from novelwriter.enum import nwItemClass
 from novelwriter.types import QtAlignRight
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from novelwriter.core.tree import NWTree
 
 logger = logging.getLogger(__name__)
@@ -60,9 +60,7 @@ NODE_FLAGS = Qt.ItemFlag.ItemIsEnabled
 NODE_FLAGS |= Qt.ItemFlag.ItemIsSelectable
 NODE_FLAGS |= Qt.ItemFlag.ItemIsDropEnabled
 
-if TYPE_CHECKING:  # pragma: no cover
-    # Requires Python 3.10
-    T_NodeData = str | QIcon | QFont | Qt.AlignmentFlag | None
+T_NodeData = str | QIcon | QFont | Qt.AlignmentFlag | None
 
 
 class ProjectNode:
@@ -91,7 +89,7 @@ class ProjectNode:
     C_ACTIVE = 2
     C_STATUS = 3
 
-    __slots__ = ("_item", "_children", "_parent", "_row", "_cache", "_flags", "_count")
+    __slots__ = ("_cache", "_children", "_count", "_flags", "_item", "_parent", "_row")
 
     def __init__(self, item: NWItem) -> None:
         self._item = item
@@ -164,7 +162,7 @@ class ProjectNode:
 
     def updateCount(self, propagate: bool = True) -> None:
         """Update counts, and propagate upwards in the tree."""
-        self._count = self._item.wordCount + sum(c._count for c in self._children)
+        self._count = self._item.wordCount + sum(c._count for c in self._children)  # noqa: SLF001
         self._cache[C_COUNT_TEXT] = f"{self._count:n}"
         if propagate and (parent := self._parent):
             parent.updateCount()
@@ -195,7 +193,7 @@ class ProjectNode:
         return self._parent
 
     def child(self, row: int) -> ProjectNode | None:
-        """Return a child ofg the node."""
+        """Return a child of the node."""
         if 0 <= row < len(self._children):
             return self._children[row]
         return None
@@ -220,6 +218,7 @@ class ProjectNode:
             child._row = len(self._children)
             self._children.append(child)
         self._refreshChildrenPos()
+        self._item.notifyNovelStructureChange()
         return
 
     def takeChild(self, pos: int) -> ProjectNode | None:
@@ -228,6 +227,7 @@ class ProjectNode:
             node = self._children.pop(pos)
             self._refreshChildrenPos()
             self.updateCount()
+            self._item.notifyNovelStructureChange()
             return node
         return None
 
@@ -238,6 +238,7 @@ class ProjectNode:
             node = self._children.pop(source)
             self._children.insert(target, node)
             self._refreshChildrenPos()
+            self._item.notifyNovelStructureChange()
         return
 
     def setExpanded(self, state: bool) -> None:
@@ -256,13 +257,13 @@ class ProjectNode:
         """Recursively add all nodes to a list."""
         for node in self._children:
             children.append(node)
-            node._recursiveAppendChildren(children)
+            node._recursiveAppendChildren(children)  # noqa: SLF001
         return
 
     def _refreshChildrenPos(self) -> None:
         """Update the row value on all children."""
         for n, child in enumerate(self._children):
-            child._row = n
+            child._row = n  # noqa: SLF001
             child.item.setOrder(n)
         return
 
@@ -289,12 +290,12 @@ class ProjectModel(QAbstractItemModel):
     methods needed primarily by the project tree GUI component.
     """
 
-    __slots__ = ("_tree", "_root")
+    __slots__ = ("_root", "_tree")
 
     def __init__(self, tree: NWTree) -> None:
         super().__init__()
         self._tree = tree
-        self._root = ProjectNode(NWItem(tree._project, INV_ROOT))
+        self._root = ProjectNode(NWItem(tree.project, INV_ROOT))
         self._root.item.setName("Invisible Root")
         logger.debug("Ready: ProjectModel")
         return
@@ -332,8 +333,9 @@ class ProjectModel(QAbstractItemModel):
             return self.createIndex(parent.row(), 0, parent)
         return QModelIndex()
 
-    def index(self, row: int, column: int, parent: QModelIndex = QModelIndex()) -> QModelIndex:
-        """get the index of a child item of a parent."""
+    def index(self, row: int, column: int, parent: QModelIndex | None = None) -> QModelIndex:
+        """Get the index of a child item of a parent."""
+        parent = parent or QModelIndex()
         if self.hasIndex(row, column, parent):
             node: ProjectNode = parent.internalPointer() if parent.isValid() else self._root
             if child := node.child(row):
@@ -389,10 +391,10 @@ class ProjectModel(QAbstractItemModel):
     ) -> bool:
         """Process mime data drop."""
         if self.canDropMimeData(data, action, row, column, parent):
-            items = []
-            for handle in decodeMimeHandles(data):
-                if (index := self.indexFromHandle(handle)).isValid():
-                    items.append(index)
+            items = [
+                index for handle in decodeMimeHandles(data)
+                if (index := self.indexFromHandle(handle)).isValid()
+            ]
             self.multiMove(items, parent, row)
             return True
         return False
@@ -488,7 +490,7 @@ class ProjectModel(QAbstractItemModel):
                     if temp := self.removeChild(index.parent(), index.row()):
                         self.insertChild(temp, target, pos)
                         for child in reversed(node.allChildren()):
-                            node._updateRelationships(child)
+                            node._updateRelationships(child)  # noqa: SLF001
                             child.item.notifyToRefresh()
                         node.item.notifyToRefresh()
         return
@@ -499,16 +501,15 @@ class ProjectModel(QAbstractItemModel):
 
     def clear(self) -> None:
         """Clear the project model."""
-        self._root._children.clear()
+        self._root.children.clear()
         return
 
     def allExpanded(self) -> list[QModelIndex]:
         """Return a list of all expanded items."""
-        expanded = []
-        for node in self._root.allChildren():
-            if node._item.isExpanded:
-                expanded.append(self.createIndex(node.row(), 0, node))
-        return expanded
+        return [
+            self.createIndex(node.row(), 0, node) for node in self._root.allChildren()
+            if node.item.isExpanded
+        ]
 
     def trashSelection(self, indices: list[QModelIndex]) -> bool:
         """Check if a selection of indices are all in trash or not."""