strictdoc 0.9.0__tar.gz → 0.9.1__tar.gz

{strictdoc-0.9.0 → strictdoc-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strictdoc
-Version: 0.9.0
+Version: 0.9.1
 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.9.0 → strictdoc-0.9.1}/strictdoc/__init__.py

@@ -1,6 +1,6 @@
 from strictdoc.core.environment import SDocRuntimeEnvironment
 
-__version__ = "0.9.0"
+__version__ = "0.9.1"
 
 
 environment = SDocRuntimeEnvironment(__file__)

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/backend/sdoc/errors/document_tree_error.py

@@ -1,15 +1,19 @@
-# mypy: disable-error-code="no-untyped-call,no-untyped-def"
+from typing import List
+
+
 class DocumentTreeError(Exception):
-    def __init__(self, problem_uid, cycled_uids):
+    def __init__(self, problem_uid: str, cycled_uids: List[str]) -> None:
         super().__init__()
-        self.problem_uid = problem_uid
-        self.cycled_uids = cycled_uids
+        self.problem_uid: str = problem_uid
+        self.cycled_uids: List[str] = cycled_uids
 
     @staticmethod
-    def cycle_error(problem_uid, cycled_uids):
+    def cycle_error(
+        problem_uid: str, cycled_uids: List[str]
+    ) -> "DocumentTreeError":
         return DocumentTreeError(problem_uid, cycled_uids)
 
-    def to_print_message(self):
+    def to_print_message(self) -> str:
         cycled_uids = ", ".join(self.cycled_uids)
         message = (
             "error: document tree: "
@@ -19,7 +23,7 @@ class DocumentTreeError(Exception):
         )
         return message
 
-    def to_validation_message(self):
+    def to_validation_message(self) -> str:
         return (
             "A cycle detected: requirements in the document tree must not "
             "reference each other. "

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/backend/sdoc/models/type_system.py

@@ -204,7 +204,7 @@ class GrammarElementRelationParent:
     ):
         assert relation_type == "Parent"
         self.parent = parent
-        self.relation_type = relation_type
+        self.relation_type: str = relation_type
         self.relation_role: Optional[str] = (
             relation_role
             if relation_role is not None and len(relation_role) > 0

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/cli/cli_arg_parser.py

@@ -122,7 +122,7 @@ class ExportCommandConfig:
     def __init__(
         self,
         input_paths,
-        output_dir: str,
+        output_dir: Optional[str],
         config_path: Optional[str],
         project_title: Optional[str],
         formats,
@@ -141,7 +141,7 @@ class ExportCommandConfig:
     ):
         assert isinstance(input_paths, list), f"{input_paths}"
         self.input_paths: List[str] = input_paths
-        self.output_dir: str = output_dir
+        self.output_dir: Optional[str] = output_dir
         self._config_path: Optional[str] = config_path
         self.project_title: Optional[str] = project_title
         self.formats = formats
@@ -156,7 +156,6 @@ class ExportCommandConfig:
         self.reqif_multiline_is_xhtml: bool = reqif_multiline_is_xhtml
         self.reqif_enable_mid: bool = reqif_enable_mid
         self.view: Optional[str] = view
-        self.output_html_root: str = os.path.join(output_dir, "html")
         self.chromedriver: Optional[str] = chromedriver
 
     def get_path_to_config(self) -> str:
@@ -259,14 +258,9 @@ class SDocArgsParser:
     def get_export_config(self) -> ExportCommandConfig:
         project_title: Optional[str] = self.args.project_title
 
-        output_dir = self.args.output_dir if self.args.output_dir else "output"
-        if not os.path.isabs(output_dir):
-            cwd = os.getcwd()
-            output_dir = os.path.join(cwd, output_dir)
-
         return ExportCommandConfig(
             self.args.input_paths,
-            output_dir,
+            self.args.output_dir,
             self.args.config,
             project_title,
             self.args.formats,

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/core/project_config.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import toml
 
-from strictdoc import SDocRuntimeEnvironment
+from strictdoc import SDocRuntimeEnvironment, __version__
 from strictdoc.backend.reqif.sdoc_reqif_fields import ReqIFProfile
 from strictdoc.backend.sdoc.constants import SDocMarkup
 from strictdoc.cli.cli_arg_parser import (
@@ -67,7 +67,7 @@ class ProjectFeature(str, Enum):
 class ProjectConfig:
     DEFAULT_PROJECT_TITLE = "Untitled Project"
     DEFAULT_DIR_FOR_SDOC_ASSETS = "_static"
-    DEFAULT_DIR_FOR_SDOC_CACHE = "$TMPDIR"
+    DEFAULT_DIR_FOR_SDOC_CACHE = "output/_cache"
 
     DEFAULT_FEATURES: List[str] = [
         ProjectFeature.TABLE_SCREEN,
@@ -125,7 +125,7 @@ class ProjectConfig:
         if env_cache_dir := os.environ.get("STRICTDOC_CACHE_DIR"):
             # The only use case for STRICTDOC_CACHE_DIR is to make the cache
             # local to an itest folder.
-            assert env_cache_dir == "Output/cache", env_cache_dir
+            assert env_cache_dir == "Output/_cache", env_cache_dir
             dir_for_sdoc_cache = env_cache_dir
         elif dir_for_sdoc_cache == "$TMPDIR":
             dir_for_sdoc_cache = os.path.join(
@@ -134,6 +134,12 @@ class ProjectConfig:
                 get_md5(os.getcwd()),
             )
 
+        # Adding a __version__ part to the cache directory improves traceability
+        # by indicating which StrictDoc version the cache belongs to.
+        # This helps prevent issues when switching between versions that may use
+        # incompatible cache schemas.
+        dir_for_sdoc_cache = os.path.join(dir_for_sdoc_cache, __version__)
+
         self.dir_for_sdoc_cache: str = dir_for_sdoc_cache
 
         self.project_features: List[str] = project_features
@@ -251,6 +257,14 @@ class ProjectConfig:
         if (output_dir_ := server_config.output_path) is not None:
             self.output_dir = output_dir_
             self.export_output_html_root = os.path.join(output_dir_, "html")
+            # If a custom cache folder is not specified in the config, adjust the
+            # cache folder to be located in the output folder.
+            if self.dir_for_sdoc_cache.startswith(
+                ProjectConfig.DEFAULT_DIR_FOR_SDOC_CACHE
+            ):
+                self.dir_for_sdoc_cache = os.path.join(
+                    output_dir_, "_cache", __version__
+                )
 
         self.export_formats = ["html"]
         self.generate_bundle_document = False
@@ -270,8 +284,27 @@ class ProjectConfig:
             source_root_path = source_root_path.rstrip("/")
             self.source_root_path = source_root_path
 
-        self.output_dir = export_config.output_dir
-        self.export_output_html_root = export_config.output_html_root
+        #
+        # Adjust the default output dir to the user-provided dir if needed.
+        #
+        output_dir = self.output_dir
+        if export_config.output_dir is not None:
+            output_dir = export_config.output_dir
+        if not os.path.isabs(output_dir):
+            cwd = os.getcwd()
+            output_dir = os.path.join(cwd, output_dir)
+        self.output_dir = output_dir
+
+        # If a custom cache folder is not specified in the config, adjust the
+        # cache folder to be located in the output folder.
+        if self.dir_for_sdoc_cache.startswith(
+            ProjectConfig.DEFAULT_DIR_FOR_SDOC_CACHE
+        ):
+            self.dir_for_sdoc_cache = os.path.join(
+                output_dir, "_cache", __version__
+            )
+
+        self.export_output_html_root = os.path.join(self.output_dir, "html")
         self.export_formats = export_config.formats
         self.export_included_documents = export_config.included_documents
         self.generate_bundle_document = export_config.generate_bundle_document

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/core/transforms/update_requirement.py

@@ -121,6 +121,7 @@ class CreateOrUpdateNodeCommand:
                     context_document=self.context_document,
                 ).write_with_validation(field_.field_value)
                 if parsed_html is None:
+                    assert rst_error is not None
                     form_object.add_error(field_.field_name, rst_error)
                 else:
                     try:

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/core/tree_cycle_detector.py

@@ -1,30 +1,30 @@
-# mypy: disable-error-code="no-untyped-call,no-untyped-def"
 from collections import deque
-from typing import Deque, Tuple
+from typing import Callable, Deque, List, Set, Tuple
 
 from strictdoc.backend.sdoc.errors.document_tree_error import DocumentTreeError
-from strictdoc.backend.sdoc.models.model import SDocNodeIF
 
 BEFORE = 1
 AFTER = 2
 
 
 class TreeCycleDetector:
-    def __init__(self):
-        self.checked = set()
+    def __init__(self) -> None:
+        self.checked: Set[str] = set()
 
-    def check_node(self, node: SDocNodeIF, links_function):
+    def check_node(
+        self, node: str, links_function: Callable[[str], List[str]]
+    ) -> None:
         if node in self.checked:
             return
-        stack: Deque[Tuple[SDocNodeIF, int]] = deque()
+        stack: Deque[Tuple[str, int]] = deque()
         stack.append((node, BEFORE))
-        visited = set()
+        visited: Set[str] = set()
         while stack:
             current_node, token = stack[-1]
             if token == BEFORE:
                 visited.add(current_node)
                 stack[-1] = (current_node, AFTER)
-                node_links = links_function(current_node)
+                node_links: List[str] = links_function(current_node)
                 for node_link in reversed(node_links):
                     if node_link in visited:
                         cycled_nodes = []
@@ -45,10 +45,24 @@ class TreeCycleDetector:
 
 
 class SingleShotTreeCycleDetector:
-    def check_node(self, new_uid, node, links_function):
-        checked = set()
+    def check_node(
+        self,
+        new_uid: str,
+        node: str,
+        links_function: Callable[[str], List[str]],
+    ) -> None:
+        """
+        Detect if a newly added node would cause a link/relation cycle in the
+        traceability index.
+
+        FIXME: Both cycle detector classes are very similar. Find a way to merge
+               them. The added value of this 'single shot' detector is that it
+               checks for cycles possibly added by a new node.
+        """
+
+        checked: Set[str] = set()
 
-        stack: Deque[Tuple[SDocNodeIF, int]] = deque()
+        stack: Deque[Tuple[str, int]] = deque()
         stack.append((node, BEFORE))
         visited = {new_uid}
         while stack:

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/export/html/form_objects/requirement_form_object.py

@@ -1,7 +1,6 @@
-# mypy: disable-error-code="arg-type,attr-defined,no-untyped-call,no-untyped-def,union-attr"
 from collections import defaultdict
 from enum import Enum
-from typing import Dict, Iterable, List, Optional, Set, Union
+from typing import Dict, Iterator, List, Optional, Set, Tuple, Union
 
 from starlette.datastructures import FormData
 
@@ -27,10 +26,10 @@ from strictdoc.backend.sdoc.models.type_system import (
     GrammarElementFieldSingleChoice,
     RequirementFieldType,
 )
+from strictdoc.core.constants import GraphLinkType
 from strictdoc.core.graph.abstract_bucket import ALL_EDGES
 from strictdoc.core.project_config import ProjectConfig
 from strictdoc.core.traceability_index import (
-    GraphLinkType,
     TraceabilityIndex,
 )
 from strictdoc.core.tree_cycle_detector import SingleShotTreeCycleDetector
@@ -59,7 +58,7 @@ class RequirementFormField:
         field_type: RequirementFormFieldType,
         field_value: str,
         field_gef_type: str = RequirementFieldType.STRING,
-    ):
+    ) -> None:
         assert isinstance(field_value, str)
         self.field_mid: str = field_mid
         self.field_name: str = field_name
@@ -86,10 +85,10 @@ class RequirementFormField:
             RequirementFieldType.TAG,
         )
 
-    def get_input_field_name(self):
+    def get_input_field_name(self) -> str:
         return f"requirement[fields][{self.field_mid}][value]"
 
-    def get_input_field_type_name(self):
+    def get_input_field_type_name(self) -> str:
         return f"requirement[fields][{self.field_mid}][name]"
 
     @staticmethod
@@ -173,7 +172,7 @@ class RequirementReferenceFormField:
         field_type: FieldType,
         field_value: str,
         field_role: Optional[str],
-    ):
+    ) -> None:
         assert isinstance(field_mid, str), field_mid
         assert isinstance(field_value, str), field_value
         self.field_mid: str = field_mid
@@ -184,13 +183,13 @@ class RequirementReferenceFormField:
         )
         self.validation_messages: List[str] = []
 
-    def get_input_field_name(self):
+    def get_input_field_name(self) -> str:
         return "requirement_relation"
 
-    def get_value_field_name(self):
+    def get_value_field_name(self) -> str:
         return f"requirement[relations][{self.field_mid}][value]"
 
-    def get_type_field_name(self):
+    def get_type_field_name(self) -> str:
         return f"requirement[relations][{self.field_mid}][typerole]"
 
 
@@ -217,7 +216,7 @@ class RequirementFormObject(ErrorObject):
         grammar: DocumentGrammar,
         # FIXME: Better name.
         relation_types: List[str],
-    ):
+    ) -> None:
         super().__init__()
         assert isinstance(element_type, str), element_type
         self.is_new: bool = is_new
@@ -256,7 +255,9 @@ class RequirementFormObject(ErrorObject):
         requirement_fields = defaultdict(list)
         form_ref_fields: List[RequirementReferenceFormField] = []
 
-        context_document_mid = request_form_dict["context_document_mid"]
+        context_document_mid = assert_cast(
+            request_form_dict["context_document_mid"], str
+        )
         requirement_dict = assert_cast(request_form_dict["requirement"], dict)
 
         element_type = assert_cast(request_form_dict["element_type"], str)
@@ -282,24 +283,13 @@ class RequirementFormObject(ErrorObject):
                 relation_role = None
             else:
                 raise AssertionError("Must not reach here")  # pragma: no cover
-            field_type = (
-                RequirementReferenceFormField.FieldType.PARENT
-                if relation_type == "Parent"
-                else (
-                    RequirementReferenceFormField.FieldType.CHILD
-                    if relation_type == "Child"
-                    else (
-                        RequirementReferenceFormField.FieldType.FILE
-                        if relation_type == "File"
-                        else ""
-                    )
-                )
-            )
-            assert field_type in (
-                RequirementReferenceFormField.FieldType.PARENT,
-                RequirementReferenceFormField.FieldType.CHILD,
-                RequirementReferenceFormField.FieldType.FILE,
-            )
+
+            field_type = {
+                "Parent": RequirementReferenceFormField.FieldType.PARENT,
+                "Child": RequirementReferenceFormField.FieldType.CHILD,
+                "File": RequirementReferenceFormField.FieldType.FILE,
+            }[relation_type]
+
             relation_value = relation_dict["value"].strip()
 
             form_ref_fields.append(
@@ -517,7 +507,7 @@ class RequirementFormObject(ErrorObject):
 
         return form_object
 
-    def any_errors(self):
+    def any_errors(self) -> bool:
         if super().any_errors():
             return True
         for reference_field in self.reference_fields:
@@ -565,7 +555,9 @@ class RequirementFormObject(ErrorObject):
                 raise NotImplementedError(ref_type)
         return references
 
-    def enumerate_fields(self, multiline: bool):
+    def enumerate_fields(
+        self, multiline: bool
+    ) -> Iterator[List[RequirementFormField]]:
         for field_name_, field in self.fields.items():
             try:
                 requirement_field: RequirementFormField = field[0]
@@ -582,12 +574,14 @@ class RequirementFormObject(ErrorObject):
                     continue
             yield field
 
-    def enumerate_reference_fields(self):
+    def enumerate_reference_fields(
+        self,
+    ) -> Iterator[List[RequirementReferenceFormField]]:
         yield from self.reference_fields
 
     def enumerate_relation_roles(
         self, relation_field: RequirementReferenceFormField
-    ):
+    ) -> Iterator[Tuple[str, Optional[str], bool]]:
         requirement_element = self.grammar.elements_by_type[self.element_type]
         for relation_ in requirement_element.relations:
             is_current = (
@@ -608,7 +602,7 @@ class RequirementFormObject(ErrorObject):
         traceability_index: TraceabilityIndex,
         context_document: SDocDocument,
         config: ProjectConfig,
-    ):
+    ) -> None:
         assert isinstance(traceability_index, TraceabilityIndex)
         assert isinstance(context_document, SDocDocument)
 
@@ -723,6 +717,7 @@ class RequirementFormObject(ErrorObject):
                             context_document=context_document,
                         ).write_with_validation(field_value)
                         if parsed_html is None:
+                            assert rst_error is not None
                             self.add_error(
                                 grammar_element_field_.title, rst_error
                             )
@@ -834,60 +829,75 @@ class RequirementFormObject(ErrorObject):
                         reference_field.field_type, field_role_or_none
                     )
 
-                    # Check if the relation forms a cycle.
-                    ref_uid = reference_field.field_value
+                    self._validate_no_cycle_by_new_node(
+                        traceability_index, reference_field, requirement_uid
+                    )
 
-                    def parent_lambda(node_id):
-                        node = traceability_index.graph_database.get_link_value(
-                            link_type=GraphLinkType.UID_TO_NODE,
-                            lhs_node=node_id,
-                        )
-                        return list(
-                            map(
-                                lambda node_: node_.reserved_uid,
-                                traceability_index.graph_database.get_link_values(
-                                    link_type=GraphLinkType.NODE_TO_PARENT_NODES,
-                                    lhs_node=node,
-                                    edge=ALL_EDGES,
-                                ),
-                            )
-                        )
+    @staticmethod
+    def _validate_no_cycle_by_new_node(
+        traceability_index: TraceabilityIndex,
+        reference_field: RequirementReferenceFormField,
+        requirement_uid: str,
+    ) -> None:
+        """
+        Check if a relation being added by a new node would form a cycle.
+        """
 
-                    def child_lambda(node_id) -> Iterable[str]:
-                        node = traceability_index.graph_database.get_link_value(
-                            link_type=GraphLinkType.UID_TO_NODE,
-                            lhs_node=node_id,
-                        )
-                        return list(
-                            map(
-                                lambda node_: node_.reserved_uid,
-                                traceability_index.graph_database.get_link_values(
-                                    link_type=GraphLinkType.NODE_TO_CHILD_NODES,
-                                    lhs_node=node,
-                                    edge=ALL_EDGES,
-                                ),
-                            )
-                        )
+        ref_uid = reference_field.field_value
 
-                    relations_lambda = (
-                        parent_lambda
-                        if reference_field.field_type == "Parent"
-                        else child_lambda
-                    )
+        def parent_lambda(node_id: str) -> List[str]:
+            node = traceability_index.graph_database.get_link_value(
+                link_type=GraphLinkType.UID_TO_NODE,
+                lhs_node=node_id,
+            )
+            return list(
+                map(
+                    lambda node_: node_.reserved_uid,
+                    traceability_index.graph_database.get_link_values(
+                        link_type=GraphLinkType.NODE_TO_PARENT_NODES,
+                        lhs_node=node,
+                        edge=ALL_EDGES,
+                    ),
+                )
+            )
 
-                    cycle_detector = SingleShotTreeCycleDetector()
-                    try:
-                        cycle_detector.check_node(
-                            requirement_uid,
-                            ref_uid,
-                            relations_lambda,
-                        )
-                    except DocumentTreeError as error_:
-                        reference_field.validation_messages.append(
-                            error_.to_validation_message()
-                        )
+        def child_lambda(node_id: str) -> List[str]:
+            node = traceability_index.graph_database.get_link_value(
+                link_type=GraphLinkType.UID_TO_NODE,
+                lhs_node=node_id,
+            )
+            return list(
+                map(
+                    lambda node_: node_.reserved_uid,
+                    traceability_index.graph_database.get_link_values(
+                        link_type=GraphLinkType.NODE_TO_CHILD_NODES,
+                        lhs_node=node,
+                        edge=ALL_EDGES,
+                    ),
+                )
+            )
+
+        relations_lambda = (
+            parent_lambda
+            if reference_field.field_type == "Parent"
+            else child_lambda
+        )
+
+        cycle_detector = SingleShotTreeCycleDetector()
+        try:
+            cycle_detector.check_node(
+                requirement_uid,
+                ref_uid,
+                relations_lambda,
+            )
+        except DocumentTreeError as error_:
+            reference_field.validation_messages.append(
+                error_.to_validation_message()
+            )
 
-    def _validate_choice(self, grammar_element_field: GrammarElementField):
+    def _validate_choice(
+        self, grammar_element_field: GrammarElementField
+    ) -> None:
         field_0 = self.fields[grammar_element_field.title][0]
         if len(field_0.field_value) == 0 and not grammar_element_field.required:
             # The empty choice fields are allowed if the field is not REQUIRED.

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/export/rst/rst_to_html_fragment_writer.py

@@ -5,7 +5,7 @@ import os
 import re
 import sys
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 
 from docutils.core import publish_parts
 from docutils.parsers.rst import directives, roles
@@ -145,7 +145,9 @@ class RstToHtmlFragmentWriter:
 
         return html
 
-    def write_with_validation(self, rst_fragment):
+    def write_with_validation(
+        self, rst_fragment
+    ) -> Tuple[Optional[str], Optional[str]]:
         # How do I convert a docutils document tree into an HTML string?
         # https://stackoverflow.com/a/32168938/598057
         # Use a io.StringIO as the warning stream to prevent warnings from

{strictdoc-0.9.0 → strictdoc-0.9.1}/strictdoc/helpers/mid.py

@@ -11,5 +11,5 @@ class MID(str):
     def create() -> "MID":
         return MID(uuid.uuid4().hex)
 
-    def get_string_value(self):
+    def get_string_value(self) -> str:
         return str(self)

strictdoc-0.9.1/strictdoc/server/error_object.py

@@ -0,0 +1,18 @@
+from typing import Dict, List
+
+
+class ErrorObject:
+    def __init__(self) -> None:
+        self.errors: Dict[str, List[str]] = {}
+
+    def any_errors(self) -> bool:
+        return len(self.errors) > 0
+
+    def get_errors(self, field_name: str) -> List[str]:
+        if field_name not in self.errors:
+            return []
+        return self.errors[field_name]
+
+    def add_error(self, field_name: str, error: str) -> None:
+        error_container = self.errors.setdefault(field_name, [])
+        error_container.append(error)

strictdoc-0.9.0/strictdoc/server/error_object.py

@@ -1,16 +0,0 @@
-# mypy: disable-error-code="no-untyped-def"
-class ErrorObject:
-    def __init__(self):
-        self.errors = {}
-
-    def any_errors(self):
-        return len(self.errors)
-
-    def get_errors(self, field_name):
-        if field_name not in self.errors:
-            return []
-        return self.errors[field_name]
-
-    def add_error(self, field_name, error):
-        error_container = self.errors.setdefault(field_name, [])
-        error_container.append(error)