pytomography.io.PET.prd._ndjson

Module Contents

Classes

NDJsonProtocolWriter	Helper class that provides a standard way to create an ABC using
NDJsonProtocolReader
JsonConverter	Abstract base class for generic types.
BoolConverter	Abstract base class for generic types.
Int8Converter	Abstract base class for generic types.
UInt8Converter	Abstract base class for generic types.
Int16Converter	Abstract base class for generic types.
UInt16Converter	Abstract base class for generic types.
Int32Converter	Abstract base class for generic types.
UInt32Converter	Abstract base class for generic types.
Int64Converter	Abstract base class for generic types.
UInt64Converter	Abstract base class for generic types.
SizeConverter	Abstract base class for generic types.
Float32Converter	Abstract base class for generic types.
Float64Converter	Abstract base class for generic types.
Complex32Converter	Abstract base class for generic types.
Complex64Converter	Abstract base class for generic types.
StringConverter	Abstract base class for generic types.
DateConverter	Abstract base class for generic types.
TimeConverter	Abstract base class for generic types.
DateTimeConverter	Abstract base class for generic types.
EnumConverter	Abstract base class for generic types.
FlagsConverter	Abstract base class for generic types.
OptionalConverter	Abstract base class for generic types.
UnionConverter	Abstract base class for generic types.
VectorConverter	Abstract base class for generic types.
FixedVectorConverter	Abstract base class for generic types.
MapConverter	Abstract base class for generic types.
NDArrayConverterBase	Abstract base class for generic types.
FixedNDArrayConverter	Abstract base class for generic types.
DynamicNDArrayConverter	Abstract base class for generic types.
NDArrayConverter	Abstract base class for generic types.

Attributes

CURRENT_NDJSON_FORMAT_VERSION
INT8_MIN
INT8_MAX
UINT8_MAX
INT16_MIN
INT16_MAX
UINT16_MAX
INT32_MIN
INT32_MAX
UINT32_MAX
INT64_MIN
INT64_MAX
UINT64_MAX
MISSING_SENTINEL
T
T_NP
bool_converter
int8_converter
uint8_converter
int16_converter
uint16_converter
int32_converter
uint32_converter
int64_converter
uint64_converter
size_converter
float32_converter
float64_converter
complexfloat32_converter
complexfloat64_converter
string_converter
date_converter
time_converter
datetime_converter
TEnum
TFlag
TKey
TKey_NP
TValue
TValue_NP

pytomography.io.PET.prd._ndjson.CURRENT_NDJSON_FORMAT_VERSION: int = 1

pytomography.io.PET.prd._ndjson.INT8_MIN: int

pytomography.io.PET.prd._ndjson.INT8_MAX: int

pytomography.io.PET.prd._ndjson.UINT8_MAX: int

pytomography.io.PET.prd._ndjson.INT16_MIN: int

pytomography.io.PET.prd._ndjson.INT16_MAX: int

pytomography.io.PET.prd._ndjson.UINT16_MAX: int

pytomography.io.PET.prd._ndjson.INT32_MIN: int

pytomography.io.PET.prd._ndjson.INT32_MAX: int

pytomography.io.PET.prd._ndjson.UINT32_MAX: int

pytomography.io.PET.prd._ndjson.INT64_MIN: int

pytomography.io.PET.prd._ndjson.INT64_MAX: int

pytomography.io.PET.prd._ndjson.UINT64_MAX: int

pytomography.io.PET.prd._ndjson.MISSING_SENTINEL

class pytomography.io.PET.prd._ndjson.NDJsonProtocolWriter(stream, schema)

Bases: pytomography.io.PET.prd.yardl_types.ABC

Helper class that provides a standard way to create an ABC using inheritance.

Parameters:

• stream (pytomography.io.PET.prd.yardl_types.Union[TextIO, str]) –

• schema (str) –

close()

Return type:

None

_end_stream()

Return type:

None

_write_json_line(value)

Parameters:

value (object) –

Return type:

None

class pytomography.io.PET.prd._ndjson.NDJsonProtocolReader(stream, schema)

Parameters:

• stream (pytomography.io.PET.prd.yardl_types.Union[io.BufferedReader, TextIO, str]) –

• schema (str) –

close()

Return type:

None

_read_json_line(stepName, required)

Parameters:

• stepName (str) –

• required (bool) –

Return type:

object

pytomography.io.PET.prd._ndjson.T

pytomography.io.PET.prd._ndjson.T_NP

class pytomography.io.PET.prd._ndjson.JsonConverter(dtype)

Bases: pytomography.io.PET.prd.yardl_types.Generic[T, T_NP], pytomography.io.PET.prd.yardl_types.ABC

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

dtype (numpy.typing.DTypeLike) –

overall_dtype()

Return type:

pytomography.io.PET.prd.yardl_types.np.dtype[Any]

abstract to_json(value)

Parameters:

value (T) –

Return type:

object

abstract numpy_to_json(value)

Parameters:

value (T_NP) –

Return type:

object

abstract from_json(json_object)

Parameters:

json_object (object) –

Return type:

T

abstract from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

T_NP

supports_none()

Return type:

bool

class pytomography.io.PET.prd._ndjson.BoolConverter

Bases: JsonConverter[bool, pytomography.io.PET.prd.yardl_types.np.bool_]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (bool) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.bool_) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

bool

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.bool_

pytomography.io.PET.prd._ndjson.bool_converter

class pytomography.io.PET.prd._ndjson.Int8Converter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.int8]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.int8) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.int8

pytomography.io.PET.prd._ndjson.int8_converter

class pytomography.io.PET.prd._ndjson.UInt8Converter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.uint8]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.uint8) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.uint8

pytomography.io.PET.prd._ndjson.uint8_converter

class pytomography.io.PET.prd._ndjson.Int16Converter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.int16]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.int16) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.int16

pytomography.io.PET.prd._ndjson.int16_converter

class pytomography.io.PET.prd._ndjson.UInt16Converter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.uint16]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.uint16) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.uint16

pytomography.io.PET.prd._ndjson.uint16_converter

class pytomography.io.PET.prd._ndjson.Int32Converter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.int32]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.int32) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.int32

pytomography.io.PET.prd._ndjson.int32_converter

class pytomography.io.PET.prd._ndjson.UInt32Converter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.uint32]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.uint32) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.uint32

pytomography.io.PET.prd._ndjson.uint32_converter

class pytomography.io.PET.prd._ndjson.Int64Converter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.int64]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.int64) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.int64

pytomography.io.PET.prd._ndjson.int64_converter

class pytomography.io.PET.prd._ndjson.UInt64Converter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.uint64]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.uint64) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.uint64

pytomography.io.PET.prd._ndjson.uint64_converter

class pytomography.io.PET.prd._ndjson.SizeConverter

Bases: JsonConverter[int, pytomography.io.PET.prd.yardl_types.np.uint64]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (int) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.uint64) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

int

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.uint64

pytomography.io.PET.prd._ndjson.size_converter

class pytomography.io.PET.prd._ndjson.Float32Converter

Bases: JsonConverter[float, pytomography.io.PET.prd.yardl_types.np.float32]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (float) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.float32) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

float

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.float32

pytomography.io.PET.prd._ndjson.float32_converter

class pytomography.io.PET.prd._ndjson.Float64Converter

Bases: JsonConverter[float, pytomography.io.PET.prd.yardl_types.np.float64]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (float) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.float64) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

float

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.float64

pytomography.io.PET.prd._ndjson.float64_converter

class pytomography.io.PET.prd._ndjson.Complex32Converter

Bases: JsonConverter[complex, pytomography.io.PET.prd.yardl_types.np.complex64]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (complex) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.complex64) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

complex

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.complex64

pytomography.io.PET.prd._ndjson.complexfloat32_converter

class pytomography.io.PET.prd._ndjson.Complex64Converter

Bases: JsonConverter[complex, pytomography.io.PET.prd.yardl_types.np.complex128]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (complex) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.complex128) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

complex

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.complex128

pytomography.io.PET.prd._ndjson.complexfloat64_converter

class pytomography.io.PET.prd._ndjson.StringConverter

Bases: JsonConverter[str, pytomography.io.PET.prd.yardl_types.np.object_]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (str) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.object_) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

str

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.object_

pytomography.io.PET.prd._ndjson.string_converter

class pytomography.io.PET.prd._ndjson.DateConverter

Bases: JsonConverter[pytomography.io.PET.prd.yardl_types.datetime.date, pytomography.io.PET.prd.yardl_types.np.datetime64]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.datetime.date) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.datetime64) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.datetime.date

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.datetime64

pytomography.io.PET.prd._ndjson.date_converter

class pytomography.io.PET.prd._ndjson.TimeConverter

Bases: JsonConverter[pytomography.io.PET.prd.yardl_types.Time, pytomography.io.PET.prd.yardl_types.np.timedelta64]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.Time) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.timedelta64) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.Time

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.timedelta64

pytomography.io.PET.prd._ndjson.time_converter

class pytomography.io.PET.prd._ndjson.DateTimeConverter

Bases: JsonConverter[pytomography.io.PET.prd.yardl_types.DateTime, pytomography.io.PET.prd.yardl_types.np.datetime64]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.DateTime) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.datetime64) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.DateTime

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.datetime64

pytomography.io.PET.prd._ndjson.datetime_converter

pytomography.io.PET.prd._ndjson.TEnum

class pytomography.io.PET.prd._ndjson.EnumConverter(enum_type, numpy_type, name_to_value, value_to_name)

Bases: pytomography.io.PET.prd.yardl_types.Generic[TEnum, T_NP], JsonConverter[TEnum, T_NP]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

• enum_type (type[TEnum]) –

• numpy_type (type) –

• name_to_value (dict[str, TEnum]) –

• value_to_name (dict[TEnum, str]) –

to_json(value)

Parameters:

value (TEnum) –

Return type:

object

numpy_to_json(value)

Parameters:

value (T_NP) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

TEnum

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

T_NP

pytomography.io.PET.prd._ndjson.TFlag

class pytomography.io.PET.prd._ndjson.FlagsConverter(enum_type, numpy_type, name_to_value, value_to_name)

Bases: pytomography.io.PET.prd.yardl_types.Generic[TFlag, T_NP], JsonConverter[TFlag, T_NP]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

• enum_type (type[TFlag]) –

• numpy_type (type) –

• name_to_value (dict[str, TFlag]) –

• value_to_name (dict[TFlag, str]) –

to_json(value)

Parameters:

value (TFlag) –

Return type:

object

numpy_to_json(value)

Parameters:

value (T_NP) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

TFlag

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

T_NP

class pytomography.io.PET.prd._ndjson.OptionalConverter(element_converter)

Bases: pytomography.io.PET.prd.yardl_types.Generic[T, T_NP], JsonConverter[Optional[T], pytomography.io.PET.prd.yardl_types.np.void]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

element_converter (JsonConverter[T, T_NP]) –

to_json(value)

Parameters:

value (Optional[T]) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.void) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

Optional[T]

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.void

supports_none()

Return type:

bool

class pytomography.io.PET.prd._ndjson.UnionConverter(union_type, cases, simple)

Bases: JsonConverter[T, pytomography.io.PET.prd.yardl_types.np.object_]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

• union_type (type) –

• cases (list[Optional[tuple[type, JsonConverter[Any, Any], list[type]]]]) –

• simple (bool) –

to_json(value)

Parameters:

value (T) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.object_) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

T

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.object_

supports_none()

Return type:

bool

class pytomography.io.PET.prd._ndjson.VectorConverter(element_converter)

Bases: pytomography.io.PET.prd.yardl_types.Generic[T, T_NP], JsonConverter[list[T], pytomography.io.PET.prd.yardl_types.np.object_]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

element_converter (JsonConverter[T, T_NP]) –

to_json(value)

Parameters:

value (list[T]) –

Return type:

object

numpy_to_json(value)

Parameters:

value (object) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

list[T]

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.object_

class pytomography.io.PET.prd._ndjson.FixedVectorConverter(element_converter, length)

Bases: pytomography.io.PET.prd.yardl_types.Generic[T, T_NP], JsonConverter[list[T], pytomography.io.PET.prd.yardl_types.np.object_]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

• element_converter (JsonConverter[T, T_NP]) –

• length (int) –

to_json(value)

Parameters:

value (list[T]) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.object_) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

list[T]

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.object_

pytomography.io.PET.prd._ndjson.TKey

pytomography.io.PET.prd._ndjson.TKey_NP

pytomography.io.PET.prd._ndjson.TValue

pytomography.io.PET.prd._ndjson.TValue_NP

class pytomography.io.PET.prd._ndjson.MapConverter(key_converter, value_converter)

Bases: pytomography.io.PET.prd.yardl_types.Generic[TKey, TKey_NP, TValue, TValue_NP], JsonConverter[dict[TKey, TValue], pytomography.io.PET.prd.yardl_types.np.object_]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

• key_converter (JsonConverter[TKey, TKey_NP]) –

• value_converter (JsonConverter[TValue, TValue_NP]) –

to_json(value)

Parameters:

value (dict[TKey, TValue]) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.object_) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

dict[TKey, TValue]

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.object_

class pytomography.io.PET.prd._ndjson.NDArrayConverterBase(overall_dtype, element_converter, dtype)

Bases: pytomography.io.PET.prd.yardl_types.Generic[T, T_NP], JsonConverter[numpy.typing.NDArray[Any], pytomography.io.PET.prd.yardl_types.np.object_]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

• overall_dtype (numpy.typing.DTypeLike) –

• element_converter (JsonConverter[T, T_NP]) –

• dtype (numpy.typing.DTypeLike) –

static _get_dtype_and_subarray_shape(dtype)

Parameters:

dtype (pytomography.io.PET.prd.yardl_types.np.dtype[Any]) –

Return type:

tuple[pytomography.io.PET.prd.yardl_types.np.dtype[Any], tuple[int, Ellipsis]]

check_dtype(input_dtype)

Parameters:

input_dtype (numpy.typing.DTypeLike) –

_read(shape, json_object)

Parameters:

• shape (tuple[int, Ellipsis]) –

• json_object (list[object]) –

Return type:

numpy.typing.NDArray[Any]

class pytomography.io.PET.prd._ndjson.FixedNDArrayConverter(element_converter, shape)

Bases: pytomography.io.PET.prd.yardl_types.Generic[T, T_NP], NDArrayConverterBase[T, T_NP]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

• element_converter (JsonConverter[T, T_NP]) –

• shape (tuple[int, Ellipsis]) –

to_json(value)

Parameters:

value (numpy.typing.NDArray[Any]) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.object_) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

numpy.typing.NDArray[Any]

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.object_

class pytomography.io.PET.prd._ndjson.DynamicNDArrayConverter(element_serializer)

Bases: NDArrayConverterBase[T, T_NP]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

element_serializer (JsonConverter[T, T_NP]) –

to_json(value)

Parameters:

value (numpy.typing.NDArray[Any]) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.object_) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

numpy.typing.NDArray[Any]

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.object_

class pytomography.io.PET.prd._ndjson.NDArrayConverter(element_converter, ndims)

Bases: pytomography.io.PET.prd.yardl_types.Generic[T, T_NP], NDArrayConverterBase[T, T_NP]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Parameters:

• element_converter (JsonConverter[T, T_NP]) –

• ndims (int) –

to_json(value)

Parameters:

value (numpy.typing.NDArray[Any]) –

Return type:

object

numpy_to_json(value)

Parameters:

value (pytomography.io.PET.prd.yardl_types.np.object_) –

Return type:

object

from_json(json_object)

Parameters:

json_object (object) –

Return type:

numpy.typing.NDArray[Any]

from_json_to_numpy(json_object)

Parameters:

json_object (object) –

Return type:

pytomography.io.PET.prd.yardl_types.np.object_