DIRAC Encoding utilities based on json

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

Bases: json.decoder.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 _sre.SRE_Pattern object>)

Return the Python representation of s (a str or unicode 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 or unicode 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, encoding='utf-8', default=None)

Bases: json.encoder.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, encoding='utf-8', 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, long, float or None. If skipkeys is True, such items are simply skipped.

If ensure_ascii is true (the default), all non-ASCII characters in the output are escaped with uXXXX sequences, and the results are str instances consisting of ASCII characters only. If ensure_ascii is False, a result may be a unicode instance. This usually happens if the input contains unicode strings or the encoding parameter is used.

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 OverflowError). 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. Since the default item separator is ‘, ‘, the output might include trailing whitespace when indent is specified. You can use separators=(‘,’, ‘: ‘) to avoid this.

If specified, separators should be a (item_separator, key_separator) tuple. The default is (‘, ‘, ‘: ‘). 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.

If encoding is not None, then all input strings will be transformed into unicode using that encoding prior to JSON-encoding. The default is UTF-8.


Add supports for datetime and JSerializable class to default json

Parameters:obj – object to serialize
Returns:json string of the serialized objects

Return a JSON string representation of a Python data structure.

>>> 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):
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


class Serializable(JSerializable):

_attrToSerialize = [‘myAttr’]

def __init__(self, myAttr = None):
self.myAttr = myAttr
  • 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.

x.__init__(…) initializes x; see help(type(x)) for signature


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


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

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}