comment here

.CondaPkg/env/lib/python3.11/site-packages/jsons/deserializers/default_dict.py

@@ -0,0 +1,87 @@
+from typing import Callable, Optional, Tuple
+
+from typish import get_args
+
+from jsons._load_impl import load
+from jsons.exceptions import DeserializationError
+
+
+def default_dict_deserializer(
+        obj: dict,
+        cls: type,
+        *,
+        key_transformer: Optional[Callable[[str], str]] = None,
+        **kwargs) -> dict:
+    """
+    Deserialize a dict by deserializing all instances of that dict.
+    :param obj: the dict that needs deserializing.
+    :param key_transformer: a function that transforms the keys to a different
+    style (e.g. PascalCase).
+    :param cls: not used.
+    :param kwargs: any keyword arguments.
+    :return: a deserialized dict instance.
+    """
+    cls_args = get_args(cls)
+
+    obj_, keys_were_hashed = _load_hashed_keys(
+        obj, cls, cls_args, key_transformer=key_transformer, **kwargs)
+
+    return _deserialize(obj_, cls_args, key_transformer, keys_were_hashed, kwargs)
+
+
+def _load_hashed_keys(
+        obj: dict,
+        cls: type,
+        cls_args: tuple,
+        **kwargs) -> Tuple[dict, bool]:
+    # Load any hashed keys and return a copy of the given obj if any hashed
+    # keys are unpacked.
+    result = obj
+
+    stored_keys = set(obj.get('-keys', set()))
+    if stored_keys:
+        # Apparently, there are stored hashed keys, we need to unpack them.
+        if len(cls_args) != 2:
+            raise DeserializationError('A detailed type is needed for cls of '
+                                       'the form Dict[<type>, <type>] to '
+                                       'deserialize a dict with hashed keys.',
+                                       obj, cls)
+        result = {**obj}
+        key_type = cls_args[0]
+        for key in stored_keys:
+            # Get the original (unhashed) key and load it.
+            original_key = result['-keys'][key]
+            loaded_key = load(original_key, cls=key_type, **kwargs)
+
+            # Replace the hashed key by the loaded key entirely.
+            result[loaded_key] = result[key]
+            del result['-keys'][key]
+            del result[key]
+
+        del result['-keys']
+    return result, len(stored_keys) > 0
+
+
+def _deserialize(
+        obj: dict,
+        cls_args: tuple,
+        key_transformer: Callable[[str], str],
+        keys_were_hashed: bool,
+        kwargs: dict) -> dict:
+    key_transformer = key_transformer or (lambda key: key)
+    key_func = key_transformer
+    kwargs_ = {**kwargs, 'key_transformer': key_transformer}
+
+    if len(cls_args) == 2:
+        cls_k, cls_v = cls_args
+        kwargs_['cls'] = cls_v
+        if not keys_were_hashed:
+            # In case of cls is something like Dict[<key>, <value>], we need to
+            # ensure that the keys in the result are <key>. If the keys were
+            # hashed though, they have been loaded already.
+            kwargs_k = {**kwargs, 'cls': cls_k}
+            key_func = lambda key: load(key_transformer(key), **kwargs_k)
+    return {
+        key_func(key): load(obj[key], **kwargs_)
+        for key in obj
+    }