deev.translation#

class DeevJsonEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)#

Bases: JSONEncoder

Constructor for JSONEncoder, with sensible defaults.

If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, float, bool or None. If skipkeys is True, such items are simply skipped.

If ensure_ascii is true, the output is guaranteed to be str objects with all incoming non-ASCII characters escaped. If ensure_ascii is false, the output can contain non-ASCII characters.

If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an RecursionError). Otherwise, no such check takes place.

If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats.

If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis.

If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation.

If specified, separators should be an (item_separator, key_separator) tuple. The default is (’, ‘, ‘: ‘) if indent is None and (‘,’, ‘: ‘) otherwise. To get the most compact JSON representation, you should specify (‘,’, ‘:’) to eliminate whitespace.

If specified, default is a function that gets called for objects that can’t otherwise be serialized. It should return a JSON encodable version of the object or raise a TypeError.

encode(o)#

Return a JSON string representation of a Python data structure.

Return type:

str

>>> from json.encoder import JSONEncoder
>>> JSONEncoder().encode({"foo": ["bar", "baz"]})
'{"foo": ["bar", "baz"]}'
class DeevJsonDecoder(*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)#

Bases: JSONDecoder

object_hook, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given dict. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting).

object_pairs_hook, if specified will be called with the result of every JSON object decoded with an ordered list of pairs. The return value of object_pairs_hook will be used instead of the dict. This feature can be used to implement custom decoders. If object_hook is also defined, the object_pairs_hook takes priority.

parse_float, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal).

parse_int, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float).

parse_constant, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered.

If strict is false (true is the default), then control characters will be allowed inside strings. Control characters in this context are those with character codes in the 0-31 range, including '\t' (tab), '\n', '\r' and '\0'.

decode(s, _w=None)#

Return the Python representation of s (a str instance containing a JSON document).

Return type:

Any

configure_serialization(*, encoder=None, decoder=None, serializer=None, deserializer=None)#

Set json encoders/decoders used for sql translations.

This because complex types such as lists, tuples, dicts, Decimals, etc/etc being stored to db get serialized (stored as a string.)

When the default serializer encounters an unsupported type the serialization fails.

This provides you a mechanism to customize serialization.

If you wish to extend the default behavior without re-implementing it all, you can inherit from the exposed DeevJsonEncoder and DeevJsonDecoder, then pass your subclassed versions in. If your work is not proprietary, consider submitting an issue on github to have the support formally added.

Alternatively, if you want to wholesale swap the serializer (something other than json, or a json impl you prefer) you can provide serializer and deserializer callbacks instead. If you set new serializer/deserializer callbacks the encoders will not be used (and, detecting that serializer/deserializer are custom will throw on any attempt to set new encoders.)

Return type:

None

deunionize(t)#
Return type:

type

hydrate(entity, data, attrs=None, from_sql=False)#

Hydrates an entity in-place from a “splat.”

Parameters:

  • entity (object) – The entity to hydrate.

  • data (dict[str, Any]) – The data to hydrate.

  • attrs (Optional[list[str]]) – Specify which attrs/props to hydrate, otherwise hydrates all.

  • from_sql (bool) – If True, source values are presumed to be sql objects that need to be mapped to python objects.

Return type:

Any

Returns:

The original entity, hydrated.

splat(entity, attrs=None, to_sql=False)#

Splatter entity attributes/fields into a dict.

Parameters:

  • entity (object) – The entity to splatter.

  • attrs (Optional[list[str]]) – Specify which attrs/fields to splatter, otherwise splatter all.

  • to_sql (bool) – If True, destination values need to be mapped to sql objects.

Return type:

dict[str, Any]

Returns:

The resulting splat.

to_pyobject(value, hint)#
Return type:

Any

to_sqlobject(value, hint)#
Return type:

Any