spdx_tools.spdx.parser.jsonlikedict.json_like_dict_parser

 1# SPDX-FileCopyrightText: 2022 spdx contributors
 2#
 3# SPDX-License-Identifier: Apache-2.0
 4from beartype.typing import Dict
 5
 6from spdx_tools.spdx.model import Document
 7from spdx_tools.spdx.parser.error import SPDXParsingError
 8from spdx_tools.spdx.parser.jsonlikedict.annotation_parser import AnnotationParser
 9from spdx_tools.spdx.parser.jsonlikedict.creation_info_parser import CreationInfoParser
10from spdx_tools.spdx.parser.jsonlikedict.dict_parsing_functions import parse_list_of_elements
11from spdx_tools.spdx.parser.jsonlikedict.extracted_licensing_info_parser import ExtractedLicensingInfoParser
12from spdx_tools.spdx.parser.jsonlikedict.file_parser import FileParser
13from spdx_tools.spdx.parser.jsonlikedict.package_parser import PackageParser
14from spdx_tools.spdx.parser.jsonlikedict.relationship_parser import RelationshipParser
15from spdx_tools.spdx.parser.jsonlikedict.snippet_parser import SnippetParser
16from spdx_tools.spdx.parser.logger import Logger
17from spdx_tools.spdx.parser.parsing_functions import (
18    construct_or_raise_parsing_error,
19    raise_parsing_error_if_logger_has_messages,
20)
21
22
23class JsonLikeDictParser:
24    logger: Logger
25    creation_info_parser: CreationInfoParser
26    package_parser: PackageParser
27    file_parser: FileParser
28    snippet_parser: SnippetParser
29    extracted_licensing_info_parser: ExtractedLicensingInfoParser
30    relationship_parser: RelationshipParser
31    annotation_parser: AnnotationParser
32
33    def __init__(self):
34        self.logger = Logger()
35        self.creation_info_parser = CreationInfoParser()
36        self.package_parser = PackageParser()
37        self.file_parser = FileParser()
38        self.snippet_parser = SnippetParser()
39        self.extracted_licensing_info_parser = ExtractedLicensingInfoParser()
40        self.relationship_parser = RelationshipParser()
41        self.annotation_parser = AnnotationParser()
42
43    def parse(self, json_like_dict: Dict) -> Document:
44        fields_to_parse = [
45            ("creation_info", json_like_dict, self.creation_info_parser.parse_creation_info, False),
46            (
47                "packages",
48                json_like_dict.get("packages"),
49                lambda x: parse_list_of_elements(x, self.package_parser.parse_package, self.package_parser.logger),
50                True,
51            ),
52            (
53                "files",
54                json_like_dict.get("files"),
55                lambda x: parse_list_of_elements(x, self.file_parser.parse_file, self.file_parser.logger),
56                True,
57            ),
58            ("annotations", json_like_dict, self.annotation_parser.parse_all_annotations, True),
59            (
60                "snippets",
61                json_like_dict.get("snippets"),
62                lambda x: parse_list_of_elements(x, self.snippet_parser.parse_snippet, self.snippet_parser.logger),
63                True,
64            ),
65            ("relationships", json_like_dict, self.relationship_parser.parse_all_relationships, True),
66            (
67                "extracted_licensing_info",
68                json_like_dict.get("hasExtractedLicensingInfos"),
69                lambda x: parse_list_of_elements(
70                    x,
71                    self.extracted_licensing_info_parser.parse_extracted_licensing_info,
72                    self.extracted_licensing_info_parser.logger,
73                ),
74                True,
75            ),
76        ]
77
78        parsed_fields = {}
79
80        for argument_name, field, parsing_method, optional in fields_to_parse:
81            if optional and not field:
82                continue
83            try:
84                parsed_fields[argument_name] = parsing_method(field)
85            except SPDXParsingError as err:
86                self.logger.extend(err.get_messages())
87
88        raise_parsing_error_if_logger_has_messages(self.logger)
89
90        document = construct_or_raise_parsing_error(Document, parsed_fields)
91
92        return document
class JsonLikeDictParser:
24class JsonLikeDictParser:
25    logger: Logger
26    creation_info_parser: CreationInfoParser
27    package_parser: PackageParser
28    file_parser: FileParser
29    snippet_parser: SnippetParser
30    extracted_licensing_info_parser: ExtractedLicensingInfoParser
31    relationship_parser: RelationshipParser
32    annotation_parser: AnnotationParser
33
34    def __init__(self):
35        self.logger = Logger()
36        self.creation_info_parser = CreationInfoParser()
37        self.package_parser = PackageParser()
38        self.file_parser = FileParser()
39        self.snippet_parser = SnippetParser()
40        self.extracted_licensing_info_parser = ExtractedLicensingInfoParser()
41        self.relationship_parser = RelationshipParser()
42        self.annotation_parser = AnnotationParser()
43
44    def parse(self, json_like_dict: Dict) -> Document:
45        fields_to_parse = [
46            ("creation_info", json_like_dict, self.creation_info_parser.parse_creation_info, False),
47            (
48                "packages",
49                json_like_dict.get("packages"),
50                lambda x: parse_list_of_elements(x, self.package_parser.parse_package, self.package_parser.logger),
51                True,
52            ),
53            (
54                "files",
55                json_like_dict.get("files"),
56                lambda x: parse_list_of_elements(x, self.file_parser.parse_file, self.file_parser.logger),
57                True,
58            ),
59            ("annotations", json_like_dict, self.annotation_parser.parse_all_annotations, True),
60            (
61                "snippets",
62                json_like_dict.get("snippets"),
63                lambda x: parse_list_of_elements(x, self.snippet_parser.parse_snippet, self.snippet_parser.logger),
64                True,
65            ),
66            ("relationships", json_like_dict, self.relationship_parser.parse_all_relationships, True),
67            (
68                "extracted_licensing_info",
69                json_like_dict.get("hasExtractedLicensingInfos"),
70                lambda x: parse_list_of_elements(
71                    x,
72                    self.extracted_licensing_info_parser.parse_extracted_licensing_info,
73                    self.extracted_licensing_info_parser.logger,
74                ),
75                True,
76            ),
77        ]
78
79        parsed_fields = {}
80
81        for argument_name, field, parsing_method, optional in fields_to_parse:
82            if optional and not field:
83                continue
84            try:
85                parsed_fields[argument_name] = parsing_method(field)
86            except SPDXParsingError as err:
87                self.logger.extend(err.get_messages())
88
89        raise_parsing_error_if_logger_has_messages(self.logger)
90
91        document = construct_or_raise_parsing_error(Document, parsed_fields)
92
93        return document
def parse(self, json_like_dict: dict) -> spdx_tools.spdx.model.document.Document:
44    def parse(self, json_like_dict: Dict) -> Document:
45        fields_to_parse = [
46            ("creation_info", json_like_dict, self.creation_info_parser.parse_creation_info, False),
47            (
48                "packages",
49                json_like_dict.get("packages"),
50                lambda x: parse_list_of_elements(x, self.package_parser.parse_package, self.package_parser.logger),
51                True,
52            ),
53            (
54                "files",
55                json_like_dict.get("files"),
56                lambda x: parse_list_of_elements(x, self.file_parser.parse_file, self.file_parser.logger),
57                True,
58            ),
59            ("annotations", json_like_dict, self.annotation_parser.parse_all_annotations, True),
60            (
61                "snippets",
62                json_like_dict.get("snippets"),
63                lambda x: parse_list_of_elements(x, self.snippet_parser.parse_snippet, self.snippet_parser.logger),
64                True,
65            ),
66            ("relationships", json_like_dict, self.relationship_parser.parse_all_relationships, True),
67            (
68                "extracted_licensing_info",
69                json_like_dict.get("hasExtractedLicensingInfos"),
70                lambda x: parse_list_of_elements(
71                    x,
72                    self.extracted_licensing_info_parser.parse_extracted_licensing_info,
73                    self.extracted_licensing_info_parser.logger,
74                ),
75                True,
76            ),
77        ]
78
79        parsed_fields = {}
80
81        for argument_name, field, parsing_method, optional in fields_to_parse:
82            if optional and not field:
83                continue
84            try:
85                parsed_fields[argument_name] = parsing_method(field)
86            except SPDXParsingError as err:
87                self.logger.extend(err.get_messages())
88
89        raise_parsing_error_if_logger_has_messages(self.logger)
90
91        document = construct_or_raise_parsing_error(Document, parsed_fields)
92
93        return document