deephaven.json¶

jackson
- provider()

The deephaven JSON module presents a declarative and composable configuration layer for describing the structure of a JSON (https://www.json.org) value. Most commonly, this will be used to model the structure for a JSON object. For example, the JSON object

{ "name": "Foo", "age": 42, "location": { "lat": 45.018269, "lon": -93.473892 } }

can be modelled with the dictionary

{ "name": str, "age": int, "location": { "lat": float, "lon": float } }

Notice that this allows for the nested modelling of JSON values. Other common constructions involve the modelling of JSON arrays. For example, a variable-length JSON array where the elements are the same type

[42, 31, ..., 12345]

can be modelled with a single-element list containing the element type

[ int ]

If the JSON array is a fixed size and each elements’ type is known, for example

["Foo", 42, [45.018269, -93.473892]]

can be modelled with a tuple containing each type

(str, int, (float, float))

Notice again that this allows for the nested modelling of JSON values. Of course, these constructions can be all be used together. For example, the JSON object

{
  "name": "Foo",
  "locations": [
    [45.018269, -93.473892],
    ...,
    [40.730610, -73.935242]
  ]
}

can be modelled as

{"name": str, "locations": [(float, float)]}

See the methods in this module more more details on modelling JSON values.

class JsonValue(j_value)[source]¶

Bases: JObjectWrapper

The JSON Value type.

j_object_type¶: alias of Value

JsonValueType¶

The JSON value alias

alias of Union[JsonValue, DType, type, Dict[str, Union[JsonValueType, ObjectField]], List[JsonValueType], Tuple[JsonValueType, …]]

class ObjectField(value_type, aliases=<factory>, repeated_behavior=RepeatedFieldBehavior.ERROR, case_sensitive=True)[source]¶

Bases: object

The object field options.

In contexts where the user needs to create an object field value and isn’t changing any default values, the user can simplify by just using the JsonValueType. For example,

{
    "name": ObjectField(str),
    "age": ObjectField(int),
}

could be simplified to

{
    "name": str,
    "age": int,
}

aliases¶: The field name aliases. By default, is an empty list.

case_sensitive = True¶: If the field name and aliases should be compared using case-sensitive equality. By default, is True.

repeated_behavior = io.deephaven.json.ObjectField$RepeatedBehavior(objectRef=0x5565f354b60a)¶: The repeated field behavior. By default, is RepeatedFieldBehavior.ERROR.

value_type¶: The json value type

class RepeatedFieldBehavior(value)[source]¶

Bases: Enum

The behavior to use when a repeated field is encountered in a JSON object. For example,

{
  "foo": 42,
  "foo": 43
}

ERROR = io.deephaven.json.ObjectField$RepeatedBehavior(objectRef=0x5565f354b60a)¶: Raise an error

USE_FIRST = io.deephaven.json.ObjectField$RepeatedBehavior(objectRef=0x5565f354b612)¶: Use the first field

any_val()[source]¶

Creates an “any” value. The resulting type is implementation dependant.

Return type:: JsonValue
Returns:: the “any” value

array_val(element, allow_missing=True, allow_null=True)[source]¶

Creates a “typed array”, where all elements of the array have the same element type. For example, the JSON array

[1, 42, 43, 13]

might be modelled as an array of ints

array_val(int)

In contexts where the user needs to create a JsonValueType and isn’t changing any default values, the user can simplify by using a list with a single element type. For example,

some_method(array_val(element))

could be simplified to

some_method([element])

Parameters:

element (JsonValueType) – the array element type
allow_missing (bool) – if the array is allowed to be missing, by default is True
allow_null (bool) – if the array is allowed to be a JSON null type, by default is True

Return type: