JEncode

DIRAC Encoding utilities based on json

class DIRAC.Core.Utilities.JEncode.DJSONDecoder(*args, **kargs)

Bases: JSONDecoder

This custom decoder is to add support to json for tuple, datetime, and any object inheriting from JSerializable

__init__(*args, **kargs)

Init method needed in order to give the object_hook to have special deserialization method.

decode(s, _w=<built-in method match of re.Pattern object>)

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

static dict_to_object(dataDict)

Convert the dictionary into an object. Adds deserialization support for datetype and JSerializable

Parameters:

dataDict – json dictionary representing the data

Returns:

deserialized object

raw_decode(s, idx=0)

Decode a JSON document from s (a str beginning with a JSON document) and return a 2-tuple of the Python representation and the index in s where the document ended.

This can be used to decode a JSON document from a string that may have extraneous data at the end.

class DIRAC.Core.Utilities.JEncode.DJSONEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: JSONEncoder

This custom encoder is to add support to json for tuple, datetime, and any object inheriting from JSerializable

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

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 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.

default(obj)

Add supports for datetime and JSerializable class to default json

Parameters:

obj – object to serialize

Returns:

json string of the serialized objects

encode(o)

Return a JSON string representation of a Python data structure.

>>> from json.encoder import JSONEncoder
>>> JSONEncoder().encode({"foo": ["bar", "baz"]})
'{"foo": ["bar", "baz"]}'

item_separator = ', '

iterencode(o, _one_shot=False)

Encode the given object and yield each string representation as available.

For example:

for chunk in JSONEncoder().iterencode(bigobject):
    mysocket.write(chunk)

key_separator = ': '

class DIRAC.Core.Utilities.JEncode.JSerializable

Bases: object

Base class to define a serializable object by DIRAC.

An object that ought to be serialized throught DISET shoud:

• inherit from this class

• define the _attrToSerialize list as class member. It is a list of strings containing the name of the attributes that should be serialized

• have a constructor that takes no arguments, or only keywords arguments

Exemple:

class Serializable(JSerializable):

_attrToSerialize = [‘myAttr’]

def __init__(self, myAttr = None):

self.myAttr = myAttr

Limitations:

• This will not work for classes defined inside classes. The class definition shoud be visible from the global scope

• Class attributes cannot be serialized as such. They are converted to instance attributes.

DIRAC.Core.Utilities.JEncode.decode(encodedData)

Decode the json encoded string

Parameters:

encodedData – json encoded string

Returns:

the decoded objects, encoded object length

Arguably, the length of the encodedData is useless, but it is for compatibility

DIRAC.Core.Utilities.JEncode.encode(inData)

Encode the input data into a JSON string

Parameters:

inData – anything that can be serialized. Namely, anything that can be serialized by standard json package, datetime object, tuples, and any class that inherits from JSerializable

Returns:

a json string

DIRAC.Core.Utilities.JEncode.strToFloatDict(inDict)

Because JSON will transform dict with float keys to str keys, this utility method is just to cast it back.

Parameters:

inDict – dictionary with strings as keys e.g. {‘1.0’: 1, ‘2.1’: 2}

Returns:

dictionary with float as keys e.g. {1.0: 1, 2.1: 2}

DIRAC.Core.Utilities.JEncode.strToIntDict(inDict)

Because JSON will transform dict with int keys to str keys, this utility method is just to cast it back. This shows useful in cases when sending dict indexed on jobID or requestID for example

Parameters:

inDict – dictionary with strings as keys e.g. {‘1’: 1, ‘2’: 2}

Returns:

dictionary with int as keys e.g. {1: 1, 2: 2}