psychopy 2024.2.1__py3-none-any.whl → 2024.2.4__py3-none-any.whl

psychopy/iohub/datastore/util.py.orig

@@ -0,0 +1,692 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Part of the PsychoPy library
+# Copyright (C) 2012-2020 iSolver Software Solutions (C) 2021 Open Science Tools Ltd.
+# Distributed under the terms of the GNU General Public License (GPL).
+
+import numbers  # numbers.Integral is like (int, long) but supports Py3
+import os
+from collections import namedtuple
+import json
+import numpy
+
+from ..errors import print2err
+
+from pkg_resources import parse_version
+import tables
+
+if parse_version(tables.__version__) < parse_version('3'):
+    from tables import openFile as open_file
+
+    walk_groups = "walkGroups"
+    list_nodes = "listNodes"
+    get_node = "getNode"
+    read_where = "readWhere"
+else:
+    from tables import open_file
+
+    walk_groups = "walk_groups"
+    list_nodes = "list_nodes"
+    get_node = "get_node"
+    read_where = "read_where"
+
+_hubFiles = []
+
+
+def openHubFile(filepath, filename, mode):
+    """
+    Open an HDF5 DataStore file and register it so that it is closed even on interpreter crash.
+    """
+    global _hubFiles
+    hubFile = open_file(os.path.join(filepath, filename), mode)
+    _hubFiles.append(hubFile)
+    return hubFile
+
+
+def displayDataFileSelectionDialog(starting_dir=None):
+    """Shows a FileDialog and lets you select a .hdf5 file to open for
+    processing."""
+    from psychopy.gui.qtgui import fileOpenDlg
+
+    filePath = fileOpenDlg(tryFilePath=starting_dir,
+                           prompt="Select a ioHub HDF5 File",
+                           allowed='HDF5 Files (*.hdf5)')
+
+    if filePath is None:
+        return None
+
+    return filePath
+
+
+def displayEventTableSelectionDialog(title, list_label, list_values, default=u'Select'):
+    from psychopy import gui
+    if default not in list_values:
+        list_values.insert(0, default)
+    else:
+        list_values.remove(list_values)
+        list_values.insert(0, default)
+
+    selection_dict = {list_label: list_values}
+    dlg_info = dict(selection_dict)
+    infoDlg = gui.DlgFromDict(dictionary=dlg_info, title=title)
+    if not infoDlg.OK:
+        return None
+
+    while list(dlg_info.values())[0] == default and infoDlg.OK:
+        dlg_info = dict(selection_dict)
+        infoDlg = gui.DlgFromDict(dictionary=dlg_info, title=title)
+
+    if not infoDlg.OK:
+        return None
+
+    return list(dlg_info.values())[0]
+
+
+def saveEventReport(hdf5FilePath="", eventType="", eventFields=[], trialStartMessage=None, trialStopMessage=None,
+                    timeMargins=(0.0, 0.0)):
+    """
+    Save a tab delimited event report, optionally splitting events into (trial) groups.
+
+    :param hdf5FilePath:
+    :param eventType:
+    :param eventFields:
+    :param trialStartMessage:
+    :param trialStopMessage:
+    :param timeMargins:
+    :return:
+    """
+    # Select the hdf5 file to process.
+    if not hdf5FilePath:
+        selectedFilePath = displayDataFileSelectionDialog(os.getcwd())
+        if selectedFilePath:
+            hdf5FilePath = selectedFilePath[0]
+    if not hdf5FilePath:
+        print("Warning: saveEventReport requires hdf5FilePath. No report saved.")
+        return None
+
+    dpath, dfile = os.path.split(hdf5FilePath)
+    datafile = ExperimentDataAccessUtility(dpath, dfile)
+
+    if not eventType:
+        # Get a dict of all event types -> DataStore table info for the selected DataStore file.
+        eventTableMappings = datafile.getEventMappingInformation()
+        # Get event tables that have data...
+        events_with_data = datafile.getEventsByType()
+
+        # Select which event table to output
+        eventNameList = []
+        for event_id in list(events_with_data.keys()):
+            eventNameList.append(eventTableMappings[event_id].class_name.decode('utf-8'))
+        eventType = displayEventTableSelectionDialog("Select Event Type to Save", "Event Type:", eventNameList)
+        if eventType is None:
+            print("Warning: saveEventReport requires eventType. No report saved.")
+            datafile.close()
+            return None
+
+    trial_times = []
+    if trialStartMessage and trialStopMessage:
+        # Create a table of trial_index, trial_start_time, trial_end_time for each trial by
+        # getting the time of 'TRIAL_START' and 'TRIAL_END' experiment messages.
+        mgs_table = datafile.getEventTable('MessageEvent')
+        trial_start_msgs = mgs_table.where('text == b"%s"' % trialStartMessage)
+        for mix, msg in enumerate(trial_start_msgs):
+            trial_times.append([mix + 1, msg['time'] - timeMargins[0], 0])
+        trial_end_msgs = mgs_table.where('text == b"%s"' % trialStopMessage)
+        for mix, msg in enumerate(trial_end_msgs):
+            trial_times[mix][2] = msg['time'] + timeMargins[1]
+        del mgs_table
+    elif trialStartMessage is None and trialStopMessage is None:
+        # do not split events into trial groupings
+        pass
+    else:
+        print("Warning: saveEventReport requires trialStartMessage and trialStopMessage to be strings or both None."
+              " No report saved.")
+        datafile.close()
+        return None
+
+    # Get the event table to generate report for
+    event_table = datafile.getEventTable(eventType)
+
+    if not eventFields:
+        # If no event fields were specified, report (almost) all event fields.
+        eventFields = [c for c in event_table.colnames if c not in ['experiment_id', 'session_id', 'device_id',
+                                                                    'type', 'filter_id']]
+
+    if eventType == 'MessageEvent':
+        # Sort experiment messages by time since they may not be ordered chronologically.
+        event_table = event_table.read()
+        event_table.sort(order='time')
+
+    ecount = 0
+    # Open a file to save the tab delimited output to.
+    output_file_name = os.path.join(dpath, "%s.%s.txt" % (dfile[:-5], eventType))
+    with open(output_file_name, 'w') as output_file:
+        # Save header row to file
+        if trial_times:
+            column_names = ['TRIAL_INDEX', trialStartMessage, trialStopMessage] + eventFields
+        else:
+            column_names = eventFields
+
+        output_file.write('\t'.join(column_names))
+        output_file.write('\n')
+
+        event_groupings = []
+        if trial_times:
+            # Split events into trials
+            for tindex, tstart, tstop in trial_times:
+                if eventType == 'MessageEvent':
+                    event_groupings.append(event_table[(event_table['time'] >= tstart) & (event_table['time']
+                                                                                          <= tstop)])
+                else:
+                    event_groupings.append(event_table.where("(time >= %f) & (time <= %f)" % (tstart, tstop)))
+        else:
+            # Report events without splitting them into trials
+            if eventType == 'MessageEvent':
+                event_groupings.append(event_table)
+            else:
+                event_groupings.append(event_table.iterrows())
+
+        # Save a row for each event within the trial period
+        for tid, trial_events in enumerate(event_groupings):
+            for event in trial_events:
+                event_data = []
+                for c in eventFields:
+                    cv = event[c]
+                    if type(cv) == numpy.bytes_:
+                        cv = event[c].decode('utf-8')
+                    if type(cv) == str and len(cv) == 0:
+                        cv = '.'
+                    event_data.append(str(cv))
+                if trial_times:
+                    tindex, tstart, tstop = trial_times[tid]
+                    output_file.write('\t'.join([str(tindex), str(tstart), str(tstop)] + event_data))
+                else:
+                    output_file.write('\t'.join(event_data))
+                output_file.write('\n')
+                ecount += 1
+
+    # Done report creation, close input file
+    datafile.close()
+    return output_file_name, ecount
+
+
+########### Experiment / Experiment Session Based Data Access #################
+
+
+class ExperimentDataAccessUtility:
+    """The ExperimentDataAccessUtility  provides a simple, high level, way to
+    access data saved in an ioHub DataStore HDF5 file. Data access is done by
+    providing information at an experiment and session level, as well as
+    specifying the ioHub Event types you want to retrieve data for.
+
+    An instance of the ExperimentDataAccessUtility class is created by providing
+    the location and name of the file to read, as well as any session code
+    filtering you want applied to the retrieved datasets.
+
+    Args:
+        hdfFilePath (str): The path of the directory the DataStore HDF5 file is in.
+
+        hdfFileName (str): The name of the DataStore HDF5 file.
+
+        experimentCode (str): If multi-experiment support is enabled for the DataStore file, this argument can be used to specify what experiment data to load based on the experiment_code given. NOTE: Multi-experiment data file support is not well tested and should not be used at this point.
+
+        sessionCodes (str or list): The experiment session code to filter data by. If a list of codes is given, then all codes in the list will be used.
+
+    Returns:
+        object: the created instance of the ExperimentDataAccessUtility, ready to get your data!
+
+    """
+
+    def __init__(self, hdfFilePath, hdfFileName, experimentCode=None, sessionCodes=[], mode='r'):
+        """An instance of the ExperimentDataAccessUtility class is created by
+        providing the location and name of the file to read, as well as any
+        session code filtering you want applied to the retrieved datasets.
+
+        Args:
+            hdfFilePath (str): The path of the directory the DataStore HDF5 file is in.
+
+            hdfFileName (str): The name of the DataStore HDF5 file.
+
+            experimentCode (str): If multi-experiment support is enabled for the DataStore file, this argument can be used to specify what experiment data to load based on the experiment_code given. NOTE: Multi-experiment data file support is not well tested and should not be used at this point.
+
+            sessionCodes (str or list): The experiment session code to filter data by. If a list of codes is given, then all codes in the list will be used.
+
+        Returns:
+            object: the created instance of the ExperimentDataAccessUtility, ready to get your data!
+
+        """
+        self.hdfFilePath = hdfFilePath
+        self.hdfFileName = hdfFileName
+        self.mode = mode
+        self.hdfFile = None
+
+        self._experimentCode = experimentCode
+        self._sessionCodes = sessionCodes
+        self._lastWhereClause = None
+
+        try:
+            self.hdfFile = openHubFile(hdfFilePath, hdfFileName, mode)
+        except Exception as e:
+            raise ExperimentDataAccessException(e)
+
+        self.getExperimentMetaData()
+
+    def printTableStructure(self, tableName):
+        """Print to stdout the current structure and content statistics of the
+        specified DataStore table. To print out the complete structure of the
+        DataStore file, including the name of all available tables, see the
+        printHubFileStructure method.
+
+        Args:
+            tableName (str): The DataStore table name to print metadata information out for.
+
+        """
+        if self.hdfFile:
+            hubFile = self.hdfFile
+            for group in getattr(hubFile, walk_groups)("/"):
+                for table in getattr(hubFile, list_nodes)(group, classname='Table'):
+                    if table.name == tableName:
+                        print('------------------')
+                        print('Path:', table)
+                        print('Table name:', table.name)
+                        print('Number of rows in table:', table.nrows)
+                        print('Number of cols in table:', len(table.colnames))
+                        print('Attribute name := type, shape:')
+                        for name in table.colnames:
+                            print('\t', name, ':= %s, %s' % (table.coldtypes[name], table.coldtypes[name].shape))
+                        print('------------------')
+                        return
+
+    def printHubFileStructure(self):
+        """Print to stdout the current global structure of the loaded DataStore
+        File."""
+        if self.hdfFile:
+            print(self.hdfFile)
+
+    def getExperimentMetaData(self):
+        """Returns the the metadata for the experiment the datStore file is
+        for.
+
+        **Docstr TBC.**
+
+        """
+        if self.hdfFile:
+            expcols = self.hdfFile.root.data_collection.experiment_meta_data.colnames
+            if 'sessions' not in expcols:
+                expcols.append('sessions')
+            ExperimentMetaDataInstance = namedtuple(
+                'ExperimentMetaDataInstance', expcols)
+            experiments = []
+            for e in self.hdfFile.root.data_collection.experiment_meta_data:
+                self._experimentID = e['experiment_id']
+                a_exp = list(e[:])
+                a_exp.append(self.getSessionMetaData())
+                experiments.append(ExperimentMetaDataInstance(*a_exp))
+            return experiments
+
+    def getSessionMetaData(self, sessions=None):
+        """
+        Returns the the metadata associated with the experiment session codes in use.
+
+        **Docstr TBC.**
+
+        """
+        if self.hdfFile:
+            if sessions is None:
+                sessions = []
+
+            sessionCodes = self._sessionCodes
+            sesscols = self.hdfFile.root.data_collection.session_meta_data.colnames
+            SessionMetaDataInstance = namedtuple('SessionMetaDataInstance', sesscols)
+            for r in self.hdfFile.root.data_collection.session_meta_data:
+                if (len(sessionCodes) == 0 or r['code'] in sessionCodes) and r['experiment_id'] == self._experimentID:
+                    rcpy = list(r[:])
+                    rcpy[-1] = json.loads(rcpy[-1])
+                    sessions.append(SessionMetaDataInstance(*rcpy))
+            return sessions
+
+    def getTableForPath(self, path):
+        """
+        Given a valid table path within the DataStore file, return the accociated table.
+        """
+        getattr(self.hdfFile, get_node)(path)
+
+    def getEventTable(self, event_type):
+        """
+        Returns the DataStore table that contains events of the specified type.
+
+        **Docstr TBC.**
+
+        """
+        if self.hdfFile:
+            klassTables = self.hdfFile.root.class_table_mapping
+            event_column = None
+            event_value = None
+
+            if isinstance(event_type, str):
+                if event_type.find('Event') >= 0:
+                    event_column = 'class_name'
+                    event_value = event_type
+                else:
+                    event_value = ''
+                    tokens = event_type.split('_')
+                    for t in tokens:
+                        event_value += t[0].upper() + t[1:].lower()
+                    event_value = event_type + 'Event'
+            elif isinstance(event_type, numbers.Integral):
+                event_column = 'class_id'
+                event_value = event_type
+            else:
+<<<<<<< HEAD
+                print2err('getEventTable error: event_type arguement must be a string or and int')
+=======
+                print2err(
+                    'getEventTable error: event_type argument must be a string or and int')
+>>>>>>> release
+                return None
+
+            result = []
+            where_cls = '(%s == b"%s") & (class_type_id == 1)' % (event_column, event_value)
+            for row in klassTables.where(where_cls):
+                result.append(row.fetch_all_fields())
+
+            if len(result) == 0:
+                return None
+
+            if len(result) != 1:
+                print2err('event_type_id passed to getEventAttribute can only return one row from CLASS_MAPPINGS.')
+                return None
+            tablePathString = result[0][3]
+            if isinstance(tablePathString, bytes):
+                tablePathString = tablePathString.decode('utf-8')
+            return getattr(self.hdfFile, get_node)(tablePathString)
+        return None
+
+    def getEventMappingInformation(self):
+        """Returns details on how ioHub Event Types are mapped to tables within
+        the given DataStore file."""
+        if self.hdfFile:
+            eventMappings = dict()
+            class_2_table = self.hdfFile.root.class_table_mapping
+            EventTableMapping = namedtuple(
+                'EventTableMapping',
+                self.hdfFile.root.class_table_mapping.colnames)
+            for row in class_2_table[:]:
+                eventMappings[row['class_id']] = EventTableMapping(*row)
+            return eventMappings
+        return None
+
+    def getEventsByType(self, condition_str=None):
+        """Returns a dict of all event tables within the DataStore file that
+        have at least one event instance saved.
+
+        Keys are Event Type constants, as specified by
+        iohub.EventConstants. Each value is a row iterator for events of
+        that type.
+
+        """
+        eventTableMappings = self.getEventMappingInformation()
+        if eventTableMappings:
+            events_by_type = dict()
+            getNode = getattr(self.hdfFile, get_node)
+            for event_type_id, event_mapping_info in eventTableMappings.items():
+                try:
+                    cond = '(type == %d)' % (event_type_id)
+                    if condition_str:
+                        cond += ' & ' + condition_str
+                    et_path = event_mapping_info.table_path
+                    if isinstance(et_path, bytes):
+                        et_path = et_path.decode('utf-8')
+                    events_by_type[event_type_id] = next(getNode(et_path).where(cond))
+                except StopIteration:
+                    pass
+            return events_by_type
+        return None
+
+    def getConditionVariablesTable(self):
+        """
+        **Docstr TBC.**
+        """
+        cv_group = self.hdfFile.root.data_collection.condition_variables
+        ecv = 'EXP_CV_%d' % (self._experimentID,)
+        if ecv in cv_group._v_leaves:
+            return cv_group._v_leaves[ecv]
+        return None
+
+    def getConditionVariableNames(self):
+        """
+        **Docstr TBC.**
+        """
+        cv_group = self.hdfFile.root.data_collection.condition_variables
+        ecv = "EXP_CV_%d" % (self._experimentID,)
+        if ecv in cv_group._v_leaves:
+            ecvTable = cv_group._v_leaves[ecv]
+            return ecvTable.colnames
+        return None
+
+    def getConditionVariables(self, filter=None):
+        """
+        **Docstr TBC.**
+        """
+        if filter is None:
+            session_ids = []
+            for s in self.getExperimentMetaData()[0].sessions:
+                session_ids.append(s.session_id)
+            filter = dict(SESSION_ID=(' in ', session_ids))
+
+        ConditionSetInstance = None
+
+        for conditionVarName, conditionVarComparitor in filter.items():
+            avComparison, value = conditionVarComparitor
+
+            cv_group = self.hdfFile.root.data_collection.condition_variables
+            cvrows = []
+            ecv = "EXP_CV_%d" % (self._experimentID,)
+            if ecv in cv_group._v_leaves:
+                ecvTable = cv_group._v_leaves[ecv]
+
+                if ConditionSetInstance is None:
+                    colnam = ecvTable.colnames
+                    ConditionSetInstance = namedtuple('ConditionSetInstance', colnam)
+
+                cvrows.extend(
+                    [
+                        ConditionSetInstance(
+                            *
+                            r[:]) for r in ecvTable if all(
+                        [
+                            eval(
+                                '{0} {1} {2}'.format(
+                                    r[conditionVarName],
+                                    conditionVarComparitor[0],
+                                    conditionVarComparitor[1])) for conditionVarName,
+                                                                    conditionVarComparitor in filter.items()])])
+        return cvrows
+
+    def getValuesForVariables(self, cv, value, cvNames):
+        """
+        **Docstr TBC.**
+        """
+        if isinstance(value, (list, tuple)):
+            resolvedValues = []
+            for v in value:
+                if isinstance(value, str) and value.startswith('@') and value.endswith('@'):
+                    value = value[1:-1]
+                    if value in cvNames:
+                        resolvedValues.append(getattr(cv, v))
+                    else:
+                        raise ExperimentDataAccessException('getEventAttributeValues: {0} is not a valid attribute '
+                                                            'name in {1}'.format(v, cvNames))
+                elif isinstance(value, str):
+                    resolvedValues.append(value)
+            return resolvedValues
+        elif isinstance(value, str) and value.startswith('@') and value.endswith('@'):
+            value = value[1:-1]
+            if value in cvNames:
+                return getattr(cv, value)
+            else:
+                raise ExperimentDataAccessException('getEventAttributeValues: {0} is not a valid attribute name'
+                                                    ' in {1}'.format(value, cvNames))
+        else:
+            raise ExperimentDataAccessException('Unhandled value type !: {0} is not a valid type for value '
+                                                '{1}'.format(type(value), value))
+
+    def getEventAttributeValues(self, event_type_id, event_attribute_names, filter_id=None,
+                                conditionVariablesFilter=None, startConditions=None, endConditions=None):
+        """
+        **Docstr TBC.**
+
+        Args:
+            event_type_id
+            event_attribute_names
+            filter_id
+            conditionVariablesFilter
+            startConditions
+            endConditions
+
+        Returns:
+            Values for the specified event type and event attribute columns which match the provided experiment
+            condition variable filter, starting condition filer, and ending condition filter criteria.
+        """
+        if self.hdfFile:
+            klassTables = self.hdfFile.root.class_table_mapping
+
+            deviceEventTable = None
+
+            result = [row.fetch_all_fields() for row in klassTables.where('(class_id == %d) &'
+                                                                          ' (class_type_id == 1)' % (event_type_id))]
+            if len(result) != 1:
+                raise ExperimentDataAccessException("event_type_id returned > 1 row from CLASS_MAPPINGS.")
+            tablePathString = result[0][3]
+            if isinstance(tablePathString, bytes):
+                tablePathString = tablePathString.decode('utf-8')
+            deviceEventTable = getattr(self.hdfFile, get_node)(tablePathString)
+
+            for ename in event_attribute_names:
+                if ename not in deviceEventTable.colnames:
+                    raise ExperimentDataAccessException('getEventAttribute: %s does not have a column named %s' %
+                                                        (deviceEventTable.title, event_attribute_names))
+
+            resultSetList = []
+
+            csier = list(event_attribute_names)
+            csier.append('query_string')
+            csier.append('condition_set')
+            EventAttributeResults = namedtuple('EventAttributeResults', csier)
+
+            if deviceEventTable is not None:
+                if not isinstance(event_attribute_names, (list, tuple)):
+                    event_attribute_names = [event_attribute_names, ]
+
+                filteredConditionVariableList = None
+                if conditionVariablesFilter is None:
+                    filteredConditionVariableList = self.getConditionVariables()
+                else:
+                    filteredConditionVariableList = self.getConditionVariables(conditionVariablesFilter)
+
+                cvNames = self.getConditionVariableNames()
+
+                # no further where clause building needed; get reseults and
+                # return
+                if startConditions is None and endConditions is None:
+                    for cv in filteredConditionVariableList:
+
+                        wclause = '( experiment_id == {0} ) & ( SESSION_ID == {1} )'.format(self._experimentID,
+                                                                                            cv.SESSION_ID)
+
+                        wclause += ' & ( type == {0} ) '.format(event_type_id)
+
+                        if filter_id is not None:
+                            wclause += '& ( filter_id == {0} ) '.format(filter_id)
+
+                        resultSetList.append([])
+
+                        for ename in event_attribute_names:
+                            resultSetList[-1].append(getattr(deviceEventTable, read_where)(wclause, field=ename))
+                        resultSetList[-1].append(wclause)
+                        resultSetList[-1].append(cv)
+
+                        eventAttributeResults = EventAttributeResults(*resultSetList[-1])
+                        resultSetList[-1] = eventAttributeResults
+
+                    return resultSetList
+
+                # start or end conditions exist....
+                for cv in filteredConditionVariableList:
+                    resultSetList.append([])
+
+                    wclause = '( experiment_id == {0} ) & ( session_id == {1} )'.format(self._experimentID,
+                                                                                        cv.SESSION_ID)
+
+                    wclause += ' & ( type == {0} ) '.format(event_type_id)
+
+                    if filter_id is not None:
+                        wclause += '& ( filter_id == {0} ) '.format(filter_id)
+
+                    # start Conditions need to be added to where clause
+                    if startConditions is not None:
+                        wclause += '& ('
+                        for conditionAttributeName, conditionAttributeComparitor in startConditions.items():
+                            avComparison, value = conditionAttributeComparitor
+                            value = self.getValuesForVariables(cv, value, cvNames)
+                            wclause += ' ( {0} {1} {2} ) & '.format(conditionAttributeName, avComparison, value)
+                        wclause = wclause[:-3]
+                        wclause += ' ) '
+
+                    # end Conditions need to be added to where clause
+                    if endConditions is not None:
+                        wclause += ' & ('
+                        for conditionAttributeName, conditionAttributeComparitor in endConditions.items():
+                            avComparison, value = conditionAttributeComparitor
+                            value = self.getValuesForVariables(cv, value, cvNames)
+                            wclause += ' ( {0} {1} {2} ) & '.format(conditionAttributeName, avComparison, value)
+                        wclause = wclause[:-3]
+                        wclause += ' ) '
+
+                    for ename in event_attribute_names:
+                        resultSetList[-1].append(getattr(deviceEventTable, read_where)(wclause, field=ename))
+                    resultSetList[-1].append(wclause)
+                    resultSetList[-1].append(cv)
+
+                    eventAttributeResults = EventAttributeResults(*resultSetList[-1])
+                    resultSetList[-1] = eventAttributeResults
+
+                return resultSetList
+
+            return None
+
+    def getEventIterator(self, event_type):
+        """
+        **Docstr TBC.**
+
+        Args:
+            event_type
+
+        Returns:
+            (iterator): An iterator providing access to each matching event  as a numpy recarray.
+        """
+        return self.getEventTable(event_type).iterrows()
+
+    def close(self):
+        """Close the ExperimentDataAccessUtility and associated DataStore
+        File."""
+        global _hubFiles
+        if self.hdfFile in _hubFiles:
+            _hubFiles.remove(self.hdfFile)
+        self.hdfFile.close()
+
+        self.experimentCodes = None
+        self.hdfFilePath = None
+        self.hdfFileName = None
+        self.mode = None
+        self.hdfFile = None
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
+
+class ExperimentDataAccessException(Exception):
+    pass