strictdoc 0.0.54a2__tar.gz → 0.0.55a1__tar.gz

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strictdoc
-Version: 0.0.54a2
+Version: 0.0.55a1
 Summary: StrictDoc is open-source software for technical documentation and requirements management.
 Project-URL: Changelog, https://github.com/strictdoc-project/strictdoc/blob/main/CHANGELOG.md
 Project-URL: Homepage, https://strictdoc.readthedocs.io/en/stable/

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/__init__.py

@@ -1,6 +1,6 @@
 from strictdoc.core.environment import SDocRuntimeEnvironment
 
-__version__ = "0.0.54a2"
+__version__ = "0.0.55a1"
 
 
 environment = SDocRuntimeEnvironment(__file__)

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/backend/sdoc/models/document.py

@@ -94,6 +94,11 @@ class SDocDocument:  # pylint: disable=too-many-instance-attributes
     def get_included_document(self):
         return self.ng_including_document_reference.get_document()
 
+    def iterate_included_documents_depth_first(self):
+        for included_document_ in self.included_documents:
+            yield included_document_
+            yield from included_document_.iterate_included_documents_depth_first()
+
     @property
     def reserved_uid(self) -> Optional[str]:
         return self.config.uid
@@ -107,6 +112,8 @@ class SDocDocument:  # pylint: disable=too-many-instance-attributes
 
     def has_any_toc_nodes(self) -> bool:
         for node_ in self.section_contents:
+            if node_.__class__.__name__ == "DocumentFromFile":
+                return True
             if node_.is_section:
                 if node_.ng_resolved_custom_level != "None":
                     return True

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/commands/diff_command.py

@@ -122,7 +122,8 @@ class DiffCommand:
         html_generator = HTMLGenerator(
             project_config=project_config, html_templates=html_templates
         )
-        # FIXME: Traceability argument is not really important here.
         html_generator.export_assets(
-            traceability_index=change_container.traceability_index_lhs
+            traceability_index=change_container.traceability_index_lhs,
+            project_config=project_config,
+            export_output_html_root=project_config.export_output_html_root,
         )

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/core/actions/passthrough_action.py

@@ -38,8 +38,8 @@ class PassthroughAction:
         for document in traceability_index.document_tree.document_list:
             output, fragments_dict = writer.write_with_fragments(document)
 
-            path_to_output_file_dir = os.path.join(
-                output_dir, document.meta.input_doc_dir_rel_path
+            path_to_output_file_dir: str = os.path.join(
+                output_dir, document.meta.input_doc_dir_rel_path.relative_path
             )
             Path(path_to_output_file_dir).mkdir(parents=True, exist_ok=True)
             path_to_output_file = os.path.join(

strictdoc-0.0.55a1/strictdoc/core/asset_manager.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+
+from strictdoc.helpers.paths import SDocRelativePath
+
+
+@dataclass
+class AssetDir:
+    full_path: str
+    relative_path: SDocRelativePath
+
+    def __post_init__(self):
+        assert isinstance(
+            self.relative_path, SDocRelativePath
+        ), self.relative_path
+
+
+class AssetManager:
+    def __init__(self):
+        self.asset_dirs = []
+        self.asset_dirs_lookup = {}
+
+    def add_asset_dir(self, full_path: str, relative_path: SDocRelativePath):
+        asset_dir = AssetDir(full_path=full_path, relative_path=relative_path)
+        self.asset_dirs.append(asset_dir)
+
+        self.asset_dirs_lookup[relative_path] = asset_dir
+
+    def get_asset_dir_by_relative_path(self, relative_path: str):
+        return self.asset_dirs_lookup[relative_path]
+
+    def iterate(self):
+        yield from self.asset_dirs

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/core/document_finder.py

@@ -7,6 +7,7 @@ from strictdoc.backend.sdoc.grammar_reader import SDocGrammarReader
 from strictdoc.backend.sdoc.models.document import SDocDocument
 from strictdoc.backend.sdoc.models.document_grammar import DocumentGrammar
 from strictdoc.backend.sdoc.reader import SDReader
+from strictdoc.core.asset_manager import AssetManager
 from strictdoc.core.document_meta import DocumentMeta
 from strictdoc.core.document_tree import DocumentTree
 from strictdoc.core.file_tree import (
@@ -17,6 +18,7 @@ from strictdoc.core.file_tree import (
     PathFinder,
 )
 from strictdoc.core.project_config import ProjectConfig
+from strictdoc.helpers.paths import SDocRelativePath
 from strictdoc.helpers.textx import drop_textx_meta
 from strictdoc.helpers.timing import measure_performance, timing_decorator
 
@@ -24,7 +26,9 @@ from strictdoc.helpers.timing import measure_performance, timing_decorator
 class DocumentFinder:
     @staticmethod
     @timing_decorator("Find and read SDoc files")
-    def find_sdoc_content(project_config: ProjectConfig, parallelizer):
+    def find_sdoc_content(
+        project_config: ProjectConfig, parallelizer
+    ) -> Tuple[DocumentTree, AssetManager]:
         for paths_to_files_or_doc in project_config.export_input_paths:
             if not os.path.exists(paths_to_files_or_doc):
                 sys.stdout.flush()
@@ -36,14 +40,14 @@ class DocumentFinder:
                 print(err)  # noqa: T201
                 sys.exit(1)
 
-        file_tree, asset_dirs = DocumentFinder._build_file_tree(
+        file_tree, asset_manager = DocumentFinder._build_file_tree(
             project_config=project_config
         )
         document_tree = DocumentFinder._build_document_tree(
             file_tree, project_config, parallelizer
         )
 
-        return document_tree, asset_dirs
+        return document_tree, asset_manager
 
     @staticmethod
     def _process_worker_parse_document(document_triple, path_to_output_root):
@@ -76,7 +80,7 @@ class DocumentFinder:
 
         document_list: List[SDocDocument] = []
         map_docs_by_paths = {}
-        map_docs_by_rel_paths = {}
+        map_docs_by_rel_paths: Dict[str, SDocDocument] = {}
         map_grammars_by_filenames = {}
 
         file_tree_list: List[Tuple[Union[Folder, File], File, str]] = []
@@ -94,6 +98,10 @@ class DocumentFinder:
 
         doc_file: File
         for doc_file, file_tree_mount_folder, document in found_documents:
+            assert isinstance(
+                file_tree_mount_folder, str
+            ), file_tree_mount_folder
+
             if isinstance(document, DocumentGrammar):
                 map_grammars_by_filenames[doc_file.file_name] = document
                 continue
@@ -104,18 +112,33 @@ class DocumentFinder:
 
             input_doc_full_path = doc_file.get_full_path()
 
-            doc_relative_path_folder = os.path.dirname(doc_file.rel_path)
-            output_document_dir_rel_path = (
-                os.path.join(file_tree_mount_folder, doc_relative_path_folder)
-                if doc_relative_path_folder
+            doc_relative_path_folder: SDocRelativePath = SDocRelativePath(
+                os.path.dirname(doc_file.rel_path.relative_path)
+            )
+            output_document_dir_rel_path: SDocRelativePath = SDocRelativePath(
+                os.path.join(
+                    file_tree_mount_folder,
+                    doc_relative_path_folder.relative_path,
+                )
+                if len(doc_relative_path_folder.relative_path) > 0
                 else file_tree_mount_folder
             )
 
             document_filename = doc_file.file_name
             document_filename_base = os.path.splitext(document_filename)[0]
 
-            output_document_dir_full_path = (
-                f"{output_root_html}/{output_document_dir_rel_path}"
+            output_document_dir_full_path: str = os.path.join(
+                output_root_html, output_document_dir_rel_path.relative_path
+            )
+
+            input_doc_assets_dir_rel_path: SDocRelativePath = SDocRelativePath(
+                os.path.join(
+                    file_tree_mount_folder,
+                    doc_relative_path_folder.relative_path,
+                    "_assets",
+                )
+                if doc_relative_path_folder.length() > 0
+                else "/".join((file_tree_mount_folder, "_assets"))
             )
 
             document_meta = DocumentMeta(
@@ -126,21 +149,23 @@ class DocumentFinder:
                 input_doc_full_path,
                 doc_file.rel_path,
                 doc_relative_path_folder,
+                input_doc_assets_dir_rel_path,
                 output_document_dir_full_path,
                 output_document_dir_rel_path,
             )
             document.assign_meta(document_meta)
 
-            output_document_rel_path = os.path.join(
-                output_document_dir_rel_path, f"{document_filename_base}.html"
-            )
-            # This rel path will be used for lookups of URL pages that are
-            # always "/"-based, even on Windows.
-            output_document_rel_path = output_document_rel_path.replace(
-                "\\", "/"
+            output_document_rel_path: SDocRelativePath = SDocRelativePath(
+                os.path.join(
+                    output_document_dir_rel_path.relative_path,
+                    f"{document_filename_base}.html",
+                )
             )
+
             map_docs_by_paths[input_doc_full_path] = document
-            map_docs_by_rel_paths[output_document_rel_path] = document
+            map_docs_by_rel_paths[output_document_rel_path.relative_path] = (
+                document
+            )
 
         return DocumentTree(
             file_trees,
@@ -153,12 +178,12 @@ class DocumentFinder:
     @staticmethod
     def _build_file_tree(
         project_config: ProjectConfig,
-    ) -> Tuple[List[FileTree], List[Dict]]:
+    ) -> Tuple[List[FileTree], AssetManager]:
         assert isinstance(project_config.export_input_paths, list)
         assert len(project_config.export_input_paths) > 0
 
         root_trees: List[FileTree] = []
-        asset_dirs: List[Dict] = []
+        asset_manager = AssetManager()
 
         for path_to_doc_root_raw in project_config.export_input_paths:
             if os.path.isfile(path_to_doc_root_raw):
@@ -169,15 +194,13 @@ class DocumentFinder:
                 parent_dir = os.path.dirname(path_to_doc_root)
                 path_to_doc_root_base = os.path.dirname(parent_dir)
 
-                assets_dir = os.path.join(parent_dir, "_assets")
+                assets_dir: str = os.path.join(parent_dir, "_assets")
                 if os.path.isdir(assets_dir):
-                    asset_dirs.append(
-                        {
-                            "full_path": assets_dir,
-                            "relative_path": os.path.relpath(
-                                assets_dir, path_to_doc_root_base
-                            ),
-                        }
+                    asset_manager.add_asset_dir(
+                        full_path=assets_dir,
+                        relative_path=SDocRelativePath(
+                            os.path.relpath(assets_dir, path_to_doc_root_base)
+                        ),
                     )
                 root_trees.append(
                     FileTree.create_single_file_tree(path_to_doc_root)
@@ -191,21 +214,19 @@ class DocumentFinder:
             path_to_doc_root_base = os.path.dirname(path_to_doc_root)
 
             # Finding assets.
-            tree_asset_dirs = PathFinder.find_directories(
+            tree_asset_dirs: List[str] = PathFinder.find_directories(
                 path_to_doc_root,
                 "_assets",
                 include_paths=project_config.include_doc_paths,
                 exclude_paths=project_config.exclude_doc_paths,
             )
 
-            for asset_dir in tree_asset_dirs:
-                asset_dirs.append(
-                    {
-                        "full_path": asset_dir,
-                        "relative_path": os.path.relpath(
-                            asset_dir, path_to_doc_root_base
-                        ),
-                    }
+            for asset_dir_ in tree_asset_dirs:
+                asset_manager.add_asset_dir(
+                    full_path=asset_dir_,
+                    relative_path=SDocRelativePath(
+                        os.path.relpath(asset_dir_, path_to_doc_root_base)
+                    ),
                 )
 
             # Finding SDoc files.
@@ -219,4 +240,4 @@ class DocumentFinder:
             )
             root_trees.append(file_tree_structure)
 
-        return root_trees, asset_dirs
+        return root_trees, asset_manager

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/core/document_meta.py

@@ -1,5 +1,6 @@
 from strictdoc.export.html.document_type import DocumentType
 from strictdoc.helpers.auto_described import auto_described
+from strictdoc.helpers.paths import SDocRelativePath
 
 
 @auto_described
@@ -11,10 +12,11 @@ class DocumentMeta:
         document_filename: str,
         document_filename_base,
         input_doc_full_path,
-        input_doc_rel_path: str,
-        input_doc_dir_rel_path,
+        input_doc_rel_path: SDocRelativePath,
+        input_doc_dir_rel_path: SDocRelativePath,
+        input_doc_assets_dir_rel_path: SDocRelativePath,
         output_document_dir_full_path,
-        output_document_dir_rel_path,
+        output_document_dir_rel_path: SDocRelativePath,
     ):
         """
         Example explaining meta data stored by this class:
@@ -27,19 +29,38 @@ class DocumentMeta:
             input_doc_full_path = "/tmp/doc_project/child.sdoc",
             input_doc_rel_path = "child.sdoc",
             input_doc_dir_rel_path = "",
+            input_doc_assets_dir_rel_path = "doc_project/_assets",
             output_document_dir_full_path = "/tmp/doc_project/output/html/doc_project",
             output_document_dir_rel_path = "doc_project"
         )
         """
+        assert isinstance(
+            input_doc_rel_path, SDocRelativePath
+        ), input_doc_rel_path
+        assert isinstance(
+            input_doc_dir_rel_path, SDocRelativePath
+        ), input_doc_dir_rel_path
+        assert isinstance(
+            input_doc_assets_dir_rel_path, SDocRelativePath
+        ), input_doc_assets_dir_rel_path
+        assert isinstance(
+            output_document_dir_rel_path, SDocRelativePath
+        ), output_document_dir_rel_path
+
         self.level = level
         self.file_tree_mount_folder = file_tree_mount_folder
         self.document_filename: str = document_filename
         self.document_filename_base = document_filename_base
         self.input_doc_full_path = input_doc_full_path
-        self.input_doc_rel_path: str = input_doc_rel_path
-        self.input_doc_dir_rel_path = input_doc_dir_rel_path
+        self.input_doc_rel_path: SDocRelativePath = input_doc_rel_path
+        self.input_doc_dir_rel_path: SDocRelativePath = input_doc_dir_rel_path
+        self.input_doc_assets_dir_rel_path: SDocRelativePath = (
+            input_doc_assets_dir_rel_path
+        )
         self.output_document_dir_full_path = output_document_dir_full_path
-        self.output_document_dir_rel_path = output_document_dir_rel_path
+        self.output_document_dir_rel_path: SDocRelativePath = (
+            output_document_dir_rel_path
+        )
 
     # Paths
     def get_html_doc_path(self):
@@ -87,42 +108,42 @@ class DocumentMeta:
     # Links
     def get_html_doc_link(self):
         return (
-            f"{self.output_document_dir_rel_path}"
+            f"{self.output_document_dir_rel_path.relative_path_posix}"
             f"/"
             f"{self.document_filename_base}.html"
         )
 
     def get_html_table_link(self):
         return (
-            f"{self.output_document_dir_rel_path}"
+            f"{self.output_document_dir_rel_path.relative_path_posix}"
             f"/"
             f"{self.document_filename_base}-TABLE.html"
         )
 
     def get_html_traceability_link(self):
         return (
-            f"{self.output_document_dir_rel_path}"
+            f"{self.output_document_dir_rel_path.relative_path_posix}"
             f"/"
             f"{self.document_filename_base}-TRACE.html"
         )
 
     def get_html_deep_traceability_link(self):
         return (
-            f"{self.output_document_dir_rel_path}"
+            f"{self.output_document_dir_rel_path.relative_path_posix}"
             f"/"
             f"{self.document_filename_base}-DEEP-TRACE.html"
         )
 
     def get_html_pdf_link(self):
         return (
-            f"{self.output_document_dir_rel_path}"
+            f"{self.output_document_dir_rel_path.relative_path_posix}"
             f"/"
             f"{self.document_filename_base}-PDF.html"
         )
 
     def get_html_standalone_document_link(self):
         return (
-            f"{self.output_document_dir_rel_path}"
+            f"{self.output_document_dir_rel_path.relative_path_posix}"
             f"/"
             f"{self.document_filename_base}.standalone.html"
         )

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/core/document_tree.py

@@ -42,7 +42,8 @@ class DocumentTree:
         document = self.map_docs_by_paths[doc_full_path]
         return document
 
-    def get_document_by_rel_path(self, doc_rel_path):
+    def get_document_by_rel_path(self, doc_rel_path: str):
+        assert isinstance(doc_rel_path, str), doc_rel_path
         document = self.map_docs_by_rel_paths[doc_rel_path]
         return document
 

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/core/file_tree.py

@@ -4,6 +4,7 @@ import os
 from typing import Dict, List, Optional, Union
 
 from strictdoc.helpers.path_filter import PathFilter
+from strictdoc.helpers.paths import SDocRelativePath
 from strictdoc.helpers.sorting import alphanumeric_sort
 
 
@@ -22,14 +23,15 @@ class FileOrFolderEntry:
 
 
 class File(FileOrFolderEntry):
-    def __init__(self, level, full_path, rel_path: str):
+    def __init__(self, level, full_path, rel_path: SDocRelativePath):
         assert os.path.isfile(full_path)
         assert os.path.isabs(full_path)
-        assert isinstance(rel_path, str)
+        assert isinstance(rel_path, SDocRelativePath)
+
         self.level = level
         self.full_path = full_path
         self.root_path = full_path
-        self.rel_path = rel_path
+        self.rel_path: SDocRelativePath = rel_path
         self.file_name = os.path.basename(self.full_path)
         self.files = [self]
         self.subfolder_trees = []
@@ -112,7 +114,7 @@ class FileTree:
 
     @staticmethod
     def create_single_file_tree(root_path):
-        single_file = File(0, root_path, "")
+        single_file = File(0, root_path, SDocRelativePath(""))
         return FileTree(root_folder_or_file=single_file)
 
     def iterate(self):
@@ -227,7 +229,7 @@ class FileFinder:
                         File(
                             current_tree.level + 1,
                             full_file_path,
-                            rel_file_path,
+                            SDocRelativePath(rel_file_path),
                         )
                     )
 
@@ -276,7 +278,7 @@ class PathFinder:
     @staticmethod
     def find_directories(
         root_path, directory, include_paths: List[str], exclude_paths: List[str]
-    ):
+    ) -> List[str]:
         assert os.path.isdir(root_path)
         assert os.path.isabs(root_path)
 

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/core/traceability_index.py

@@ -90,7 +90,7 @@ class TraceabilityIndex:  # pylint: disable=too-many-public-methods, too-many-in
 
         self.graph_database: GraphDatabase = graph_database
         self.document_tree: Optional[DocumentTree] = None
-        self.asset_dirs = None
+        self.asset_manager = None
         self.index_last_updated = datetime.today()
         self.contains_included_documents = False
         self.strictdoc_last_update = None

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/core/traceability_index_builder.py

@@ -89,7 +89,7 @@ class TraceabilityIndexBuilder:
         ):
             strictdoc_last_update = project_config.config_last_update
 
-        document_tree, asset_dirs = DocumentFinder.find_sdoc_content(
+        document_tree, asset_manager = DocumentFinder.find_sdoc_content(
             project_config=project_config, parallelizer=parallelizer
         )
 
@@ -104,7 +104,7 @@ class TraceabilityIndexBuilder:
             TraceabilityIndexBuilder.create_from_document_tree(document_tree)
         )
         traceability_index.document_tree = document_tree
-        traceability_index.asset_dirs = asset_dirs
+        traceability_index.asset_manager = asset_manager
         traceability_index.strictdoc_last_update = strictdoc_last_update
 
         TraceabilityIndexBuilder._filter_nodes(
@@ -663,23 +663,26 @@ class TraceabilityIndexBuilder:
                 assert isinstance(
                     document_from_file_, DocumentFromFile
                 ), document_from_file_
+
+                resolved_document = map_documents_by_input_rel_path[
+                    document_from_file_.resolved_full_path_to_document_file
+                ]
+
                 if (
                     document_from_file_.resolved_full_path_to_document_file
                     in unique_document_from_file_occurences
-                ):
+                ) and resolved_document.has_any_requirements():
                     raise StrictDocException(
                         "[DOCUMENT_FROM_FILE]: "
                         "A multiple inclusion of a document is detected. "
-                        "A document can be only included once: "
+                        "A document that contains requirements or other nodes "
+                        "can be only included once: "
                         f"{document_from_file_.file}."
                     )
                 unique_document_from_file_occurences.add(
                     document_from_file_.resolved_full_path_to_document_file
                 )
 
-                resolved_document = map_documents_by_input_rel_path[
-                    document_from_file_.resolved_full_path_to_document_file
-                ]
                 document_from_file_.configure_with_resolved_document(
                     resolved_document
                 )

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/export/dot/document_dot_generator.py

@@ -2,7 +2,7 @@ import os
 import random
 from collections import defaultdict
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union
 
 import graphviz
 
@@ -50,12 +50,12 @@ class DocumentDotGenerator:
 
         project_tree_content = ""
 
-        documents_by_folder = defaultdict(list)
+        documents_by_folder: Dict[str, List[SDocDocument]] = defaultdict(list)
         for document in traceability_index.document_tree.document_list:
             if not document.has_any_requirements():
                 continue
             documents_by_folder[
-                document.meta.output_document_dir_rel_path
+                document.meta.output_document_dir_rel_path.relative_path
             ].append(document)
 
         accumulated_links: List[Tuple[str, str]] = []

{strictdoc-0.0.54a2 → strictdoc-0.0.55a1}/strictdoc/export/html/generators/view_objects/document_screen_view_object.py

@@ -9,6 +9,7 @@ from strictdoc.backend.sdoc.models.document import SDocDocument
 from strictdoc.backend.sdoc.models.document_grammar import GrammarElement
 from strictdoc.backend.sdoc.models.document_view import ViewElement
 from strictdoc.core.document_tree_iterator import DocumentTreeIterator
+from strictdoc.core.file_tree import Folder
 from strictdoc.core.project_config import ProjectConfig
 from strictdoc.core.traceability_index import TraceabilityIndex
 from strictdoc.export.html.document_type import DocumentType
@@ -141,6 +142,30 @@ class DocumentScreenViewObject:
 
         return output
 
+    def render_update_document_content_with_moved_node(
+        self, jinja_environment: Environment, moved_node
+    ) -> str:
+        template = jinja_environment.get_template(
+            "screens/document/document/frame_document_content.jinja.html"
+        )
+        output = render_turbo_stream(
+            content=template.render(view_object=self),
+            action="replace",
+            target="frame_document_content",
+        )
+        toc_template = jinja_environment.get_template(
+            "actions/document/_shared/stream_updated_toc.jinja.html"
+        )
+        output += render_turbo_stream(
+            toc_template.render(
+                view_object=self,
+                last_moved_node_id=moved_node.reserved_mid,
+            ),
+            action="update",
+            target="frame-toc",
+        )
+        return output
+
     def is_empty_tree(self) -> bool:
         return self.document_tree_iterator.is_empty_tree()
 
@@ -153,6 +178,16 @@ class DocumentScreenViewObject:
     def iterator_files_first(self):
         yield from self.document_tree_iterator.iterator_files_first()
 
+    def folder_contains_including_documents(self, folder: Folder):
+        assert isinstance(folder, Folder), folder
+        for file_ in folder.files:
+            if not file_.has_extension(".sdoc"):
+                continue
+            document_ = self.get_document_by_path(file_.get_full_path())
+            if not document_.document_is_included():
+                return True
+        return False
+
     def render_url(self, url: str):
         return self.link_renderer.render_url(url)
 
@@ -176,7 +211,7 @@ class DocumentScreenViewObject:
     def date_today(self):
         return datetime.today().strftime("%Y-%m-%d")
 
-    def get_document_by_path(self, full_path: str):
+    def get_document_by_path(self, full_path: str) -> SDocDocument:
         return self.traceability_index.document_tree.get_document_by_path(
             full_path
         )