core.custom.custom_json

Sigh. Here we go again, another json implementation with support for:

• date

• datetime

• time

Because nobody else does all of these. And if they do (like standardjson), they don’t support decoding…

Module Contents

Classes

Serializer	Provides a way to encode all objects of a given class or its
PrefixSerializer	Serializes objects to a string with a prefix.
DictionarySerializer	Serialises objects that can be built with keyword arguments.
Serializers	Organises the different serializer implementations under a unifiying
Serializable	Classes inheriting from this base are serialised using the

Functions

dumps(…)
loads(→ Any)
dump(→ None)
load(→ Any)

Attributes

AnySerializer
_T
_ST
default_serializers

core.custom.custom_json.AnySerializer: typing_extensions.TypeAlias

core.custom.custom_json._T

core.custom.custom_json._ST

class core.custom.custom_json.Serializer(target: type[_T])

Bases: Generic[_T, _ST]

Provides a way to encode all objects of a given class or its subclasses to and from json.

abstract encode(obj: _T) → _ST

abstract decode(value: _ST) → _T

class core.custom.custom_json.PrefixSerializer(target: type[_T], prefix: str, encode: Callable[[_T], str], decode: Callable[[str], _T])

Bases: Serializer[_T, str]

Serializes objects to a string with a prefix.

Resulting json values take the form of __prefix__@<value>, where <value> is the encoded value and __prefix__@ is the prefix that is used to differentiate between normal strings and encoded strings.

Note that the part after the prefix is user-supplied and possibly unsafe. So something like an ‘eval’ should be out of the question!

prefix_format = '__{}__@{}'

prefix_expression

prefix_characters

encode(obj: _T) → str

decode(string: str) → _T

class core.custom.custom_json.DictionarySerializer(target: type[_T], keys: Iterable[str])

Bases: Serializer[_T, onegov.core.types.JSONObject_ro]

Serialises objects that can be built with keyword arguments.

For example:

class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y

Can be serialised using:

DictionarySerializer(Point, ('x', 'y'))

Which results in something like this in JSON:

{'x': 1, 'y': 2}

As the internal __dict__ represenation is of no concern, __slots__ may be used:

class Point:

__slots__ = (‘x’, ‘y’)

def __init__(self, x, y):

self.x = x self.y = y

encode(obj: _T) → onegov.core.types.JSONObject_ro

decode(dictionary: onegov.core.types.JSONObject_ro) → _T

class core.custom.custom_json.Serializers

Organises the different serializer implementations under a unifiying interface. This allows the actual encoder/decoder to call a single class without having to worry how the various serializers need to be looked up and called.

property registered: Iterator[AnySerializer[Any]]

by_prefix: dict[str, PrefixSerializer[Any]]

by_keys: dict[frozenset[str], DictionarySerializer[Any]]

known_key_lengths: set[int]

register(serializer: PrefixSerializer[Any] | DictionarySerializer[Any]) → None

serializer_for(value: object) → AnySerializer[Any] | None

serializer_for_string(string: str) → PrefixSerializer[Any] | None

serializer_for_dict(dictionary: dict[str, Any]) → DictionarySerializer[Any] | None

serializer_for_class(cls: type[_T]) → AnySerializer[_T] | None

encode(value: object) → onegov.core.types.JSON_ro

decode(value: Any) → Any

core.custom.custom_json.default_serializers

class core.custom.custom_json.Serializable

Classes inheriting from this base are serialised using the DictionarySerializer class.

The keys that should be used need to be specified as follows:

class Point(Serializable, keys=('x', 'y')):

    def __init__(self, x, y):
        self.x = x
        self.y = y

serialized_keys: ClassVar[Collection[str]]

classmethod serializers() → Serializers

classmethod __init_subclass__(keys: Collection[str], **kwargs: Any)

core.custom.custom_json.dumps(obj: None, **extra: Any) → None

core.custom.custom_json.dumps(obj: Any, **extra: Any) → str

core.custom.custom_json.loads(txt: str | bytes | bytearray | None, **extra: Any) → Any

core.custom.custom_json.dump(data: Any, fp: SupportsWrite[str], **extra: Any) → None

core.custom.custom_json.load(fp: SupportsRead[str | bytes], **extra: Any) → Any