# encoding: utf-8
# module h5py.h5f
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\h5py\h5f.cp311-win_amd64.pyd
# by generator 1.147
""" Low-level operations on HDF5 file objects. """

# imports
import builtins as __builtins__ # <module 'builtins' (built-in)>
import gc as gc # <module 'gc' (built-in)>
import h5py._objects as _objects # C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\h5py\_objects.cp311-win_amd64.pyd
from h5py._objects import with_phil

import h5py.h5g as __h5py_h5g


# Variables with simple values

ACC_EXCL = 4
ACC_RDONLY = 0
ACC_RDWR = 1

ACC_SWMR_READ = 64
ACC_SWMR_WRITE = 32

ACC_TRUNC = 2

CLOSE_DEFAULT = 0
CLOSE_SEMI = 2
CLOSE_STRONG = 3
CLOSE_WEAK = 1

FILE_IMAGE_OPEN_RW = 1

FSPACE_STRATEGY_AGGR = 2

FSPACE_STRATEGY_FSM_AGGR = 0

FSPACE_STRATEGY_NONE = 3
FSPACE_STRATEGY_PAGE = 1

LIBVER_EARLIEST = 0
LIBVER_LATEST = 3
LIBVER_V110 = 2
LIBVER_V112 = 3
LIBVER_V18 = 1

OBJ_ALL = 31
OBJ_ATTR = 16
OBJ_DATASET = 2
OBJ_DATATYPE = 8
OBJ_FILE = 1
OBJ_GROUP = 4
OBJ_LOCAL = 32

SCOPE_GLOBAL = 1
SCOPE_LOCAL = 0

UNLIMITED = 18446744073709551615

# functions

def create(*args, **kwargs): # real signature unknown
    """
    (STRING name, INT flags=ACC_TRUNC, PropFCID fcpl=None,
        PropFAID fapl=None) => FileID
    
        Create a new HDF5 file.  Keyword "flags" may be:
    
        ACC_TRUNC
            Truncate an existing file, discarding its data
    
        ACC_EXCL
            Fail if a conflicting file exists
    
        To keep the behavior in line with that of Python's built-in functions,
        the default is ACC_TRUNC.  Be careful!
    """
    pass

def flush(*args, **kwargs): # real signature unknown
    """
    (ObjectID obj, INT scope=SCOPE_LOCAL)
    
        Tell the HDF5 library to flush file buffers to disk.  "obj" may
        be the file identifier, or the identifier of any object residing in
        the file.  Keyword "scope" may be:
    
        SCOPE_LOCAL
            Flush only the given file
    
        SCOPE_GLOBAL
            Flush the entire virtual file
    """
    pass

def get_name(*args, **kwargs): # real signature unknown
    """
    (ObjectID obj) => STRING
    
        Determine the name of the file in which the specified object resides.
    """
    pass

def get_obj_count(*args, **kwargs): # real signature unknown
    """
    (OBJECT where=OBJ_ALL, types=OBJ_ALL) => INT
    
        Get the number of open objects.
    
        where
            Either a FileID instance representing an HDF5 file, or the
            special constant OBJ_ALL, to count objects in all files.
    
        type
            Specify what kinds of object to include.  May be one of OBJ*,
            or any bitwise combination (e.g. ``OBJ_FILE | OBJ_ATTR``).
    
            The special value OBJ_ALL matches all object types, and
            OBJ_LOCAL will only match objects opened through a specific
            identifier.
    """
    pass

def get_obj_ids(*args, **kwargs): # real signature unknown
    """
    (OBJECT where=OBJ_ALL, types=OBJ_ALL) => LIST
    
        Get a list of identifier instances for open objects.
    
        where
            Either a FileID instance representing an HDF5 file, or the
            special constant OBJ_ALL, to list objects in all files.
    
        type
            Specify what kinds of object to include.  May be one of OBJ*,
            or any bitwise combination (e.g. ``OBJ_FILE | OBJ_ATTR``).
    
            The special value OBJ_ALL matches all object types, and
            OBJ_LOCAL will only match objects opened through a specific
            identifier.
    """
    pass

def is_hdf5(*args, **kwargs): # real signature unknown
    """
    (STRING name) => BOOL
    
        Determine if a given file is an HDF5 file.  Note this raises an
        exception if the file doesn't exist.
    """
    pass

def mount(*args, **kwargs): # real signature unknown
    """
    (ObjectID loc, STRING name, FileID fid)
    
        Mount an open file on the group "name" under group loc_id.  Note that
        "name" must already exist.
    """
    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 open(*args, **kwargs): # real signature unknown
    """
    (STRING name, UINT flags=ACC_RDWR, PropFAID fapl=None) => FileID
    
        Open an existing HDF5 file.  Keyword "flags" may be:
    
        ACC_RDWR
            Open in read-write mode
    
        ACC_RDONLY
            Open in readonly mode
    
        Keyword fapl may be a file access property list.
    """
    pass

def open_file_image(*args, **kwargs): # real signature unknown
    """
    (STRING image, INT flags=0) => FileID
    
            Load a new HDF5 file into memory.  Keyword "flags" may be:
    
            FILE_IMAGE_OPEN_RW
                Specifies opening the file image in read/write mode.
    """
    pass

def unmount(*args, **kwargs): # real signature unknown
    """
    (ObjectID loc, STRING name)
    
        Unmount a file, mounted at "name" under group loc_id.
    """
    pass

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

# classes

class FileID(__h5py_h5g.GroupID):
    """
    Represents an HDF5 file identifier.
    
            These objects wrap a small portion of the H5F interface; all the
            H5F functions which can take arbitrary objects in addition to
            file identifiers are provided as functions in the h5f module.
    
            Properties:
    
            * name:   File name on disk
    
            Behavior:
    
            * Hashable: Yes, unique to the file (but not the access mode)
            * Equality: Hash comparison
    """
    def close(self, *args, **kwargs): # real signature unknown
        """
        ()
        
                Terminate access through this identifier.  Note that depending on
                what property list settings were used to open the file, the
                physical file might not be closed until all remaining open
                identifiers are freed.
        """
        pass

    def get_access_plist(self, *args, **kwargs): # real signature unknown
        """
        () => PropFAID
        
                Retrieve a copy of the file access property list which manages access
                to this file.
        """
        pass

    def get_create_plist(self, *args, **kwargs): # real signature unknown
        """
        () => PropFCID
        
                Retrieve a copy of the file creation property list used to
                create this file.
        """
        pass

    def get_filesize(self, *args, **kwargs): # real signature unknown
        """
        () => LONG size
        
                Determine the total size (in bytes) of the HDF5 file,
                including any user block.
        """
        pass

    def get_file_image(self, *args, **kwargs): # real signature unknown
        """
        () => BYTES
        
                    Retrieves a copy of the image of an existing, open file.
        
                    Feature requires: 1.8.9
        """
        pass

    def get_freespace(self, *args, **kwargs): # real signature unknown
        """
        () => LONG freespace
        
                Determine the amount of free space in this file.  Note that this
                only tracks free space until the file is closed.
        """
        pass

    def get_intent(self, *args, **kwargs): # real signature unknown
        """
        () => INT
        
                Determine the file's write intent, either of:
                - H5F_ACC_RDONLY
                - H5F_ACC_RDWR
        """
        pass

    def get_mdc_config(self, *args, **kwargs): # real signature unknown
        """
        () => CacheConfig
                Returns an object that stores all the information about the meta-data cache
                configuration. This config is created for every file in-memory with the default
                cache config values, it is not saved to the hdf5 file.
        """
        pass

    def get_mdc_hit_rate(self, *args, **kwargs): # real signature unknown
        """
        () => DOUBLE
        
                Retrieve the cache hit rate
        """
        pass

    def get_mdc_size(self, *args, **kwargs): # real signature unknown
        """
        () => (max_size, min_clean_size, cur_size, cur_num_entries) [SIZE_T, SIZE_T, SIZE_T, INT]
        
                Obtain current metadata cache size data for specified file.
        """
        pass

    def get_page_buffering_stats(self, *args, **kwargs): # real signature unknown
        """
        () -> NAMEDTUPLE PageBufStats(NAMEDTUPLE meta=PageStats, NAMEDTUPLE raw=PageStats)
        
                    Retrieve page buffering statistics for the file as the number of
                    metadata and raw data accesses, hits, misses, evictions, and
                    accesses that bypass the page buffer (bypasses).
        """
        pass

    def get_vfd_handle(self, *args, **kwargs): # real signature unknown
        """
        (PropFAID) => INT
        
                Retrieve the file handle used by the virtual file driver.
        
                This may not be supported for all file drivers, and the meaning of the
                return value may depend on the file driver.
        
                The 'family' and 'multi' drivers access multiple files, and a file
                access property list (fapl) can be used to indicate which to access,
                with H5Pset_family_offset or H5Pset_multi_type.
        """
        pass

    def reopen(self, *args, **kwargs): # real signature unknown
        """
        () => FileID
        
                Retrieve another identifier for a file (which must still be open).
                The new identifier is guaranteed to neither be mounted nor contain
                a mounted file.
        """
        pass

    def reset_mdc_hit_rate_stats(self, *args, **kwargs): # real signature unknown
        """
        no return
        
                rests the hit-rate statistics
        """
        pass

    def reset_page_buffering_stats(self, *args, **kwargs): # real signature unknown
        """
        ()
        
                    Reset page buffer statistics for the file.
        """
        pass

    def set_mdc_config(self, *args, **kwargs): # real signature unknown
        """
        (CacheConfig) => None
                Sets the meta-data cache configuration for a file. This config is created for every file
                in-memory with the default config values, it is not saved to the hdf5 file. Any change to
                the configuration lives until the hdf5 file is closed.
        """
        pass

    def start_swmr_write(self, *args, **kwargs): # real signature unknown
        """
        no return
        
                    Enables SWMR writing mode for a file.
        
                    This function will activate SWMR writing mode for a file associated
                    with file_id. This routine will prepare and ensure the file is safe
                    for SWMR writing as follows:
        
                        * Check that the file is opened with write access (H5F_ACC_RDWR).
                        * Check that the file is opened with the latest library format
                          to ensure data structures with check-summed metadata are used.
                        * Check that the file is not already marked in SWMR writing mode.
                        * Enable reading retries for check-summed metadata to remedy
                          possible checksum failures from reading inconsistent metadata
                          on a system that is not atomic.
                        * Turn off usage of the library’s accumulator to avoid possible
                          ordering problem on a system that is not atomic.
                        * Perform a flush of the file’s data buffers and metadata to set
                          a consistent state for starting SWMR write operations.
        
                    Library objects are groups, datasets, and committed datatypes. For
                    the current implementation, groups and datasets can remain open when
                    activating SWMR writing mode, but not committed datatypes. Attributes
                    attached to objects cannot remain open.
        
                    Feature requires: 1.9.178 HDF5
        """
        pass

    def _close_open_objects(self, *args, **kwargs): # real signature unknown
        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

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

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

    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ File name on disk (according to h5f.get_name()) """



class PageBufStats(tuple):
    """ PageBufferStats(meta, raw) """
    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 PageBufferStats object from a sequence or iterable """
        pass

    def _replace(self, **kwds): # reliably restored by inspect
        """ Return a new PageBufferStats 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, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(_cls, meta, raw): # reliably restored by inspect
        """ Create new instance of PageBufferStats(meta, raw) """
        pass

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

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


class PageStats(tuple):
    """ PageStats(accesses, hits, misses, evictions, bypasses) """
    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 PageStats object from a sequence or iterable """
        pass

    def _replace(self, **kwds): # reliably restored by inspect
        """ Return a new PageStats 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, accesses, hits, misses, evictions, bypasses): # real signature unknown; restored from __doc__
        pass

    @staticmethod # known case of __new__
    def __new__(_cls, accesses, hits, misses, evictions, bypasses): # reliably restored by inspect
        """ Create new instance of PageStats(accesses, hits, misses, evictions, bypasses) """
        pass

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

    accesses = _tuplegetter(0, 'Alias for field number 0')
    bypasses = _tuplegetter(4, 'Alias for field number 4')
    evictions = _tuplegetter(3, 'Alias for field number 3')
    hits = _tuplegetter(1, 'Alias for field number 1')
    misses = _tuplegetter(2, 'Alias for field number 2')
    _fields = (
        'accesses',
        'hits',
        'misses',
        'evictions',
        'bypasses',
    )
    _field_defaults = {}
    __match_args__ = (
        'accesses',
        'hits',
        'misses',
        'evictions',
        'bypasses',
    )
    __slots__ = ()


# variables with complex values

phil = _objects.phil

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

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

__test__ = {}