spdx_tools.spdx.parser.jsonlikedict.dict_parsing_functions

View Source

 1# SPDX-FileCopyrightText: 2022 spdx contributors
 2#
 3# SPDX-License-Identifier: Apache-2.0
 4from beartype.typing import Any, Callable, Dict, List, Optional
 5
 6from spdx_tools.spdx.model import SpdxNoAssertion, SpdxNone
 7from spdx_tools.spdx.parser.error import SPDXParsingError
 8from spdx_tools.spdx.parser.logger import Logger
 9from spdx_tools.spdx.parser.parsing_functions import raise_parsing_error_if_logger_has_messages
10
11
12def json_str_to_enum_name(json_str: str) -> str:
13    if not isinstance(json_str, str):
14        raise SPDXParsingError([f"Type for enum must be str not {type(json_str).__name__}"])
15    return json_str.replace("-", "_").upper()
16
17
18def parse_field_or_log_error(
19    logger: Logger,
20    field: Any,
21    parsing_method: Callable = lambda x: x,
22    default: Any = None,
23    field_is_list: bool = False,
24) -> Any:
25    if not field:
26        return default
27    try:
28        if field_is_list:
29            return parse_list_of_elements(field, parsing_method)
30        else:
31            return parsing_method(field)
32    except SPDXParsingError as err:
33        logger.extend(err.get_messages())
34    except (TypeError, ValueError) as err:
35        logger.append(err.args[0])
36    return default
37
38
39def append_parsed_field_or_log_error(
40    logger: Logger, list_to_append_to: List[Any], field: Any, method_to_parse: Callable
41) -> List[Any]:
42    try:
43        parsed_element = method_to_parse(field)
44        list_to_append_to.append(parsed_element)
45    except SPDXParsingError as err:
46        logger.extend(err.get_messages())
47    except (TypeError, ValueError) as err:
48        logger.append(err.args[0])
49    return list_to_append_to
50
51
52def parse_field_or_no_assertion_or_none(field: Optional[str], method_for_field: Callable = lambda x: x) -> Any:
53    if field == SpdxNoAssertion().__str__():
54        return SpdxNoAssertion()
55    elif field == SpdxNone().__str__():
56        return SpdxNone()
57    else:
58        return method_for_field(field)
59
60
61def parse_field_or_no_assertion(field: Optional[str], method_for_field: Callable = lambda x: x) -> Any:
62    if field == SpdxNoAssertion().__str__():
63        return SpdxNoAssertion()
64    else:
65        return method_for_field(field)
66
67
68def parse_list_of_elements(list_of_elements: List[Dict], method_to_parse_element: Callable, logger=None) -> List[Any]:
69    if not logger:
70        logger = Logger()
71    parsed_elements = []
72    for element_dict in list_of_elements:
73        parsed_elements = append_parsed_field_or_log_error(
74            logger, parsed_elements, element_dict, method_to_parse_element
75        )
76    raise_parsing_error_if_logger_has_messages(logger)
77    return parsed_elements
78
79
80def delete_duplicates_from_list(list_with_potential_duplicates: List[Any]) -> List[Any]:
81    list_without_duplicates = list(dict.fromkeys(list_with_potential_duplicates))
82    return list_without_duplicates

def json_str_to_enum_name(json_str: str) -> str: View Source

13def json_str_to_enum_name(json_str: str) -> str:
14    if not isinstance(json_str, str):
15        raise SPDXParsingError([f"Type for enum must be str not {type(json_str).__name__}"])
16    return json_str.replace("-", "_").upper()

def parse_field_or_log_error( logger: spdx_tools.spdx.parser.logger.Logger, field: Any, parsing_method: Callable = <function <lambda>>, default: Any = None, field_is_list: bool = False) -> Any: View Source

19def parse_field_or_log_error(
20    logger: Logger,
21    field: Any,
22    parsing_method: Callable = lambda x: x,
23    default: Any = None,
24    field_is_list: bool = False,
25) -> Any:
26    if not field:
27        return default
28    try:
29        if field_is_list:
30            return parse_list_of_elements(field, parsing_method)
31        else:
32            return parsing_method(field)
33    except SPDXParsingError as err:
34        logger.extend(err.get_messages())
35    except (TypeError, ValueError) as err:
36        logger.append(err.args[0])
37    return default

def append_parsed_field_or_log_error( logger: spdx_tools.spdx.parser.logger.Logger, list_to_append_to: list[typing.Any], field: Any, method_to_parse: Callable) -> list[typing.Any]: View Source

40def append_parsed_field_or_log_error(
41    logger: Logger, list_to_append_to: List[Any], field: Any, method_to_parse: Callable
42) -> List[Any]:
43    try:
44        parsed_element = method_to_parse(field)
45        list_to_append_to.append(parsed_element)
46    except SPDXParsingError as err:
47        logger.extend(err.get_messages())
48    except (TypeError, ValueError) as err:
49        logger.append(err.args[0])
50    return list_to_append_to

def parse_field_or_no_assertion_or_none( field: Optional[str], method_for_field: Callable = <function <lambda>>) -> Any: View Source

53def parse_field_or_no_assertion_or_none(field: Optional[str], method_for_field: Callable = lambda x: x) -> Any:
54    if field == SpdxNoAssertion().__str__():
55        return SpdxNoAssertion()
56    elif field == SpdxNone().__str__():
57        return SpdxNone()
58    else:
59        return method_for_field(field)

def parse_field_or_no_assertion( field: Optional[str], method_for_field: Callable = <function <lambda>>) -> Any: View Source

62def parse_field_or_no_assertion(field: Optional[str], method_for_field: Callable = lambda x: x) -> Any:
63    if field == SpdxNoAssertion().__str__():
64        return SpdxNoAssertion()
65    else:
66        return method_for_field(field)

def parse_list_of_elements( list_of_elements: list[dict], method_to_parse_element: Callable, logger=None) -> list[typing.Any]: View Source

69def parse_list_of_elements(list_of_elements: List[Dict], method_to_parse_element: Callable, logger=None) -> List[Any]:
70    if not logger:
71        logger = Logger()
72    parsed_elements = []
73    for element_dict in list_of_elements:
74        parsed_elements = append_parsed_field_or_log_error(
75            logger, parsed_elements, element_dict, method_to_parse_element
76        )
77    raise_parsing_error_if_logger_has_messages(logger)
78    return parsed_elements

def delete_duplicates_from_list(list_with_potential_duplicates: list[typing.Any]) -> list[typing.Any]: View Source

81def delete_duplicates_from_list(list_with_potential_duplicates: List[Any]) -> List[Any]:
82    list_without_duplicates = list(dict.fromkeys(list_with_potential_duplicates))
83    return list_without_duplicates