strictdoc 0.1.0__tar.gz → 0.2.1__tar.gz

{strictdoc-0.1.0 → strictdoc-0.2.1}/PKG-INFO

@@ -1,14 +1,11 @@
 Metadata-Version: 2.3
 Name: strictdoc
-Version: 0.1.0
+Version: 0.2.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/
 Project-URL: Source, https://github.com/strictdoc-project/strictdoc
 Author-email: Stanislav Pankevich <s.pankevich@gmail.com>, Maryna Balioura <mettta@gmail.com>
-License-Expression: Apache-2.0
-License-File: LICENSE
-License-File: NOTICE
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/__init__.py

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

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/grammar_reader.py

@@ -12,6 +12,7 @@ from strictdoc.backend.sdoc.models.document_grammar import (
     DocumentGrammarWrapper,
 )
 from strictdoc.backend.sdoc.pickle_cache import PickleCache
+from strictdoc.core.project_config import ProjectConfig
 from strictdoc.helpers.cast import assert_optional_cast
 from strictdoc.helpers.textx import (
     drop_textx_meta,
@@ -26,9 +27,6 @@ class SDocGrammarReader:
         use_regexp_group=True,
     )
 
-    def __init__(self, path_to_output_root: str) -> None:
-        self.path_to_output_root: str = path_to_output_root
-
     @staticmethod
     def read(
         input_string: str, file_path: Optional[str] = None
@@ -60,9 +58,11 @@ class SDocGrammarReader:
 
         return grammar
 
-    def read_from_file(self, file_path: str) -> DocumentGrammar:
+    def read_from_file(
+        self, file_path: str, project_config: ProjectConfig
+    ) -> DocumentGrammar:
         unpickled_content: Optional[DocumentGrammar] = assert_optional_cast(
-            PickleCache.read_from_cache(file_path, self.path_to_output_root),
+            PickleCache.read_from_cache(file_path, project_config, "grammar"),
             DocumentGrammar,
         )
         if unpickled_content is not None:
@@ -76,7 +76,7 @@ class SDocGrammarReader:
                 grammar_content, file_path=file_path
             )
             PickleCache.save_to_cache(
-                grammar, file_path, self.path_to_output_root
+                grammar, file_path, project_config, "grammar"
             )
 
             return grammar

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/models/document.py

@@ -1,3 +1,7 @@
+"""
+@relation(SDOC-SRS-109, scope=file)
+"""
+
 # mypy: disable-error-code="union-attr,type-arg"
 from typing import Generator, List, Optional
 

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/models/document_from_file.py

@@ -1,3 +1,7 @@
+"""
+@relation(SDOC-SRS-109, scope=file)
+"""
+
 # mypy: disable-error-code="no-untyped-def,type-arg"
 from typing import List, Optional
 

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/models/document_grammar.py

@@ -210,7 +210,7 @@ class DocumentGrammar:
             DocumentGrammar.create_default_text_element()
         )
 
-        # @sdoc[SDOC-SRS-132]
+        # @relation(SDOC-SRS-132, scope=range_start)
         fields: List[
             Union[
                 GrammarElementFieldString,
@@ -270,7 +270,7 @@ class DocumentGrammar:
         requirement_element = GrammarElement(
             parent=None, tag="REQUIREMENT", fields=fields, relations=[]
         )
-        # @sdoc[/SDOC-SRS-132]
+        # @relation(SDOC-SRS-132, scope=range_end)
 
         requirement_element.relations = create_default_relations(
             requirement_element

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/models/free_text.py

@@ -1,3 +1,7 @@
+"""
+@relation(SDOC-SRS-135, scope=file)
+"""
+
 from typing import Any, List, Optional
 
 from strictdoc.backend.sdoc.models.anchor import Anchor

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/models/node.py

@@ -1,3 +1,7 @@
+"""
+@relation(SDOC-SRS-26, scope=file)
+"""
+
 # mypy: disable-error-code="union-attr"
 from collections import OrderedDict
 from typing import Any, Generator, List, Optional, Tuple, Union

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/models/section.py

@@ -1,3 +1,7 @@
+"""
+@relation(SDOC-SRS-99, scope=file)
+"""
+
 # mypy: disable-error-code="attr-defined,no-untyped-call,no-untyped-def,union-attr"
 from typing import List, Optional, Union
 

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/pickle_cache.py

@@ -1,18 +1,20 @@
 import hashlib
 import os
-import tempfile
 from pathlib import Path
 from typing import Any
 
+from strictdoc.core.project_config import ProjectConfig
 from strictdoc.helpers.md5 import get_file_md5
 from strictdoc.helpers.pickle import pickle_dump, pickle_load
 
 
 class PickleCache:
     @staticmethod
-    def read_from_cache(file_path: str, path_to_root: str) -> Any:
+    def read_from_cache(
+        file_path: str, project_config: ProjectConfig, content_kind: str
+    ) -> Any:
         path_to_cached_file: str = PickleCache.get_cached_file_path(
-            file_path, path_to_root
+            file_path, project_config, content_kind
         )
         if os.path.isfile(path_to_cached_file):
             with open(path_to_cached_file, "rb") as cache_file:
@@ -30,9 +32,14 @@ class PickleCache:
         return None
 
     @staticmethod
-    def save_to_cache(content: Any, file_path: str, path_to_root: str) -> None:
+    def save_to_cache(
+        content: Any,
+        file_path: str,
+        project_config: ProjectConfig,
+        content_kind: str,
+    ) -> None:
         path_to_cached_file: str = PickleCache.get_cached_file_path(
-            file_path, path_to_root
+            file_path, project_config, content_kind
         )
         path_to_cached_file_dir: str = os.path.dirname(path_to_cached_file)
         Path(path_to_cached_file_dir).mkdir(parents=True, exist_ok=True)
@@ -41,8 +48,10 @@ class PickleCache:
             cache_file.write(pickled_content)
 
     @staticmethod
-    def get_cached_file_path(file_path: str, path_to_output_root: str) -> str:
-        path_to_tmp_dir = tempfile.gettempdir()
+    def get_cached_file_path(
+        file_path: str, project_config: ProjectConfig, content_kind: str
+    ) -> str:
+        path_to_tmp_dir = project_config.get_path_to_cache_dir()
 
         full_path_to_file = (
             file_path
@@ -57,7 +66,7 @@ class PickleCache:
         # contains a full path to the output root to prevent collisions
         # between StrictDoc invocations running against the same set of SDoc
         # files in parallel.
-        unique_identifier = path_to_output_root + full_path_to_file
+        unique_identifier = project_config.output_dir + full_path_to_file
         unique_identifier_md5 = hashlib.md5(
             unique_identifier.encode("utf-8")
         ).hexdigest()
@@ -66,7 +75,7 @@ class PickleCache:
 
         path_to_cached_file = os.path.join(
             path_to_tmp_dir,
-            "strictdoc_cache",
+            content_kind,
             file_name,
         )
 

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc/reader.py

@@ -11,6 +11,7 @@ from strictdoc.backend.sdoc.models.constants import DOCUMENT_MODELS
 from strictdoc.backend.sdoc.models.document import SDocDocument
 from strictdoc.backend.sdoc.pickle_cache import PickleCache
 from strictdoc.backend.sdoc.processor import ParseContext, SDocParsingProcessor
+from strictdoc.core.project_config import ProjectConfig
 from strictdoc.helpers.cast import assert_cast
 from strictdoc.helpers.exception import StrictDocException
 from strictdoc.helpers.textx import drop_textx_meta
@@ -23,9 +24,6 @@ class SDReader:
         use_regexp_group=True,
     )
 
-    def __init__(self, path_to_output_root: str = "NOT_RELEVANT"):
-        self.path_to_output_root = path_to_output_root
-
     @staticmethod
     def _read(input_string, file_path=None):
         parse_context = ParseContext(path_to_sdoc_file=file_path)
@@ -54,14 +52,16 @@ class SDReader:
         document, parse_context = SDReader._read(input_string, file_path)
         return document, parse_context
 
-    def read_from_file(self, file_path: str) -> SDocDocument:
+    def read_from_file(
+        self, file_path: str, project_config: ProjectConfig
+    ) -> SDocDocument:
         """
         This function parses the provided .sdoc file and returns a Document
         object.
         """
 
         unpickled_content = PickleCache.read_from_cache(
-            file_path, self.path_to_output_root
+            file_path, project_config, "sdoc"
         )
         if unpickled_content:
             return assert_cast(unpickled_content, SDocDocument)
@@ -82,7 +82,7 @@ class SDReader:
             # are not used anyway.
             drop_textx_meta(sdoc)
 
-            PickleCache.save_to_cache(sdoc, file_path, self.path_to_output_root)
+            PickleCache.save_to_cache(sdoc, file_path, project_config, "sdoc")
 
             return sdoc
         except StrictDocException as exception:

strictdoc-0.2.1/strictdoc/backend/sdoc_source_code/caching_reader.py

@@ -0,0 +1,59 @@
+from typing import Union
+
+from strictdoc.backend.sdoc.pickle_cache import PickleCache
+from strictdoc.backend.sdoc_source_code.models.source_file_info import (
+    SourceFileTraceabilityInfo,
+)
+from strictdoc.backend.sdoc_source_code.reader import (
+    SourceFileTraceabilityReader,
+)
+from strictdoc.backend.sdoc_source_code.reader_c import (
+    SourceFileTraceabilityReader_C,
+)
+from strictdoc.backend.sdoc_source_code.reader_python import (
+    SourceFileTraceabilityReader_Python,
+)
+from strictdoc.core.project_config import ProjectConfig
+
+
+class SourceFileTraceabilityCachingReader:
+    @staticmethod
+    def read_from_file(
+        path_to_file: str, project_config: ProjectConfig
+    ) -> SourceFileTraceabilityInfo:
+        unpickled_content = PickleCache.read_from_cache(
+            path_to_file, project_config, "source_file"
+        )
+        if unpickled_content is not None:
+            assert isinstance(unpickled_content, SourceFileTraceabilityInfo), (
+                path_to_file,
+                unpickled_content,
+            )
+            return unpickled_content
+
+        reader = SourceFileTraceabilityCachingReader._get_reader(
+            path_to_file, project_config
+        )
+        traceability_info: SourceFileTraceabilityInfo = reader.read_from_file(
+            path_to_file
+        )
+        PickleCache.save_to_cache(
+            traceability_info, path_to_file, project_config, "source_file"
+        )
+
+        return traceability_info
+
+    @staticmethod
+    def _get_reader(
+        path_to_file: str, project_config: ProjectConfig
+    ) -> Union[
+        SourceFileTraceabilityReader,
+        SourceFileTraceabilityReader_Python,
+        SourceFileTraceabilityReader_C,
+    ]:
+        if project_config.is_activated_source_file_language_parsers():
+            if path_to_file.endswith(".py"):
+                return SourceFileTraceabilityReader_Python()
+            if path_to_file.endswith(".c"):
+                return SourceFileTraceabilityReader_C()
+        return SourceFileTraceabilityReader()

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc_source_code/grammar.py

@@ -7,7 +7,7 @@ Part[noskipws]:
   // The EmptyLine is needed in addition to the SingleLineString because
   // otherwise textX's get_location() ignores the whitespaces.
   // TODO: Maybe there is a trick to disable that and only use SingleLineString.
-  EmptyLine | RangeMarker | LineMarker | SingleLineString
+  EmptyLine | RangeMarker | LineMarker | FunctionRangeMarker | SingleLineString
 ;
 
 EmptyLine[noskipws]:
@@ -31,6 +31,11 @@ RangeMarker[noskipws]:
   )
 ;
 
+FunctionRangeMarker[noskipws]:
+  /^.*?@relation/
+  "(" (reqs_objs += Req[', ']) ', scope=file)' '\n'?
+;
+
 LineMarker[noskipws]:
   // It is a hard-won result: it is important that the "@sdoc" is within the
   // regex. Putting it next to the regex as "@sdoc" does not work.

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc_source_code/marker_parser.py

@@ -1,5 +1,5 @@
 import re
-from typing import List, Union
+from typing import List, Optional, Union
 
 from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
     FunctionRangeMarker,
@@ -23,6 +23,7 @@ class MarkerParser:
         line_end: int,
         comment_line_start: int,
         comment_column_start: int,
+        entity_name: Optional[str] = None,
     ) -> List[Union[FunctionRangeMarker, RangeMarker, LineMarker]]:
         markers: List[Union[FunctionRangeMarker, RangeMarker, LineMarker]] = []
         for input_line_idx_, input_line_ in enumerate(
@@ -63,6 +64,12 @@ class MarkerParser:
                 function_marker.ng_range_line_end = line_end
                 function_marker.ng_marker_line = current_line
                 function_marker.ng_marker_column = first_requirement_column
+                if marker_type == "file":
+                    function_marker.set_description("the whole file")
+                elif marker_type == "function":
+                    function_marker.set_description(f"function {entity_name}")
+                elif marker_type == "class":
+                    function_marker.set_description(f"class {entity_name}")
                 markers.append(function_marker)
             elif marker_type in ("range_start", "range_end"):
                 start_or_end = marker_type == "range_start"
@@ -73,7 +80,7 @@ class MarkerParser:
                 range_marker.ng_source_column_begin = first_requirement_column
                 range_marker.ng_range_line_begin = line_start
                 range_marker.ng_range_line_end = line_end
-                range_marker.ng_is_language_parsed = True
+                range_marker.ng_new_relation_keyword = True
                 markers.append(range_marker)
             elif marker_type == "line":
                 line_marker = LineMarker(None, requirements)

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc_source_code/models/function_range_marker.py

@@ -1,10 +1,17 @@
 # mypy: disable-error-code="no-untyped-def,type-arg"
+from enum import Enum
 from typing import List, Optional
 
 from strictdoc.backend.sdoc_source_code.models.requirement_marker import Req
 from strictdoc.helpers.auto_described import auto_described
 
 
+class RangeMarkerType(Enum):
+    FUNCTION = "function"
+    CLASS = "class"
+    FILE = "file"
+
+
 @auto_described
 class FunctionRangeMarker:
     def __init__(self, parent, reqs_objs: List[Req]):
@@ -33,6 +40,8 @@ class FunctionRangeMarker:
 
         self.ng_is_nodoc = "nosdoc" in self.reqs
 
+        self._description: Optional[str] = None
+
     def is_range_marker(self) -> bool:
         return True
 
@@ -45,6 +54,13 @@ class FunctionRangeMarker:
     def is_end(self) -> bool:
         return False
 
+    def get_description(self) -> Optional[str]:
+        return self._description
+
+    def set_description(self, description: str) -> None:
+        assert isinstance(description, str)
+        self._description = description
+
 
 @auto_described
 class ForwardFunctionRangeMarker(FunctionRangeMarker):

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc_source_code/models/range_marker.py

@@ -24,6 +24,7 @@ class RangeMarker:
         else:
             assert scope in ("range_start", "range_end")
             self.begin_or_end = "[" if scope == "range_start" else "[/"
+            self.ng_new_relation_keyword = True
 
         self.reqs_objs: List[Req] = reqs_objs
         self.reqs: List[str] = list(map(lambda req: req.uid, reqs_objs))
@@ -44,7 +45,7 @@ class RangeMarker:
         self.ng_range_line_end: Optional[int] = None
 
         self.ng_is_nodoc = "nosdoc" in self.reqs
-        self.ng_is_language_parsed = False
+        self.ng_new_relation_keyword = False
 
     def is_begin(self) -> bool:
         return self.begin_or_end == "["
@@ -58,6 +59,9 @@ class RangeMarker:
     def is_line_marker(self) -> bool:
         return False
 
+    def get_description(self) -> Optional[str]:
+        return "range"
+
 
 @auto_described
 class LineMarker:
@@ -88,6 +92,9 @@ class LineMarker:
     def is_line_marker(self) -> bool:
         return True
 
+    def get_description(self) -> Optional[str]:
+        return "line"
+
 
 @auto_described
 class ForwardRangeMarker:
@@ -116,3 +123,6 @@ class ForwardRangeMarker:
 
     def is_line_marker(self) -> bool:
         return False
+
+    def get_description(self) -> Optional[str]:
+        return "range"

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc_source_code/reader.py

@@ -8,6 +8,9 @@ from textx import get_location, metamodel_from_str
 
 from strictdoc.backend.sdoc.error_handling import StrictDocSemanticError
 from strictdoc.backend.sdoc_source_code.grammar import SOURCE_FILE_GRAMMAR
+from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
+    FunctionRangeMarker,
+)
 from strictdoc.backend.sdoc_source_code.models.range_marker import (
     LineMarker,
     RangeMarker,
@@ -206,22 +209,49 @@ def line_marker_processor(line_marker: LineMarker, parse_context: ParseContext):
         markers.append(line_marker)
 
 
+def function_range_marker_processor(
+    function_range_marker: FunctionRangeMarker, parse_context: ParseContext
+):
+    location = get_location(function_range_marker)
+    line = location["line"]
+    column = location["col"]
+
+    if (
+        len(parse_context.marker_stack) > 0
+        and parse_context.marker_stack[-1].ng_is_nodoc
+    ):
+        # This marker is within a "nosdoc" block, so we ignore it.
+        return
+
+    parse_context.markers.append(function_range_marker)
+    function_range_marker.ng_source_line_begin = 1
+    function_range_marker.ng_range_line_begin = 1
+    function_range_marker.ng_range_line_end = parse_context.lines_total
+    function_range_marker.ng_marker_line = line
+    function_range_marker.ng_marker_column = column
+
+    for req in function_range_marker.reqs:
+        markers = parse_context.map_reqs_to_markers.setdefault(req, [])
+        markers.append(function_range_marker)
+
+
 class SourceFileTraceabilityReader:
     SOURCE_FILE_MODELS = [
-        Req,
+        FunctionRangeMarker,
         LineMarker,
+        Req,
         SourceFileTraceabilityInfo,
         RangeMarker,
     ]
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.meta_model = metamodel_from_str(
             SOURCE_FILE_GRAMMAR,
             classes=SourceFileTraceabilityReader.SOURCE_FILE_MODELS,
             use_regexp_group=True,
         )
 
-    def read(self, input_string, file_path=None):
+    def read(self, input_string, file_path=None) -> SourceFileTraceabilityInfo:
         # TODO: This might be possible to handle directly in the textx grammar.
         # AttributeError: 'str' object has no attribute '_tx_parser'
         file_size = len(input_string)
@@ -241,8 +271,12 @@ class SourceFileTraceabilityReader:
         parse_line_marker_processor = partial(
             line_marker_processor, parse_context=parse_context
         )
+        parse_function_range_marker_processor = partial(
+            function_range_marker_processor, parse_context=parse_context
+        )
 
         obj_processors = {
+            "FunctionRangeMarker": parse_function_range_marker_processor,
             "LineMarker": parse_line_marker_processor,
             "RangeMarker": parse_range_marker_processor,
             "Req": parse_req_processor,
@@ -271,7 +305,7 @@ class SourceFileTraceabilityReader:
         drop_textx_meta(source_file_traceability_info)
         return source_file_traceability_info
 
-    def read_from_file(self, file_path):
+    def read_from_file(self, file_path) -> SourceFileTraceabilityInfo:
         try:
             with open(file_path, encoding="utf-8") as file:
                 sdoc_content = file.read()

{strictdoc-0.1.0 → strictdoc-0.2.1}/strictdoc/backend/sdoc_source_code/reader_c.py

@@ -1,10 +1,10 @@
 # mypy: disable-error-code="no-redef,no-untyped-call,no-untyped-def,type-arg,var-annotated"
 import sys
 import traceback
-from typing import List, Union
+from typing import List, Optional, Union
 
 import tree_sitter_c
-from tree_sitter import Language, Parser
+from tree_sitter import Language, Node, Parser
 
 from strictdoc.backend.sdoc.error_handling import StrictDocSemanticError
 from strictdoc.backend.sdoc_source_code.marker_parser import MarkerParser
@@ -31,7 +31,9 @@ from strictdoc.helpers.string import get_lines_count
 
 
 class SourceFileTraceabilityReader_C:
-    def read(self, input_buffer: bytes, file_path=None):
+    def read(
+        self, input_buffer: bytes, file_path=None
+    ) -> SourceFileTraceabilityInfo:
         assert isinstance(input_buffer, bytes)
 
         file_size = len(input_buffer)
@@ -55,7 +57,36 @@ class SourceFileTraceabilityReader_C:
 
         nodes = traverse_tree(tree)
         for node_ in nodes:
-            if node_.type == "function_definition":
+            if node_.type == "translation_unit":
+                if (
+                    len(node_.children) > 0
+                    and node_.children[0].type == "comment"
+                    and (comment_node := node_.children[0])
+                ):
+                    if comment_node.text is not None:
+                        comment_text = comment_node.text.decode("utf-8")
+                        markers = MarkerParser.parse(
+                            comment_text,
+                            node_.start_point[0] + 1,
+                            # It is important that +1 is not present here because
+                            # currently StrictDoc does not display the last empty line (\n is 10).
+                            node_.end_point[0]
+                            if input_buffer[-1] == 10
+                            else node_.end_point[0] + 1,
+                            node_.start_point[0] + 1,
+                            node_.start_point[1] + 1,
+                        )
+                        for marker_ in markers:
+                            if isinstance(marker_, FunctionRangeMarker) and (
+                                function_range_marker_ := marker_
+                            ):
+                                function_range_marker_processor(
+                                    function_range_marker_, parse_context
+                                )
+                                traceability_info.markers.append(
+                                    function_range_marker_
+                                )
+            elif node_.type == "function_definition":
                 function_name: str = ""
 
                 for child_ in node_.children:
@@ -66,6 +97,7 @@ class SourceFileTraceabilityReader_C:
                         function_name = child_.children[0].text.decode("utf8")
                 assert function_name is not None, "Function name"
 
+                function_comment_node: Optional[Node] = None
                 function_comment_text = None
                 if (
                     node_.prev_sibling is not None
@@ -87,6 +119,7 @@ class SourceFileTraceabilityReader_C:
                         function_last_line,
                         function_comment_node.start_point[0] + 1,
                         function_comment_node.start_point[1] + 1,
+                        entity_name=function_name,
                     )
                     for marker_ in markers:
                         if isinstance(marker_, FunctionRangeMarker) and (
@@ -102,10 +135,13 @@ class SourceFileTraceabilityReader_C:
                                 function_range_marker_
                             )
 
+                # The function range includes the top comment if it exists.
                 new_function = Function(
                     parent=None,
                     name=function_name,
-                    line_begin=node_.range.start_point[0] + 1,
+                    line_begin=function_comment_node.start_point[0] + 1
+                    if function_comment_node is not None
+                    else node_.range.start_point[0] + 1,
                     line_end=node_.range.end_point[0] + 1,
                     parts=[],
                 )