pninexus 3.3.0__cp310-cp310-manylinux_2_35_x86_64.whl

pninexus/__init__.py

@@ -0,0 +1,6 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)
+
+try:
+    from . import filters
+except ImportError:
+    pass

pninexus/filters/__init__.py

@@ -0,0 +1,7 @@
+"""
+:py:mod:`pninexus.filters` is a path setter for HDF5_PLUGIN_PATH
+"""
+import os
+from pathlib import Path
+
+os.environ["HDF5_PLUGIN_PATH"] = os.path.split(Path(__file__))[0]

pninexus/h5cpp/__init__.py

@@ -0,0 +1,28 @@
+"""
+:py:mod:`pninexus.io.h5cpp` is a thin wrapper around the *h5cpp* C++
+library where every
+namespace in the C++ library has a counterpart as a sub-package of
+:py:mod:`pninexus.io.h5cpp`
+"""
+
+
+from pninexus.h5cpp import _h5cpp
+from pninexus.h5cpp import attribute
+from pninexus.h5cpp import dataspace
+from pninexus.h5cpp import datatype
+from pninexus.h5cpp import file
+from pninexus.h5cpp import filter
+from pninexus.h5cpp import node
+from pninexus.h5cpp import property
+
+from pninexus.h5cpp._h5cpp import IteratorConfig
+from pninexus.h5cpp._h5cpp import IterationOrder
+from pninexus.h5cpp._h5cpp import IterationIndex
+from pninexus.h5cpp._h5cpp import Path
+from pninexus.h5cpp._h5cpp import print_hdf5_errors
+from pninexus.h5cpp._h5cpp import current_library_version
+
+__all__ = ["IteratorConfig", "IterationOrder", "IterationIndex", "Path",
+           "print_hdf5_errors", "current_library_version",
+           "attribute", "dataspace", "datatype", "file", "filter", "node",
+           "property", "_h5cpp"]

pninexus/h5cpp/attribute/__init__.py

@@ -0,0 +1,65 @@
+from __future__ import print_function
+import numpy
+import sys
+
+from pninexus.h5cpp import property
+from pninexus.h5cpp._attribute import AttributeManager
+from pninexus.h5cpp._attribute import Attribute
+
+__all__ = ["property", "AttributeManager", "Attribute"]
+
+
+if sys.version_info > (3,):
+    unicode = str
+
+
+def attribute__getitem__(self, index):
+
+    data = self.read()
+
+    return data[index]
+
+
+def attribute_write(self, data):
+
+    write_data = data
+    if not isinstance(write_data, numpy.ndarray):
+        write_data = numpy.array(write_data)
+    if write_data.dtype.kind == 'U':
+        try:
+            write_data = write_data.astype("S")
+        except Exception:
+            if isinstance(data, numpy.ndarray) and data.shape:
+                shape = data.shape
+                if len(shape) > 1:
+                    data = data.flatten()
+                write_data = numpy.array(
+                    [bytes(unicode(dt).encode('utf-8')) for dt in data])
+                if len(shape) > 1:
+                    write_data = write_data.reshape(shape)
+            else:
+                write_data = numpy.array(unicode(data).encode('utf-8'))
+    elif write_data.dtype == 'bool':
+        write_data = write_data.astype("int8")
+
+    #  print("DATA", data, write_data)
+    try:
+        self._write(write_data)
+    except RuntimeError as e:
+        print(str(e))
+        print(write_data, write_data.dtype)
+
+
+def attribute_read(self):
+
+    read_data = self._read()
+
+    if isinstance(read_data, numpy.ndarray) and read_data.dtype.kind == 'S':
+        return read_data.astype('U')
+    else:
+        return read_data
+
+
+Attribute.__getitem__ = attribute__getitem__
+Attribute.write = attribute_write
+Attribute.read = attribute_read

pninexus/h5cpp/dataspace/__init__.py

@@ -0,0 +1,18 @@
+from pninexus.h5cpp._dataspace import Dataspace
+from pninexus.h5cpp._dataspace import Type
+from pninexus.h5cpp._dataspace import Simple
+from pninexus.h5cpp._dataspace import Scalar
+from pninexus.h5cpp._dataspace import UNLIMITED
+
+# from .._dataspace import Selection
+from pninexus.h5cpp._dataspace import SelectionManager
+from pninexus.h5cpp._dataspace import Hyperslab
+from pninexus.h5cpp._dataspace import Points
+from pninexus.h5cpp._dataspace import SelectionType
+from pninexus.h5cpp._dataspace import SelectionOperation
+from pninexus.h5cpp._dataspace import View
+
+__all__ = ["Dataspace", "Type", "Simple", "Scalar", "UNLIMITED",
+           "SelectionManager",
+           "Hyperslab", "SelectionType", "SelectionOperation", "View",
+           "Points"]

pninexus/h5cpp/datatype/__init__.py

@@ -0,0 +1,183 @@
+#
+# Import enumerations
+#
+from pninexus.h5cpp._datatype import Class
+from pninexus.h5cpp._datatype import Order
+from pninexus.h5cpp._datatype import Sign
+from pninexus.h5cpp._datatype import Norm
+from pninexus.h5cpp._datatype import Pad
+from pninexus.h5cpp._datatype import StringPad
+from pninexus.h5cpp._datatype import Direction
+from pninexus.h5cpp._datatype import CharacterEncoding
+
+#
+# Import classes
+#
+from pninexus.h5cpp._datatype import Datatype
+from pninexus.h5cpp._datatype import Float
+from pninexus.h5cpp._datatype import Integer
+from pninexus.h5cpp._datatype import Compound
+from pninexus.h5cpp._datatype import String
+from pninexus.h5cpp._datatype import Enum
+
+#
+# Import predefined constant types
+#
+from pninexus.h5cpp._datatype import kUInt8
+from pninexus.h5cpp._datatype import kInt8
+from pninexus.h5cpp._datatype import kUInt16
+from pninexus.h5cpp._datatype import kInt16
+from pninexus.h5cpp._datatype import kUInt32
+from pninexus.h5cpp._datatype import kInt32
+from pninexus.h5cpp._datatype import kUInt64
+from pninexus.h5cpp._datatype import kInt64
+from pninexus.h5cpp._datatype import kFloat16
+from pninexus.h5cpp._datatype import kFloat32
+from pninexus.h5cpp._datatype import kFloat64
+from pninexus.h5cpp._datatype import kFloat128
+from pninexus.h5cpp._datatype import kComplex32
+from pninexus.h5cpp._datatype import kComplex64
+from pninexus.h5cpp._datatype import kComplex128
+from pninexus.h5cpp._datatype import kComplex256
+from pninexus.h5cpp._datatype import kVariableString
+from pninexus.h5cpp._datatype import kEBool
+
+from pninexus.h5cpp._datatype import is_bool
+
+
+class Factory(object):
+    """Construct HDF5 datatypes from numpy types
+
+    """
+
+    type_map = {
+        "bool": kEBool,
+        "int8": kInt8,
+        "uint8": kUInt8,
+        "int16": kInt16,
+        "uint16": kUInt16,
+        "int32": kInt32,
+        "uint32": kUInt32,
+        "int64": kInt64,
+        "uint64": kUInt64,
+        "float16": kFloat16,
+        "float32": kFloat32,
+        "float64": kFloat64,
+        "float128": kFloat128,
+        "complex32": kComplex32,
+        "complex64": kComplex64,
+        "complex128": kComplex128,
+        "complex256": kComplex256,
+    }
+
+    def create(self, dtype):
+        """Create HDF5 type from numpy type
+
+        :param numpy.dtype dtype: numpy datat type
+        :return: HDF5 datatype
+        :rtype: Datatype
+        """
+
+        if dtype.kind == 'S' or dtype.kind == 'U':
+            if dtype.itemsize != 0:
+                type = String.fixed(dtype.itemsize)
+                type.padding = StringPad.NULLPAD
+                return type
+            else:
+                return String.variable()
+        else:
+            return self.type_map[dtype.name]
+
+
+kFactory = Factory()
+
+
+def to_numpy(hdf5_datatype):
+    """Convert an HDF5 datatype to a numpy type
+
+    Takes an HDF5 datatype and converts it to the string representation
+    of its numpy counterpart.
+
+    :param Datatype hdf5_datatype: the HDF5 datatype to convert
+    :return: numpy type
+    :rtype: str
+    """
+
+    if not isinstance(hdf5_datatype, Datatype):
+        raise TypeError("Instance of an HDF5 datatype required!")
+
+    if hdf5_datatype == kInt8:
+        return "int8"
+    elif hdf5_datatype == kUInt8:
+        return "uint8"
+    elif hdf5_datatype == kInt16:
+        return "int16"
+    elif hdf5_datatype == kUInt16:
+        return "uint16"
+    elif hdf5_datatype == kInt32:
+        return "int32"
+    elif hdf5_datatype == kUInt32:
+        return "uint32"
+    elif hdf5_datatype == kInt64:
+        return "int64"
+    elif hdf5_datatype == kUInt64:
+        return "uint64"
+    elif hdf5_datatype == kFloat16:
+        return "float16"
+    elif hdf5_datatype == kFloat32:
+        return "float32"
+    elif hdf5_datatype == kFloat64:
+        return "float64"
+    elif hdf5_datatype == kFloat128:
+        return "float128"
+    elif hdf5_datatype == kComplex32:
+        return "complex32"
+    elif hdf5_datatype == kComplex64:
+        return "complex64"
+    elif hdf5_datatype == kComplex128:
+        return "complex128"
+    elif hdf5_datatype == kComplex256:
+        return "complex256"
+    elif hdf5_datatype == kEBool:
+        return "bool"
+    elif isinstance(hdf5_datatype, String):
+        if hdf5_datatype.is_variable_length:
+            return "object"
+        else:
+            return "S{}".format(hdf5_datatype.size)
+    else:
+        raise ValueError("Unsupported HDF5 datatype!")
+
+
+def compound_getitem(self, key):
+    """ get comound item datatype
+
+    :param key: field index or field name
+    :type key: `obj`:int: or `obj`:str:
+    :returns: datatype
+    :raises RuntimeError: in case of a failure
+    """
+    dt = self._getitem(key)
+    if dt.type == Class.FLOAT:
+        return Float(dt)
+    if dt.type == Class.INTEGER:
+        return Integer(dt)
+    if dt.type == Class.STRING:
+        return String(dt)
+    if dt.type == Class.ENUM:
+        return Enum(dt)
+    return dt
+
+
+Compound.__getitem__ = compound_getitem
+
+
+__all__ = ["Class", "Order", "Sign", "Norm", "Pad", "StringPad", "Direction",
+           "CharacterEncoding", "Datatype", "Float", "Integer", "String",
+           "Compound",
+           "kUInt8", "kInt8", "kUInt16", "kInt16", "kUInt32", "kInt32",
+           "kUInt64", "kInt64",
+           "kFloat16", "kFloat32", "kFloat64", "kFloat128",
+           "kComplex32", "kComplex64", "kComplex128", "kComplex256",
+           "kVariableString",
+           "Factory", "kFactory", "to_numpy", "kEBool", "is_bool", "Enum"]

pninexus/h5cpp/file/__init__.py

@@ -0,0 +1,15 @@
+from pninexus.h5cpp._file import File
+from pninexus.h5cpp._file import AccessFlags
+from pninexus.h5cpp._file import ImageFlags
+from pninexus.h5cpp._file import Scope
+
+#
+# utility functions
+#
+from pninexus.h5cpp._file import create
+from pninexus.h5cpp._file import open
+from pninexus.h5cpp._file import is_hdf5_file
+from pninexus.h5cpp._file import from_buffer
+
+__all__ = ["File", "ImageFlags", "AccessFlags", "Scope", "create", "open",
+           "is_hdf5_file", "from_buffer"]

pninexus/h5cpp/filter/__init__.py

@@ -0,0 +1,37 @@
+from pninexus.h5cpp._filter import Filter
+from pninexus.h5cpp._filter import Deflate
+from pninexus.h5cpp._filter import Shuffle
+from pninexus.h5cpp._filter import Fletcher32
+from pninexus.h5cpp._filter import NBit
+from pninexus.h5cpp._filter import SZip
+from pninexus.h5cpp._filter import SZipOptionMask
+from pninexus.h5cpp._filter import ScaleOffset
+from pninexus.h5cpp._filter import SOScaleType
+from pninexus.h5cpp._filter import ExternalFilter
+from pninexus.h5cpp._filter import Availability
+from pninexus.h5cpp._filter import is_filter_available
+from pninexus.h5cpp._filter import _externalfilters_fill
+
+
+class ExternalFilters(list):
+    """ List of ExternalFilters"""
+
+    def fill(self, dcpl, max_cd_number=16, max_name_size=257):
+        """ fills the list with conntent provided by  DatasetCreationList
+
+        :param dcpl: dataset creationlist
+        :type dcpl: :class:`DatasetCreationList`
+        :param max_cd_number: maximal cd parameters number
+        :type max_cd_number: int
+        :param max_name_size: maximal name size
+        :type max_name_size: int
+        :returns: a list of Availability flags
+        :rtype: :obj: `list` <:class:`Availability`>
+        """
+        return _externalfilters_fill(self, dcpl, max_cd_number, max_name_size)
+
+
+__all__ = ["Filter", "Deflate", "Shuffle", "Fletcher32", "NBit", "SZip",
+           "SZippOptionMask"
+           "ExternalFilter", "ExternalFilters", "Availability", "ScaleOffset",
+           "SOScaleType", "is_filter_available"]