spdx_tools.spdx.parser.jsonlikedict.file_parser 

 1# SPDX-FileCopyrightText: 2022 spdx contributors
 2#
 3# SPDX-License-Identifier: Apache-2.0
 4from beartype.typing import Dict, List, Optional, Union
 5from license_expression import LicenseExpression
 6
 7from spdx_tools.spdx.model import Checksum, File, FileType, SpdxNoAssertion, SpdxNone
 8from spdx_tools.spdx.parser.jsonlikedict.checksum_parser import ChecksumParser
 9from spdx_tools.spdx.parser.jsonlikedict.dict_parsing_functions import (
10    parse_field_or_log_error,
11    parse_field_or_no_assertion_or_none,
12)
13from spdx_tools.spdx.parser.jsonlikedict.license_expression_parser import LicenseExpressionParser
14from spdx_tools.spdx.parser.logger import Logger
15from spdx_tools.spdx.parser.parsing_functions import (
16    construct_or_raise_parsing_error,
17    raise_parsing_error_if_logger_has_messages,
18)
19
20
21class FileParser:
22    logger: Logger
23    checksum_parser: ChecksumParser
24    license_expression_parser: LicenseExpressionParser
25
26    def __init__(self):
27        self.logger = Logger()
28        self.checksum_parser = ChecksumParser()
29        self.license_expression_parser = LicenseExpressionParser()
30
31    def parse_file(self, file_dict: Dict) -> Optional[File]:
32        logger = Logger()
33        name: Optional[str] = file_dict.get("fileName")
34        spdx_id: Optional[str] = file_dict.get("SPDXID")
35        checksums_list: List[Dict] = file_dict.get("checksums")
36        checksums: List[Checksum] = parse_field_or_log_error(
37            logger, checksums_list, self.checksum_parser.parse_checksum, field_is_list=True
38        )
39
40        attribution_texts: List[str] = file_dict.get("attributionTexts", [])
41        comment: Optional[str] = file_dict.get("comment")
42        copyright_text: Optional[Union[str, SpdxNoAssertion, SpdxNone]] = parse_field_or_no_assertion_or_none(
43            file_dict.get("copyrightText")
44        )
45        file_contributors: List[str] = file_dict.get("fileContributors", [])
46        file_types: List[FileType] = parse_field_or_log_error(
47            logger, file_dict.get("fileTypes"), self.parse_file_types
48        )
49
50        license_comments: Optional[str] = file_dict.get("licenseComments")
51
52        license_concluded: Optional[Union[LicenseExpression, SpdxNoAssertion, SpdxNone]] = parse_field_or_log_error(
53            logger, file_dict.get("licenseConcluded"), self.license_expression_parser.parse_license_expression
54        )
55
56        license_info_in_files: List[Union[LicenseExpression, SpdxNoAssertion, SpdxNone]] = parse_field_or_log_error(
57            logger,
58            file_dict.get("licenseInfoInFiles"),
59            self.license_expression_parser.parse_license_expression,
60            field_is_list=True,
61        )
62        notice_text: Optional[str] = file_dict.get("noticeText")
63        raise_parsing_error_if_logger_has_messages(logger, "File")
64
65        file = construct_or_raise_parsing_error(
66            File,
67            dict(
68                name=name,
69                spdx_id=spdx_id,
70                checksums=checksums,
71                attribution_texts=attribution_texts,
72                comment=comment,
73                copyright_text=copyright_text,
74                file_types=file_types,
75                contributors=file_contributors,
76                license_comment=license_comments,
77                license_concluded=license_concluded,
78                license_info_in_file=license_info_in_files,
79                notice=notice_text,
80            ),
81        )
82        return file
83
84    @staticmethod
85    def parse_file_types(file_types_list: List[str]) -> List[FileType]:
86        logger = Logger()
87        file_types = []
88        for file_type in file_types_list:
89            try:
90                file_type = FileType[file_type]
91            except KeyError:
92                logger.append(f"Invalid FileType: {file_type}")
93                continue
94            file_types.append(file_type)
95        raise_parsing_error_if_logger_has_messages(logger, "FileType")
96        return file_types
class FileParser: 
22class FileParser:
23    logger: Logger
24    checksum_parser: ChecksumParser
25    license_expression_parser: LicenseExpressionParser
26
27    def __init__(self):
28        self.logger = Logger()
29        self.checksum_parser = ChecksumParser()
30        self.license_expression_parser = LicenseExpressionParser()
31
32    def parse_file(self, file_dict: Dict) -> Optional[File]:
33        logger = Logger()
34        name: Optional[str] = file_dict.get("fileName")
35        spdx_id: Optional[str] = file_dict.get("SPDXID")
36        checksums_list: List[Dict] = file_dict.get("checksums")
37        checksums: List[Checksum] = parse_field_or_log_error(
38            logger, checksums_list, self.checksum_parser.parse_checksum, field_is_list=True
39        )
40
41        attribution_texts: List[str] = file_dict.get("attributionTexts", [])
42        comment: Optional[str] = file_dict.get("comment")
43        copyright_text: Optional[Union[str, SpdxNoAssertion, SpdxNone]] = parse_field_or_no_assertion_or_none(
44            file_dict.get("copyrightText")
45        )
46        file_contributors: List[str] = file_dict.get("fileContributors", [])
47        file_types: List[FileType] = parse_field_or_log_error(
48            logger, file_dict.get("fileTypes"), self.parse_file_types
49        )
50
51        license_comments: Optional[str] = file_dict.get("licenseComments")
52
53        license_concluded: Optional[Union[LicenseExpression, SpdxNoAssertion, SpdxNone]] = parse_field_or_log_error(
54            logger, file_dict.get("licenseConcluded"), self.license_expression_parser.parse_license_expression
55        )
56
57        license_info_in_files: List[Union[LicenseExpression, SpdxNoAssertion, SpdxNone]] = parse_field_or_log_error(
58            logger,
59            file_dict.get("licenseInfoInFiles"),
60            self.license_expression_parser.parse_license_expression,
61            field_is_list=True,
62        )
63        notice_text: Optional[str] = file_dict.get("noticeText")
64        raise_parsing_error_if_logger_has_messages(logger, "File")
65
66        file = construct_or_raise_parsing_error(
67            File,
68            dict(
69                name=name,
70                spdx_id=spdx_id,
71                checksums=checksums,
72                attribution_texts=attribution_texts,
73                comment=comment,
74                copyright_text=copyright_text,
75                file_types=file_types,
76                contributors=file_contributors,
77                license_comment=license_comments,
78                license_concluded=license_concluded,
79                license_info_in_file=license_info_in_files,
80                notice=notice_text,
81            ),
82        )
83        return file
84
85    @staticmethod
86    def parse_file_types(file_types_list: List[str]) -> List[FileType]:
87        logger = Logger()
88        file_types = []
89        for file_type in file_types_list:
90            try:
91                file_type = FileType[file_type]
92            except KeyError:
93                logger.append(f"Invalid FileType: {file_type}")
94                continue
95            file_types.append(file_type)
96        raise_parsing_error_if_logger_has_messages(logger, "FileType")
97        return file_types
def parse_file(self, file_dict: dict) -> Optional[spdx_tools.spdx.model.file.File]: 
32    def parse_file(self, file_dict: Dict) -> Optional[File]:
33        logger = Logger()
34        name: Optional[str] = file_dict.get("fileName")
35        spdx_id: Optional[str] = file_dict.get("SPDXID")
36        checksums_list: List[Dict] = file_dict.get("checksums")
37        checksums: List[Checksum] = parse_field_or_log_error(
38            logger, checksums_list, self.checksum_parser.parse_checksum, field_is_list=True
39        )
40
41        attribution_texts: List[str] = file_dict.get("attributionTexts", [])
42        comment: Optional[str] = file_dict.get("comment")
43        copyright_text: Optional[Union[str, SpdxNoAssertion, SpdxNone]] = parse_field_or_no_assertion_or_none(
44            file_dict.get("copyrightText")
45        )
46        file_contributors: List[str] = file_dict.get("fileContributors", [])
47        file_types: List[FileType] = parse_field_or_log_error(
48            logger, file_dict.get("fileTypes"), self.parse_file_types
49        )
50
51        license_comments: Optional[str] = file_dict.get("licenseComments")
52
53        license_concluded: Optional[Union[LicenseExpression, SpdxNoAssertion, SpdxNone]] = parse_field_or_log_error(
54            logger, file_dict.get("licenseConcluded"), self.license_expression_parser.parse_license_expression
55        )
56
57        license_info_in_files: List[Union[LicenseExpression, SpdxNoAssertion, SpdxNone]] = parse_field_or_log_error(
58            logger,
59            file_dict.get("licenseInfoInFiles"),
60            self.license_expression_parser.parse_license_expression,
61            field_is_list=True,
62        )
63        notice_text: Optional[str] = file_dict.get("noticeText")
64        raise_parsing_error_if_logger_has_messages(logger, "File")
65
66        file = construct_or_raise_parsing_error(
67            File,
68            dict(
69                name=name,
70                spdx_id=spdx_id,
71                checksums=checksums,
72                attribution_texts=attribution_texts,
73                comment=comment,
74                copyright_text=copyright_text,
75                file_types=file_types,
76                contributors=file_contributors,
77                license_comment=license_comments,
78                license_concluded=license_concluded,
79                license_info_in_file=license_info_in_files,
80                notice=notice_text,
81            ),
82        )
83        return file
@staticmethod
def parse_file_types(file_types_list: list[str]) -> list[spdx_tools.spdx.model.file.FileType]: 
85    @staticmethod
86    def parse_file_types(file_types_list: List[str]) -> List[FileType]:
87        logger = Logger()
88        file_types = []
89        for file_type in file_types_list:
90            try:
91                file_type = FileType[file_type]
92            except KeyError:
93                logger.append(f"Invalid FileType: {file_type}")
94                continue
95            file_types.append(file_type)
96        raise_parsing_error_if_logger_has_messages(logger, "FileType")
97        return file_types