def getEventTable(self,event_type):
     if self.hdfFile:
         klassTables=self.hdfFile.root.class_table_mapping
         deviceEventTable=None
         event_column=None
         event_value=None
         
         if isinstance(event_type,basestring):
             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'         
             event_value='"%s"'%(event_value)
         elif isinstance(event_type,(int,long)):
             event_column='class_id'
             event_value=event_type
         else:
             iohub.print2err("getEventTable error: event_type arguement must be a string or and int")
             return None
         
         result=[row.fetch_all_fields() for row in klassTables.where('({0} == {1}) & (class_type_id == 1)'.format(event_column,event_value))]
         if len(result)!= 1:
             iohub.print2err("event_type_id passed to getEventAttribute can only return one row from CLASS_MAPPINGS: ",len(result))
             return None
             
         tablePathString=result[0][3]
         return self.hdfFile.getNode(tablePathString)
     return None

 def getSerialRx(self):
     try:
         while self._serial_port.inWaiting()>= 2:
             request_id = ord(self._serial_port.read(1))
             if request_id < T3Request.REQ_COUNTER_START:
                 event_byte_count = ord(self._serial_port.read(1))
                 time_bytes = [ord(c) for c in self._serial_port.read(6)]
                 remaining_byte_count= event_byte_count-(len(time_bytes)+2)
                 remaining_bytes = []
                 if remaining_byte_count > 0:
                     remaining_bytes = [ord(c) for c in self._serial_port.read(remaining_byte_count)]
                 if request_id in EVENT_TYPE_2_CLASS:
                     event = EVENT_TYPE_2_CLASS[request_id](request_id, time_bytes, remaining_bytes)
                     self._rx_events.append(event)
             else:
                 reply=T3Request._readRequestReply(self, request_id)
                 if reply:
                     if reply._type == T3Request.SYNC_TIME_BASE:
                         reply.syncWithT3Time()
                     else:
                         self._request_replies.append(reply)
                 else:
                     print2err("INVALID REQUEST ID in reply:",  request_id)
     except Exception as e:
         print2err("ERROR During getSerialRx: ",e,". Has ioSync been disconnected?")
         self.close()

 def shutdown(self):
     try:
         self._running=False
 
         if Computer.system=='linux2':
             if self._hookManager:
                 self._hookManager.cancel()
 
         while len(self.deviceMonitors) > 0:
             m=self.deviceMonitors.pop(0)
             m.running=False
         if self.eventBuffer:
             self.clearEventBuffer()
         try:
             self.closeDataStoreFile()
         except:
             pass
         while len(self.devices) > 0:
             d=self.devices.pop(0)
             try:
                 if d is not None:
                     d._close()
             except:
                     pass
         gevent.sleep()
     except:
         print2err("Error in ioSever.shutdown():")
         printExceptionDetailsToStdErr()

    def __init__(self, *args, **kwargs):
        Device.__init__(self, *args, **kwargs['dconfig'])
        self._serial = None
        self.port = self.getConfiguration().get('port')
        if self.port.lower() == 'auto':
            pports = self.findPorts()
            if pports:
                self.port = pports[0]
                if len(pports) > 1:
                    print2err("Warning: Serial device port configuration set to 'auto'.\nMultiple serial ports found:\n", pports, "\n** Using port ", self.port)
        self.baud = self.getConfiguration().get('baud')

        self._parser_config = self.getConfiguration().get('event_parser')
        self._byte_diff_mode = self._parser_config.get('byte_diff')

        if self._byte_diff_mode:
            self._rx_buffer = None
        else:
            self._resetParserState()
            self._rx_buffer = ''

        self._event_count = 0
        self._timeout = None
        self._serial = None
        self.setConnectionState(True)

    def _handleEvents(self, events):
        # saves many events to pytables table at once.
        # EVENTS MUST ALL BE OF SAME TYPE!!!!!
        try:
            #ioHub.print2err("_handleEvent: ",self.active_experiment_id,self.active_session_id)

            if self.checkForExperimentAndSessionIDs(len(events)) is False:
                return False

            event=events[0]

            etype=event[DeviceEvent.EVENT_TYPE_ID_INDEX]
            #ioHub.print2err("etype: ",etype)
            eventClass=EventConstants.getClass(etype)
            etable=self.TABLES[eventClass.IOHUB_DATA_TABLE]
            #ioHub.print2err("eventClass: etable",eventClass,etable)

            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= N.array(np_events,dtype=eventClass.NUMPY_DTYPE)
            #ioHub.print2err('np_array:',np_array)
            etable.append(np_array)

            self.bufferedFlush(len(np_events))

        except ioHubError, e:
            print2err(e)

    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)
            #ioHub.print2err('np_array:',np_array)
            etable.append(np_array)
            self.bufferedFlush(len(np_events))
        except ioHubError as e:
            print2err(e)
        except Exception:
            printExceptionDetailsToStdErr()

 def initConditionVariableTable(
         self, experiment_id, session_id, np_dtype):
     expcv_table = None
     expcv_node = self.emrtFile.root.data_collection.condition_variables
     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)
     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 as nsne:
         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 __init__(self, rootScriptPathDir, config=None):
        self._session_id=None
        self._experiment_id=None

        self.log("Server Time Offset: {0}".format(Computer.globalClock.getLastResetTime()))

        self._hookManager=None
        self.emrt_file=None
        self.config=config
        self.devices=[]
        self.deviceMonitors=[]
        self.sessionInfoDict=None
        self.experimentInfoList=None
        self.filterLookupByInput={}
        self.filterLookupByOutput={}
        self.filterLookupByName={}  
        self._hookDevice=None
        ioServer.eventBuffer=deque(maxlen=config.get('global_event_buffer',2048))

        self._running=True
        
        # start UDP service
        self.udpService=udpServer(self,':%d'%config.get('udp_port',9000))

        try:
            # initial dataStore setup
            if 'data_store' in config and psychopy.iohub._DATA_STORE_AVAILABLE:
                experiment_datastore_config=config.get('data_store')
                default_datastore_config_path=os.path.join(IO_HUB_DIRECTORY,'datastore','default_datastore.yaml')
                #print2err('default_datastore_config_path: ',default_datastore_config_path)
                _dslabel,default_datastore_config=load(file(default_datastore_config_path,'r'), Loader=Loader).popitem()

                for default_key,default_value in default_datastore_config.iteritems():
                    if default_key not in experiment_datastore_config:
                        experiment_datastore_config[default_key]=default_value
                                
                if experiment_datastore_config.get('enable', True):
                    #print2err("Creating ioDataStore....")

                    resultsFilePath=rootScriptPathDir
                    self.createDataStoreFile(experiment_datastore_config.get('filename','events')+'.hdf5',resultsFilePath,'a',experiment_datastore_config)

                    #print2err("Created ioDataStore.")
        except:
            print2err("Error during ioDataStore creation....")
            printExceptionDetailsToStdErr()


        #built device list and config from initial yaml config settings
        try:
            for iodevice in config.get('monitor_devices',()):
                for device_class_name,deviceConfig in iodevice.iteritems():
                    #print2err("======================================================")
                    #print2err("Started load process for: {0}".format(device_class_name))
                    self.createNewMonitoredDevice(device_class_name,deviceConfig)
        except:
            print2err("Error during device creation ....")
            printExceptionDetailsToStdErr()
            raise ioHubError("Error during device creation ....")

 def shutDown(self):
     try:
         self.disableHighPriority()
         self.iohub.shutdown()
         self._running=False
         self.stop()
     except:
         print2err("Error in ioSever.shutdown():")
         printExceptionDetailsToStdErr()
         sys.exit(1)

 def _sendT3Request(self,request):
     try:
         request.tx_time=getTime()
         tx_count=self._serial_port.write(request.getTxByteArray())
         self._serial_port.flush()
         self._active_requests[request.getID()]=request
         return tx_count
     except Exception as e:
         print2err("ERROR During sendT3Request: ",e,". Has ioSync been disconnected?")
         self.close()

 def _run(self):
     self._running=True
     while self._sync(False) is False:
         sleep(0.5)
     self._sync(False)
     while self._running is True:
         sleep(self.initial_sync_interval)
         r=self._sync()
         if r is False:
             print2err("SYNC FAILED: ioHubTimeGreenSyncManager {0}.".format(self._remote_address))
     self._close()

 def __init__(self,remote_address,sync_state_target):
     try:
         Greenlet.__init__(self)
         self._sync_socket=None
         self.initial_sync_interval=0.2
         self._remote_address=remote_address
         while self._sync_socket is None:
             self._sync_socket=ioHubTimeSyncConnection(remote_address)
             sleep(1)
         self.sync_state_target=proxy(sync_state_target)
     except Exception as e:
         print2err("** Exception during ioHubTimeGreenSyncManager.__init__: ",self._remote_address)
         printExceptionDetailsToStdErr()

    def handleGetEvents(self,replyTo):
        try:
            currentEvents=list(self.iohub.eventBuffer)
            self.iohub.eventBuffer.clear()

            if len(currentEvents)>0:
                currentEvents=sorted(currentEvents, key=itemgetter(DeviceEvent.EVENT_HUB_TIME_INDEX))
                self.sendResponse(('GET_EVENTS_RESULT',currentEvents),replyTo)
            else:
                self.sendResponse(('GET_EVENTS_RESULT', None),replyTo)
            return True
        except Exception, e:
            print2err("IOHUB_GET_EVENTS_ERROR")
            printExceptionDetailsToStdErr()
            self.sendResponse('IOHUB_GET_EVENTS_ERROR', replyTo)
            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 findSyncs(cls):
        """
        Finds serial ports with an ioSync connected.
        Code from StimSync python source and modified.
        """
        import os

        available = []
        if os.name == "nt":  # Windows
            for i in range(1, 256):
                try:
                    sport = "COM" + str(i)
                    s = serial.Serial(sport)
                    available.append(sport)
                    s.close()
                except serial.SerialException:
                    pass
        else:  # Mac / Linux
            from serial.tools import list_ports

            available = [port[0] for port in list_ports.comports()]
            # available = [s for s in available if ".us" in s]

        if len(available) < 1:
            print2err("Error: unable to find ioSync. Check Teensy 3 drivers.")
            return []

        # check each available port to see if it has an ioSync running on it
        test_request_id = 170
        tx = bytearray([T3Request.GET_USEC_TIME, test_request_id, 3])
        iosync_ports = []
        for p in available:
            try:
                sport = serial.Serial(p, 115200, timeout=1)
                sport.flushInput()
                sport.write(tx)
                sport.flush()

                obs = sport.read(8)
                if ord(obs[0]) == test_request_id or ord(obs[1]) == 8:
                    iosync_ports.append(p)
                p.close()
            except Exception:
                pass
        return iosync_ports

    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
            deviceEventTable = None
            event_column = None
            event_value = None

            if isinstance(event_type, basestring):
                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"
                event_value = '"%s"' % (event_value)
            elif isinstance(event_type, (int, long)):
                event_column = "class_id"
                event_value = event_type
            else:
                iohub.print2err("getEventTable error: event_type arguement must be a string or and int")
                return None

            result = [
                row.fetch_all_fields()
                for row in klassTables.where("({0} == {1}) & (class_type_id == 1)".format(event_column, event_value))
            ]
            if len(result) != 1:
                iohub.print2err(
                    "event_type_id passed to getEventAttribute can only return one row from CLASS_MAPPINGS: ",
                    len(result),
                )
                return None

            tablePathString = result[0][3]
            return self.hdfFile.getNode(tablePathString)
        return None

def checkForSerialEvents(read_time, rx_data, parser_state, **kwargs):
    """
    Must have the following signature:

    evt_list = someCustomParserName(read_time, rx_data, parser_state, **kwargs)

    where:
        read_time: The time when the serial device read() returned
                with the new rx_data.
        rx_data: The new serial data received. Any buffering of data
                across function calls must be done by the function
                logic itself. parser_state could be used to hold
                such a buffer if needed.
        parser_state: A dict which can be used by the function to
                store any values that need to be accessed
                across multiple calls to the function. The dict
                is initially empty.
        kwargs: The parser_kwargs preference dict read from
                the event_parser preferences; or an empty dict if
                parser_kwargs was not found.

    If events should be generated by iohub, the function must return a
    list like object, used to provide ioHub with any new serial events that
    have been found. Each element of the list must be a dict like object,
    representing a single serial device event found by the parsing function.
    An event dict can contain the following key, value pairs:
       data: The string containing the parsed event data. (REQUIRED)
       time: The timestamp for the event (Optional). If not provided,
             the return time of the latest serial.read() is used.

    If the function has detected no serial events, an empty list or None
    can be returned.

    :return: list of ioHub serial device events found. None == [] here.
    """

    print2err("checkForSerialEvents called: ", (read_time, rx_data, parser_state, kwargs))
    parser_state['last_time'] = read_time

    serial_events = []
    if rx_data == 'TEST':
        serial_events.append({'data': rx_data})
    return serial_events

 def _initializeConditionVariableTable(self,experiment_id,session_id,np_dtype):
     experimentConditionVariableTable=None
     exp_session=[('EXPERIMENT_ID','i4'),('SESSION_ID','i4')]
     exp_session.extend(np_dtype)
     np_dtype=exp_session
     print2err('np_dtype: ',np_dtype,' ',type(np_dtype))
     self._EXP_COND_DTYPE=N.dtype(np_dtype)
     try:
         expCondTableName="EXP_CV_%d"%(experiment_id)
         experimentConditionVariableTable=self.emrtFile.root.data_collection.condition_variables._f_getChild(expCondTableName)
         self.TABLES['EXP_CV']=experimentConditionVariableTable
     except NoSuchNodeError, nsne:
         try:
             experimentConditionVariableTable=self.emrtFile.createTable(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:
             printExceptionDetailsToStdErr()
             return False

        def addClassMappings(cls,device_class,device_event_ids,event_classes):
            if cls._classes is None:
                cls._classes={}

            #import iohub
            #iohub.print2err("Adding Device Event Mappings for device: ",device_class.__name__)

            for event_id in device_event_ids:
                event_constant_string=cls.getName(event_id)
                event_class=None
                for event_class in list(event_classes.values()):
                    if event_class.EVENT_TYPE_ID == event_id:
                        cls._classes[event_id]=event_class
                        cls._classes[event_class]=event_id
                        #iohub.print2err("\tAdding Event Class Mapping: ",event_constant_string, " = ",event_id)
                        break

                if event_id not in cls._classes:
                        from psychopy.iohub import print2err
                        print2err("\t*** ERROR ADDING EVENT CLASSS MAPPING: Could not find class: ",event_constant_string, " = ",event_id)