spdx_tools.spdx.parser.jsonlikedict.creation_info_parser

  1# SPDX-FileCopyrightText: 2022 spdx contributors
  2#
  3# SPDX-License-Identifier: Apache-2.0
  4from datetime import datetime
  5
  6from beartype.typing import Dict, List, Optional
  7
  8from spdx_tools.spdx.datetime_conversions import datetime_from_str
  9from spdx_tools.spdx.model import Actor, Checksum, CreationInfo, ExternalDocumentRef, Version
 10from spdx_tools.spdx.parser.actor_parser import ActorParser
 11from spdx_tools.spdx.parser.error import SPDXParsingError
 12from spdx_tools.spdx.parser.jsonlikedict.checksum_parser import ChecksumParser
 13from spdx_tools.spdx.parser.jsonlikedict.dict_parsing_functions import parse_field_or_log_error
 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 CreationInfoParser:
 22    logger: Logger
 23    actor_parser: ActorParser
 24    checksum_parser: ChecksumParser
 25
 26    def __init__(self):
 27        self.logger = Logger()
 28        self.actor_parser = ActorParser()
 29        self.checksum_parser = ChecksumParser()
 30
 31    def parse_creation_info(self, doc_dict: Dict) -> CreationInfo:
 32        logger = Logger()
 33        spdx_version: Optional[str] = doc_dict.get("spdxVersion")
 34        spdx_id: Optional[str] = doc_dict.get("SPDXID")
 35        name: Optional[str] = doc_dict.get("name")
 36        document_namespace: Optional[str] = doc_dict.get("documentNamespace")
 37        creation_info_dict: Optional[Dict] = doc_dict.get("creationInfo")
 38
 39        # There are nested required properties. If creationInfo is not set, we cannot continue parsing.
 40        if creation_info_dict is None:
 41            logger.append("CreationInfo does not exist.")
 42            raise SPDXParsingError([f"Error while parsing document {name}: {logger.get_messages()}"])
 43
 44        creators: List[Actor] = parse_field_or_log_error(
 45            logger, creation_info_dict.get("creators"), self.actor_parser.parse_actor, field_is_list=True
 46        )
 47
 48        created: Optional[datetime] = parse_field_or_log_error(
 49            logger, creation_info_dict.get("created"), datetime_from_str
 50        )
 51
 52        creator_comment: Optional[str] = creation_info_dict.get("comment")
 53        data_license: Optional[str] = doc_dict.get("dataLicense")
 54
 55        external_document_refs: List[ExternalDocumentRef] = parse_field_or_log_error(
 56            logger, doc_dict.get("externalDocumentRefs"), self.parse_external_document_refs
 57        )
 58        license_list_version: Optional[Version] = parse_field_or_log_error(
 59            logger, creation_info_dict.get("licenseListVersion"), self.parse_version
 60        )
 61        document_comment: Optional[str] = doc_dict.get("comment")
 62        raise_parsing_error_if_logger_has_messages(logger, "Document")
 63
 64        creation_info = construct_or_raise_parsing_error(
 65            CreationInfo,
 66            dict(
 67                spdx_version=spdx_version,
 68                spdx_id=spdx_id,
 69                name=name,
 70                document_namespace=document_namespace,
 71                creators=creators,
 72                created=created,
 73                license_list_version=license_list_version,
 74                document_comment=document_comment,
 75                creator_comment=creator_comment,
 76                data_license=data_license,
 77                external_document_refs=external_document_refs,
 78            ),
 79        )
 80
 81        return creation_info
 82
 83    @staticmethod
 84    def parse_version(version_str: str) -> Version:
 85        try:
 86            return Version.from_string(version_str)
 87        except ValueError as err:
 88            raise SPDXParsingError([f"Error while parsing version {version_str}: {err.args[0]}"])
 89
 90    def parse_external_document_refs(self, external_document_ref_dicts: List[Dict]) -> List[ExternalDocumentRef]:
 91        logger = Logger()
 92        external_document_refs = []
 93        for external_document_ref_dict in external_document_ref_dicts:
 94            external_document_ref: ExternalDocumentRef = parse_field_or_log_error(
 95                logger, external_document_ref_dict, self.parse_external_document_ref
 96            )
 97
 98            external_document_refs.append(external_document_ref)
 99
100        raise_parsing_error_if_logger_has_messages(logger)
101        return external_document_refs
102
103    def parse_external_document_ref(self, external_document_ref_dict: Dict) -> ExternalDocumentRef:
104        logger = Logger()
105        checksum: Optional[Checksum] = parse_field_or_log_error(
106            logger, external_document_ref_dict.get("checksum"), self.checksum_parser.parse_checksum
107        )
108
109        external_document_id: Optional[str] = external_document_ref_dict.get("externalDocumentId")
110        document_uri: Optional[str] = external_document_ref_dict.get("spdxDocument")
111        raise_parsing_error_if_logger_has_messages(logger, "ExternalDocumentRef")
112        external_document_ref: ExternalDocumentRef = construct_or_raise_parsing_error(
113            ExternalDocumentRef,
114            dict(document_ref_id=external_document_id, checksum=checksum, document_uri=document_uri),
115        )
116
117        return external_document_ref