jsons.serializers.default_dict.default_dict_serializer() - Code Metrics - ramonhagenaars/jsons - Measure and Improve Code Quality continuously with Scrutinizer

default_dict_serializer() B
last analyzed 2022-06-09 19:52 UTC

↳ Parent: jsons.serializers.default_dict

Complexity

Conditions

Size

Total Lines	53
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	31
dl	0
loc	53
rs	8.2026
c	0
b	0
f	0
cc	6
nop	8

How to fix Long Method Many Parameters

from typing import Callable, Dict, Optional, Tuple

from jsons._common_impl import JSON_KEYS
from jsons._dump_impl import dump


def default_dict_serializer(
        obj: dict,
        cls: Optional[type] = None,
        *,
        strict: bool = False,
        strip_nulls: bool = False,
        key_transformer: Optional[Callable[[str], str]] = None,
        types: Optional[Dict[str, type]] = None,
        **kwargs) -> dict:
    """
    Serialize the given ``obj`` to a dict of serialized objects.
    :param obj: the dict that is to be serialized.
    :param cls: not used.
    :param strict: if ``True`` the serialization will raise upon any the
    failure of any attribute. Otherwise it continues with a warning.
    :param strict: a bool to determine if the serializer should be strict
    (i.e. only dumping stuff that is known to ``cls``).
    :param strip_nulls: if ``True`` the resulting dict will not contain null
    values.
    :param key_transformer: a function that will be applied to all keys in the
    resulting dict.
    :param types: a ``dict`` with attribute names (keys) and their types
    (values).
    :param kwargs: any keyword arguments that may be given to the serialization
    process.
    :return: a dict of which all elements are serialized.
    """
    result = dict()
    types = types or dict()
    for key in obj:
        obj_ = obj[key]
        cls_ = types.get(key, None)

        # If key is not a valid json type, use the hash as key and store the
        # original key in a separate section.
        dict_and_key = _store_and_hash(result, key,
                                       key_transformer=key_transformer,
                                       strip_nulls=strip_nulls, strict=strict,
                                       types=types, **kwargs)
        if dict_and_key:
            result, key = dict_and_key

        dumped_elem = dump(obj_,
                           cls=cls_,
                           key_transformer=key_transformer,
                           strip_nulls=strip_nulls,
                           strict=strict,
                           **kwargs)
        if not (strip_nulls and dumped_elem is None):
            if key_transformer:
                key = key_transformer(key)
            result[key] = dumped_elem
    return result


def _store_and_hash(
        obj: dict,
        key: object,
        **kwargs
) -> Optional[Tuple[dict, int]]:
    # Store the given key in the given dict under a special section if that
    # key is not a valid json key. Return a hash of that key.
    result = None
    if not _is_valid_json_key(key):
        # First try to dump the key, that might be enough already.
        dumped_key = dump(key, **kwargs)
        result = obj, dumped_key
        if not _is_valid_json_key(dumped_key):
            # Apparently, this was not enough; the key is still not "jsonable".
            key_hash = hash(key)
            obj_ = {**obj}
            obj_.setdefault('-keys', {})
            obj_['-keys'][key_hash] = dumped_key
            result = obj_, key_hash
    return result


def _is_valid_json_key(key: object) -> bool:
    return any(issubclass(type(key), json_key) for json_key in JSON_KEYS)


1			from typing import Callable, Dict, Optional, Tuple
2
3			from jsons._common_impl import JSON_KEYS
4			from jsons._dump_impl import dump
5
6
7			def default_dict_serializer(
8			obj: dict,
9			cls: Optional[type] = None,
10			*,
11			strict: bool = False,
12			strip_nulls: bool = False,
13			key_transformer: Optional[Callable[[str], str]] = None,
14			types: Optional[Dict[str, type]] = None,
15			**kwargs) -> dict:
16			"""
17			Serialize the given ``obj`` to a dict of serialized objects.
18			:param obj: the dict that is to be serialized.
19			:param cls: not used.
20			:param strict: if ``True`` the serialization will raise upon any the
21			failure of any attribute. Otherwise it continues with a warning.
22			:param strict: a bool to determine if the serializer should be strict
23			(i.e. only dumping stuff that is known to ``cls``).
24			:param strip_nulls: if ``True`` the resulting dict will not contain null
25			values.
26			:param key_transformer: a function that will be applied to all keys in the
27			resulting dict.
28			:param types: a ``dict`` with attribute names (keys) and their types
29			(values).
30			:param kwargs: any keyword arguments that may be given to the serialization
31			process.
32			:return: a dict of which all elements are serialized.
33			"""
34			result = dict()
35			types = types or dict()
36			for key in obj:
37			obj_ = obj[key]
38			cls_ = types.get(key, None)
39
40			# If key is not a valid json type, use the hash as key and store the
41			# original key in a separate section.
42			dict_and_key = _store_and_hash(result, key,
43			key_transformer=key_transformer,
44			strip_nulls=strip_nulls, strict=strict,
45			types=types, **kwargs)
46			if dict_and_key:
47			result, key = dict_and_key
48
49			dumped_elem = dump(obj_,
50			cls=cls_,
51			key_transformer=key_transformer,
52			strip_nulls=strip_nulls,
53			strict=strict,
54			**kwargs)
55			if not (strip_nulls and dumped_elem is None):
56			if key_transformer:
57			key = key_transformer(key)
58			result[key] = dumped_elem
59			return result
60
61
62			def _store_and_hash(
63			obj: dict,
64			key: object,
65			**kwargs
66			) -> Optional[Tuple[dict, int]]:
67			# Store the given key in the given dict under a special section if that
68			# key is not a valid json key. Return a hash of that key.
69			result = None
70			if not _is_valid_json_key(key):
71			# First try to dump the key, that might be enough already.
72			dumped_key = dump(key, **kwargs)
73			result = obj, dumped_key
74			if not _is_valid_json_key(dumped_key):
75			# Apparently, this was not enough; the key is still not "jsonable".
76			key_hash = hash(key)
77			obj_ = {**obj}
78			obj_.setdefault('-keys', {})
79			obj_['-keys'][key_hash] = dumped_key
80			result = obj_, key_hash
81			return result
82
83
84			def _is_valid_json_key(key: object) -> bool:
85			return any(issubclass(type(key), json_key) for json_key in JSON_KEYS)
86

ramonhagenaars / jsons

default_dict_serializer() B last analyzed 2022-06-09 19:52 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Many Parameters

Long Method

Many Parameters

Duplication Side-by-Side

Filter issues like

default_dict_serializer() B
last analyzed 2022-06-09 19:52 UTC