adctk.adc_types Namespace Reference

Classes
class	Field
	Field details indicate how to handle a data returned from builder lookups. More...
class	KeyType
	The builder type (section or map value) or unknown. More...
class	ScalarType
	field types for scientific data encode/decode with json. More...

Functions
bool	is_string_type (ScalarType st)
	return True if st is of the single string subclassifications
str	scalar_to_json (ScalarType st, array_type=False)
	scalar_from_json (str name, strict=False)
	convert json type string used in add functions to ScalarType
	scalar_from_numpy (numpy.dtype dt)
	convert numpy dtype to adc scalar type
ScalarType	get_common_scalar (list|tuple|collections.abc.Set slt, int depth, list[int] maxdepth)
	get the common scalar type from a possibly nested tuple/set/list
numpy.ndarray	forsplitcomplex (numpy.ndarray a)
numpy.ndarray	csplitcomplex (numpy.ndarray a)
	get_list_format_numpy (numpy.ndarray a)
	build a nested list out of numpy array, accounting for int must fit in int64 or be string encoded and accounting for complex numbers.
	get_list_format (list|tuple|collections.abc.Set|numpy.ndarray slt, ScalarType st=None)
	build a nested list out of homogeneous python or numpy nest
	typecode_to_scalar (array.array v)
	type_to_scalar (type t, value=None)
	convert python type to ScalarType numpy array types are supported if value is given.
bool	fits_int64 (int v)
bool	fits_uint64 (int v)

Variables
int	ADC_SUPPORT_GPU_FLOATS = 0
	Set to 1 if 8/16 bit float types for gpus are supported.
int	ADC_SUPPORT_EXTENDED_FLOATS = 1
	Set to 1 if 80 bit floats for cpus are supported.
int	ADC_SUPPORT_QUAD_FLOATS = 0
	Set to 1 if 128 bit floats for cpus are supported.

Function Documentation

csplitcomplex()

numpy.ndarray adctk.adc_types.csplitcomplex

(

numpy.ndarray

a

)

Convert a numpy array of complex to a flat array of real pairs

def csplitcomplex(a: numpy.ndarray) -> numpy.ndarray:
    """Convert a numpy array of complex to a flat array of real pairs"""
    t = a.real.dtype
    c = numpy.ravel(a)
    top = 2*c.size
    r = numpy.ndarray((top), dtype=t)
    for i in range(0,c.size):
        r[2*i] = c[i].real
        r[2*i+1] = c[i].imag
    return r
 
# pylint: disable-next=too-many-return-statements

fits_int64()

bool adctk.adc_types.fits_int64

(

int

v

)

Returns

True if v can be stored as json signed int 64 bit

def fits_int64(v: int) -> bool:
    """! @return True if v can be stored as json signed int 64 bit"""
    if v is not None and type(v) == int:
        if -9223372036854775808 <= v <= 9223372036854775807:
            return True
        return False
    raise ValueError("argument must be int")
 

fits_uint64()

bool adctk.adc_types.fits_uint64

(

int

v

)

Returns

True if v can be stored as json unsigned int 64 bit

def fits_uint64(v: int) -> bool:
    """! @return True if v can be stored as json unsigned int 64 bit"""
    if v is not None and type(v) == int:
        if 0 <= v <= 18446744073709551615:
            return True
        return False
    raise ValueError("argument must be int")

forsplitcomplex()

numpy.ndarray adctk.adc_types.forsplitcomplex

(

numpy.ndarray

a

)

Convert a numpy array of fortran complex to a flat array of real pairs

def forsplitcomplex(a: numpy.ndarray) -> numpy.ndarray:
    """Convert a numpy array of fortran complex to a flat array of real pairs"""
    t = a.real.dtype
    c = numpy.ravel(a, order='F')
    top = 2*c.size
    r = numpy.ndarray((top), dtype=t)
    for i in range(0,c.size):
        r[2*i] = c[i].real
        r[2*i+1] = c[i].imag
    return r
 

get_common_scalar()

ScalarType adctk.adc_types.get_common_scalar	(	list|tuple|collections.abc.Set	slt,
		int	depth,
		list[int]	maxdepth
	)

get the common scalar type from a possibly nested tuple/set/list

Parameters

slt	data nest with single scalar type at the leaf locations.
depth	current recursion depth, 0 at the application level.
maxdepth	is a one-element array output argument.

                    maxdepth: list[int]) -> ScalarType:
    """! @brief get the common scalar type from a possibly nested tuple/set/list
 
     @param slt data nest with single scalar type at the leaf locations.
     @param depth current recursion depth, 0 at the application level.
     @param maxdepth is a one-element array output argument.
     """
    imin =[0]
    imax =[0]
    dtypes = set()
    pt = __get_common_py_type(slt, depth, maxdepth, imin, imax, dtypes)
    if pt is None:
        return ScalarType.cp_none
    if pt == int:
        if fits_int64(imin[0]) and fits_int64(imax[0]):
            return ScalarType.cp_int64
        return ScalarType.cp_number_str
    return type_to_scalar(pt, next(iter(slt)))
 
# pylint: disable-next=R0917,R0913,R0912

get_list_format()

adctk.adc_types.get_list_format	(	list|tuple|collections.abc.Set|numpy.ndarray	slt,
		ScalarType	st = None
	)

build a nested list out of homogeneous python or numpy nest

def get_list_format(slt: list|tuple|collections.abc.Set|numpy.ndarray, st: ScalarType = None):
    """! @brief build a nested list out of homogeneous python or numpy nest"""
    if slt is None:
        return None
    if isinstance(slt, numpy.ndarray):
        return get_list_format_numpy(slt)
    result = []
    for i in slt:
        if isinstance(i, list|tuple|collections.abc.Set):
            it = get_list_format(i, st)
        else:
            # fixme: it = pyval(py_or_numpy). is there a numpy func for this
            match st:
                case ScalarType.cp_uint64:
                    it = str(int(i))
                case ScalarType.cp_number_str:
                    it = i
                case _:
                    it = i
                    
        result.append(it)
    return result
 

get_list_format_numpy()

adctk.adc_types.get_list_format_numpy

(

numpy.ndarray

a

)

build a nested list out of numpy array, accounting for int must fit in int64 or be string encoded and accounting for complex numbers.

def get_list_format_numpy(a: numpy.ndarray):
    """! @brief build a nested list out of numpy array, accounting for
    int must fit in int64 or be string encoded and accounting for
    complex numbers.
    """
    if a is None:
        return None
    if __py_json_numpy_ok(a):
        
        return numpy.ravel(a).tolist()
    # cp_uint64 cp_c_f32 cp_c_f64 cp_c_f80 cp_c_f128
    if a.dtype == numpy.dtype('uint64'):
        a_copy = a.astype(numpy.str_)
        return numpy.ravel(a_copy).tolist()
    if a.dtype == numpy.dtype('complex64'):
        if a.flags['F_CONTIGUOUS']:
            r_view = forsplitcomplex(a)
            return r_view.tolist()
        r_view = csplitcomplex(a)
        return r_view.tolist()
    if a.dtype == numpy.dtype('complex128'):
        if a.flags['F_CONTIGUOUS']:
            r_view = forsplitcomplex(a)
            return r_view.tolist()
        r_view = csplitcomplex(a)
        return r_view.tolist()
    if a.dtype == numpy.dtype('complex256'):
        if a.flags['F_CONTIGUOUS']:
            r_view = forsplitcomplex(a)
            a_copy = r_view.astype(numpy.str_)
            return a_copy.tolist()
        r_view = csplitcomplex(a)
        a_copy = r_view.astype(numpy.str_)
        return a_copy.tolist()
    return ["NOT_YET_SUPPORTED(numpy array):"+a.dtype.name]
 

is_string_type()

bool adctk.adc_types.is_string_type

(

ScalarType

st

)

return True if st is of the single string subclassifications

def is_string_type(st: ScalarType) -> bool:
    """! return True if st is of the single string subclassifications"""
    if st in ( ScalarType.cp_cstr,
            ScalarType.cp_json_str,
            ScalarType.cp_yaml_str,
            ScalarType.cp_xml_str,
            ScalarType.cp_path):
        return True
    return False
 

scalar_from_json()

adctk.adc_types.scalar_from_json	(	str	name,
			strict = False
	)

convert json type string used in add functions to ScalarType

Parameters

name	convert json scalar type label to enum.
strict	if True, raises an exception when name is invalid array_* type prefix is stripped, if present in name.

def scalar_from_json(name: str, strict=False):
    """! convert json type string used in add functions to ScalarType
 
    @param name convert json scalar type label to enum.
    @param strict if True, raises an exception when name is invalid
    array_* type prefix is stripped, if present in name.
    """
    if name.startswith("array_"):
        name = name[6:]
    if strict:
        return ScalarType.__members__["cp_"+name]
    try:
        x = ScalarType.__members__["cp_"+name]
    except:
        x = ScalarType.cp_none
    
    return x
 
# mapping of numpy types to adc type.
# notes:
# - numpy 2.3 and older do not support precision higher than c long double (64 or 80bit)
# - currently this assumes an x86_64 or similar environment for int sizing (32 bit
#   platforms/build need to be detected and supported)
# - datetime64 and deltatime from numpy are not supported yet. fixme

scalar_from_numpy()

adctk.adc_types.scalar_from_numpy

(

numpy.dtype

dt

)

convert numpy dtype to adc scalar type

• numpy 2.3 and older do not support precision higher than c long double (64 or 80bit)
• currently this assumes an x86_64 or similar environment for int sizing
• 32 bit platforms/builds may need to be detected and supported, if they still exist

def scalar_from_numpy(dt: numpy.dtype):
    """! convert numpy dtype to adc scalar type
    - numpy 2.3 and older do not support precision higher than c long double (64 or 80bit)
    - currently this assumes an x86_64 or similar environment for int sizing
    - 32 bit platforms/builds may need to be detected and supported, if they still exist
    """
    __scalar_from_numpy_conditional()
    if dt in __scalar_from_numpy:
        return __scalar_from_numpy[dt]
    
    raise ValueError("unknown numpy type mapping")
 

scalar_to_json()

str adctk.adc_types.scalar_to_json	(	ScalarType	st,
			array_type = False
	)

Convert ScalarType to json type string used in add functions

def scalar_to_json(st: ScalarType, array_type=False) -> str:
    """Convert ScalarType to json type string used in add functions"""
    r = st.name[3:]
    if array_type:
        r = f"array_{r}"
    
    return r
 

type_to_scalar()

adctk.adc_types.type_to_scalar	(	type	t,
			value = None
	)

convert python type to ScalarType numpy array types are supported if value is given.

int type is supported only if a value is given. Semantic variations on string content are all mapped to cp_cstr.

def type_to_scalar(t: type, value=None):
    """! @brief convert python type to ScalarType
    numpy array types are supported if value is given.
    int type is supported only if a value is given.
    Semantic variations on string content are all mapped to cp_cstr.
    """
    if t is None:
        return ScalarType.cp_none
    if t == int:
        if value is None:
            raise ValueError("type_to_scalar(int) needs value argument")
        if fits_int64(value):
            return ScalarType.cp_int64
        return ScalarType.cp_number_str
    if t == str:
        return ScalarType.cp_cstr
    if t == bool:
        
        return ScalarType.cp_bool
    if t == float:
        return ScalarType.cp_f64
    if t == complex:
        return ScalarType.cp_c_f64
    if t == decimal.Decimal:
        return ScalarType.cp_number_str
    if t in (list, tuple, collections.abc.Set):
        if not value:
            raise ValueError("type_to_scalar needs value argument for list/set/tuple")
        md = [0]
        return get_common_scalar(value, 0, md )
    if t == numpy.ndarray and not value:
        raise ValueError("type_to_scalar needs value argument")
    if value is not None and type(value).__module__ == numpy.__name__:
        if isinstance(value, numpy.ndarray):
            return scalar_from_numpy(value.dtype)
            # print(value.shape)
            # print(value.itemsize)
            # print(value.dtype)
        
        match value:
            case numpy.float64() | numpy.float32() | numpy.float16() | \
                 numpy.int64() | numpy.int32() | numpy.int16() | numpy.int8() | \
                 numpy.uint32() | numpy.uint16() | numpy.uint8() |numpy.bool() | \
                 numpy.str_() | numpy.bytes_() | \
                 numpy.uint64() | \
                 numpy.complex64() | numpy.complex128() | \
                 numpy.complex192() | numpy.complex256():
                return scalar_from_numpy(value.dtype)
    return ScalarType.cp_none
 
# pylint: too-few-public-methods

typecode_to_scalar()

adctk.adc_types.typecode_to_scalar

(

array.array

v

)

def typecode_to_scalar(v: array.array):
    tc = v.typecode
    match tc:
        case 'b':
            return ScalarType.cp_char
        case 'B':
            return ScalarType.cp_char8
        case 'u':
            if v.itemsize == 4:
                return ScalarType.cp_char32
            return ScalarType.cp_char16
        case 'w':
            return ScalarType.cp_char32
        case 'h':
            if v.itemsize == 2:
                return ScalarType.cp_int16
            return ScalarType.cp_int32
        case 'H':
            if v.itemsize == 2:
                return ScalarType.cp_uint16
            return ScalarType.cp_uint32
        case 'i':
            if v.itemsize == 2:
                return ScalarType.cp_int16
            return ScalarType.cp_int32
        case 'I':
            if v.itemsize == 2:
                return ScalarType.cp_uint16
            return ScalarType.cp_uint32
        case 'l':
            if v.itemsize == 4:
                return ScalarType.cp_int32
            return ScalarType.cp_int64
        case 'L':
            if v.itemsize == 4:
                return ScalarType.cp_uint32
            return ScalarType.cp_uint64
        case 'q':
            if v.itemsize == 8:
                return ScalarType.cp_int64
            return ScalarType.cp_number_str
        case 'Q':
            if v.itemsize == 8:
                return ScalarType.cp_uint64
            return ScalarType.cp_number_str
        case 'f':
            if v.itemsize == 4:
                return ScalarType.cp_f32
            return ScalarType.cp_f64
        case 'd':
            if v.itemsize == 8:
                return ScalarType.cp_f64
            return ScalarType.cp_number_str
 
# pylint: disable-next=too-many-return-statements,too-many-branches

Variable Documentation

ADC_SUPPORT_EXTENDED_FLOATS

int adctk.adc_types.ADC_SUPPORT_EXTENDED_FLOATS = 1

Set to 1 if 80 bit floats for cpus are supported.

ADC_SUPPORT_EXTENDED_FLOATS should be defined by build-time configuration

ADC_SUPPORT_GPU_FLOATS

int adctk.adc_types.ADC_SUPPORT_GPU_FLOATS = 0

Set to 1 if 8/16 bit float types for gpus are supported.

ADC_SUPPORT_GPU_FLOATS should be defined by build-time configuration

ADC_SUPPORT_QUAD_FLOATS

int adctk.adc_types.ADC_SUPPORT_QUAD_FLOATS = 0

Set to 1 if 128 bit floats for cpus are supported.

ADC_SUPPORT_QUAD_FLOATS should be defined by build-time configuration