strictdoc 0.0.58a1__tar.gz → 0.0.59__tar.gz

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: strictdoc
-Version: 0.0.58a1
+Version: 0.0.59
 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/
@@ -12,14 +12,13 @@ License-File: NOTICE
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Requires-Dist: beautifulsoup4==4.*,>=4.12.0
 Requires-Dist: docutils==0.*,>=0.16
 Requires-Dist: fastapi>=0.83.0

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/docs_extra/DO178_requirements.sdoc

@@ -10,8 +10,19 @@ OPTIONS:
 
 [GRAMMAR]
 ELEMENTS:
+- TAG: TEXT
+  FIELDS:
+  - TITLE: UID
+    TYPE: String
+    REQUIRED: False
+  - TITLE: STATEMENT
+    TYPE: String
+    REQUIRED: False
 - TAG: REQUIREMENT
   FIELDS:
+  - TITLE: MID
+    TYPE: String
+    REQUIRED: False
   - TITLE: UID
     TYPE: String
     REQUIRED: False

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/docs_extra/Zephyr_requirements.sdoc

@@ -6,6 +6,43 @@ ROOT: True
 OPTIONS:
   ENABLE_MID: True
 
+[GRAMMAR]
+ELEMENTS:
+- TAG: TEXT
+  FIELDS:
+  - TITLE: UID
+    TYPE: String
+    REQUIRED: False
+  - TITLE: STATEMENT
+    TYPE: String
+    REQUIRED: False
+- TAG: REQUIREMENT
+  FIELDS:
+  - TITLE: MID
+    TYPE: String
+    REQUIRED: False
+  - TITLE: UID
+    TYPE: String
+    REQUIRED: False
+  - TITLE: STATUS
+    TYPE: String
+    REQUIRED: False
+  - TITLE: TITLE
+    TYPE: String
+    REQUIRED: False
+  - TITLE: STATEMENT
+    TYPE: String
+    REQUIRED: False
+  - TITLE: RATIONALE
+    TYPE: String
+    REQUIRED: False
+  - TITLE: COMMENT
+    TYPE: String
+    REQUIRED: False
+  RELATIONS:
+  - TYPE: Parent
+  - TYPE: File
+
 [REQUIREMENT]
 MID: 68e87901205c4b0dbb6a0071479330b5
 UID: ZEP-1

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/pyproject.toml

@@ -24,7 +24,7 @@ dynamic = ["version"]
 description = "StrictDoc is open-source software for technical documentation and requirements management."
 readme = "README.md"
 license = "Apache-2.0"
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 authors = [
     { name = "Stanislav Pankevich", email = "s.pankevich@gmail.com" },
     { name = "Maryna Balioura", email = "mettta@gmail.com" },
@@ -36,7 +36,6 @@ classifiers = [
     "License :: OSI Approved :: BSD License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",

strictdoc-0.0.59/requirements.bootstrap.txt

@@ -0,0 +1,5 @@
+invoke
+tox
+toml
+setuptools
+packaging

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/requirements.check.txt

@@ -15,7 +15,7 @@ httpx
 
 # Integration tests
 lit>=0.11.0.post1
-filecheck>=0.0.20
+filecheck>=0.0.20,<1.0.0
 pytidylib>=0.3.2
 openpyxl>=3.0.5
 

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/strictdoc/__init__.py

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

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/strictdoc/backend/excel/export/excel_generator.py

@@ -109,13 +109,10 @@ class ExcelGenerator:
                             if len(parent_refs) > 0:
                                 # TODO Allow multiple parent refs
                                 ref = parent_refs[0]
-                                if (
-                                    len(ref.ref_uid)
-                                    > columns[field][MAX_WIDTH_KEY]
-                                ):
-                                    columns[field][MAX_WIDTH_KEY] = len(
-                                        ref.ref_uid
-                                    )
+                                columns[field][MAX_WIDTH_KEY] = max(
+                                    len(ref.ref_uid),
+                                    columns[field][MAX_WIDTH_KEY],
+                                )
                                 if ref.ref_uid in req_uid_rows:
                                     worksheet.write_url(
                                         row,
@@ -171,15 +168,17 @@ class ExcelGenerator:
                                 )
                                 worksheet.write(row, idx, relations_row_value)
                                 value_len = len(relations_row_value)
-                                if value_len > columns[field][MAX_WIDTH_KEY]:
-                                    columns[field][MAX_WIDTH_KEY] = value_len
+                                columns[field][MAX_WIDTH_KEY] = max(
+                                    value_len, columns[field][MAX_WIDTH_KEY]
+                                )
                         elif field_uc in node.ordered_fields_lookup.keys():
                             req_field = node.ordered_fields_lookup[field_uc][0]
                             value: str = req_field.get_text_value()
                             worksheet.write(row, idx, value)
                             value_len = len(value)
-                            if value_len > columns[field][MAX_WIDTH_KEY]:
-                                columns[field][MAX_WIDTH_KEY] = value_len
+                            columns[field][MAX_WIDTH_KEY] = max(
+                                value_len, columns[field][MAX_WIDTH_KEY]
+                            )
                         elif hasattr(node, "special_fields"):
                             if len(node.special_fields):
                                 for special_field in node.special_fields:

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/strictdoc/backend/excel/import_/excel_to_sdoc_converter.py

@@ -185,7 +185,7 @@ class ExcelToSDocConverter:
 
         template_requirement = SDocObjectFactory.create_requirement(
             document,
-            requirement_type="REQUIREMENT",
+            node_type="REQUIREMENT",
             title=title,
             uid=uid,
             level=None,
@@ -214,8 +214,7 @@ class ExcelToSDocConverter:
             template_requirement.relations = [reference]
         requirement = SDocNode(
             parent=template_requirement.parent,
-            requirement_type=template_requirement.requirement_type,
-            mid=None,
+            node_type=template_requirement.node_type,
             fields=list(template_requirement.enumerate_fields()),
             relations=template_requirement.relations,
         )

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/strictdoc/backend/reqif/p01_sdoc/reqif_to_sdoc_converter.py

@@ -1,5 +1,5 @@
 # mypy: disable-error-code="no-untyped-def,union-attr,operator"
-from typing import Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from reqif.models.reqif_data_type import ReqIFDataTypeDefinitionEnumeration
 from reqif.models.reqif_spec_object import ReqIFSpecObject
@@ -34,7 +34,9 @@ from strictdoc.backend.sdoc.models.type_system import (
     GrammarElementFieldMultipleChoice,
     GrammarElementFieldSingleChoice,
     GrammarElementFieldString,
+    GrammarElementRelationParent,
 )
+from strictdoc.helpers.ordered_set import OrderedSet
 from strictdoc.helpers.string import (
     create_safe_requirement_tag_string,
     ensure_newline,
@@ -49,6 +51,12 @@ class P01_ReqIFToSDocBuildContext:
         self.map_spec_object_type_identifier_to_grammar_node_tags: Dict[
             str, GrammarElement
         ] = {}
+        self.map_source_target_pairs_to_spec_relation_types: Dict[
+            Tuple[str, str], Any
+        ] = {}
+        self.unique_grammar_element_relations: Dict[
+            GrammarElement, OrderedSet[Tuple[str, Optional[str]]]
+        ] = {}
 
 
 class P01_ReqIFToSDocConverter:
@@ -69,6 +77,16 @@ class P01_ReqIFToSDocConverter:
         ):
             return []
 
+        for (
+            spec_relation_
+        ) in reqif_bundle.core_content.req_if_content.spec_relations:
+            spec_relation_type_ = reqif_bundle.lookup.get_spec_type_by_ref(
+                spec_relation_.relation_type_ref
+            )
+            context.map_source_target_pairs_to_spec_relation_types[
+                (spec_relation_.source, spec_relation_.target)
+            ] = spec_relation_type_
+
         documents: List[SDocDocument] = []
         for (
             specification
@@ -131,7 +149,9 @@ class P01_ReqIFToSDocConverter:
         # StrictDoc document is not created with irrelevant grammar elements that
         # actually belong to other Specifications in this ReqIF bundle.
         # Using Dict as an ordered set.
-        spec_object_type_identifiers_used_by_this_document: Dict[str, None] = {}
+        spec_object_type_identifiers_used_by_this_document: OrderedSet[str] = (
+            OrderedSet()
+        )
 
         def node_converter_lambda(
             current_hierarchy_,
@@ -140,9 +160,9 @@ class P01_ReqIFToSDocConverter:
             spec_object = reqif_bundle.get_spec_object_by_ref(
                 current_hierarchy_.spec_object
             )
-            spec_object_type_identifiers_used_by_this_document[
+            spec_object_type_identifiers_used_by_this_document.add(
                 spec_object.spec_object_type
-            ] = None
+            )
 
             is_section = P01_ReqIFToSDocConverter.is_spec_object_section(
                 spec_object,
@@ -181,7 +201,7 @@ class P01_ReqIFToSDocConverter:
         elements: List[GrammarElement] = []
         for (
             spec_object_type_identifier_
-        ) in spec_object_type_identifiers_used_by_this_document.keys():
+        ) in spec_object_type_identifiers_used_by_this_document:
             spec_object_type: ReqIFSpecObjectType = (
                 reqif_bundle.lookup.get_spec_type_by_ref(
                     spec_object_type_identifier_
@@ -194,7 +214,13 @@ class P01_ReqIFToSDocConverter:
                     spec_object_type_identifier_
                 ]
             )
+            if len(grammar_element.relations) == 0:
+                grammar_element.relations = create_default_relations(
+                    grammar_element
+                )
+
             elements.append(grammar_element)
+
         grammar: DocumentGrammar
         if len(elements) > 0:
             grammar = DocumentGrammar(parent=document, elements=elements)
@@ -288,9 +314,6 @@ class P01_ReqIFToSDocConverter:
             fields=fields,
             relations=[],
         )
-        requirement_element.relations = create_default_relations(
-            requirement_element
-        )
         return requirement_element
 
     @staticmethod
@@ -381,8 +404,7 @@ class P01_ReqIFToSDocConverter:
             )
             node: SDocNode = SDocNode(
                 parent=section,
-                requirement_type="TEXT",
-                mid=None,
+                node_type="TEXT",
                 fields=[node_field],
                 relations=[],
             )
@@ -465,8 +487,11 @@ class P01_ReqIFToSDocConverter:
             if (
                 "\n" in attribute_value
                 or attribute.attribute_type == SpecObjectAttributeType.XHTML
-                or field_name == ReqIFRequirementReservedField.TEXT
-                or field_name == ReqIFRequirementReservedField.COMMENT_NOTES
+                or field_name
+                in (
+                    ReqIFRequirementReservedField.TEXT,
+                    ReqIFRequirementReservedField.COMMENT_NOTES,
+                )
             ):
                 attribute_value = attribute_value.lstrip()
                 multiline = True
@@ -499,22 +524,67 @@ class P01_ReqIFToSDocConverter:
                 spec_object_type.identifier
             ]
         )
-
+        if requirement_mid is not None:
+            fields.insert(
+                0,
+                SDocNodeField.create_from_string(
+                    None, "MID", requirement_mid, multiline=False
+                ),
+            )
         requirement = SDocNode(
             parent=parent_section,
-            requirement_type=grammar_element.tag,
-            mid=requirement_mid,
+            node_type=grammar_element.tag,
             fields=fields,
             relations=[],
         )
         requirement.ng_level = level
-
+        for field_ in fields:
+            field_.parent = requirement
         if foreign_key_id_or_none is not None:
             spec_object_parents = reqif_bundle.get_spec_object_parents(
                 spec_object.identifier
             )
             parent_refs: List[Reference] = []
             for spec_object_parent in spec_object_parents:
+                spec_relation_type = (
+                    context.map_source_target_pairs_to_spec_relation_types[
+                        (spec_object.identifier, spec_object_parent)
+                    ]
+                )
+
+                relation_role = (
+                    spec_relation_type.long_name
+                    if spec_relation_type.long_name is not None
+                    else None
+                )
+                if relation_role == "Parent":
+                    relation_role = None
+
+                if (
+                    grammar_element
+                    not in context.unique_grammar_element_relations
+                ):
+                    context.unique_grammar_element_relations[
+                        grammar_element
+                    ] = OrderedSet()
+
+                if (
+                    "Parent",
+                    relation_role,
+                ) not in context.unique_grammar_element_relations[
+                    grammar_element
+                ]:
+                    context.unique_grammar_element_relations[
+                        grammar_element
+                    ].add(("Parent", relation_role))
+                    grammar_element.relations.append(
+                        GrammarElementRelationParent(
+                            parent=grammar_element,
+                            relation_type="Parent",
+                            relation_role=relation_role,
+                        )
+                    )
+
                 parent_spec_object_parent = (
                     reqif_bundle.lookup.get_spec_object_by_ref(
                         spec_object_parent
@@ -527,7 +597,7 @@ class P01_ReqIFToSDocConverter:
                         parent_spec_object_parent.attribute_map[
                             foreign_key_id_or_none
                         ].value,
-                        role=None,
+                        role=relation_role,
                     )
                 )
             if len(parent_refs) > 0:

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/strictdoc/backend/reqif/p01_sdoc/sdoc_to_reqif_converter.py

@@ -3,7 +3,7 @@ import datetime
 import uuid
 from collections import defaultdict
 from enum import Enum
-from typing import Dict, List
+from typing import Dict, List, Optional, Tuple
 
 from reqif.models.reqif_core_content import ReqIFCoreContent
 from reqif.models.reqif_data_type import (
@@ -22,6 +22,7 @@ from reqif.models.reqif_spec_object_type import (
     SpecAttributeDefinition,
 )
 from reqif.models.reqif_spec_relation import ReqIFSpecRelation
+from reqif.models.reqif_spec_relation_type import ReqIFSpecRelationType
 from reqif.models.reqif_specification import ReqIFSpecification
 from reqif.models.reqif_specification_type import ReqIFSpecificationType
 from reqif.models.reqif_types import SpecObjectAttributeType
@@ -29,7 +30,6 @@ from reqif.object_lookup import ReqIFObjectLookup
 from reqif.reqif_bundle import ReqIFBundle
 
 from strictdoc.backend.reqif.sdoc_reqif_fields import (
-    SDOC_SPEC_RELATION_PARENT_TYPE_SINGLETON,
     SDOC_SPECIFICATION_TYPE_SINGLETON,
     SDOC_TO_REQIF_FIELD_MAP,
     ReqIFChapterField,
@@ -38,18 +38,22 @@ from strictdoc.backend.reqif.sdoc_reqif_fields import (
 from strictdoc.backend.sdoc.models.document import SDocDocument
 from strictdoc.backend.sdoc.models.document_grammar import DocumentGrammar
 from strictdoc.backend.sdoc.models.node import SDocNode
-from strictdoc.backend.sdoc.models.reference import ParentReqReference
+from strictdoc.backend.sdoc.models.reference import (
+    ChildReqReference,
+    ParentReqReference,
+    Reference,
+)
 from strictdoc.backend.sdoc.models.section import SDocSection
 from strictdoc.backend.sdoc.models.type_system import (
     GrammarElementField,
     GrammarElementFieldMultipleChoice,
     GrammarElementFieldSingleChoice,
     GrammarElementFieldString,
-    ReferenceType,
 )
 from strictdoc.core.document_iterator import DocumentCachingIterator
 from strictdoc.core.document_tree import DocumentTree
 from strictdoc.helpers.cast import assert_cast
+from strictdoc.helpers.ordered_set import OrderedSet
 from strictdoc.helpers.string import escape
 
 
@@ -69,10 +73,15 @@ class P01_SDocToReqIFBuildContext:
         self.multiline_is_xhtml: bool = multiline_is_xhtml
         self.enable_mid: bool = enable_mid
         self.map_uid_to_spec_objects: Dict[str, ReqIFSpecObject] = {}
-        self.map_uid_to_parent_uids: Dict[str, List[str]] = {}
+        self.map_node_uids_to_their_relations: Dict[str, List[Reference]] = (
+            defaultdict(list)
+        )
         self.map_grammar_node_tags_to_spec_object_type: Dict[
             SDocDocument, Dict[str, ReqIFSpecObjectType]
         ] = defaultdict(dict)
+        self.map_spec_relation_tuple_to_spec_relation_type: Dict[
+            Tuple[str, Optional[str]], ReqIFSpecRelationType
+        ] = {}
 
 
 class P01_SDocToReqIFObjectConverter:
@@ -235,21 +244,22 @@ class P01_SDocToReqIFObjectConverter:
             current_hierarchy = root_hierarchy
 
             # FIXME: ReqIF must export complete documents including fragments.
-            for node in document_iterator.all_content(
+            for node_ in document_iterator.all_content(
                 print_fragments=False, print_fragments_from_files=False
             ):
-                if node.is_composite_requirement:
+                if node_.is_composite_requirement:
                     raise NotImplementedError(
                         "Exporting composite requirements is not "
                         "supported yet.",
-                        node,
+                        node_,
                     )
-                if node.is_section:
+                if node_.is_section:
+                    section: SDocSection = assert_cast(node_, SDocSection)
                     # fmt: off
                     spec_object = (
                         P01_SDocToReqIFObjectConverter
                         ._convert_section_to_spec_object(
-                            section=node,
+                            section=section,
                             context=context,
                         )
                     )
@@ -264,14 +274,14 @@ class P01_SDocToReqIFObjectConverter:
                         spec_object=spec_object.identifier,
                         children=[],
                         ref_then_children_order=True,
-                        level=node.ng_level,
+                        level=section.ng_level,
                     )
-                    if node.ng_level > current_hierarchy.level:
+                    if section.ng_level > current_hierarchy.level:
                         parents[hierarchy] = current_hierarchy
                         current_hierarchy.add_child(hierarchy)
-                    elif node.ng_level < current_hierarchy.level:
+                    elif section.ng_level < current_hierarchy.level:
                         for _ in range(
-                            0, (current_hierarchy.level - node.ng_level + 1)
+                            0, (current_hierarchy.level - section.ng_level + 1)
                         ):
                             current_hierarchy = parents[current_hierarchy]
                         current_hierarchy.add_child(hierarchy)
@@ -282,9 +292,10 @@ class P01_SDocToReqIFObjectConverter:
                         parents[hierarchy] = current_hierarchy_parent
                     current_hierarchy = hierarchy
 
-                elif node.is_requirement:
+                elif node_.is_requirement:
+                    requirement = assert_cast(node_, SDocNode)
                     spec_object = cls._convert_requirement_to_spec_object(
-                        requirement=node,
+                        requirement=requirement,
                         grammar=assert_cast(document.grammar, DocumentGrammar),
                         context=context,
                         data_types=data_types,
@@ -302,10 +313,10 @@ class P01_SDocToReqIFObjectConverter:
                         spec_object=spec_object.identifier,
                         children=None,
                         ref_then_children_order=True,
-                        level=node.ng_level,
+                        level=requirement.ng_level,
                     )
                     for _ in range(
-                        0, (current_hierarchy.level - node.ng_level + 1)
+                        0, (current_hierarchy.level - requirement.ng_level + 1)
                     ):
                         current_hierarchy = parents[current_hierarchy]
                     parents[hierarchy] = current_hierarchy
@@ -332,18 +343,31 @@ class P01_SDocToReqIFObjectConverter:
 
         for (
             requirement_id,
-            parent_uids,
-        ) in context.map_uid_to_parent_uids.items():
+            node_relations_,
+        ) in context.map_node_uids_to_their_relations.items():
             spec_object = context.map_uid_to_spec_objects[requirement_id]
-            for parent_uid in parent_uids:
-                parent_spec_object = context.map_uid_to_spec_objects[parent_uid]
+            for node_relation_ in node_relations_:
+                # For now, the File-relations are not supported.
+                if not isinstance(
+                    node_relation_, (ParentReqReference, ChildReqReference)
+                ):
+                    continue
+                related_node_uid = node_relation_.ref_uid
+                parent_spec_object = context.map_uid_to_spec_objects[
+                    related_node_uid
+                ]
+                spec_relation_type: ReqIFSpecRelationType = (
+                    context.map_spec_relation_tuple_to_spec_relation_type[
+                        (node_relation_.ref_type, node_relation_.role)
+                    ]
+                )
                 spec_relations.append(
                     ReqIFSpecRelation(
                         xml_node=None,
                         description=None,
                         identifier=generate_unique_identifier("SPEC-RELATION"),
                         last_change=None,
-                        relation_type_ref=SDOC_SPEC_RELATION_PARENT_TYPE_SINGLETON,
+                        relation_type_ref=spec_relation_type.identifier,
                         source=spec_object.identifier,
                         target=parent_spec_object.identifier,
                         values_attribute=None,
@@ -461,10 +485,13 @@ class P01_SDocToReqIFObjectConverter:
         else:
             requirement_identifier = generate_unique_identifier("REQUIREMENT")
 
-        grammar_element = grammar.elements_by_type[requirement.requirement_type]
+        grammar_element = grammar.elements_by_type[requirement.node_type]
 
         attributes: List[SpecObjectAttribute] = []
         for field in requirement.fields_as_parsed:
+            # The MID field, if exists, is extracted separately as a ReqIF Identifier.
+            if field.field_name == "MID":
+                continue
             grammar_field = grammar_element.fields_map[field.field_name]
             if isinstance(grammar_field, GrammarElementFieldSingleChoice):
                 data_type_ref = data_types_lookup[field.field_name]
@@ -539,23 +566,15 @@ class P01_SDocToReqIFObjectConverter:
             attributes.append(attribute)
 
         if requirement.reserved_uid is not None:
-            parent_references: List[str] = []
-            for reference in requirement.relations:
-                if reference.ref_type != ReferenceType.PARENT:
-                    continue
-                parent_reference: ParentReqReference = assert_cast(
-                    reference, ParentReqReference
-                )
-                parent_references.append(parent_reference.ref_uid)
-
-            context.map_uid_to_parent_uids[requirement.reserved_uid] = (
-                parent_references
-            )
+            if len(requirement.relations) > 0:
+                context.map_node_uids_to_their_relations[
+                    requirement.reserved_uid
+                ] = requirement.relations
 
         spec_object_type: ReqIFSpecObjectType = (
             context.map_grammar_node_tags_to_spec_object_type[
                 requirement.document
-            ][requirement.requirement_type]
+            ][requirement.node_type]
         )
         spec_object = ReqIFSpecObject.create(
             identifier=requirement_identifier,
@@ -665,7 +684,31 @@ class P01_SDocToReqIFObjectConverter:
         ] = section_spec_type
         spec_object_types.append(section_spec_type)
 
-        return spec_object_types
+        # Using dict as an ordered set.
+        spec_relation_tuples: OrderedSet = OrderedSet()
+        for element_ in grammar.elements:
+            for relation_ in element_.relations:
+                spec_relation_tuples.add(
+                    (relation_.relation_type, relation_.relation_role)
+                )
+
+        spec_relation_types: List = []
+        for spec_relation_tuple_ in spec_relation_tuples:
+            spec_relation_type_name = (
+                spec_relation_tuple_[1]
+                if spec_relation_tuple_[1] is not None
+                else spec_relation_tuple_[0]
+            )
+            spec_relation_type = ReqIFSpecRelationType(
+                identifier=generate_unique_identifier(spec_relation_type_name),
+                long_name=spec_relation_type_name,
+            )
+            spec_relation_types.append(spec_relation_type)
+            context.map_spec_relation_tuple_to_spec_relation_type[
+                spec_relation_tuple_
+            ] = spec_relation_type
+
+        return spec_object_types + spec_relation_types
 
     @classmethod
     def _create_section_spec_object_type(

{strictdoc-0.0.58a1 → strictdoc-0.0.59}/strictdoc/backend/reqif/sdoc_reqif_fields.py

@@ -62,7 +62,3 @@ DEFAULT_SDOC_GRAMMAR_FIELDS = [
 ]
 
 SDOC_SPECIFICATION_TYPE_SINGLETON = "SDOC_SPECIFICATION_TYPE_SINGLETON"
-
-SDOC_SPEC_RELATION_PARENT_TYPE_SINGLETON = (
-    "SDOC_SPEC_RELATION_PARENT_TYPE_SINGLETON"
-)