# encoding: utf-8
# module h5py.h5t
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\h5py\h5t.cp311-win_amd64.pyd
# by generator 1.147
"""
HDF5 "H5T" data-type API

    This module contains the datatype identifier class TypeID, and its
    subclasses which represent things like integer/float/compound identifiers.
    The majority of the H5T API is presented as methods on these identifiers.
"""

# imports
import builtins as __builtins__ # <module 'builtins' (built-in)>
import codecs as codecs # C:\Programs\Python\Python311\Lib\codecs.py
import sys as sys # <module 'sys' (built-in)>
import numpy as np # C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\numpy\__init__.py
from h5py._objects import with_phil

import h5py._objects as __h5py__objects


# Variables with simple values

ARRAY = 10

BITFIELD = 4

BKG_NO = 0
BKG_TEMP = 1
BKG_YES = 2

COMPOUND = 6

CSET_ASCII = 0
CSET_UTF8 = 1

DIR_ASCEND = 1
DIR_DEFAULT = 0
DIR_DESCEND = 2

ENUM = 8

FLOAT = 1

INTEGER = 0

NORM_IMPLIED = 0
NORM_MSBSET = 1
NORM_NONE = 2

NO_CLASS = -1

OPAQUE = 5

ORDER_BE = 1
ORDER_LE = 0
ORDER_NATIVE = 0
ORDER_NONE = 4
ORDER_VAX = 2

PAD_BACKGROUND = 2
PAD_ONE = 1
PAD_ZERO = 0

REFERENCE = 7

SGN_2 = 1
SGN_NONE = 0

STRING = 3

STR_NULLPAD = 1
STR_NULLTERM = 0
STR_SPACEPAD = 2

TIME = 2

VARIABLE = 18446744073709551615

VLEN = 9

# functions

def array_create(*args, **kwargs): # real signature unknown
    """
    (TypeID base, TUPLE dimensions) => TypeArrayID
    
        Create a new array datatype, using and HDF5 parent type and
        dimensions given via a tuple of positive integers.  "Unlimited"
        dimensions are not allowed.
    """
    pass

def check_dtype(*args, **kwargs): # real signature unknown
    """
    Check a dtype for h5py special type "hint" information.  Only one
        keyword may be given.
    
        vlen = dtype
            If the dtype represents an HDF5 vlen, returns the Python base class.
            Currently only builting string vlens (str) are supported.  Returns
            None if the dtype does not represent an HDF5 vlen.
    
        enum = dtype
            If the dtype represents an HDF5 enumerated type, returns the dictionary
            mapping string names to integer values.  Returns None if the dtype does
            not represent an HDF5 enumerated type.
    
        ref = dtype
            If the dtype represents an HDF5 reference type, returns the reference
            class (either Reference or RegionReference).  Returns None if the dtype
            does not represent an HDF5 reference type.
    """
    pass

def check_enum_dtype(*args, **kwargs): # real signature unknown
    """
    If the dtype represents an HDF5 enumerated type, returns the dictionary
        mapping string names to integer values.
    
        Returns None if the dtype does not represent an HDF5 enumerated type.
    """
    pass

def check_opaque_dtype(*args, **kwargs): # real signature unknown
    """ Return True if the dtype given is tagged to be stored as HDF5 opaque data """
    pass

def check_ref_dtype(*args, **kwargs): # real signature unknown
    """
    If the dtype represents an HDF5 reference type, returns the reference
        class (either Reference or RegionReference).
    
        Returns None if the dtype does not represent an HDF5 reference type.
    """
    pass

def check_string_dtype(*args, **kwargs): # real signature unknown
    """
    If the dtype represents an HDF5 string, returns a string_info object.
    
        The returned string_info object holds the encoding and the length.
        The encoding can only be 'utf-8' or 'ascii'. The length may be None
        for a variable-length string, or a fixed length in bytes.
    
        Returns None if the dtype does not represent an HDF5 string.
    """
    pass

def check_vlen_dtype(*args, **kwargs): # real signature unknown
    """
    If the dtype represents an HDF5 vlen, returns the Python base class.
    
        Returns None if the dtype does not represent an HDF5 vlen.
    """
    pass

def convert(*args, **kwargs): # real signature unknown
    """
    (TypeID src, TypeID dst, UINT n, NDARRAY buf, NDARRAY bkg=None,
        PropID dxpl=None)
    
        Convert n contiguous elements of a buffer in-place.  The array dtype
        is ignored.  The backing buffer is optional; for conversion of compound
        types, a temporary copy of conversion buffer will used for backing if
        one is not supplied.
    """
    pass

def create(*args, **kwargs): # real signature unknown
    """
    (INT classtype, UINT size) => TypeID
    
        Create a new HDF5 type object.  Legal class values are
        COMPOUND and OPAQUE.  Use enum_create for enums.
    """
    pass

def decode(*args, **kwargs): # real signature unknown
    """
    (STRING buf) => TypeID
    
        Deserialize an HDF5 type.  You can also do this with the native
        Python pickling machinery.
    """
    pass

def enum_create(*args, **kwargs): # real signature unknown
    """
    (TypeID base) => TypeID
    
        Create a new enumerated type based on an (integer) parent type.
    """
    pass

def enum_dtype(*args, **kwargs): # real signature unknown
    """
    Create a NumPy representation of an HDF5 enumerated type
    
        *values_dict* maps string names to integer values. *basetype* is an
        appropriate integer base dtype large enough to hold the possible options.
    """
    pass

def find(*args, **kwargs): # real signature unknown
    """
    (TypeID src, TypeID dst) => TUPLE or None
    
        Determine if a conversion path exists from src to dst.  Result is None
        or a tuple describing the conversion path.  Currently tuple entries are:
    
        1. INT need_bkg:    Whether this routine requires a backing buffer.
                            Values are BKG_NO, BKG_TEMP and BKG_YES.
    """
    pass

def get_config(*args, **kwargs): # real signature unknown
    """
    () => H5PYConfig
    
        Get a reference to the global library configuration object.
    """
    pass

def namedtuple(typename, field_names, *, rename=False, defaults=None, module=None): # reliably restored by inspect
    """
    Returns a new subclass of tuple with named fields.
    
        >>> Point = namedtuple('Point', ['x', 'y'])
        >>> Point.__doc__                   # docstring for the new class
        'Point(x, y)'
        >>> p = Point(11, y=22)             # instantiate with positional args or keywords
        >>> p[0] + p[1]                     # indexable like a plain tuple
        33
        >>> x, y = p                        # unpack like a regular tuple
        >>> x, y
        (11, 22)
        >>> p.x + p.y                       # fields also accessible by name
        33
        >>> d = p._asdict()                 # convert to a dictionary
        >>> d['x']
        11
        >>> Point(**d)                      # convert from a dictionary
        Point(x=11, y=22)
        >>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
        Point(x=100, y=22)
    """
    pass

def opaque_dtype(*args, **kwargs): # real signature unknown
    """
    Return an equivalent dtype tagged to be stored in an HDF5 opaque type.
    
        This makes it easy to store numpy data like datetimes for which there is
        no equivalent HDF5 type, but it's not interoperable: other tools won't treat
        the opaque data as datetimes.
    """
    pass

def open(*args, **kwargs): # real signature unknown
    """
    (ObjectID group, STRING name) => TypeID
    
        Open a named datatype from a file.
        If present, tapl must be a datatype access property list.
    """
    pass

def py_create(*args, **kwargs): # real signature unknown
    """
    (OBJECT dtype_in, BOOL logical=False) => TypeID
    
        Given a Numpy dtype object, generate a byte-for-byte memory-compatible
        HDF5 datatype object.  The result is guaranteed to be transient and
        unlocked.
    
        :param dtype_in: may be a dtype object, or anything which can be
            converted to a dtype, including strings like '<i4' or an "int".
        :param logical: when this flag is set, instead of returning a byte-for-byte
            identical representation of the type, the function returns the closest
            logically appropriate HDF5 type.  For example, in the case of a "hinted"
            dtype of kind "O" representing a string, it would return an HDF5 variable-
            length string type.
    """
    pass

def special_dtype(vlen=None): # real signature unknown; restored from __doc__
    """
    Create a new h5py "special" type.  Only one keyword may be given.
    
        Legal keywords are:
    
        vlen = basetype
            Base type for HDF5 variable-length datatype. This can be Python
            str type or instance of np.dtype.
            Example: special_dtype( vlen=str )
    
        enum = (basetype, values_dict)
            Create a NumPy representation of an HDF5 enumerated type.  Provide
            a 2-tuple containing an (integer) base dtype and a dict mapping
            string names to integer values.
    
        ref = Reference | RegionReference
            Create a NumPy representation of an HDF5 object or region reference
            type.
    """
    pass

def string_dtype(*args, **kwargs): # real signature unknown
    """
    Make a numpy dtype for HDF5 strings
    
        encoding may be 'utf-8' or 'ascii'.
    
        length may be an integer for a fixed length string dtype, or None for
        variable length strings. String lengths for HDF5 are counted in bytes,
        not unicode code points.
    
        For variable length strings, the data should be passed as Python str objects
        (unicode in Python 2) if the encoding is 'utf-8', and bytes if it is 'ascii'.
        For fixed length strings, the data should be numpy fixed length *bytes*
        arrays, regardless of the encoding. Fixed length unicode data is not
        supported.
    """
    pass

def typewrap(*args, **kwargs): # real signature unknown
    pass

def vlen_create(*args, **kwargs): # real signature unknown
    """
    (TypeID base) => TypeID
    
        Create a new variable-length datatype, using any HDF5 type as a base.
    
        Although the Python interface can manipulate these types, there is no
        provision for reading/writing vlen data.
    """
    pass

def vlen_dtype(*args, **kwargs): # real signature unknown
    """
    Make a numpy dtype for an HDF5 variable-length datatype
    
        For variable-length string dtypes, use :func:`string_dtype` instead.
    """
    pass

def _get_float_dtype_to_hdf5(*args, **kwargs): # real signature unknown
    pass

# classes

class string_info(tuple):
    """ string_info(encoding, length) """
    def _asdict(self): # reliably restored by inspect
        """ Return a new dict which maps field names to their values. """
        pass

    @classmethod
    def _make(cls, *args, **kwargs): # real signature unknown
        """ Make a new string_info object from a sequence or iterable """
        pass

    def _replace(self, **kwds): # reliably restored by inspect
        """ Return a new string_info object replacing specified fields with new values """
        pass

    def __getnewargs__(self): # reliably restored by inspect
        """ Return self as a plain tuple.  Used by copy and pickle. """
        pass

    def __init__(self, encoding, length): # real signature unknown; restored from __doc__
        pass

    @staticmethod # known case of __new__
    def __new__(_cls, encoding, length): # reliably restored by inspect
        """ Create new instance of string_info(encoding, length) """
        pass

    def __repr__(self): # reliably restored by inspect
        """ Return a nicely formatted representation string """
        pass

    encoding = _tuplegetter(0, 'Alias for field number 0')
    length = _tuplegetter(1, 'Alias for field number 1')
    _fields = (
        'encoding',
        'length',
    )
    _field_defaults = {}
    __match_args__ = (
        'encoding',
        'length',
    )
    __slots__ = ()


class TypeID(__h5py__objects.ObjectID):
    """
    Base class for type identifiers (implements common operations)
    
            * Hashable: If committed; in HDF5 1.8.X, also if locked
            * Equality: Logical H5T comparison
    """
    def commit(self, *args, **kwargs): # real signature unknown
        """
        (ObjectID group, STRING name, PropID lcpl=None)
        
                Commit this (transient) datatype to a named datatype in a file.
                If present, lcpl may be a link creation property list.
        """
        pass

    def committed(self, *args, **kwargs): # real signature unknown
        """
        () => BOOL is_comitted
        
                Determine if a given type object is named (T) or transient (F).
        """
        pass

    def copy(self, *args, **kwargs): # real signature unknown
        """
        () => TypeID
        
                Create a copy of this type object.
        """
        pass

    def detect_class(self, *args, **kwargs): # real signature unknown
        """
        (INT classtype) => BOOL class_is_present
        
                Determine if a member of the given class exists in a compound
                datatype.  The search is recursive.
        """
        pass

    def encode(self, *args, **kwargs): # real signature unknown
        """
        () => STRING
        
                Serialize an HDF5 type.  Bear in mind you can also use the
                native Python pickle/unpickle machinery to do this.  The
                returned string may contain binary values, including NULLs.
        """
        pass

    def equal(self, *args, **kwargs): # real signature unknown
        """
        (TypeID typeid) => BOOL
        
                Logical comparison between datatypes.  Also called by
                Python's "==" operator.
        """
        pass

    def get_class(self, *args, **kwargs): # real signature unknown
        """
        () => INT classcode
        
                Determine the datatype's class code.
        """
        pass

    def get_create_plist(self, *args, **kwargs): # real signature unknown
        """
        () => PropTCID
        
                    Create and return a new copy of the datatype creation property list
                    used when this datatype was created.
        """
        pass

    def get_size(self, *args, **kwargs): # real signature unknown
        """
        () => INT size
        
                    Determine the total size of a datatype, in bytes.
        """
        pass

    def get_super(self, *args, **kwargs): # real signature unknown
        """
        () => TypeID
        
                Determine the parent type of an array, enumeration or vlen datatype.
        """
        pass

    def lock(self, *args, **kwargs): # real signature unknown
        """
        ()
        
                Lock this datatype, which makes it immutable and indestructible.
                Once locked, it can't be unlocked.
        """
        pass

    def set_size(self, *args, **kwargs): # real signature unknown
        """
        (UINT size)
        
                Set the total size of the datatype, in bytes.
        """
        pass

    def __copy__(self, *args, **kwargs): # real signature unknown
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __reduce__(self, *args, **kwargs): # real signature unknown
        pass

    def __setstate__(self, *args, **kwargs): # real signature unknown
        pass

    dtype = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ A Numpy-style dtype object representing this object.
        """


    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B500F0>'


class TypeArrayID(TypeID):
    """ Represents an array datatype """
    def get_array_dims(self, *args, **kwargs): # real signature unknown
        """
        () => TUPLE dimensions
        
                Get the dimensions of the given array datatype as
                a tuple of integers.
        """
        pass

    def get_array_ndims(self, *args, **kwargs): # real signature unknown
        """
        () => INT rank
        
                Get the rank of the given array datatype.
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B50150>'


class TypeAtomicID(TypeID):
    """ Base class for atomic datatypes (float or integer) """
    def get_offset(self, *args, **kwargs): # real signature unknown
        """
        () => INT offset
        
                Get the offset of the first significant bit.
        """
        pass

    def get_order(self, *args, **kwargs): # real signature unknown
        """
        () => INT order
        
                Obtain the byte order of the datatype; one of:
        
                - ORDER_LE
                - ORDER_BE
        """
        pass

    def get_pad(self, *args, **kwargs): # real signature unknown
        """
        () => (INT lsb_pad_code, INT msb_pad_code)
        
                Determine the padding type.  Possible values are:
        
                - PAD_ZERO
                - PAD_ONE
                - PAD_BACKGROUND
        """
        pass

    def get_precision(self, *args, **kwargs): # real signature unknown
        """
        () => UINT precision
        
                Get the number of significant bits (excludes padding).
        """
        pass

    def set_offset(self, *args, **kwargs): # real signature unknown
        """
        (UINT offset)
        
                Set the offset of the first significant bit.
        """
        pass

    def set_order(self, *args, **kwargs): # real signature unknown
        """
        (INT order)
        
                Set the byte order of the datatype; one of:
        
                - ORDER_LE
                - ORDER_BE
        """
        pass

    def set_pad(self, *args, **kwargs): # real signature unknown
        """
        (INT lsb_pad_code, INT msb_pad_code)
        
                Set the padding type.  Possible values are:
        
                - PAD_ZERO
                - PAD_ONE
                - PAD_BACKGROUND
        """
        pass

    def set_precision(self, *args, **kwargs): # real signature unknown
        """
        (UINT precision)
        
                Set the number of significant bits (excludes padding).
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B503F0>'


class TypeBitfieldID(TypeID):
    """ HDF5 bitfield type """
    def get_order(self, *args, **kwargs): # real signature unknown
        """
        () => INT order
        
                Obtain the byte order of the datatype; one of:
        
                - ORDER_LE
                - ORDER_BE
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B50330>'


class TypeCompositeID(TypeID):
    """ Base class for enumerated and compound types. """
    def get_member_index(self, *args, **kwargs): # real signature unknown
        """
        (STRING name) => INT index
        
                Determine the index of a member of a compound or enumerated datatype
                identified by a string name.
        """
        pass

    def get_member_name(self, *args, **kwargs): # real signature unknown
        """
        (INT member) => STRING name
        
                Determine the name of a member of a compound or enumerated type,
                identified by its index (0 <= member < nmembers).
        """
        pass

    def get_nmembers(self, *args, **kwargs): # real signature unknown
        """
        () => INT number_of_members
        
                Determine the number of members in a compound or enumerated type.
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B50510>'


class TypeCompoundID(TypeCompositeID):
    """ Represents a compound datatype """
    def get_member_class(self, *args, **kwargs): # real signature unknown
        """
        (INT member) => INT class
        
                Determine the datatype class of the member of a compound type,
                identified by its index (0 <= member < nmembers).
        """
        pass

    def get_member_offset(self, *args, **kwargs): # real signature unknown
        """
        (INT member) => INT offset
        
                Determine the offset, in bytes, of the beginning of the specified
                member of a compound datatype.
        """
        pass

    def get_member_type(self, *args, **kwargs): # real signature unknown
        """
        (INT member) => TypeID
        
                Create a copy of a member of a compound datatype, identified by its
                index.
        """
        pass

    def insert(self, *args, **kwargs): # real signature unknown
        """
        (STRING name, UINT offset, TypeID field)
        
                Add a named member datatype to a compound datatype.  The parameter
                offset indicates the offset from the start of the compound datatype,
                in bytes.
        """
        pass

    def pack(self, *args, **kwargs): # real signature unknown
        """
        ()
        
                Recursively removes padding (introduced on account of e.g. compiler
                alignment rules) from a compound datatype.
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B505D0>'


class TypeEnumID(TypeCompositeID):
    """ Represents an enumerated type """
    def enum_insert(self, *args, **kwargs): # real signature unknown
        """
        (STRING name, INT/LONG value)
        
                Define a new member of an enumerated type.  The value will be
                automatically converted to the base type defined for this enum.  If
                the conversion results in overflow, the value will be silently
                clipped.
        """
        pass

    def enum_nameof(self, *args, **kwargs): # real signature unknown
        """
        (LONG value) => STRING name
        
                Determine the name associated with the given value.  Due to a
                limitation of the HDF5 library, this can only retrieve names up to
                1023 characters in length.
        """
        pass

    def enum_valueof(self, *args, **kwargs): # real signature unknown
        """
        (STRING name) => LONG value
        
                Get the value associated with an enum name.
        """
        pass

    def get_member_value(self, *args, **kwargs): # real signature unknown
        """
        (UINT index) => LONG value
        
                Determine the value for the member at the given zero-based index.
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B50570>'


class TypeFloatID(TypeAtomicID):
    """ Floating-point atomic datatypes """
    def get_ebias(self, *args, **kwargs): # real signature unknown
        """
        () => UINT ebias
        
                Get the exponent bias.
        """
        pass

    def get_fields(self, *args, **kwargs): # real signature unknown
        """
        () => TUPLE field_info
        
                Get information about floating-point bit fields.  See the HDF5
                docs for a full description.  Tuple has the following members:
        
                0. UINT spos
                1. UINT epos
                2. UINT esize
                3. UINT mpos
                4. UINT msize
        """
        pass

    def get_inpad(self, *args, **kwargs): # real signature unknown
        """
        () => INT pad_code
        
                Determine the internal padding strategy.  Legal values are:
        
                - PAD_ZERO
                - PAD_ONE
                - PAD_BACKGROUND
        """
        pass

    def get_norm(self, *args, **kwargs): # real signature unknown
        """
        () => INT normalization_code
        
                Get the normalization strategy.  Legal values are:
        
                - NORM_IMPLIED
                - NORM_MSBSET
                - NORM_NONE
        """
        pass

    def set_ebias(self, *args, **kwargs): # real signature unknown
        """
        (UINT ebias)
        
                Set the exponent bias.
        """
        pass

    def set_fields(self, *args, **kwargs): # real signature unknown
        """
        (UINT spos, UINT epos, UINT esize, UINT mpos, UINT msize)
        
                Set floating-point bit fields.  Refer to the HDF5 docs for
                argument definitions.
        """
        pass

    def set_inpad(self, *args, **kwargs): # real signature unknown
        """
        (INT pad_code)
        
                Set the internal padding strategy.  Legal values are:
        
                - PAD_ZERO
                - PAD_ONE
                - PAD_BACKGROUND
        """
        pass

    def set_norm(self, *args, **kwargs): # real signature unknown
        """
        (INT normalization_code)
        
                Set the normalization strategy.  Legal values are:
        
                - NORM_IMPLIED
                - NORM_MSBSET
                - NORM_NONE
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B504B0>'


class TypeIntegerID(TypeAtomicID):
    """ Integer atomic datatypes """
    def get_sign(self, *args, **kwargs): # real signature unknown
        """
        () => INT sign
        
                Get the "signedness" of the datatype; one of:
        
                SGN_NONE
                    Unsigned
        
                SGN_2
                    Signed 2's complement
        """
        pass

    def set_sign(self, *args, **kwargs): # real signature unknown
        """
        (INT sign)
        
                Set the "signedness" of the datatype; one of:
        
                SGN_NONE
                    Unsigned
        
                SGN_2
                    Signed 2's complement
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B50450>'


class TypeOpaqueID(TypeID):
    """ Represents an opaque type """
    def get_tag(self, *args, **kwargs): # real signature unknown
        """
        () => STRING tag
        
                Get the tag associated with an opaque datatype.
        """
        pass

    def set_tag(self, *args, **kwargs): # real signature unknown
        """
        (STRING tag)
        
                Set a string describing the contents of an opaque datatype.
                Limited to 256 characters.
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B501B0>'


class TypeReferenceID(TypeID):
    """ HDF5 object or region reference """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B50390>'


class TypeStringID(TypeID):
    """ String datatypes, both fixed and vlen. """
    def get_cset(self, *args, **kwargs): # real signature unknown
        """
        () => INT character_set
        
                Retrieve the character set used for a string.
        """
        pass

    def get_strpad(self, *args, **kwargs): # real signature unknown
        """
        () => INT padding_type
        
                Get the padding type.  Legal values are:
        
                STR_NULLTERM
                    NULL termination only (C style)
        
                STR_NULLPAD
                    Pad buffer with NULLs
        
                STR_SPACEPAD
                    Pad buffer with spaces (FORTRAN style)
        """
        pass

    def is_variable_str(self, *args, **kwargs): # real signature unknown
        """
        () => BOOL is_variable
        
                Determine if the given string datatype is a variable-length string.
        """
        pass

    def set_cset(self, *args, **kwargs): # real signature unknown
        """
        (INT character_set)
        
                Set the character set used for a string.
        """
        pass

    def set_strpad(self, *args, **kwargs): # real signature unknown
        """
        (INT pad)
        
                Set the padding type.  Legal values are:
        
                STR_NULLTERM
                    NULL termination only (C style)
        
                STR_NULLPAD
                    Pad buffer with NULLs
        
                STR_SPACEPAD
                    Pad buffer with spaces (FORTRAN style)
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B50210>'


class TypeTimeID(TypeID):
    """ Unix-style time_t (deprecated) """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B502D0>'


class TypeVlenID(TypeID):
    """ Non-string vlen datatypes. """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001FFA0B50270>'


# variables with complex values

cfg = None # (!) real value is '<h5py.h5.H5PYConfig object at 0x000001FFA0B30190>'

C_S1 = None # (!) real value is '<h5py.h5t.TypeStringID object at 0x000001FFA1487510>'

FORTRAN_S1 = None # (!) real value is '<h5py.h5t.TypeStringID object at 0x000001FFA14875B0>'

IEEE_F128BE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA14877E0>'

IEEE_F128LE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA1487880>'

IEEE_F16BE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA14876F0>'

IEEE_F16LE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA1487740>'

IEEE_F32BE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA0B47330>'

IEEE_F32LE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA0B472E0>'

IEEE_F64BE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA1485850>'

IEEE_F64LE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA1485760>'

LDOUBLE_BE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA14879C0>'

LDOUBLE_LE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA1487920>'

NATIVE_B16 = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA14869D0>'

NATIVE_B32 = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1486BB0>'

NATIVE_B64 = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1486D90>'

NATIVE_B8 = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA14867F0>'

NATIVE_DOUBLE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA1487010>'

NATIVE_FLOAT = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA1486F70>'

NATIVE_INT16 = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486A70>'

NATIVE_INT32 = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486C50>'

NATIVE_INT64 = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486E30>'

NATIVE_INT8 = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486890>'

NATIVE_LDOUBLE = None # (!) real value is '<h5py.h5t.TypeFloatID object at 0x000001FFA14870B0>'

NATIVE_UINT16 = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486B10>'

NATIVE_UINT32 = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486CF0>'

NATIVE_UINT64 = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486ED0>'

NATIVE_UINT8 = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486930>'

phil = None # (!) real value is '<h5py._objects.FastRLock object at 0x000001FFA0B3E5B0>'

PYTHON_OBJECT = None # (!) real value is '<h5py.h5t.TypeOpaqueID object at 0x000001FFA1487650>'

ref_dtype = None # (!) real value is "dtype('O')"

regionref_dtype = None # (!) real value is "dtype('O')"

STD_B16BE = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1486110>'

STD_B16LE = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1485E90>'

STD_B32BE = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA14861B0>'

STD_B32LE = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1485F30>'

STD_B64BE = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1486250>'

STD_B64LE = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1485FD0>'

STD_B8BE = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1486070>'

STD_B8LE = None # (!) real value is '<h5py.h5t.TypeBitfieldID object at 0x000001FFA1485DF0>'

STD_I16BE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1485C10>'

STD_I16LE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1485990>'

STD_I32BE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1485CB0>'

STD_I32LE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1485A30>'

STD_I64BE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1485D50>'

STD_I64LE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1485AD0>'

STD_I8BE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1485B70>'

STD_I8LE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA14858F0>'

STD_REF_DSETREG = None # (!) real value is '<h5py.h5t.TypeReferenceID object at 0x000001FFA1487470>'

STD_REF_OBJ = None # (!) real value is '<h5py.h5t.TypeReferenceID object at 0x000001FFA14873D0>'

STD_U16BE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486610>'

STD_U16LE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486390>'

STD_U32BE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA14866B0>'

STD_U32LE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486430>'

STD_U64BE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486750>'

STD_U64LE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA14864D0>'

STD_U8BE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA1486570>'

STD_U8LE = None # (!) real value is '<h5py.h5t.TypeIntegerID object at 0x000001FFA14862F0>'

UNIX_D32BE = None # (!) real value is '<h5py.h5t.TypeTimeID object at 0x000001FFA1487290>'

UNIX_D32LE = None # (!) real value is '<h5py.h5t.TypeTimeID object at 0x000001FFA1487150>'

UNIX_D64BE = None # (!) real value is '<h5py.h5t.TypeTimeID object at 0x000001FFA1487330>'

UNIX_D64LE = None # (!) real value is '<h5py.h5t.TypeTimeID object at 0x000001FFA14871F0>'

__loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x000001FFA0B493D0>'

__pyx_capi__ = {
    'H5PY_OBJ': None, # (!) real value is '<capsule object "hid_t" at 0x000001FFA0B3FFC0>'
    'H5PY_PYTHON_OPAQUE_TAG': None, # (!) real value is '<capsule object "char *" at 0x000001FFA0B50030>'
    'py_create': None, # (!) real value is '<capsule object "struct __pyx_obj_4h5py_3h5t_TypeID *(PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_4h5py_3h5t_py_create *__pyx_optional_args)" at 0x000001FFA0B50090>'
    'typewrap': None, # (!) real value is '<capsule object "struct __pyx_obj_4h5py_3h5t_TypeID *(hid_t, int __pyx_skip_dispatch)" at 0x000001FFA0B50060>'
}

__spec__ = None # (!) real value is "ModuleSpec(name='h5py.h5t', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x000001FFA0B493D0>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\h5py\\\\h5t.cp311-win_amd64.pyd')"

__test__ = {}