psychopy 2024.2.5__py3-none-any.whl → 2025.1.1__py3-none-any.whl

psychopy/hardware/iolab.py.orig

@@ -1,238 +0,0 @@
-
-"""The `ioLab python library
-    <http://github.com/ioLab/python-ioLabs>`_ is now defunct and the company
-    no longer trades
-"""
-<<<<<<< Updated upstream
-#  This file can't be named ioLabs.py, otherwise "import ioLabs" doesn't work.
-# And iolabs.py (lowercase) did not solve it either, something is case
-# insensitive somewhere
-
-from numpy import ubyte
-from psychopy import core, event, logging
-
-try:
-    import ioLabs
-    from ioLabs import USBBox, REPORT, COMMAND
-except ImportError:
-    err = """Failed to import the ioLabs library. If you're using your own
-        copy of python (not the Standalone distribution of PsychoPy) then
-        try installing it with:
-           > pip install ioLabs""".replace('    ', '')
-    logging.error(err)
-
-from psychopy.constants import PRESSED, RELEASED
-btn2str = {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7',
-           64: 'voice'}
-
-# hack to fake a USBBox on ubuntu during documentation
-import sys
-if 'sphinx' in sys.modules:
-    USBBox = object
-
-class ButtonBox(USBBox):
-    """PsychoPy's interface to ioLabs.USBBox. Voice key completely untested.
-
-    Original author: Jonathan Roberts
-    PsychoPy rewrite: Jeremy Gray, 2013
-    """
-
-    def __init__(self):
-        """Class to detect and report
-        `ioLab button box <http://www.iolab.co.uk>`_.
-
-        The ioLabs library needs to be installed. It is included in the
-        *Standalone* distributions of PsychoPy as of version 1.62.01.
-        Otherwise try "pip install ioLabs"
-
-        Usage::
-
-            from psychopy.hardware import iolab
-            bbox = iolab.ButtonBox()
-
-        For examples see the demos menu of the PsychoPy Coder or go to the
-        URL above.
-
-        All times are reported in units of seconds.
-        """
-        ioLabs.USBBox.__init__(self)
-        logging.debug('init iolabs bbox')
-        self.events = []
-        self.status = None  # helps Builder
-        self._lastReset = 0.0  # time on baseclock when bbox clock was reset
-        self._baseclock = core.Clock()  # for basetime, not RT time
-        self.resetClock(log=True)  # internal clock on the bbox
-        msg = 'button box resetClock(log=True) took %.4fs'
-        logging.exp(msg % self._baseclock.getTime())
-
-        self.commands.add_callback(REPORT.KEYDN, self._onKeyDown)
-        self.commands.add_callback(REPORT.KEYUP, self._onKeyUp)
-        self.commands.add_callback(REPORT.RTCREP, self._onRtcRep)
-
-    # set up callbacks for key events ("key" = button and or voice key):
-    def _onKey(self, report):
-        report.rt = report.rtc / 1000.
-        report.btn = report.key_code  # int
-        report.key = btn2str[report.key_code]  # str
-        self.events.append(report)
-
-    def _onKeyDown(self, report):
-        report.direction = PRESSED
-        self._onKey(report)
-
-    def _onKeyUp(self, report):
-        report.direction = RELEASED
-        self._onKey(report)
-
-    def _onRtcRep(self, report):
-        # read internal clock without needing a button-press; not working
-        report.rt = self.commands.rtcget()['rtc'] / 1000.
-
-    def __del__(self):
-        # does not seem to ever get called
-        self.standby()
-        for rep in [REPORT.KEYDN, REPORT.KEYUP, REPORT.RTCREP]:
-            self.remove_callback(rep)
-        ioLabs.USBBox.__del__(self)
-
-    def standby(self):
-        """Disable all buttons and lights.
-        """
-        self.buttons.enabled = 0x00  # 8 bit pattern 0=disabled 1=enabled
-        self.leds.state = 0xFF  # leds == port2 == lights, 8 bits 0=on 1=off
-        return self
-
-    def resetClock(self, log=True):
-        """Reset the clock on the bbox internal clock, e.g., at the start
-        of a trial.
-
-        ~1ms for me; logging is much faster than the reset
-        """
-        # better / faster than self.reset_clock() (no wait for report):
-        self.commands.resrtc()
-        self._lastReset = self._baseclock.getTime()
-        if log:
-            msg = 'reset bbox internal clock at basetime = %.3f'
-            logging.exp(msg % self._lastReset)
-
-    def _getTime(self, log=False):
-        """Return the time on the bbox internal clock, relative to last reset.
-
-        Status: rtcget() not working
-
-        `log=True` will log the bbox time and elapsed CPU (python) time.
-        """
-        bboxTime = self.commands.rtcget()['rtc'] / 1000.
-        logging.debug('bbox rtc: %.3f' % bboxTime)
-        if log:
-            cpuTime = self._baseclock.getTime() - self._lastReset
-            logging.debug('cpu time: %.3f' % cpuTime)
-
-        return bboxTime
-
-    def getBaseTime(self):
-        """Return the time since init (using the CPU clock, not ioLab bbox).
-
-        Aim is to provide a similar API as for a Cedrus box.
-        Could let both clocks run for a long time to assess relative drift.
-        """
-        return self._baseclock.getTime()
-
-    def setEnabled(self, buttonList=(0, 1, 2, 3, 4, 5, 6, 7), voice=False):
-        """Set a filter to suppress events from non-enabled buttons.
-
-        The ioLabs bbox filters buttons in hardware; here we just tell it
-        what we want:
-        None - disable all buttons
-        an integer (0..7) - enable a single button
-        a list of integers (0..7) - enable all buttons in the list
-
-        Set voice=True to enable the voiceKey - gets reported as button 64
-        """
-        allInRange = all([b in range(8) for b in buttonList])
-        if not (buttonList is None or allInRange):
-            raise ValueError('buttonList needs to be a list of 0..7, or None')
-        self.buttons.enabled = _list2bits(buttonList)
-        self.int0.enabled = int(voice)
-
-    def getEnabled(self):
-        """Return a list of the buttons that are currently enabled.
-        """
-        return _bits2list(self.buttons.enabled)
-
-    def setLights(self, lightList=(0, 1, 2, 3, 4, 5, 6, 7)):
-        """Turn on the specified LEDs (None, 0..7, list of 0..7)
-        """
-        self.leds.state = ~_list2bits(lightList)
-
-    def waitEvents(self, downOnly=True, timeout=0, escape='escape',
-                   wait=0.002):
-        """Wait for and return the first button press event.
-
-        Always calls `clearEvents()` first (like PsychoPy keyboard waitKeys).
-
-        Use `downOnly=False` to include button-release events.
-
-        `escape` is a list/tuple of keyboard events that, if pressed, will
-        interrupt the bbox wait; `waitKeys` will return `None` in that case.
-
-        `timeout` is the max time to wait in seconds before returning `None`.
-        `timeout` of 0 means no time-out (= default).
-        """
-        self.clearEvents()  # e.g., removes UP from previous DOWN
-        if timeout > 0:
-            c = core.Clock()
-        if escape and not type(escape) in [list, tuple]:
-            escape = [escape]
-        while True:
-            if wait:
-                core.wait(wait, 0)  # throttle CPU; event RTs come from bbox
-            evt = self.getEvents(downOnly=downOnly)
-            if evt:
-                evt = evt[0]
-                break
-            if escape and event.getKeys(escape) or 0 < timeout < c.getTime():
-                return
-        return evt
-
-    def getEvents(self, downOnly=True):
-        """Detect and return a list of all events (likely just one); no block.
-
-        Use `downOnly=False` to include button-release events.
-        """
-        if downOnly is False:
-            raise NotImplementedError()
-        self.process_received_reports()
-        evts = []
-        for evt in self.events:
-            if evt.direction == PRESSED or not downOnly:
-                evts.append(evt)
-        return evts
-
-    def clearEvents(self):
-        """Discard all button / voice key events.
-        """
-        self.events[:] = []
-        self.commands.clear_received_reports()
-        logging.debug('bbox clear events')
-
-
-pow2 = [2**i for i in range(8)]
-
-
-def _list2bits(arg):
-    # return a numpy.ubyte with bits set based on integers 0..7 in arg
-    if type(arg) == int and 0 <= arg < 8:
-        return ubyte(pow2[arg])
-    elif hasattr(arg, '__iter__'):
-        return ubyte(sum([pow2[btn] for btn in arg]))
-    else:  # None
-        return ubyte(0)
-
-=======
->>>>>>> Stashed changes
-
-raise DeprecationWarning("The ioLab button box is no longer being sold and the library is no"
-                         "longer supported. This library has been removed from PsychoPy as of"
-                         "version 2022.1. We would recommend you use an alternative button box"
-                         "such as the LabHackers MilliKey <https://www.labhackers.com/millikey.html>")

psychopy/iohub/datastore/__init__.py.orig

@@ -1,443 +0,0 @@
-#!/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 os
-import atexit
-import numpy as np
-from pkg_resources import parse_version
-from ..server import DeviceEvent
-from ..constants import EventConstants
-from ..errors import ioHubError, printExceptionDetailsToStdErr, print2err
-
-import tables
-from tables import parameters, StringCol, UInt32Col, UInt16Col, NoSuchNodeError
-
-if parse_version(tables.__version__) < parse_version('3'):
-    from tables import openFile as open_file
-
-    create_table = "createTable"
-    create_group = "createGroup"
-    f_get_child = "_f_getChild"
-else:
-    from tables import open_file
-
-    create_table = "create_table"
-    create_group = "create_group"
-    _f_get_child = "_f_get_child"
-
-parameters.MAX_NUMEXPR_THREADS = None
-"""The maximum number of threads that PyTables should use internally in
-Numexpr.  If `None`, it is automatically set to the number of cores in
-your machine."""
-
-parameters.MAX_BLOSC_THREADS = None
-"""The maximum number of threads that PyTables should use internally in
-Blosc.  If `None`, it is automatically set to the number of cores in
-your machine."""
-
-DATA_FILE_TITLE = "ioHub DataStore - Experiment Data File."
-FILE_VERSION = '0.9.1.2'
-SCHEMA_AUTHORS = 'Sol Simpson'
-SCHEMA_MODIFIED_DATE = 'October 27, 2021'
-
-
-class DataStoreFile():
-    def __init__(self, fileName, folderPath, fmode='a', iohub_settings=None):
-        self.fileName = fileName
-        self.folderPath = folderPath
-        self.filePath = os.path.join(folderPath, fileName)
-
-        if iohub_settings.get('multiple_sessions', False) is False:
-            fmode = 'w'
-
-        self.settings = iohub_settings
-
-        self.active_experiment_id = None
-        self.active_session_id = None
-
-        self.flushCounter = self.settings.get('flush_interval', 32)
-        self._eventCounter = 0
-
-        self.TABLES = dict()
-        self._eventGroupMappings = dict()
-        self.emrtFile = open_file(self.filePath, mode=fmode)
-
-        atexit.register(close_open_data_files, False)
-
-        if len(self.emrtFile.title) == 0:
-            self.buildOutTemplate()
-            self.flush()
-        else:
-            self.loadTableMappings()
-
-    def loadTableMappings(self):
-        # create meta-data tables
-        self.TABLES['EXPERIMENT_METADETA'] = self.emrtFile.root.data_collection.experiment_meta_data
-        self.TABLES['SESSION_METADETA'] = self.emrtFile.root.data_collection.session_meta_data
-        self.TABLES['CLASS_TABLE_MAPPINGS'] = self.emrtFile.root.class_table_mapping
-
-    def buildOutTemplate(self):
-        self.emrtFile.title = DATA_FILE_TITLE
-        self.emrtFile.FILE_VERSION = FILE_VERSION
-        self.emrtFile.SCHEMA_DESIGNER = SCHEMA_AUTHORS
-        self.emrtFile.SCHEMA_MODIFIED = SCHEMA_MODIFIED_DATE
-
-        create_group_func = getattr(self.emrtFile, create_group)
-        create_table_func = getattr(self.emrtFile, create_table)
-
-        # CREATE GROUPS
-        self.TABLES['CLASS_TABLE_MAPPINGS'] = create_table_func(self.emrtFile.root, 'class_table_mapping',
-                                                                ClassTableMappings, title='ioHub DeviceEvent Class to '
-                                                                                          'DataStore Table Mappings.')
-
-        create_group_func(self.emrtFile.root, 'data_collection', title='Data collected using ioHub.')
-        self.flush()
-
-        create_group_func(self.emrtFile.root.data_collection, 'events', title='Events collected using ioHub.')
-
-        create_group_func(self.emrtFile.root.data_collection, 'condition_variables', title="Experiment Condition "
-                                                                                           "Variable Data.")
-        self.flush()
-
-        self.TABLES['EXPERIMENT_METADETA'] = create_table_func(self.emrtFile.root.data_collection,
-                                                               'experiment_meta_data', ExperimentMetaData,
-                                                               title='Experiment Metadata.')
-
-        self.TABLES['SESSION_METADETA'] = create_table_func(self.emrtFile.root.data_collection, 'session_meta_data',
-                                                            SessionMetaData, title='Session Metadata.')
-        self.flush()
-
-        create_group_func(self.emrtFile.root.data_collection.events, 'experiment', title='Experiment Device Events.')
-        create_group_func(self.emrtFile.root.data_collection.events, 'keyboard', title='Keyboard Device Events.')
-        create_group_func(self.emrtFile.root.data_collection.events, 'mouse', title='Mouse Device Events.')
-        create_group_func(self.emrtFile.root.data_collection.events, 'wintab', title='Wintab Device Events.')
-        create_group_func(self.emrtFile.root.data_collection.events, 'eyetracker', title='EyeTracker Device Events.')
-        create_group_func(self.emrtFile.root.data_collection.events, 'serial', title='Serial Interface Events.')
-        create_group_func(self.emrtFile.root.data_collection.events, 'pstbox', title='Serial Pstbox Device Events.')
-
-        self.flush()
-
-    @staticmethod
-    def eventTableLabel2ClassName(event_table_label):
-        tokens = str(event_table_label[0] + event_table_label[1:].lower() + 'Event').split('_')
-        return ''.join([t[0].upper() + t[1:] for t in tokens])
-
-    def groupNodeForEvent(self, event_cls):
-        evt_group_label = event_cls.PARENT_DEVICE.DEVICE_TYPE_STRING.lower()
-        datevts_node = self.emrtFile.root.data_collection.events
-        try:
-            # If group for event table already exists return it....
-            return datevts_node._f_get_child(evt_group_label)
-        except tables.NoSuchNodeError:
-            # Create the group node for the event....
-            egtitle = "%s%s Device Events." % (evt_group_label[0].upper(), evt_group_label[1:])
-            self.emrtFile.createGroup(datevts_node, evt_group_label, title=egtitle)
-            return datevts_node._f_get_child(evt_group_label)
-
-    def updateDataStoreStructure(self, device_instance, event_class_dict):
-        dfilter = tables.Filters(complevel=0, complib='zlib', shuffle=False, fletcher32=False)
-
-        for event_cls_name, event_cls in event_class_dict.items():
-            if event_cls.IOHUB_DATA_TABLE:
-                table_label = event_cls.IOHUB_DATA_TABLE
-                if table_label not in self.TABLES:
-                    try:
-                        tc_name = self.eventTableLabel2ClassName(table_label)
-                        create_table_func = getattr(self.emrtFile, create_table)
-                        dc_name = device_instance.__class__.__name__
-                        self.TABLES[table_label] = create_table_func(self.groupNodeForEvent(event_cls),
-                                                                     tc_name,
-                                                                     event_cls.NUMPY_DTYPE,
-                                                                     title='%s Data' % dc_name,
-                                                                     filters=dfilter.copy())
-                        self.flush()
-                    except tables.NodeError:
-                        self.TABLES[table_label] = self.groupNodeForEvent(event_cls)._f_get_child(tc_name)
-                    except Exception as e:
-                        print2err('---------------ERROR------------------')
-                        print2err('Exception %s in iohub.datastore.updateDataStoreStructure:' % (e.__class__.__name__))
-                        print2err('\tevent_cls: {0}'.format(event_cls))
-                        print2err('\tevent_cls_name: {0}'.format(event_cls_name))
-                        print2err('\tevent_table_label: {0}'.format(table_label))
-                        print2err('\teventTable2ClassName: {0}'.format(tc_name))
-                        print2err('\tgroupNodeForEvent(event_cls): {0}'.format(self.groupNodeForEvent(event_cls)))
-                        print2err('\nException:')
-                        printExceptionDetailsToStdErr()
-                        print2err('--------------------------------------')
-
-                if table_label in self.TABLES:
-                    self.addClassMapping(event_cls, self.TABLES[table_label])
-                else:
-                    print2err('---- IOHUB.DATASTORE CANNOT ADD CLASS MAPPING ----')
-                    print2err('\t** TABLES missing key: {0}'.format(table_label))
-                    print2err('\tevent_cls: {0}'.format(event_cls))
-                    print2err('\tevent_cls_name: {0}'.format(event_cls_name))
-                    print2err('\teventTableLabel2ClassName: {0}'.format(self.eventTableLabel2ClassName(table_label)))
-                    print2err('----------------------------------------------')
-
-    def addClassMapping(self, ioClass, ctable):
-        cmtable = self.TABLES['CLASS_TABLE_MAPPINGS']
-        names = [x['class_id'] for x in cmtable.where('(class_id == %d)' % ioClass.EVENT_TYPE_ID)]
-        if len(names) == 0:
-            trow = cmtable.row
-            trow['class_id'] = ioClass.EVENT_TYPE_ID
-            trow['class_type_id'] = 1  # Device or Event etc.
-            trow['class_name'] = ioClass.__name__
-            trow['table_path'] = ctable._v_pathname
-            trow.append()
-            self.flush()
-
-    def createOrUpdateExperimentEntry(self, experimentInfoList):
-        experiment_metadata = self.TABLES['EXPERIMENT_METADETA']
-        result = [row for row in experiment_metadata.iterrows() if row['code'] == experimentInfoList[1]]
-        if len(result) > 0:
-            result = result[0]
-            self.active_experiment_id = result['experiment_id']
-            return self.active_experiment_id
-        max_id = 0
-        id_col = experiment_metadata.col('experiment_id')
-        if len(id_col) > 0:
-            max_id = np.amax(id_col)
-        self.active_experiment_id = max_id + 1
-        experimentInfoList[0] = self.active_experiment_id
-        experiment_metadata.append([tuple(experimentInfoList), ])
-        self.flush()
-        return self.active_experiment_id
-
-    def createExperimentSessionEntry(self, sessionInfoDict):
-        session_metadata = self.TABLES['SESSION_METADETA']
-        max_id = 0
-        id_col = session_metadata.col('session_id')
-        if len(id_col) > 0:
-            max_id = np.amax(id_col)
-        self.active_session_id = int(max_id + 1)
-
-        values = (self.active_session_id, self.active_experiment_id, sessionInfoDict['code'], sessionInfoDict['name'],
-                  sessionInfoDict['comments'], sessionInfoDict['user_variables'])
-
-        session_metadata.append([values, ])
-        self.flush()
-        return self.active_session_id
-
-    def initConditionVariableTable(
-            self, experiment_id, session_id, np_dtype):
-        expcv_table = None
-        exp_session = [('EXPERIMENT_ID', 'i4'), ('SESSION_ID', 'i4')]
-        exp_session.extend(np_dtype)
-        np_dtype = []
-        for npctype in exp_session:
-            if isinstance(npctype[0], str):
-                nv = [str(npctype[0]), ]
-                nv.extend(npctype[1:])
-                np_dtype.append(tuple(nv))
-            else:
-                np_dtype.append(npctype)
-
-        np_dtype2 = []
-        for adtype in np_dtype:
-            adtype2 = []
-            for a in adtype:
-                if isinstance(a, bytes):
-                    a = str(a, 'utf-8')
-                adtype2.append(a)
-            np_dtype2.append(tuple(adtype2))
-        np_dtype = np_dtype2
-        self._EXP_COND_DTYPE = np.dtype(np_dtype)
-        try:
-            expCondTableName = "EXP_CV_%d" % (experiment_id)
-            experimentConditionVariableTable = getattr(self.emrtFile.root.data_collection.condition_variables,
-                                                       _f_get_child)(expCondTableName)
-            self.TABLES['EXP_CV'] = experimentConditionVariableTable
-        except NoSuchNodeError:
-            try:
-                experimentConditionVariableTable = getattr(self.emrtFile, create_table)(
-                    self.emrtFile.root.data_collection.condition_variables, expCondTableName, self._EXP_COND_DTYPE,
-                    title='Condition Variable Values for Experiment ID %d' % experiment_id)
-                self.TABLES['EXP_CV'] = experimentConditionVariableTable
-                self.emrtFile.flush()
-            except Exception:
-                printExceptionDetailsToStdErr()
-                return False
-        except Exception:
-            print2err('Error getting expcv_table for experiment %d, table name: %s' % (experiment_id, expCondTableName))
-            printExceptionDetailsToStdErr()
-            return False
-        self._activeRunTimeConditionVariableTable = expcv_table
-        return True
-
-    def extendConditionVariableTable(self, experiment_id, session_id, data):
-        if self._EXP_COND_DTYPE is None:
-            return False
-        if self.emrtFile and 'EXP_CV' in self.TABLES:
-            temp = [experiment_id, session_id]
-            temp.extend(data)
-            data = temp
-            try:
-                etable = self.TABLES['EXP_CV']
-                for i, d in enumerate(data):
-                    if isinstance(d, (list, tuple)):
-                        data[i] = tuple(d)
-                np_array = np.array([tuple(data), ], dtype=self._EXP_COND_DTYPE)
-                etable.append(np_array)
-                self.bufferedFlush()
-                return True
-            except Exception:
-                printExceptionDetailsToStdErr()
-        return False
-
-    def checkForExperimentAndSessionIDs(self, event=None):
-        if self.active_experiment_id is None or self.active_session_id is None:
-            exp_id = self.active_experiment_id
-            if exp_id is None:
-                exp_id = 0
-            sess_id = self.active_session_id
-            if sess_id is None:
-                sess_id = 0
-            return False
-        return True
-
-    def checkIfSessionCodeExists(self, sessionCode):
-        if self.emrtFile:
-            wclause = 'experiment_id == %d' % (self.active_experiment_id,)
-            sessionsForExperiment = self.emrtFile.root.data_collection.session_meta_data.where(wclause)
-            sessionCodeMatch = [sess for sess in sessionsForExperiment if sess['code'] == sessionCode]
-            if len(sessionCodeMatch) > 0:
-                return True
-            return False
-
-    def _handleEvent(self, event):
-        try:
-            if self.checkForExperimentAndSessionIDs(event) is False:
-                return False
-            etype = event[DeviceEvent.EVENT_TYPE_ID_INDEX]
-            eventClass = EventConstants.getClass(etype)
-            etable = self.TABLES[eventClass.IOHUB_DATA_TABLE]
-            event[DeviceEvent.EVENT_EXPERIMENT_ID_INDEX] = self.active_experiment_id
-            event[DeviceEvent.EVENT_SESSION_ID_INDEX] = self.active_session_id
-
-            np_array = np.array([tuple(event), ], dtype=eventClass.NUMPY_DTYPE)
-            etable.append(np_array)
-            self.bufferedFlush()
-        except Exception:
-            print2err("Error saving event: ", event)
-            printExceptionDetailsToStdErr()
-
-    def _handleEvents(self, events):
-        try:
-            if self.checkForExperimentAndSessionIDs(len(events)) is False:
-                return False
-
-            event = events[0]
-
-            etype = event[DeviceEvent.EVENT_TYPE_ID_INDEX]
-            eventClass = EventConstants.getClass(etype)
-            etable = self.TABLES[eventClass.IOHUB_DATA_TABLE]
-
-            np_events = []
-            for event in events:
-                event[DeviceEvent.EVENT_EXPERIMENT_ID_INDEX] = self.active_experiment_id
-                event[DeviceEvent.EVENT_SESSION_ID_INDEX] = self.active_session_id
-                np_events.append(tuple(event))
-
-            np_array = np.array(np_events, dtype=eventClass.NUMPY_DTYPE)
-            etable.append(np_array)
-            self.bufferedFlush(len(np_events))
-        except ioHubError as e:
-            print2err(e)
-        except Exception:
-            printExceptionDetailsToStdErr()
-
-    def bufferedFlush(self, eventCount=1):
-        """
-        If flushCounter threshold is >=0 then do some checks. If it is < 0,
-        then flush only occurs when command is sent to ioHub,
-        so do nothing here.
-        """
-        if self.flushCounter >= 0:
-            if self.flushCounter == 0:
-                self.flush()
-                return True
-            if self.flushCounter <= self._eventCounter:
-                self.flush()
-                self._eventCounter = 0
-                return True
-            self._eventCounter += eventCount
-            return False
-
-    def flush(self):
-        try:
-            if self.emrtFile:
-                self.emrtFile.flush()
-        except tables.ClosedFileError:
-            pass
-        except Exception:
-            printExceptionDetailsToStdErr()
-
-    def close(self):
-        self.flush()
-        self._activeRunTimeConditionVariableTable = None
-        self.emrtFile.close()
-
-    def __del__(self):
-        try:
-            self.close()
-        except Exception:
-            pass
-
-
-## -------------------- Utility Functions ------------------------ ##
-
-
-def close_open_data_files(verbose):
-    open_files = tables.file._open_files
-    clall = hasattr(open_files, 'close_all')
-    if clall:
-        open_files.close_all()
-    else:
-        are_open_files = len(open_files) > 0
-        if verbose and are_open_files:
-            print2err('Closing remaining open data files:')
-        for fileh in open_files:
-            if verbose:
-                print2err('%s...' % (open_files[fileh].filename,))
-            open_files[fileh].close()
-            if verbose:
-                print2err('done')
-
-
-registered_close_open_data_files = True
-atexit.register(close_open_data_files, False)
-
-
-## ---------------------- Pytable Definitions ------------------- ##
-
-
-class ClassTableMappings(tables.IsDescription):
-    class_id = UInt32Col(pos=1)
-    class_type_id = UInt32Col(pos=2)  # Device or Event etc.
-    class_name = StringCol(32, pos=3)
-    table_path = StringCol(128, pos=4)
-
-
-class ExperimentMetaData(tables.IsDescription):
-    experiment_id = UInt32Col(pos=1)
-    code = StringCol(256, pos=2)
-    title = StringCol(256, pos=3)
-    description = StringCol(4096, pos=4)
-    version = StringCol(32, pos=5)
-
-
-class SessionMetaData(tables.IsDescription):
-    session_id = UInt32Col(pos=1)
-    experiment_id = UInt32Col(pos=2)
-    code = StringCol(256, pos=3)
-    name = StringCol(256, pos=4)
-    comments = StringCol(4096, pos=5)
-<<<<<<< HEAD
-    user_variables = StringCol(16384, pos=6)  # Holds json encoded version of user variable dict for session
-=======
-    user_variables = StringCol(16384, pos=6) # Holds json encoded version of user variable dict for session
->>>>>>> release