bedrock.helpers.dictionary

  1import uuid
  2from typing import Type, Any
  3
  4from bedrock._helpers.string import camelCase_to_snake_case, snake_case_to_camelCase
  5
  6
  7def exclude_keys_from_dict(dictionary: dict, exclude_keys: list[str]) -> dict:  # pragma: unit
  8    """
  9    Returns a copy of the dictionary without the specified keys.
 10    :param dictionary: The original dictionary
 11    :param exclude_keys: The keys to exclude
 12    :return: A new dictionary
 13    """
 14    d = dictionary.copy()
 15    for key in exclude_keys:
 16        if key in d:
 17            del d[key]
 18    return d
 19
 20
 21def merge_dictionaries(base_dictionary: dict, dictionary_to_merge: dict = None,
 22                       bypass_nones=False) -> dict:  # pragma: unit
 23    """
 24    Superficially merges two dictionaries, with the second dictionary taking precedence (i.e.: if any key is present in
 25    both dictionaries, the value in the second dictionary will be used).
 26    :param base_dictionary: A dictionary
 27    :param dictionary_to_merge: The dictionary to merge into the base dictionary
 28    :param bypass_nones: Whether to bypass None values in the second dictionary
 29    :return: A new dictionary
 30    """
 31    body = base_dictionary.copy()
 32    if dictionary_to_merge is None:
 33        return body
 34
 35    for key in dictionary_to_merge:
 36        if not (bypass_nones and dictionary_to_merge[key] is None):
 37            body[snake_case_to_camelCase(key)] = dictionary_to_merge[key]
 38    return body
 39
 40
 41def get_dict_key_with_fallback(dictionary: dict, key: str, fallback=None) -> Any:  # pragma: unit
 42    """
 43    Returns the value of the specified key in the dictionary, or the fallback value if the key does not exist.
 44    :param dictionary: Dictionary to search in
 45    :param key: The key in the dictionary
 46    :param fallback: The fallback value when `key` is not found
 47    :return: Either `dictionary[key]` or `fallback`
 48    """
 49    try:
 50        return dictionary[key]
 51    except (KeyError, TypeError):
 52        if fallback is None:
 53            raise Exception(f"Could not find attribute {key} in dictionary")
 54        return fallback
 55
 56
 57def check_dict_key(dictionary: dict, key: str, exception: Type[Exception] = Exception):  # pragma: unit
 58    """
 59    Checks if the specified key exists in the dictionary, and raises the provided exception if it does not.
 60
 61    This is a handy shortcut to turn a `KeyError` or `TypeError` into a custom exception.
 62
 63    :param dictionary: Dictionary to search in
 64    :param key: The key in the dictionary
 65    :param exception: The exception to raise if the key is not found (Default: `Exception`)
 66    """
 67    try:
 68        dictionary[key]
 69    except (KeyError, TypeError):
 70        raise exception(f"{key} is required")
 71
 72
 73def get_snake_or_camel_case_key(dictionary: dict, key: str) -> str:  # pragma: unit
 74    """
 75    Returns the key in the dictionary that matches the specified key, regardless of whether it is in snake_case or camelCase.
 76    :param dictionary: The dictionary to search in
 77    :param key: The key to search for
 78    :return: The properly formatted key
 79    """
 80    try:
 81        _key = camelCase_to_snake_case(key)
 82        dictionary[_key]  # Check if the key exists
 83        return _key
 84    except KeyError:
 85        _key = snake_case_to_camelCase(key)
 86        dictionary[_key]  # Check if the key exists
 87        return _key
 88
 89
 90def get_snake_or_camel_case_value(dictionary: dict, key: str) -> Any:  # pragma: unit
 91    """
 92    Returns the value in the dictionary that matches the specified key, regardless of whether it is in snake_case or
 93    camelCase.
 94    :param dictionary: The dictionary to search in
 95    :param key: The key to search for (either in snake_case or camelCase)
 96    """
 97    try:
 98        return dictionary[camelCase_to_snake_case(key)]
 99    except KeyError:
100        return dictionary[snake_case_to_camelCase(key)]
101
102
103def has_key_value(dictionary: dict, key: str, value,
104                  snake_and_camel_case: bool = False,
105                  compare_lists_with_contains=False) -> bool:  # pragma: unit
106    """
107    Checks whether the specified key exists in the dictionary, and whether the value matches the specified value.
108    This method treats a string UUID and an object UUID the same
109
110    Optionally:
111    * the key can be in snake_case or camelCase (with `snake_and_camel_case`)
112    * the value can be a list, in which case the value will be checked with `in` instead of `==` (with `compare_lists_with_contains`)
113
114    :param dictionary: The dictionary to search in
115    :param key: The key to search for
116    :param value: The value to compare with
117    :param snake_and_camel_case: Whether the key can be in snake_case or camelCase
118    :param compare_lists_with_contains: Whether to compare lists with `in` instead of `==`
119    :return:
120    """
121    try:
122        if snake_and_camel_case:
123            _key = get_snake_or_camel_case_key(dictionary, key)
124        else:
125            _key = key
126
127        if compare_lists_with_contains and isinstance(value, list):
128            return dictionary[_key] in value
129        if isinstance(dictionary[_key], uuid.UUID):
130            return str(dictionary[_key]) == str(value)
131        return dictionary[_key] == value
132    except (KeyError, TypeError):
133        return False
134
135
136def has_key(dictionary: dict, key: str, snake_and_camel_case: bool = False) -> bool:  # pragma: unit
137    """
138    Checks whether the specified key exists in the dictionary.
139
140    Optionally, the key can be in snake_case or camelCase (with `snake_and_camel_case`).
141
142    :param dictionary: The dictionary to search in
143    :param key: The key to search for
144    :param snake_and_camel_case: Whether the key can be in snake_case or camelCase
145    """
146    try:
147        if snake_and_camel_case:
148            _key = get_snake_or_camel_case_key(dictionary, key)
149        else:
150            _key = key
151        return _key in dictionary
152    except KeyError:
153        return False
154
155
156def contains_keys(dictionary, keys, snake_and_camel_case: bool = False):  # pragma: unit
157    """
158    Checks if the dictionary contains all the specified keys.
159
160    Optionally, the keys can be in snake_case or camelCase (with `snake_and_camel_case`).
161
162    :param dictionary: The dictionary to search in
163    :param keys: The keys to search for
164    :param snake_and_camel_case: Whether the keys can be in snake_case or camelCase
165    """
166    for key in keys:
167        if not has_key(dictionary, key, snake_and_camel_case):
168            return False
169    return True