quarchpy 2.1.11.dev8__py3-none-any.whl → 2.2.17.dev2__py3-none-any.whl

quarchpy/connection_specific/connection_QIS.py

@@ -1,1777 +1,1513 @@
-import socket
-import re
-import time
-import sys
-import os
-import datetime
-import select
-import threading
-import math
-import logging
-import struct
-from pathlib import Path
-from quarchpy.user_interface import *
-import xml.etree.ElementTree as ET
-from connection_specific.StreamChannels import StreamGroups
-
-
-# QisInterface provides a way of connecting to a Quarch backend running at the specified ip address and port, defaults to localhost and 9722
-class QisInterface:
-    def __init__(self, host='127.0.0.1', port=9722, connectionMessage=True):
-        self.host = host
-        self.port = port
-        self.maxRxBytes = 4096
-        self.sock = None
-        self.StreamRunSentSemaphore = threading.Semaphore()
-        self.sockSemaphore = threading.Semaphore()
-        self.stopFlagList = []
-        self.listSemaphore = threading.Semaphore()
-        self.deviceList = []
-        self.deviceDict = {}
-        self.dictSemaphore = threading.Semaphore()
-        self.connect(connectionMessage = connectionMessage)
-        self.stripesEvent = threading.Event()
-
-        self.qps_stream_header = None
-        self.qps_record_dir_path = None
-        self.qps_record_start_time = None
-        self.qps_stream_folder_name = None
-
-        self.module_xml_header = None
-        self.streamGroups = None
-        self.has_digitals = False
-        self.is_multirate = False
-
-        self.streamSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.streamSock.settimeout(5)
-        self.streamSock.connect((self.host, self.port))
-        self.pythonVersion = sys.version[0]
-        #self.sendText(self.streamSock, '$scan')
-        #time.sleep(3)
-        if self.pythonVersion == '3':
-            temp = '>'
-            self.cursor = temp.encode()
-        else:
-            self.cursor = '>'
-        #clear packets
-        welcomeString = self.streamSock.recv(self.maxRxBytes).rstrip()
-
-
-    def connect(self, connectionMessage = True):
-        '''
-        Connect() tries to open a socket  on the host and port specified in the objects variables
-        If successful it returns the backends welcome string. If it fails it returns a string saying unable to connect
-        The backend should be running and host and port set before running this function. Normally it should be called at the beggining
-        of talking to the backend and left open until finished talking when the disconnect() function should be ran
-
-        Param:
-        connectionMessage: boolean, optional
-            Set to False if you don't want a warning message to appear when an instance is already running on that port. Useful when using isQisRunning() from qisFuncs
-        '''
-        try:
-            self.deviceDictSetup('QIS')
-            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            self.sock.settimeout(5)
-            self.sock.connect((self.host, self.port))
-
-            #clear packets
-            try:
-                welcomeString = self.sock.recv(self.maxRxBytes).rstrip()
-                welcomeString = 'Connected@' + str(self.host) + ':' + str(self.port) + ' ' + '\n    ' + str(welcomeString)
-                self.deviceDict['QIS'][0:3] = [False, 'Connected', welcomeString]
-                return welcomeString
-            except Exception as e:
-                logging.error('No welcome received. Unable to connect to Quarch backend on specified host and port (' + self.host + ':' + str(self.port) + ')')
-                logging.error('Is backend running and host accessible?')
-                self.deviceDict['QIS'][0:3] = [True, 'Disconnected', 'Unable to connect to QIS']
-                raise e
-        except Exception as e:
-            self.deviceDictSetup('QIS')
-            if connectionMessage:
-                logging.error('Unable to connect to Quarch backend on specified host and port (' + self.host + ':' + str(self.port) + ').')
-                logging.error('Is backend running and host accessible?')
-            self.deviceDict['QIS'][0:3] = [True, 'Disconnected', 'Unable to connect to QIS']
-            raise e
-    
-    # Tries to close the socket to specified host and port.
-    def disconnect(self):
-        res = 'Disconnecting from backend'
-        try:
-            self.sock.shutdown(socket.SHUT_RDWR)
-            self.sock.close()
-            self.deviceDict['QIS'][0:3] = [False, "Disconnected", 'Successfully disconnected from QIS']
-        except Exception as e:
-            exc_type, exc_obj, exc_tb = sys.exc_info()
-            fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
-            message = 'Unable to end connection. ' + self.host + ':' + str(self.port) + ' \r\n' + str(exc_type) + ' ' + str(fname) + ' ' + str(exc_tb.tb_lineno)
-            self.deviceDict['QIS'][0:3] = [True, "Connected", message]
-            raise e
-        return res
-
-    def closeConnection(self, sock=None, conString=None):
-        if sock == None:
-            sock = self.sock
-
-        if conString is None:
-           cmd="close"
-        else:
-            cmd =conString+" close"
-
-        if self.pythonVersion == '3':
-            response = self.sendAndReceiveText(sock, cmd).decode()
-        else:
-            response = self.sendAndReceiveText(sock, cmd)
-        return response
-
-    def startStream(self, module, fileName, fileMaxMB, streamName, streamAverage, releaseOnData, separator, streamDuration = None):
-        self.StreamRunSentSemaphore.acquire()
-        self.deviceDictSetup('QIS')
-        i = self.deviceMulti(module)
-        self.stopFlagList[i] = True
-        self.stripesEvent.set()
-        self.module_xml_header = None
-
-        # Create the thread
-        t1 = threading.Thread(target=self.startStreamThread, name=module,
-                              args=(module, fileName, fileMaxMB, streamName, streamAverage, releaseOnData, separator, streamDuration))
-        # Start the thread
-        t1.start()
-
-        # count = 0
-        while (self.stripesEvent.is_set()):
-            # count += 1                         --debugging to show delay
-            pass
-            # just wait until event is cleared
-
-    def startStreamQPS(self, module, fileName, fileMaxMB, streamName, streamAverage, releaseOnData, separator):
-        self.StreamRunSentSemaphore.acquire()
-        self.deviceDictSetup('QIS')
-        i = self.deviceMulti(module)
-        self.stopFlagList[i] = True
-        self.stripesEvent.set()
-        self.module_xml_header = None
-
-        # Create the thread
-        t1 = threading.Thread(target=self.startStreamThreadQPS, name=module,
-                              args=(module, fileName, fileMaxMB, streamName, streamAverage, releaseOnData, separator))
-        # Start the thread
-        t1.start()
-
-        # count = 0
-        while (self.stripesEvent.is_set()):
-            # count += 1                         --debugging to show delay
-            pass
-            # just wait until event is cleared
-
-
-    def stopStream(self, module, blocking = True):
-
-        i = self.deviceMulti(module)
-        self.stopFlagList[i] = False
-        # Wait until the stream thread is finished before returning to user.
-        # This means this function will block until the QIS buffer is emptied by the second while
-        # loop in startStreanThread. This may take some time, especially at low averaging but
-        # should gurantee the data won't be lost and QIS buffer is emptied.
-        if blocking:
-            running = True
-            while running:
-                threadNameList = []
-                for t1 in threading.enumerate():
-                    threadNameList.append(t1.name)
-                if (module in threadNameList):
-                    time.sleep(0.5)
-                else:
-                    running = False
-        time.sleep(0.1)
-    
-    # This is the function that is run when t1 is created. It is run in a seperate thread from 
-    # the main application so streaming can happen without blocking the main application from 
-    # doing other things. Within this function/thread you have to be very careful not to try 
-    # and 'communicate'  with anything from other threads. If you do, you MUST use a thread safe 
-    # way of communicating. The thread creates it's own socket and should use that, NOT the objects socket
-    # (which some of the comms with module functions will use by default).
-    def startStreamThread(self, module, fileName, fileMaxMB, streamName, streamAverage, releaseOnData, separator, streamDuration = None):                      
-        #Start module streaming and then read stream data
-
-        stripes = ['Empty Header']
-        #Send stream command so module starts streaming data into the backends buffer
-        streamRes = self.sendAndReceiveCmd(self.streamSock, 'rec stream', device=module, betweenCommandDelay = 0)
-        #printText(streamRes)
-        if ('rec stream : OK' in streamRes):
-            if (releaseOnData == False):
-                self.StreamRunSentSemaphore.release()
-                self.stripesEvent.clear()
-            self.deviceDict[module][0:3] = [False, 'Running', 'Stream Running']
-        else:
-            self.StreamRunSentSemaphore.release()
-            self.stripesEvent.clear()
-            self.deviceDict[module][0:3] = [True, 'Stopped', module + " couldn't start because " + streamRes]
-            return
-        #If recording to file then get header for file
-        if(fileName is not None):
-
-            baseSamplePeriod = self.streamHeaderAverage(device=module, sock=self.streamSock)
-            count=0
-            maxTries=10
-            while 'Header Not Available' in baseSamplePeriod:
-                baseSamplePeriod = self.streamHeaderAverage(device=module, sock=self.streamSock)
-                time.sleep(0.1)
-                count += 1
-                if count > maxTries:
-                    self.deviceDict[module][0:3] = [True, 'Stopped', 'Header not available']
-                    exit()
-            version =  self.streamHeaderVersion(device=module, sock=self.streamSock)
-            with open(fileName, 'w') as f:
-                timeStampHeader = datetime.datetime.now().strftime("%H:%M:%S:%f %d/%m/%y")
-                formatHeader = self.streamHeaderFormat(device=module, sock=self.streamSock)
-                formatHeader = formatHeader.replace(", ", separator)
-                f.write(formatHeader + '\n')
-        numStripesPerRead = 4096
-        maxFileExceeded = False
-        openAttempts = 0
-        leftover = 0
-        remainingStripes = []
-        streamOverrun = False
-        streamComplete = False
-
-        # baseSamplePeriod is a string in the form [int][unit]
-        # where the unit can be S,mS,uS,nS
-        # we need to convert it to a float number of seconds
-        # and we also derive the baseSampleUnits in string and numeric form
-        if 'ns' in baseSamplePeriod.lower():
-            baseSampleUnitText = 'ns'
-            baseSampleUnitExponent = -9
-        elif 'us' in baseSamplePeriod.lower():
-            baseSampleUnitText = 'us'
-            baseSampleUnitExponent = -6
-        elif 'ms' in baseSamplePeriod.lower():
-            baseSampleUnitText = 'ms'
-            baseSampleUnitExponent = -3
-        elif 'S' in baseSamplePeriod.lower():
-            baseSampleUnitText = 's'
-            baseSampleUnitExponent = 0
-        else:
-            raise ValueError("couldn't decode samplePeriod")
-
-        baseSamplePeriodS = int(re.search('^\d*\.?\d*', baseSamplePeriod).group())*(10**baseSampleUnitExponent)        
-
-        # TODO: MD Thinks this implements software averaging, is unused and now performed in QIS
-        if streamAverage != None:
-            #Matt converting streamAveraging into number
-            streamAverage = self.convertStreamAverage(streamAverage)
-
-            stripesPerAverage = float(streamAverage) / (float(baseSamplePeriod) * 4e-6)
-        isRun = True
-        while isRun:
-            try:
-                with open(fileName, 'ab') as f:
-                    # Until the event threadRunEvent is set externally to this thread,
-                    # loop and read from the stream
-                    i = self.deviceMulti(module)
-                    while self.stopFlagList[i] and (not streamOverrun) and (not streamComplete):
-                        #now = time.time()
-                        streamOverrun, removeChar, newStripes = self.streamGetStripesText(self.streamSock, module, numStripesPerRead)
-                        newStripes = newStripes.replace(b' ', str.encode(separator))
-                        #print (time.time() - now)
-                        if streamOverrun:
-                            self.deviceDict[module][0:3] = [True, 'Stopped', 'Device buffer overrun']
-                        # TODO: MD Why don't we return isEmpty in the tuple, instead of having this confusing test?
-                        if (removeChar == -6 and len(newStripes) == 6):
-                            isEmpty = True
-                        else:
-                            isEmpty = False
-                        if isEmpty == False:
-                            #Writes in file if not too big else stops streaming
-                            statInfo = os.stat(fileName)
-                            fileMB = statInfo.st_size / 1048576
-                            try:
-                                int(fileMaxMB)
-                            except:
-                                continue
-                            if int(fileMB) < int(fileMaxMB):
-                                if (releaseOnData == True):
-                                    self.StreamRunSentSemaphore.release()
-                                    self.stripesEvent.clear()
-                                    releaseOnData = False
-                                # TODO: MD Thinks this implements software averaging, is unused and now performed in QIS where required
-                                if(streamAverage != None):
-                                    leftover, remainingStripes = self.averageStripes(leftover, stripesPerAverage, newStripes[:removeChar], f, remainingStripes)
-                                else:
-                                    # if we have a fixed streamDuration
-                                    if streamDuration != None:
-                                        # Get the last data line in the file
-                                        lastLine = newStripes.splitlines()[-3]    # the last data line is followed by 'eof' and '>'
-                                        lastTime = lastLine.decode().split(separator)[0] # get the first (time) entry
-
-                                        # if the last entry is still within the required stream length, write the whole lot
-                                        if int(lastTime) < int(streamDuration/(10**baseSampleUnitExponent)): # < rather than <= because we start at 0
-                                            f.write(newStripes[:removeChar])
-                                        # else write each line individually until we have reached the desired endpoint
-                                        else:
-                                            for thisLine in newStripes.splitlines()[:-2]:
-                                                lastTime = thisLine.decode().split(separator)[0]
-                                                if int(lastTime) < int(streamDuration/(10**baseSampleUnitExponent)):
-                                                    f.write(thisLine + b'\r' + b'\n')  # Put the CR back on the end
-                                                else:
-                                                    streamComplete = True
-                                                    break
-                                    else:
-                                        f.write(newStripes[:removeChar])
-
-                            else:
-                                maxFileExceeded = True
-                                #printText('QisInterface file size exceeded  in loop 1- breaking')
-                                maxFileStatus = self.streamBufferStatus(device=module, sock=self.streamSock)
-                                f.write('Warning: Max file size exceeded before end of stream.\n')
-                                f.write('Unrecorded stripes in buffer when file full: ' + maxFileStatus + '.')
-                                self.deviceDict[module][0:3] = [True, 'Stopped', 'User defined max filesize reached']
-                                break
-                        else:
-                            # there's no stripes in the buffer - it's not filling up fast -
-                            # sleeps so we don't spam qis with requests (seems to make QIS crash)
-                            # it might be clever to change the sleep time accoring to the situation
-                            # e.g. wait longer with higher averaging or lots of no stripes in a row
-                            time.sleep(0.1)
-                            streamStatus = self.streamRunningStatus(device=module, sock=self.streamSock)
-                            if streamOverrun:
-                                #printText('QisInterface overrun - breaking')
-                                break
-                            elif "Stopped" in streamStatus:
-                                self.deviceDict[module][0:3] = [True, 'Stopped', 'User halted stream']
-                                break
-                    #printText('Left while 1')
-                    self.sendAndReceiveCmd(self.streamSock, 'rec stop', device=module, betweenCommandDelay = 0)
-                    if (not streamOverrun) and (not maxFileExceeded):
-                        self.deviceDict[module][0:3] = [False, 'Stopped', 'Stream stopped - emptying buffer']
-                    # print self.streamBufferStatus(device=module, sock=self.streamSock)
-                    if (not maxFileExceeded):
-                        #If the backend buffer still has data then keep reading it out
-                        #printText('Streaming stopped. Emptying data left in QIS buffer to file (' + self.streamBufferStatus(device=module, sock=self.streamSock) + ')')
-                        streamOverrun, removeChar, newStripes = self.streamGetStripesText(self.streamSock, module, numStripesPerRead)
-                        # TODO: Why don't we return isEmpty in the tuple, instead of having this confusing test?
-                        if (removeChar == -6 and len(newStripes) == 6):
-                            isEmpty = True
-                        else:
-                            isEmpty = False
-                        while isEmpty == False: # if newStripes has length 6 then it only contains 'eof\r\n'
-                            statInfo = os.stat(fileName)
-                            fileMB = statInfo.st_size / 1048576
-                            try:
-                                int(fileMaxMB)
-                            except:
-                                continue
-                            if int(fileMB) < int(fileMaxMB):
-                                if streamComplete != True:
-                                    if(streamAverage != None):
-                                        leftover, remainingStripes = self.averageStripes(leftover, stripesPerAverage, newStripes[:removeChar], f, remainingStripes)
-                                    else:
-                                        newStripes = newStripes.replace(b' ', str.encode(separator))
-                                        f.write(newStripes[:removeChar])
-                            else:
-                                if not maxFileExceeded:
-                                    maxFileStatus = self.streamBufferStatus(device=module,  sock=self.streamSock)
-                                    maxFileExceeded = True
-                                    self.deviceDict[module][0:3] = [True, 'Stopped', 'User defined max filesize reached']
-                                break
-                            #time.sleep(0.01) #reduce speed of loop to stop spamming qis
-                            streamOverrun, removeChar, newStripes = self.streamGetStripesText(self.streamSock, module, numStripesPerRead, skipStatusCheck=True)
-                            if removeChar == -6:
-                                if len(newStripes) == 6:
-                                    isEmpty = True
-                        if maxFileExceeded:
-                            f.write(b'Warning: Max file size exceeded before end of stream.\n')
-                            f.write(b'Unrecorded stripes in buffer when file full: ' + maxFileStatus + '.')
-                            logging.warning('Max file size exceeded. Some data has not been saved to file: ' + maxFileStatus + '.')
-
-                    #printText('Stripes in buffer now: ' + self.streamBufferStatus(device=module, sock=self.streamSock))
-
-                    if streamOverrun:
-                        self.deviceDict[module][0:3] = [True, 'Stopped', 'Device buffer overrun - QIS buffer empty']
-                    elif not maxFileExceeded:
-                        self.deviceDict[module][0:3] = [False, 'Stopped', 'Stream stopped']
-                    time.sleep(0.2)
-                    isRun = False
-            except IOError as err:
-                #printText('\n\n!!!!!!!!!!!!!!!!!!!! IO Error in QisInterface !!!!!!!!!!!!!!!!!!!!\n\n')
-                time.sleep(0.5)
-                openAttempts += 1
-                if openAttempts > 4:
-                    logging.error('\n\n!!!!!!!!!!!!!!!!!!!! Too many IO Errors in QisInterface !!!!!!!!!!!!!!!!!!!!\n\n')
-                    raise err
-
-        # This is the function that is ran when t1 is created. It is ran in a seperate thread from
-        # the main application so streaming can happen without blocking the main application from
-        # doing other things. Within this function/thread you have to be very careful not to try
-        # and 'communicate'  with anything from other threads. If you do, you MUST use a thread safe
-        # way of communicating. The thread creates it's own socket and should use that NOT the objects socket
-        # (which some of the comms with module functions will use by default).
-
-    def startStreamThreadQPS(self, module, fileName, fileMaxMB, streamName, streamAverage, releaseOnData, separator):
-
-        # Start module streaming and then read stream data
-        # self.sendAndReceiveCmd(self.streamSock, 'stream mode resample 10mS', device=module, betweenCommandDelay=0)
-        self.sendAndReceiveCmd(self.streamSock, 'stream mode header v3', device=module, betweenCommandDelay=0)
-        self.sendAndReceiveCmd(self.streamSock, 'stream mode power enable', device=module, betweenCommandDelay=0)
-        self.sendAndReceiveCmd(self.streamSock, 'stream mode power total enable', device=module, betweenCommandDelay=0)
-
-        self.qps_record_start_time = time.time() * 1000
-
-        stripes = ['Empty Header']
-        # Send stream command so module starts streaming data into the backends buffer
-        streamRes = self.sendAndReceiveCmd(self.streamSock, 'rec stream', device=module, betweenCommandDelay=0)
-        # printText(streamRes)
-        if ('rec stream : OK' in streamRes):
-            if (releaseOnData == False):
-                self.StreamRunSentSemaphore.release()
-                self.stripesEvent.clear()
-            self.deviceDict[module][0:3] = [False, 'Running', 'Stream Running']
-        else:
-            self.StreamRunSentSemaphore.release()
-            self.stripesEvent.clear()
-            self.deviceDict[module][0:3] = [True, 'Stopped', module + " couldn't start because " + streamRes]
-            return
-
-        # If recording to file then get header for file
-        if (fileName is not None):
-
-            baseSamplePeriod = self.streamHeaderAverage(device=module, sock=self.streamSock)
-            count = 0
-            maxTries = 10
-            while 'Header Not Available' in baseSamplePeriod:
-                baseSamplePeriod = self.streamHeaderAverage(device=module, sock=self.streamSock)
-                time.sleep(0.1)
-                count += 1
-                if count > maxTries:
-                    self.deviceDict[module][0:3] = [True, 'Stopped', 'Header not available']
-                    exit()
-            version = self.streamHeaderVersion(device=module, sock=self.streamSock)
-
-        numStripesPerRead = 4096
-        maxFileExceeded = False
-        openAttempts = 0
-        leftover = 0
-        remainingStripes = []
-        streamOverrun = False
-        if streamAverage != None:
-            # Matt converting streamAveraging into number
-            streamAverage = self.convertStreamAverage(streamAverage)
-
-            stripesPerAverage = float(streamAverage) / (float(baseSamplePeriod) * 4e-6)
-
-        isRun = True
-
-        self.create_dir_structure(module, fileName)
-
-        while isRun:
-            try:
-                # with open(fileName, 'ab') as f:
-                # Until the event threadRunEvent is set externally to this thread,
-                # loop and read from the stream
-                i = self.deviceMulti(module)
-                while self.stopFlagList[i] and (not streamOverrun):
-                    # now = time.time()
-                    streamOverrun, removeChar, newStripes = self.streamGetStripesText(self.streamSock, module,
-                                                                                      numStripesPerRead)
-                    newStripes = newStripes.replace(b' ', str.encode(separator))
-                    # print(newStripes)
-                    # print(len(newStripes))
-
-                    # print (time.time() - now)
-                    if streamOverrun:
-                        self.deviceDict[module][0:3] = [True, 'Stopped', 'Device buffer overrun']
-                    if (removeChar == -6 and len(newStripes) == 6):
-                        isEmpty = True
-                    else:
-                        isEmpty = False
-                    if isEmpty == False:
-                        # Writes in file if not too big else stops streaming
-                        # print(newStripes)
-
-                        x = newStripes[:removeChar]
-                        y = x.decode("utf-8")
-
-                        print(f"decoded stripe : {y}")
-
-                        # Writing multiple stripes
-                        if "\r\n" in y:
-                            y = y.split("\r\n")
-
-                            if self.has_digitals:
-                                # Write qps files for PAM
-                                for stripes in y:
-                                    if stripes:
-                                        stripe = stripes.split(",")
-                                        self.write_stripe_to_files_PAM(stripe)
-                            else:
-                                # Write qps files for PPM
-                                for stripes in y:
-                                    if stripes:
-                                        stripe = stripes.split(",")
-                                        self.write_stripe_to_files_HD(stripe)
-
-                        else:
-                            if self.has_digitals:
-                                # Write qps files for PAM
-                                for stripes in y:
-                                    if stripes:
-                                        stripe = stripes.split(",")
-                                        self.write_stripe_to_files_PAM(stripe)
-                            else:
-                                # Write qps files for PPM
-                                for stripes in y:
-                                    if stripes:
-                                        stripe = stripes.split(",")
-                                        self.write_stripe_to_files_HD(stripe)
-
-
-                    else:
-                        # there's no stripes in the buffer - it's not filling up fast -
-                        # sleeps so we don't spam qis with requests (seems to make QIS crash)
-                        # it might be clever to change the sleep time accoring to the situation
-                        # e.g. wait longer with higher averaging or lots of no stripes in a row
-                        time.sleep(0.1)
-                        streamStatus = self.streamRunningStatus(device=module, sock=self.streamSock)
-                        if streamOverrun:
-                            # printText('QisInterface overrun - breaking')
-                            break
-                        elif "Stopped" in streamStatus:
-                            self.deviceDict[module][0:3] = [True, 'Stopped', 'User halted stream']
-                            break
-
-                # printText('Left while 1')
-                self.sendAndReceiveCmd(self.streamSock, 'rec stop', device=module, betweenCommandDelay=0)
-
-                time.sleep(0.2)
-                isRun = False
-            except IOError as err:
-                # printText('\n\n!!!!!!!!!!!!!!!!!!!! IO Error in QisInterface !!!!!!!!!!!!!!!!!!!!\n\n')
-                time.sleep(0.5)
-                openAttempts += 1
-                if openAttempts > 4:
-                    logging.error(
-                        '\n\n!!!!!!!!!!!!!!!!!!!! Too many IO Errors in QisInterface !!!!!!!!!!!!!!!!!!!!\n\n')
-                    raise err
-
-        self.create_index_file()
-        if self.has_digitals:
-            self.create_index_file_digitals()
-
-        self.create_qps_file(module)
-
-    def write_stripe_to_files_HD(self, stripe):
-        # Cycle through items in stripe
-        for index, item in enumerate(stripe):
-            if index == 0:
-                continue
-            with open(os.path.join(self.qps_record_dir_path, "data000",
-                                   f"data000_00{index - 1}_000000000"),
-                      "ab") as file1:
-
-                x = struct.pack(">d", int(item))
-                # logging.debug(item, x)
-                file1.write(x)
-
-    def write_stripe_to_files_PAM(self, stripe):
-        # Note to reader - List should be ordered 1>x on analogue and digitals
-        counter = 0
-        for group in self.streamGroups.groups:
-            for i, channel in enumerate(group.channels):
-                # incrementing here so we skip stripe[0] which is time
-                counter += 1
-
-                x = i
-                while len(str(x)) < 3:
-                    x = "0" + str(x)
-
-                # Write all in group 0 to analogue
-                if group.group_id == 0:
-
-                    with open(os.path.join(self.qps_record_dir_path, "data000",
-                                           f"data000_{x}_000000000"),
-                              "ab") as file1:
-                        x = struct.pack(">d", int(stripe[counter]))
-                        # logging.debug(item, x)
-                        file1.write(x)
-                else:
-                    # Write all in group 1 to digital
-                    with open(os.path.join(self.qps_record_dir_path, "data101",
-                                           f"data101_{x}_000000000"),
-                              "ab") as file1:
-                        x = struct.pack(">d", int(stripe[counter]))
-                        # logging.debug(item, x)
-                        file1.write(x)
-
-
-    # Send text and get the backends response. - acts as wrapper to the sendAndReceiveText, intended to provide some extra convenience
-    # when sending commands to module (as opposed to back end)
-    # If read until cursor is set to True (which is default) then keep reading response until a cursor is returned as the last character of result string
-    # After command is sent wait for betweenCommandDelay which defaults to 0 but can be specified to add a delay between commands
-    # The objects connection needs to be opened (connect()) before this is used
-    def sendCmd(self, device='', cmd='$help', sock=None, readUntilCursor=True, betweenCommandDelay=0.0, expectedResponse = True):
-        if sock==None:
-            sock = self.sock
-        if not (device == ''):
-            self.deviceDictSetup(device)
-
-        if expectedResponse is False:
-            self.sendText(sock, cmd, device)
-            return
-
-        res =  self.sendAndReceiveText(sock, cmd, device, readUntilCursor)
-        if (betweenCommandDelay > 0):
-            time.sleep(betweenCommandDelay)
-        #If ends with cursor get rid of it
-        if res[-1:] == self.cursor:
-            res = res[:-3] #remove last three chars - hopefully '\r\n>'
-#        time.sleep(0.1)
-        return res.decode()
-     
-
-    def sendAndReceiveCmd(self, sock=None, cmd='$help', device='', readUntilCursor=True, betweenCommandDelay=0.0):
-        if sock==None:
-            sock = self.sock
-        if not (device == ''):
-            self.deviceDictSetup(device)
-        if self.pythonVersion == '3':
-            res =  self.sendAndReceiveText(sock, cmd, device, readUntilCursor).decode()
-        else:
-            res =  self.sendAndReceiveText(sock, cmd, device, readUntilCursor)
-        if (betweenCommandDelay > 0):
-            time.sleep(betweenCommandDelay)
-        #If ends with cursor get rid of it
-        if res[-1:] == '>':
-            res = res[:-3] #remove last three chars - hopefully '\r\n>'
-        return cmd + ' : ' + res
-    
-    # Send text to the back end then read it's response
-    # The objects connection needs to be opened (connect()) before this is used
-    # If read until cursor is set to True (which is default) then keep reading response until a cursor is returned as the last character of result string
-    def sendAndReceiveText(self, sock, sentText='$help', device='', readUntilCursor=True):
-        self.sockSemaphore.acquire()
-        try:
-            self.sendText(sock, sentText, device)
-            if self.pythonVersion == '3':
-                res = bytearray()
-                res.extend(self.rxBytes(sock))
-                #Somtimes we just get one cursor back of currently unknown origins
-                #If that happens discard it and read again
-                if len(res)==0:
-                    logging.warning("empty response from QIS. Retrying.")
-                    streamResp=self.sendAndReceiveText(sock, "stream?",device,readUntilCursor).lower()
-                    if len(streamResp)==0:
-                        raise("Empty response from QIS twice in a row")
-                    else:
-                        logging.warning("Response recovered Successfully. Continuing.")
-                        res = bytearray()
-                        res.extend(self.rxBytes(sock))
-                        if len(res) == 0:
-                            raise ("empty response from QIS after second ")
-                if res[0] == self.cursor:
-                    #res[0] = self.rxBytes(sock)
-                    logging.warning('Only Returned Cursor!!!!!')
-                #If create socked fail (between backend and tcp/ip module)
-                cba = 'Create Socket Fail'
-                if cba.encode() == res[0]:
-                    logging.warning(res[0].decode())
-                cba = 'Connection Timeout'
-                if cba.encode() == res[0]:
-                    logging.warning(res[0].decode())
-                #If reading until  a cursor comes back then keep reading until a cursor appears or max tries exceeded
-                if readUntilCursor:
-                    maxReads = 1000
-                    count = 1
-                    #check for cursor at end of read and if not there read again
-                    while res[-1:] != self.cursor:
-                        res.extend(self.rxBytes(sock))
-                        count += 1
-                        if count >= maxReads:
-                            raise Exception(' Count = Error: max reads exceeded before cursor returned')
-                return res
-            else:
-                res = self.rxBytes(sock)
-                #Somtimes we just get one cursor back of currently unknown origins
-                #If that happens discard it and read again
-                if res == self.cursor:
-                    #printText(" CURSOR ONLY")
-                    res = self.rxBytes(sock)
-                #If create socked fail (between backend and tcp/ip module)
-                if 'Create Socket Fail' in res:
-                    raise Exception(res)
-                if 'Connection Timeout' in res:
-                    raise Exception(res)
-                #If reading until  a cursor comes back then keep reading until a cursor appears or max tries exceeded
-                if readUntilCursor:
-                    maxReads = 1000
-                    count = 1
-                    #check for cursor at end of read and if not there read again
-                    while res[-1:] != self.cursor:
-                        res += self.rxBytes(sock)
-                        count += 1
-                        if count >= maxReads:
-                            raise Exception(' Count = Error: max reads exceeded before cursor returned')
-                return res
-                
-        except Exception as e:
-            raise e
-        finally:
-            self.sockSemaphore.release()
-
-    def rxBytes(self,sock):
-        #sock.setblocking(0) #make socket non-blocking
-        #printText('rxBytes')
-        maxExceptions=10
-        exceptions=0
-        maxReadRepeats=50
-        readRepeats=0
-        timeout_in_seconds = 10
-        #Keep trying to read bytes until we get some, unless number of read repeads or exceptions is exceeded
-        while True: 
-            try:
-                #select.select returns a list of waitable objects which are ready. On windows it has to be sockets.
-                #The first arguement is a list of objects to wait for reading, second writing, third 'exceptional condition'
-                #We only use the read list and our socket to check if it is readable. if no timeout is specified then it blocks until it becomes readable.
-                ready = select.select([sock], [], [], timeout_in_seconds)
-                #time.sleep(0.1)
-                #ready = [1,2]
-                if ready[0]:
-                    ret = sock.recv(self.maxRxBytes)
-                    #time.sleep(0.1)
-                    return ret
-                else:
-                    #printText('rxBytes - readRepeats + 1')
-                    
-                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                    sock.connect((self.host, self.port))
-                    sock.settimeout(5)
-
-                    try:
-                        welcomeString = self.sock.recv(self.maxRxBytes).rstrip()
-                        welcomeString = 'Connected@' + self.host + ':' + str(self.port) + ' ' + '\n    ' + welcomeString
-                        printText('New Welcome:' + welcomeString)
-                    except Exception as e:
-                        logging.error('tried and failed to get new welcome')
-                        raise e
-                        
-                    readRepeats=readRepeats+1
-                    time.sleep(0.5)
-
-            except Exception as e:
-                #printText('rxBytes - exceptions + 1')
-                exceptions=exceptions+1
-                time.sleep(0.5)
-                raise e
-            
-            #If read repeats has been exceeded we failed to get any data on this read.
-            #   !!! This is likely to break whatever called us !!!
-            if readRepeats >= maxReadRepeats:
-                logging.error('Max read repeats exceeded - returning.')
-                return 'No data received from QIS'
-            #If number of exceptions exceeded then give up by exiting
-            if exceptions >= maxExceptions:
-                logging.error('Max exceptions exceeded - exiting') #exceptions are probably 10035 non-blocking socket could not complete immediatley
-                exit()
-    
-    # Send text to the back end don't read it's response
-    # The objects connection needs to be opened (connect()) before this is used
-    def sendText(self, sock, message='$help', device=''):
-        if device != '':
-            specialTimeout =  '%500000'
-            message = device + specialTimeout +  ' ' + message
-            #printText('Sending: "' + message + '" ' + self.host + ':' + str(self.port))
-
-        if self.pythonVersion == 2:
-            sock.sendall(message + '\r\n')
-        else:
-            convM = message + '\r\n'
-            sock.sendall(convM.encode('utf-8'))
-        return 'Sent:' + message
-    
-    # Query the backend for a list of connected modules. A $scan command is sent to refresh the list of devices,
-    # Then a wait occurs while the backend discovers devices (network ones can take a while) and then a list of device name strings is returned
-    # The objects connection needs to be opened (connect()) before this is used
-    def getDeviceList(self, sock=None):
-
-        if sock == None:
-            sock = self.sock
-        scanWait = 2
-        #printText('Scanning for devices and waiting ' + str(scanWait) + ' seconds.')
-        if self.pythonVersion == '3':
-            #devString = self.sendAndReceiveText(sock, '$scan').decode
-            #time.sleep(scanWait)
-            devString = self.sendAndReceiveText(sock, '$list').decode()
-        else:
-            #devString = self.sendAndReceiveText(sock, '$scan')
-            #time.sleep(scanWait)
-            devString = self.sendAndReceiveText(sock, '$list')
-   
-        devString = devString.replace('>', '')            
-        devString = devString.replace(r'\d+\) ', '')   
-
-        #printText('"' + devString + '"')
-        devString = devString.split('\r\n')
-        devString = filter(None, devString) #remove empty elements
-        return devString
-
-    def get_list_details(self, sock=None):
-        if sock == None:
-            sock = self.sock
-        scanWait = 2
-        # printText('Scanning for devices and waiting ' + str(scanWait) + ' seconds.')
-        if self.pythonVersion == '3':
-            # devString = self.sendAndReceiveText(sock, '$scan').decode
-            # time.sleep(scanWait)
-            devString = self.sendAndReceiveText(sock, '$list details').decode()
-        else:
-            # devString = self.sendAndReceiveText(sock, '$scan')
-            # time.sleep(scanWait)
-            devString = self.sendAndReceiveText(sock, '$list details')
-
-        devString = devString.replace('>', '')
-        devString = devString.replace(r'\d+\) ', '')
-
-        # printText('"' + devString + '"')
-        devString = devString.split('\r\n')
-        devString = [x for x in devString if x]  # remove empty elements
-        return devString
-
-    def scanIP(QisConnection, ipAddress):
-        """
-        Triggers QIS to look at a specific IP address for a quarch module
-
-        Parameters
-        ----------
-        QisConnection : QpsInterface
-            The interface to the instance of QPS you would like to use for the scan.
-        ipAddress : str
-            The IP address of the module you are looking for eg '192.168.123.123'
-        sleep : int, optional
-            This optional variable sleeps to allow the network to scan for the module before allowing new commands to be sent to QIS.
-        """
-
-        logging.debug("Starting QIS IP Address Lookup at " + ipAddress)
-        if not ipAddress.lower().__contains__("tcp::"):
-            ipAddress = "TCP::" + ipAddress
-        response = "No response from QIS Scan"
-        try:
-            response = QisConnection.sendCmd(cmd="$scan " + ipAddress, expectedResponse=True)
-            # valid response is "Located device: 192.168.1.2"
-            if "located" in response.lower():
-                logging.debug(response)
-                # return the valid response
-                return response
-            else:
-                logging.warning("No module found at " + ipAddress)
-                logging.warning(response)
-                return response
-
-        except Exception as e:
-            logging.warning(e)
-            logging.warning("No module found at " + ipAddress)
-
-
-
-
-    def GetQisModuleSelection(self, favouriteOnly=True , additionalOptions=[], scan=True):
-        tableHeaders =["Modules"]
-        if scan :
-            foundDevices = self.qis_scan_devices(scan=scan, favouriteOnly=favouriteOnly)
-
-        myDeviceID = listSelection(title="Select a module",message="Select a module",selectionList=foundDevices,
-                                   additionalOptions= additionalOptions, nice=True, tableHeaders=tableHeaders,
-                                   indexReq=True)
-        return myDeviceID
-
-    def qis_scan_devices(self, scan=True, favouriteOnly=True):
-        deviceList = []
-        foundDevices = "1"
-        foundDevices2 = "2"  # this is used to check if new modules are being discovered or if all have been found.
-        scanWait = 2  # The number of seconds waited between the two scans.
-        if self.pythonVersion == '3':
-            if scan:
-                devString = self.sendAndReceiveText(self.sock, '$scan').decode
-                time.sleep(scanWait)
-                while foundDevices not in foundDevices2:
-                    foundDevices = self.sendAndReceiveText(self.sock, '$list').decode()
-                    time.sleep(scanWait)
-                    foundDevices2 = self.sendAndReceiveText(self.sock, '$list').decode()
-            else:
-                foundDevices = self.sendAndReceiveText(self.sock, '$list').decode()
-
-        else:
-            if scan:
-                devString = self.sendAndReceiveText(self.sock, '$scan')
-                time.sleep(scanWait)
-                while foundDevices not in foundDevices2:
-                    foundDevices = self.sendAndReceiveText(self.sock, '$list')
-                    time.sleep(scanWait)
-                    foundDevices2 = self.sendAndReceiveText(self.sock, '$list')
-            else:
-                foundDevices = self.sendAndReceiveText(self.sock, '$list')
-
-        if not "no devices found" in foundDevices.lower():
-            foundDevices = foundDevices.replace('>', '')
-            #foundDevices = foundDevices.replace(r'\d\) ', '')
-            # printText('"' + devString + '"')
-            foundDevices = foundDevices.split('\r\n')
-            #Can't stream over REST! Removing all REST connections.
-            tempList= list()
-            for item in foundDevices:
-                if item is None or "rest" in item.lower() or item == "":
-                    pass
-                else:
-                    tempList.append(item.split(")")[1].strip())
-            foundDevices = tempList
-
-            #If favourite only is True then only show one connection type for each module connected.
-            #First order the devices in preference type and then pick the first con type found for each module.
-            if (favouriteOnly):
-                foundDevices = self.sortFavourite(foundDevices)
-        else:
-            foundDevices = ["***No Devices Found***"]
-
-        return foundDevices
-
-    def sortFavourite(self, foundDevices):
-        index = 0
-        sortedFoundDevices = []
-        conPref = ["USB", "TCP", "SERIAL", "REST", "TELNET"]
-        while len(sortedFoundDevices) != len(foundDevices):
-            for device in foundDevices:
-                if conPref[index] in device.upper():
-                    sortedFoundDevices.append(device)
-            index += 1
-        foundDevices = sortedFoundDevices
-        # new dictionary only containing one favourite connection to each device.
-        favConFoundDevices = []
-        index = 0
-        for device in sortedFoundDevices:
-            if (favConFoundDevices == [] or not device.split("::")[1] in str(favConFoundDevices)):
-                favConFoundDevices.append(device)
-        foundDevices = favConFoundDevices
-        return foundDevices
-
-    # Query stream status for a device attached to backend
-    # The objects connection needs to be opened (connect()) before this is used
-    def streamRunningStatus(self, device, sock=None):
-        if sock == None:
-            sock = self.sock
-        index = 0 # index of relevant line in split string
-        if self.pythonVersion == '3':
-            streamStatus = self.sendAndReceiveText(sock, 'stream?', device).decode()
-        else:
-            streamStatus = self.sendAndReceiveText(sock, 'stream?', device)
-        streamStatus = streamStatus.split('\r\n')
-        streamStatus[index] = re.sub(r':', '', streamStatus[index]) #remove :
-        return streamStatus[index]
-
-    # Query stream buffer status for a device attached to backend
-    # The objects connection needs to be opened (connect()) before this is used
-    def streamBufferStatus(self, device, sock=None):
-        if sock == None:
-            sock = self.sock
-        index = 1 # index of relevant line in split string
-        if self.pythonVersion == '3':
-            streamStatus = self.sendAndReceiveText(sock, 'stream?', device).decode()
-        else:
-            streamStatus = self.sendAndReceiveText(sock, 'stream?', device)
-        streamStatus = streamStatus.split('\r\n')
-        streamStatus[index] = re.sub(r'^Stripes Buffered: ', '', streamStatus[index])
-        return streamStatus[index]
-    
-    # TODO: MD - This function should be replaced with a more generic method of accessing the header
-    # The return of a string with concatenated value and units should be replaced with something easier to parse
-    #
-    # Get the averaging used on the last/current stream
-    # The objects connection needs to be opened (connect()) before this is used
-    def streamHeaderAverage(self, device, sock=None):
-        try:
-            if sock == None:
-                sock = self.sock
-            index = 2 # index of relevant line in split string
-            if self.pythonVersion == '3':
-                streamStatus = self.sendAndReceiveText(sock, sentText='stream text header', device=device).decode()
-            else:
-                streamStatus = self.sendAndReceiveText(sock, sentText='stream text header', device=device)
-
-            self.qps_stream_header = streamStatus
-
-            # Check for the header format.  If XML, process here
-            if (self.isXmlHeader(streamStatus)):
-                # Get the basic averaging rate (V3 header)
-                xml_root = self.getStreamXmlHeader(device=device, sock=sock)
-
-                # For QPS streaming, stream header v3 command has already been issued before this
-                self.module_xml_header = xml_root
-
-                # Return the time based averaging string
-                device_period = xml_root.find('.//devicePeriod')
-                if device_period == None:
-                    device_period = xml_root.find('.//devicePerioduS')
-                    if device_period == None:
-                        device_period = xml_root.find('.//mainPeriod')
-                averageStr = device_period.text
-                return averageStr
-            # For legacy text headers, process here
-            else:
-                streamStatus = streamStatus.split('\r\n')
-                if('Header Not Available' in streamStatus[0]):
-                    dummy = streamStatus[0] + '. Check stream has been run on device.'
-                    return dummy
-                streamStatus[index] = re.sub(r'^Average: ', '', streamStatus[index])
-                avg = streamStatus[index]
-                avg = 2 ** int(avg)
-                return '{}'.format(avg)
-        except Exception as e:
-            logging.error(device + ' Unable to get stream average.' + self.host + ':' + str(self.port))
-            raise e
-    
-    # Get the version of the stream and convert to string for the specified device
-    # The objects connection needs to be opened (connect()) before this is used
-    def streamHeaderVersion(self, device, sock=None):
-        try:
-            if sock == None:
-                sock = self.sock
-            index = 0 # index of relevant line in split string
-            if self.pythonVersion == '3':
-                streamStatus = self.sendAndReceiveText(sock,'stream text header', device).decode()
-            else:
-                streamStatus = self.sendAndReceiveText(sock,'stream text header', device)
-            streamStatus = streamStatus.split('\r\n')
-            if 'Header Not Available' in streamStatus[0]:
-                str = streamStatus[0] + '. Check stream has been ran on device.'
-                logging.error(str)
-                return str
-            version = re.sub(r'^Version: ', '', streamStatus[index])
-            if version == '3':
-                version = 'Original PPM'
-            elif version == '4':
-                version = 'XLC PPM'
-            elif version == '5':
-                version = 'HD PPM'
-            else:
-                version = 'Unknown stream version'
-            return version
-        except Exception as e:
-            logging.error(device + ' Unable to get stream version.' + self.host + ':' + str(self.port))
-            raise e
-    
-    # Get a header string giving which measurements are returned in the string for the specified device
-    # The objects connection needs to be opened (connect()) before this is used
-    def streamHeaderFormat(self, device, sock=None):
-        try:
-            if sock == None:
-                sock = self.sock
-            index = 1 # index of relevant line in split string STREAM MODE HEADER [?|V1,V2,V3]
-            if self.pythonVersion == '3':
-                streamStatus = self.sendAndReceiveText(sock,'stream text header', device).decode()
-            else:
-                streamStatus = self.sendAndReceiveText(sock,'stream text header', device)
-            # Check if this is a new XML form header
-            if (self.isXmlHeader (streamStatus)):
-               # Get the basic averaging rate (V3 header)
-               xml_root = self.getStreamXmlHeader (device=device, sock=sock)
-               # Return the time based averaging string               
-               device_period = xml_root.find('.//devicePeriod')
-               time_unit = 'uS'
-               if device_period == None:
-                   device_period = xml_root.find('.//devicePerioduS')
-                   if device_period == None:
-                       device_period = xml_root.find('.//mainPeriod')
-                       if ('ns' in  device_period.text):
-                        time_unit = 'nS'
-               averageStr = device_period.text
-               
-               # Time column always first
-               formatHeader = 'Time ' + time_unit + ','
-               # Find the channels section of each group and iterate through it to add the channel columns
-               for group in xml_root.iter():
-                   if (group.tag == "channels"):
-                       for chan in group:
-                        # Avoid children that are not named channels
-                        if (chan.find('.//name') is not None):
-                            nameStr = chan.find('.//name').text
-                            unitStr = chan.find('.//units').text
-                            formatHeader = formatHeader +  nameStr + " " + unitStr + ","
-               return formatHeader
-            # Handle legacy text headers here
-            else:
-                streamStatus = streamStatus.split('\r\n')
-                if 'Header Not Available' in streamStatus[0]:
-                    str = streamStatus[0] + '. Check stream has been ran on device.'
-                    logging.error(str)
-                    return str
-                if self.pythonVersion == '3':
-                    outputMode = self.sendAndReceiveText(sock,'Config Output Mode?', device).decode()
-                    powerMode = self.sendAndReceiveText(sock,'stream mode power?', device).decode()
-                else:
-                    outputMode = self.sendAndReceiveText(sock,'Config Output Mode?', device)
-                    powerMode = self.sendAndReceiveText(sock,'stream mode power?', device)
-                format = int(re.sub(r'^Format: ', '', streamStatus[index]))
-                b0 = 1              #12V_I
-                b1 = 1 << 1         #12V_V
-                b2 = 1 << 2         #5V_I
-                b3 = 1 << 3         #5V_V
-                formatHeader = 'StripeNum, Trig, '
-                if format & b3:
-                    if ('3V3' in outputMode):
-                        formatHeader = formatHeader +  '3V3_V,'
-                    else:
-                        formatHeader = formatHeader +  '5V_V,'
-                if format & b2:
-                    if ('3V3' in outputMode):
-                        formatHeader = formatHeader +  ' 3V3_I,'
-                    else:
-                        formatHeader = formatHeader +  ' 5V_I,'
-                
-                if format & b1:
-                    formatHeader = formatHeader + ' 12V_V,'
-                if format & b0:
-                    formatHeader = formatHeader + ' 12V_I'
-                if 'Enabled' in powerMode:
-                    if ('3V3' in outputMode):
-                        formatHeader = formatHeader + ' 3V3_P'
-                    else:
-                        formatHeader = formatHeader + ' 5V_P'
-                    if ((format & b1) or (format & b0)):
-                        formatHeader = formatHeader + ' 12V_P'
-                return formatHeader
-        except Exception as e:
-            logging.error(device + ' Unable to get stream  format.' + self.host + ':' + '{}'.format(self.port))
-            raise e
-
-    # Get stripes out of the backends stream buffer for the specified device using text commands
-    # The objects connection needs to be opened (connect()) before this is used
-    def streamGetStripesText(self, sock, device, numStripes=4096, skipStatusCheck=False):
-
-        bufferStatus = False
-        # Allows the status check to be skipped when emptying the buffer after streaming has stopped (saving time)
-        if (skipStatusCheck == False):
-            if self.pythonVersion == '3':
-                streamStatus = self.sendAndReceiveText(sock, 'stream?', device).decode()
-            else:
-                streamStatus = self.sendAndReceiveText(sock, 'stream?', device)
-            if ('Overrun' in streamStatus) or ('8388608 of 8388608' in streamStatus):
-                bufferStatus = True
-        stripes = self.sendAndReceiveText(sock, 'stream text all', device, readUntilCursor=True)
-#            time.sleep(0.001)
-        if stripes[-1:] != self.cursor:
-            return "Error no cursor returned."
-        else:
-            if self.pythonVersion == '3':
-                endOfFile = 'eof\r\n>'
-                genEndOfFile = endOfFile.encode()
-            else:
-                genEndOfFile = 'eof\r\n>'
-            if stripes[-6:] == genEndOfFile:
-                removeChar = -6
-            else:
-                removeChar = -1
-
-        # stripes = stripes.split('\r\n')
-        # stripes = filter(None, stripes) #remove empty sting elements
-        #printText(stripes)
-        return bufferStatus, removeChar, stripes
-
-    def avgStringFromPwr(self, avgPwrTwo):
-        if(avgPwrTwo==0):
-            return '0'
-        elif(avgPwrTwo==1):
-            return '2'
-        elif(avgPwrTwo > 1 and avgPwrTwo < 10 ):
-            avg = 2 ** int(avgPwrTwo)
-            return '{}'.format(avg)
-        elif(avgPwrTwo==10):
-            return '1k'
-        elif(avgPwrTwo==11):
-            return '2k'
-        elif(avgPwrTwo==12):
-            return '4k'
-        elif(avgPwrTwo==13):
-            return '8k'
-        elif(avgPwrTwo==14):
-            return '16k'
-        elif(avgPwrTwo==15):
-            return '32k'
-        else:
-            return 'Invalid Average Value'
-    
-    # TODO: MD Thinks this implements software averaging, is unused and now performed in QIS
-    # Works out average values of timescales longer than max device averaging
-    def averageStripes(self, leftover, streamAverage, newStripes, f, remainingStripes = []):
-        newString = str(newStripes)
-        newList = []
-        if remainingStripes == []:
-            newList = newString.split('\r\n')
-        else:
-            newList = remainingStripes
-            newList.extend(newString.split('\r\n'))
-        numElements = newList[0].count(' ') + 1
-        streamTotalAverage = leftover + streamAverage
-        splitList = [] * numElements
-        if len(newList) < streamTotalAverage:
-            remainingStripes = newList[:-1]
-            return leftover, remainingStripes
-        runningAverage = [0] * (len(newList[0].split(' ')) - 2)
-        j = 0
-        z = 1
-        for i in newList[:-1]:
-            splitList = i.split(' ')
-            splitNumbers = [int(x) for x in splitList[2:]]
-            runningAverage = [sum(x) for x in zip(runningAverage, splitNumbers)]
-            if z == math.floor(streamTotalAverage):
-                finalAverage = splitList[0:2] + [str(round(x / streamAverage)) for x in runningAverage]
-                for counter in xrange(len(finalAverage)-1):
-                    finalAverage[counter] = finalAverage[counter] + ' '
-                if self.pythonVersion == '3':
-                    finalAverage = finalAverage.encode
-                for x in finalAverage:
-                    f.write(x)
-                f.write('\r\n')
-                streamTotalAverage += streamAverage
-                j += 1
-            z += 1
-        remainingStripes = newList[int(math.floor(j * streamAverage + leftover)):-1]
-        leftover = (streamTotalAverage - streamAverage) % 1
-        return leftover, remainingStripes
-
-    def deviceMulti(self, device):
-        if (device in self.deviceList):
-            return self.deviceList.index(device)
-        else:
-            self.listSemaphore.acquire()
-            self.deviceList.append(device)
-            self.stopFlagList.append(True)
-            self.listSemaphore.release()
-            return self.deviceList.index(device)
-    
-    def deviceDictSetup(self, module):
-        if module in self.deviceDict.keys():
-            return
-        elif module == 'QIS':
-            self.dictSemaphore.acquire()
-            self.deviceDict[module] = [False, 'Disconnected', "No attempt to connect to QIS yet"]
-            self.dictSemaphore.release()
-        else:
-            self.dictSemaphore.acquire()
-            self.deviceDict[module] = [False, 'Stopped', "User hasn't started stream"]
-            self.dictSemaphore.release()
-    
-    def streamInterrupt(self):
-        for key in self.deviceDict.keys():
-            if self.deviceDict[key][0]:
-                return True
-        return False
-    
-    def interruptList(self):
-        streamIssueList = []
-        for key in self.deviceDict.keys():
-            if self.deviceDict[key][0]:
-                streamIssue = [key] 
-                streamIssue.append(self.deviceDict[key][1])
-                streamIssue.append(self.deviceDict[key][2])
-                streamIssueList.append(streamIssue)
-        return streamIssueList
-    
-    def waitStop(self):
-        running = 1
-        while running != 0:
-            threadNameList = []
-            for t1 in threading.enumerate():
-                threadNameList.append(t1.name)
-            running = 0
-            for module in self.deviceList:
-                if (module in threadNameList):
-                    running += 1
-                    time.sleep(0.5)
-            time.sleep(1)
-
-    def convertStreamAverage (self, streamAveraging):
-        returnValue = 32000;
-        if ("k" in streamAveraging):
-            returnValue = streamAveraging.replace("k", "000")
-        else:
-            returnValue = streamAveraging
-
-        return returnValue
-        
-    # Pass in a stream header and we check if it is XML or legacy format
-    def isXmlHeader (self, headerText):
-        if('?xml version=' not in headerText):
-            return False;
-        else:
-            return True
-
-    # Internal function.  Gets the stream header and parses it into useful information
-    def getStreamXmlHeader (self, device, sock=None):
-        try:
-            if sock == None:
-                sock = self.sock
-            
-            # Get the raw data
-            if self.pythonVersion == '3':
-                headerData = self.sendAndReceiveText(sock, sentText='stream text header', device=device).decode()
-            else:
-                headerData = self.sendAndReceiveText(sock, sentText='stream text header', device=device)
-
-            # The XML can contain the cursor on the end!  Trap and remove it here TODO: Needs fixed in the command layer above
-            if ('\r\n>' in headerData):
-                headerData = headerData[:-1]
-            
-            # Check for no header (no stream started)
-            if('Header Not Available' in headerData):
-                logging.error(device + ' Stream header not available.' + self.host + ':' + str(self.port))
-                return None;
-                
-            # Check for XML format
-            if('?xml version=' not in headerData):
-                logging.error(device + ' Header not in XML form.' + self.host + ':' + str(self.port))
-                return None;
-                
-            # Parse XML into structured format
-            xml_root = ET.fromstring(headerData)            
-            
-            # Check header format is supported by quarchpy
-            versionStr = xml_root.find('.//version').text
-            if ('V3' not in versionStr):
-                logging.error(device + ' Stream header version not compatible: ' + xml_root['version'].text + '.' + self.host + ':' + str(self.port))
-                raise Exception ("Stream header version not supported");
-                
-            # Return the XML structure for the code to use
-            return xml_root
-            
-        except Exception as e:
-            logging.error(device + ' Exception while parsing stream header XML.' + self.host + ':' + str(self.port))
-            raise e
-
-    def create_dir_structure(self, module, directory=None):
-        """
-        Creates the QPS directory structure and (empty) files to be written to
-
-        I've put a bunch of try-except just to be sure the directory is correctly created.
-        ( There's probably a better way of doing this than this )
-
-        :param:    module: String  - Module string
-        :param: directory: String  - Name of directory for QPS stream (defaults to default recording location if invalid)
-        :return:  success: Boolean - Was the file structure created successfully?
-        """
-
-        directory = self.create_qps_directory(directory)
-
-        digital_count = 0
-        non_dig_counter = 0
-        self.streamGroups = StreamGroups()
-        for index, i in enumerate(self.module_xml_header.findall('.//channels')):
-            self.streamGroups.add_group(index)
-            for item in i.findall('.//channel'):
-                self.streamGroups.groups[index].add_channel(item.find(".//name"), item.find(".//group"), item.find(".//dataPosition"))
-                if item.find(".//group").text == "Digital":
-                    digital_count += 1
-                    self.has_digitals = True
-                else:
-                    non_dig_counter += 1
-
-        # Inner folders for analogue and digital signals streaming
-        in_folder_analogue = "data000"
-        try:
-            inner_path_analogues = os.path.join(directory, in_folder_analogue)
-            os.mkdir(inner_path_analogues)
-        except:
-            logging.warning(f"Failed to make inner directory for analogue signals {inner_path_analogues}")
-            return False
-
-        in_folder_digitals = "data101"
-        if self.has_digitals:
-            try:
-                inner_path_digitals = os.path.join(directory, in_folder_digitals)
-                os.mkdir(inner_path_digitals)
-            except:
-                logging.warning(f"Failed to make inner directory for digital signals {inner_path_digitals}")
-                return False
-
-        logging.debug(f"Steaming to : {self.qps_record_dir_path}")
-
-        logging.debug("Creating qps data files")
-        try:
-            for i in range(non_dig_counter):
-                file_name = f"data000_00{i}_000000000"
-                f = open(os.path.join(inner_path_analogues, file_name), "w")
-                f.close()
-            for i in range(digital_count):
-                x = i
-                while len(str(x)) < 3:
-                    x = "0" + str(x)
-                file_name = f"data101_{x}_000000000"
-                f = open(os.path.join(inner_path_digitals, file_name), "w")
-                f.close()
-        except:
-            logging.warning(f"failed to create qps data files for analogue signals")
-            return False
-
-        logging.debug("Finished creating qps data files")
-
-        logging.debug("Creating qps upper level files")
-        try:
-            file_names = ["annotations.xml", "notes.txt", "triggers.txt"]
-            for file_nome in file_names:
-                f = open(os.path.join(self.qps_record_dir_path, file_nome), "w")
-                f.close()
-        except Exception as err:
-            logging.warning(f"failed to create qps upper level files, {err}")
-            return False
-
-        try:
-            # Adding data000.idx separate as it's written in bytes not normal text
-            f = open(os.path.join(self.qps_record_dir_path, "data000.idx"), "wb")
-            f.close()
-            if digital_count > 0:
-                f = open(os.path.join(self.qps_record_dir_path, "data101.idx"), "wb")
-                f.close()
-        except Exception as err:
-            logging.warning(f"failed to create data000.idx file, {err}")
-            return False
-
-        logging.debug("Finished creating QPS dir structure")
-
-        return True
-
-    def create_qps_directory(self, directory):
-        folder_name = None
-        # Checking if there was a directory passed; and if it's a valid directory
-        if not directory:
-            directory = os.path.join(str(Path.home()), "AppData", "Local", "Quarch", "QPS", "Recordings")
-            logging.debug("No directory specified")
-        elif not os.path.isdir(directory):
-            new_dir = os.path.join(str(Path.home()), "AppData", "Local", "Quarch", "QPS", "Recordings")
-            logging.warning(f"{directory} was not a valid directory, streaming to default location: \n{new_dir}")
-            directory = new_dir
-        else:
-            # Split the directory into a path of folders
-            folder_name = str(directory).split(os.sep)
-            # last folder name is the name we want
-            folder_name = folder_name[-1]
-            # Make it known to the entire class that the path we're streaming to is the one sent across by the user
-            self.qps_record_dir_path = directory
-
-        # If no folder name for the stream was passed, then default to 'quarchpy_recording' and a timestamp
-        if not folder_name:
-            folder_name = "quarchpy_recording"
-            folder_name = f"{folder_name}-{time.time()}"
-            path = os.path.join(directory, self.qps_stream_folder_name)
-            os.mkdir(path)
-            self.qps_record_dir_path = path
-
-        self.qps_stream_folder_name = folder_name
-
-        return directory
-
-    def create_index_file(self):
-        """
-        Create the necessary index file for QPS data000.idx
-
-        For future revisions, this should be updated if there are file limits on each data file
-        Current implementation assumes only 1 of each data file are made.
-
-        No Return./
-        """
-
-        stream_header_size = -1
-
-        my_byte_array = []
-
-        # tree = ET.ElementTree(ET.fromstring(self.module_xml_header[:-1]))
-        tree = self.module_xml_header
-
-        return_b_array = []
-        outBuffer = []
-        x = 20
-        stream_header_size = 20
-
-        temp_dict = {"channels": 0}
-
-        return_b_array, stream_header_size = self.add_header_to_byte_array(return_b_array, stream_header_size,
-                                                                           temp_dict, tree, is_digital=False)
-
-        self.add_header_to_buffer(outBuffer, return_b_array, stream_header_size, temp_dict)
-
-        # Attempting to read the size of the first file in data files
-        file = os.path.join(self.qps_record_dir_path, "data000", "data000_000_000000000")
-        data = None
-        with open(file, "rb") as f:
-            data = f.read()  # if you only wanted to read 512 bytes, do .read(512)
-
-        if not data:
-            raise "No data written to file"
-
-        num_records = len(data) / 8
-        logging.debug(f"num_record = {num_records}")
-        return_b_array.append(int(num_records).to_bytes(4, byteorder='big'))
-
-        start_number = 0
-        logging.debug(f"start_record = {start_number}")
-        return_b_array.append(start_number.to_bytes(8, byteorder='big'))
-
-        num_records = num_records - 1
-        logging.debug(f"last_Record_number = {num_records}")
-        return_b_array.append(int(num_records).to_bytes(8, byteorder='big'))
-
-        # Add names of every file in data000 dir here.
-        files = os.listdir(os.path.join(self.qps_record_dir_path, "data000"))
-        for file3 in files:
-            # print(file)
-            item = strToBb(file3, False)
-            # print(item)
-            while len(item) < 32:
-                item.append("\x00")
-            # print(item)
-            return_b_array.append(item)
-
-        with open(os.path.join(self.qps_record_dir_path, "data000.idx"), "ab") as f:
-            for item in outBuffer:
-                # print(item)
-                # print(type(item))
-                f.write(bytes(item))
-            # f.write(outBuffer)
-
-        with open(os.path.join(self.qps_record_dir_path, "data000.idx"), "ab") as f:
-            self.write_b_array_to_idx_file(f, return_b_array)
-
-    def create_index_file_digitals(self):
-        """
-        Create the necessary index file for QPS data101.idx
-
-        For future revisions, this should be updated if there are file limits on each data file
-        Current implementation assumes only 1 of each data file are made.
-
-        No Return.
-        """
-
-        stream_header_size = -1
-        my_byte_array = []
-        tree = self.module_xml_header
-        return_b_array = []
-        outBuffer = []
-        temp_dict = {}
-
-        return_b_array, stream_header_size = self.add_header_to_byte_array(return_b_array, stream_header_size,
-                                                                           temp_dict, tree, is_digital=True)
-
-        self.add_header_to_buffer(outBuffer, return_b_array, stream_header_size, temp_dict)
-
-        # Attempting to read the size of the first file in data files
-        file = os.path.join(self.qps_record_dir_path, "data101", "data101_000_000000000")
-        data = None
-        with open(file, "rb") as f:
-            data = f.read()  # if you only wanted to read 512 bytes, do .read(512)
-
-        if not data:
-            raise "No data written to file"
-
-        num_records = len(data) / 8
-        logging.debug(f"num_record = {num_records}")
-        return_b_array.append(int(num_records).to_bytes(4, byteorder='big'))
-
-        start_number = 0
-        logging.debug(f"start_record = {start_number}")
-        return_b_array.append(start_number.to_bytes(8, byteorder='big'))
-
-        num_records = num_records - 1
-        logging.debug(f"last_Record_number = {num_records}")
-        return_b_array.append(int(num_records).to_bytes(8, byteorder='big'))
-
-        # Add names of every file in data000 dir here.
-        files = os.listdir(os.path.join(self.qps_record_dir_path, "data101"))
-        for file3 in files:
-            # print(file)
-            item = strToBb(file3, False)
-            # print(item)
-            while len(item) < 32:
-                item.append("\x00")
-            # print(item)
-            return_b_array.append(item)
-
-        with open(os.path.join(self.qps_record_dir_path, "data101.idx"), "ab") as f:
-            for item in outBuffer:
-                f.write(bytes(item))
-
-        with open(os.path.join(self.qps_record_dir_path, "data101.idx"), "ab") as f:
-            self.write_b_array_to_idx_file(f, return_b_array)
-
-    def add_header_to_byte_array(self, return_b_array, stream_header_size, temp_dict, tree, is_digital=False):
-        for element in tree:
-            if "legacyVersion" in element.tag:
-                intItem = element.text
-                temp_dict[element.tag] = intItem
-                # my_byte_array.append(int.to_bytes(intItem, 'big'))
-            if "legacyAverage" in element.tag:
-                intItem = element.text
-                temp_dict[element.tag] = intItem
-                # my_byte_array.append(int.to_bytes(intItem, 'big'))
-            if "legacyFormat" in element.tag:
-                intItem = element.text
-                temp_dict[element.tag] = intItem
-                # my_byte_array.append(int.to_bytes(intItem, 'big'))
-            if "mainPeriod" in element.tag:
-                intItem = element.text
-                intItem = intItem[:-2]
-                temp_dict[element.tag] = intItem
-            if "channels" in element.tag:
-                counter = 0
-                for child in element:
-                    for child2 in child:
-                        if "group" in child2.tag:
-                            if is_digital:
-                                if str(child2.text).lower() == "digital":
-                                    counter += 1
-                            else:
-                                if str(child2.text).lower() != "digital":
-                                    counter += 1
-
-                temp_dict[element.tag] = counter
-
-                return_b_array = []
-
-                stream_header_size = 20
-
-                # Cycle through all the channels.
-                for child in element:
-
-                    if child.tag == "groupId":
-                        continue
-
-                    if is_digital:
-                        # skip channel if we're only looking for digitals
-                        if not str(child.find(".//group").text).lower() == "digital":
-                            continue
-                    else:
-                        # skip if we're looking for analogues
-                        if str(child.find(".//group").text).lower() == "digital":
-                            continue
-
-                    # my_byte_array.append(int.to_bytes(5, 'big'))
-                    return_b_array.append(int(5).to_bytes(4, byteorder='big'))
-                    stream_header_size += 4
-                    name = None
-
-                    for child2 in child:
-
-                        if "group" in child2.tag:
-                            my_byte_array = strToBb(str(child2.text))
-                            return_b_array.append(my_byte_array)
-                            # QPS index file requires name tag come after group tag.
-                            return_b_array.append(name)
-                            stream_header_size += len(my_byte_array)
-
-                        if "name" in child2.tag:
-                            my_byte_array = strToBb(str(child2.text))
-                            name = my_byte_array
-                            stream_header_size += len(my_byte_array)
-
-                        if "units" in child2.tag:
-                            my_byte_array = strToBb(str(child2.text))
-                            return_b_array.append(my_byte_array)
-                            stream_header_size += len(my_byte_array)
-
-                            """
-                            # Unclear if the only thing here is TRUE
-                            bb = strToBB( Boolean.toString( cdr.isUsePrefixStr() ));
-                            bbList.add(bb);
-                            retVal += bb.capacity();
-                            """
-                            my_byte_array = strToBb(str("true"))
-                            return_b_array.append(my_byte_array)
-                            stream_header_size += len(my_byte_array)
-
-                        if "maxTValue" in child2.tag:
-                            my_byte_array = strToBb(str(child2.text))
-                            return_b_array.append(my_byte_array)
-                            stream_header_size += len(my_byte_array)
-
-        return return_b_array, stream_header_size
-
-    def add_header_to_buffer(self, outBuffer, return_b_array, stream_header_size, temp_dict):
-        number = 2
-        outBuffer.append(number.to_bytes(4, byteorder='big'))
-        logging.debug(f"indexVersion : {number}")
-
-        number = 1 if self.has_digitals else 0
-        outBuffer.append(number.to_bytes(4, byteorder='big'))
-        logging.debug(f"value0 : {number}")
-        number = stream_header_size
-        outBuffer.append(number.to_bytes(4, byteorder='big'))
-        logging.debug(f"header_size : {number}")
-        logging.debug(f"legacyVersion : {temp_dict['legacyVersion']}")
-        outBuffer.append(int(temp_dict["legacyVersion"]).to_bytes(4, byteorder='big'))
-        logging.debug(f"legacyAverage : {temp_dict['legacyAverage']}")
-        outBuffer.append(int(temp_dict["legacyAverage"]).to_bytes(4, byteorder='big'))
-        logging.debug(f"legacyFormat : {temp_dict['legacyFormat']}")
-        outBuffer.append(int(temp_dict["legacyFormat"]).to_bytes(4, byteorder='big'))
-        logging.debug(f"mainPeriod : {temp_dict['mainPeriod']}")
-        outBuffer.append(int(temp_dict["mainPeriod"]).to_bytes(4, byteorder='big'))
-        logging.debug(f"channels : {temp_dict['channels']}")
-        outBuffer.append(int(temp_dict["channels"]).to_bytes(4, byteorder='big'))
-        return_b_array.append(int(self.qps_record_start_time).to_bytes(8, byteorder='big'))
-        index_record_state = True
-        logging.debug(int(1))
-        return_b_array.append(int(1).to_bytes(1, byteorder='big'))
-        record_type = 1
-        logging.debug(f"record type : {int(index_record_state)}")
-        return_b_array.append(int(record_type).to_bytes(1, byteorder='big'))
-
-    def write_b_array_to_idx_file(self, f, return_b_array):
-        # print(return_b_array)
-        for item in return_b_array:
-            # print(item)
-            if isinstance(item, int):
-                # 'f.write(str(item).encode())
-                # print(item)
-                f.write(bytes([item]))
-                continue
-            if isinstance(item, bytes):
-                # print(item)
-                f.write(bytes(item))
-                continue
-            if isinstance(item, list):
-                for character in item:
-                    if isinstance(character, int):
-                        f.write(bytes([character]))
-                        continue
-                    elif isinstance(item, bytes):
-                        f.write(item)
-                        continue
-                    else:
-                        f.write(str(character).encode())
-                        continue
-
-    def create_qps_file(self, module):
-        """
-        Creates the end QPS file that is used to open QPS
-
-        :param module: Module QTL number that was used for the stream
-        :return:
-        """
-
-        with open(os.path.join(self.qps_record_dir_path, self.qps_stream_folder_name + ".qps"), "w") as f:
-            x = datetime.datetime.fromtimestamp(self.qps_record_start_time / 1000.0)
-            x = str(x).split(".")
-            x = x[0]
-            x = x.replace("-", " ")
-            f.write(f"Started: {x}\n")
-            f.write(f"Device: {module}\n")
-            f.write("Fixture: \n")
-
-            x = datetime.datetime.now()
-            x = str(x).split(".")
-            x = x[0]
-            x = x.replace("-", " ")
-            f.write(f"Saved: {x}\n")
-
-
-def strToBb(string_in, add_length=True):
-    length = len(str(string_in))
-    b_array = []
-    if add_length:
-        b_array.append(length)
-    for character in str(string_in):
-        b_array.append(character)
-
-    return b_array
+import gzip
+import re
+import socket
+import threading
+import xml.etree.ElementTree as ET
+from io import StringIO
+from typing import Tuple
+
+import select
+#from .connection_specific.StreamChannels import StreamGroups
+from .StreamChannels import StreamGroups
+
+from quarchpy.user_interface import *
+
+
+# QisInterface provides a way of connecting to a Quarch backend running at the specified ip address and port, defaults to localhost and 9722
+class QisInterface:
+    def __init__(self, host='127.0.0.1', port=9722, connectionMessage=True):
+        self.host = host
+        self.port = port
+        self.maxRxBytes = 4096
+        self.sock = None
+        self.StreamRunSentSemaphore = threading.Semaphore()
+        self.sockSemaphore = threading.Semaphore()
+        self.stopFlagList = []
+        self.listSemaphore = threading.Semaphore()
+        self.deviceList = []
+        self.deviceDict = {}
+        self.dictSemaphore = threading.Semaphore()
+        self.connect(connection_message = connectionMessage)
+        self.stripesEvent = threading.Event()
+
+        self.qps_stream_header = None
+        self.qps_record_dir_path = None
+        self.qps_record_start_time = None
+        self.qps_stream_folder_name = None
+
+        self.module_xml_header = None
+        self.streamGroups = None
+        self.has_digitals = False
+        self.is_multirate = False
+
+        self.streamSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.streamSock.settimeout(5)
+        self.streamSock.connect((self.host, self.port))
+        self.pythonVersion = sys.version[0]
+        self.cursor = '>'
+        #clear packets
+        welcome_string = self.streamSock.recv(self.maxRxBytes).rstrip()
+
+
+    def connect(self, connection_message: bool = True) -> str:
+        """
+        Opens the connection to the QIS backend
+
+        Args:
+            connection_message:
+                Defaults to True. If set to False, suppresses the warning message about an
+                instance already running on the specified port. This can be useful when
+                using `isQisRunning()` from `qisFuncs`.
+
+        Raises:
+        Exception:
+            If the connection fails or the welcome string is not received an exception is raised
+
+        Returns:
+            The welcome string received from the backend server upon a successful
+            connection.  This will confirm the QIS version but is generally not used other than
+            for debugging
+        """
+
+        try:
+            self.device_dict_setup('QIS')
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.sock.settimeout(5)
+            self.sock.connect((self.host, self.port))
+
+            #clear packets
+            try:
+                welcome_string = self.sock.recv(self.maxRxBytes).rstrip()
+                welcome_string = 'Connected@' + str(self.host) + ':' + str(self.port) + ' ' + '\n    ' + str(welcome_string)
+                self.deviceDict['QIS'][0:3] = [False, 'Connected', welcome_string]
+                return welcome_string
+            except Exception as e:
+                logger.error('No welcome received. Unable to connect to Quarch backend on specified host and port (' + self.host + ':' + str(self.port) + ')')
+                logger.error('Is backend running and host accessible?')
+                self.deviceDict['QIS'][0:3] = [True, 'Disconnected', 'Unable to connect to QIS']
+                raise e
+        except Exception as e:
+            self.device_dict_setup('QIS')
+            if connection_message:
+                logger.error('Unable to connect to Quarch backend on specified host and port (' + self.host + ':' + str(self.port) + ').')
+                logger.error('Is backend running and host accessible?')
+            self.deviceDict['QIS'][0:3] = [True, 'Disconnected', 'Unable to connect to QIS']
+            raise e
+
+
+    def disconnect(self) -> str:
+        """
+        Disconnects the current connection to the QIS backend.
+
+        This method attempts to gracefully disconnect from the backend server and updates
+        the connection state in the device dictionary. If an error occurs during the
+        disconnection process, the state is updated to indicate the failure, and the
+        exception is re-raised
+
+        Returns:
+            str: A message indicating that the disconnection process has started.
+
+        Raises:
+            Exception: Propagates any exception that occurs during the disconnection process.
+        """
+        res = 'Disconnecting from backend'
+        try:
+            self.sock.shutdown(socket.SHUT_RDWR)
+            self.sock.close()
+            self.deviceDict['QIS'][0:3] = [False, "Disconnected", 'Successfully disconnected from QIS']
+        except Exception as e:
+            exc_type, exc_obj, exc_tb = sys.exc_info()
+            fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
+            message = 'Unable to end connection. ' + self.host + ':' + str(self.port) + ' \r\n' + str(exc_type) + ' ' + str(fname) + ' ' + str(exc_tb.tb_lineno)
+            self.deviceDict['QIS'][0:3] = [True, "Connected", message]
+            raise e
+        return res
+
+    def close_connection(self, sock=None, con_string: str=None) -> str:
+        """
+        Orders QIS to release a given device (or all devices if no connection string is specified)
+        This is more important for TCP connected devices as the socket is held open until
+        specifically released.
+
+        Args:
+            sock:
+                The socket object to close the connection to. Defaults to the existing socket.
+            con_string:
+                Specify the device ID to close, otherwise all devices will be closed
+
+        Raises:
+            ConnectionResetError: Raised if the socket connection has already been reset.
+
+        Returns:
+            The response received after sending the close command. On success, this will be: 'OK'
+
+        """
+        if sock is None:
+            sock = self.sock
+        if con_string is None:
+            cmd = "close"
+        else:
+            cmd = con_string + " close"
+        try:
+            response = self.sendAndReceiveText(sock, cmd)
+            return response
+        except ConnectionResetError:
+            logger.error('Unable to close connection to device(s), QIS may be already closed')
+            return "FAIL: Unable to close connection to device(s), QIS may be already closed"
+
+    def start_stream(self, module: str, file_name: str, max_file_size: int, release_on_data: bool, separator: str,
+                     stream_duration: float=None, in_memory_data: StringIO=None, output_file_handle=None, use_gzip: bool=None,
+                     gzip_compress_level: int=9):
+        """
+        Begins a stream process which will record data from the module to a CSV file or in memory CSV equivalent
+
+        Args:
+            module:
+                The ID of the module for which the stream is being initiated.
+            file_name:
+                The target file path+name for storing the  streamed data in CSV form.
+            max_file_size:
+                The maximum size in megabytes allowed for the output file.
+            release_on_data:
+                If set, blocks further streams until this one has started
+            separator:
+                The value separator used to format the streamed CSV data.
+            stream_duration:
+                The duration (in seconds) for which the streaming process should run. Unlimited if None.
+            in_memory_data:
+                An in memory CSV StringIO as an alternate to file output
+            output_file_handle:
+                A file handle to an output file where the stream data is written as an alternate to a file name
+            use_gzip:
+                A flag indicating whether the output file should be compressed using gzip to reduce disk use
+
+        Returns:
+            None
+        """
+        self.StreamRunSentSemaphore.acquire()
+        self.device_dict_setup('QIS')
+        i = self.device_control_index(module)
+        self.stopFlagList[i] = True
+        self.stripesEvent.set()
+        self.module_xml_header = None
+
+        # Create the worker thread to handle stream processing
+        t1 = threading.Thread(target=self.start_stream_thread, name=module,
+                              args=(module, file_name, max_file_size, release_on_data, separator, stream_duration,
+                                    in_memory_data, output_file_handle, use_gzip, gzip_compress_level))
+        # Start the thread
+        t1.start()
+
+        while self.stripesEvent.is_set():
+            pass
+
+    def stop_stream(self, module, blocking:bool = True):
+        """
+
+        Args:
+            module:
+                The quarchPPM module instance for which the streaming process is to be stopped.
+            blocking:
+                If set to True, the function will block and wait until the module has
+                completely stopped streaming. Defaults to True.
+
+        Returns:
+            None
+
+        """
+
+        module_name=module.ConString
+        i = self.device_control_index(module_name)
+        self.stopFlagList[i] = False
+
+        # Wait until the stream thread is finished before returning to the user.
+        # This means this function will block until the QIS buffer is emptied by the second while
+        # loop in startStreamThread. This may take some time, especially at low averaging,
+        # but should guarantee the data won't be lost and QIS buffer is emptied.
+        if blocking:
+            running = True
+            while running:
+                thread_name_list = []
+                for t1 in threading.enumerate():
+                    thread_name_list.append(t1.name)
+                module_streaming= module.sendCommand("rec stream?").lower() #checking if module thinks its streaming.
+                module_streaming2= module.sendCommand("stream?").lower() #checking if the module has told qis it has stopped streaming.
+
+                if module_name in thread_name_list or "running" in module_streaming or "running" in module_streaming2:
+                    time.sleep(0.1)
+                else:
+                    running = False
+
+    def start_stream_thread(self, module: str, file_name: str, max_file_size: float, release_on_data: bool, separator: str,
+                          stream_duration: int=None, in_memory_data=None, output_file_handle=None, use_gzip: bool=False,
+                          gzip_compress_level: int=9):
+        """
+
+        Args:
+            module:
+                The name of the module from which data is to be streamed.
+            file_name:
+                The path to the file where streamed data will be written. Mandatory if neither an in-memory
+                buffer (in_memory_data) nor an external file handle (output_file_handle) is provided.
+            max_file_size:
+                The maximum permissible file size in MB. After reaching this limit, streaming to the current
+                file will stop
+            release_on_data:
+                True to prevent the stream lock from releasing until data has been received
+            separator:
+                Custom separator used to CSV data
+            stream_duration:
+                Duration of streaming in seconds, relative to the sampling period. Defaults to streaming
+                indefinitely.
+            in_memory_data:
+                An in-memory buffer of type StringIO to hold streamed data. If set, data is written here
+                instead of a file.
+            output_file_handle:
+                A pre-opened file handle where data will be written. If set, file_name is ignored.
+            use_gzip:
+                If True, writes streamed data to a gzip-compressed file.
+            gzip_compress_level:
+                (Default: 9) The compression level (0-9) to use for gzip.
+                1 is fastest with low compression. 9 is slowest with high compression.
+
+        Raises:
+        TypeError
+            If in_memory_data is passed but is not of type StringIO.
+        ValueError
+            If file_name is not provided and neither in_memory_data nor output_file_handle is given.
+            Also raised for invalid or undecodable sampling periods.
+
+        Returns:
+            None
+        """
+
+        f = None
+        max_mb_val = 0
+        file_opened_by_function = False  # True if this function opens the file
+        is_in_memory_stream = False  # True if using inMemoryData (StringIO)
+
+        # Output priority: 1. output_file_handle, 2. inMemoryData, 3. A new a file
+        if output_file_handle is not None:
+            f = output_file_handle
+            # Caller is responsible for the handle's mode (e.g., text/binary) and type.
+        elif in_memory_data is not None:
+            if not isinstance(in_memory_data, StringIO):
+                raise TypeError("Error! The parameter 'inMemoryData' must be of type StringIO.")
+            f = in_memory_data
+            is_in_memory_stream = True
+        else:
+            # No external handle or in-memory buffer, so open a file.
+            if not file_name:  # fileName is mandatory if we are to open a file.
+                raise ValueError("fie_name must be provided if output_file_handle and in_memory_data are None.")
+            file_opened_by_function = True
+            if use_gzip:
+                # Open in text mode ('wt'). Encoding 'utf-8' is a good default.
+                # gzip.open in text mode handles newline conversions.
+                f = gzip.open(f'{file_name}.gz', 'wt', encoding='utf-8', compresslevel=gzip_compress_level)
+            else:
+                # Open in text mode ('w').
+                # newline='' ensures that '\n' is written as '\n' on all platforms.
+                f = open(file_name, 'w', encoding='utf-8', newline='')
+
+        # Check for a valid max file size limit
+        if max_file_size is not None:
+            try:
+                max_mb_val = int(max_file_size)
+            except (ValueError, TypeError):
+                logger.warning(f"Invalid max_file_size parameter: {max_file_size}. No limit will be applied")
+                max_file_size = None
+
+        # Send stream command so the module starts streaming data into the backends buffer
+        stream_res = self.send_command('rec stream', device=module, qis_socket=self.streamSock)
+        # Check the stream started
+        if 'OK' in stream_res:
+            if not release_on_data:
+                self.StreamRunSentSemaphore.release()
+                self.stripesEvent.clear()
+            self.deviceDict[module][0:3] = [False, 'Running', 'Stream Running']
+        else:
+            self.StreamRunSentSemaphore.release()
+            self.stripesEvent.clear()
+            self.deviceDict[module][0:3] = [True, 'Stopped', module + " couldn't start because " + stream_res]
+            if file_opened_by_function and f:
+                try:
+                    f.close()
+                except Exception as e_close:
+                    logger.error(f"Error closing file {file_name} on stream start failure: {e_close}")
+            return
+
+        # Poll for the stream header to become available. This is needed to configure the output file
+        base_sample_period = self.stream_header_average(device=module, sock=self.streamSock)
+        count = 0
+        max_tries = 10
+        while 'Header Not Available' in base_sample_period:
+            base_sample_period = self.stream_header_average(device=module, sock=self.streamSock)
+            time.sleep(0.1)
+            count += 1
+            if count > max_tries:
+                self.deviceDict[module][0:3] = [True, 'Stopped', 'Header not available']
+                if file_opened_by_function and f:
+                    try:
+                        f.close()
+                    except Exception as e_close:
+                        logger.error(f"Error closing file {file_name} on header failure: {e_close}")
+                return  # Changed from exit() for cleaner thread termination
+
+        # Format the header and write it to the output file
+        format_header = self.stream_header_format(device=module, sock=self.streamSock)
+        format_header = format_header.replace(", ", separator)
+        f.write(format_header + '\n')
+
+        # Initialize stream variables
+        max_file_exceeded = False
+        open_attempts = 0
+        leftover = 0
+        remaining_stripes = []
+        stream_overrun = False
+        stream_complete = False
+        stream_status_str = ""
+
+        # Calculate and verify stripe rate information
+        if 'ns' in base_sample_period.lower():
+            base_sample_unit_exponent = -9
+        elif 'us' in base_sample_period.lower():
+            base_sample_unit_exponent = -6
+        elif 'ms' in base_sample_period.lower():
+            base_sample_unit_exponent = -3
+        elif 'S' in base_sample_period.lower():  # Original was 'S', assuming it means 's'
+            base_sample_unit_exponent = 0
+        else:
+            # Clean up and raise error if baseSamplePeriod is undecodable
+            if file_opened_by_function and f:
+                try:
+                    f.close()
+                except Exception as e_close:
+                    logger.error(f"Error closing file {file_name} due to ValueError: {e_close}")
+            raise ValueError(f"couldn't decode samplePeriod: {base_sample_period}")
+
+        base_sample_period_period_s = int(re.search(r'^\d*\.?\d*', base_sample_period).group()) * (10 ** base_sample_unit_exponent)
+
+        # Now we loop to process the stripes of data as they are available
+        is_run = True
+        while is_run:
+            try:
+                # Check for exit flags.  These can be from user request (stopFlagList) or from the stream
+                # process ending
+                i = self.device_control_index(module)
+                while self.stopFlagList[i] and (not stream_overrun) and (not stream_complete):
+
+                    # Read a block of stripes from QIS
+                    stream_status_str, new_stripes = self.stream_get_stripes_text(self.streamSock, module)
+
+                    # Overrun is a termination event where the stream stopped earlier than desired and must
+                    # be flagged to the user
+                    if "overrun" in stream_status_str:
+                        stream_overrun = True
+                        self.deviceDict[module][0:3] = [True, 'Stopped', 'Device buffer overrun']
+                    if "eof" in stream_status_str:
+                        stream_complete = True
+
+                    # Continue here if there are stripes to process
+                    if len(new_stripes) > 0:
+                        # switch in the correct value seperator
+                        new_stripes = new_stripes.replace(' ', separator)
+
+                        # Track the total size of the file here if needed
+                        if max_file_size is not None:
+                            current_file_mb = 0.0
+                            if is_in_memory_stream:
+                                current_file_mb = f.tell() / 1048576.0
+                            elif file_name:
+                                try:
+                                    # os.stat reflects the size on disk. For buffered writes (incl. gzip),
+                                    # this might not be the exact current unwritten buffer size + disk size
+                                    # without a flush, but it's an decent estimate.
+                                    stat_info = os.stat(file_name)
+                                    current_file_mb = stat_info.st_size / 1048576.0
+                                except FileNotFoundError:
+                                    current_file_mb = 0.0  # File might not exist yet or fileName is not locatable
+                                except Exception as e_stat:
+                                    logger.warning(f"Could not get file size for {file_name}: {e_stat}")
+                                    current_file_mb = 0.0  # Default to small size on error
+                            else:
+                                # output_file_handle was given, but fileName was None. Cannot check disk size.
+                                # Assume it's okay or managed by the caller. fileMaxMB check effectively bypassed.
+                                current_file_mb = 0.0
+
+                            # Flag the limit has been exceeded
+                            if current_file_mb > max_mb_val:
+                                max_file_exceeded = True
+                                max_file_status = self.stream_buffer_status(device=module, sock=self.streamSock)
+                                f.write('Warning: Max file size exceeded before end of stream.\n')
+                                f.write('Unrecorded stripes in buffer when file full: ' + max_file_status + '.\n')
+                                self.deviceDict[module][0:3] = [True, 'Stopped', 'User defined max filesize reached']
+                                break  # Exit stream processing loop
+
+                        # Release the stream semaphore now we have data
+                        if release_on_data:
+                            self.StreamRunSentSemaphore.release()
+                            self.stripesEvent.clear()
+                            release_on_data = False
+
+                        # If a duration has been set, track it based on the time of the last stripe
+                        if stream_duration is not None:
+                            last_line = new_stripes.splitlines()[-1]
+                            last_time = last_line.split(separator)[0]
+
+                            # Write all the stripes if we can
+                            if int(last_time) < int(stream_duration / (10 ** base_sample_unit_exponent)):
+                                f.write(new_stripes)
+                            # Otherwise only write stripes within the duration limit
+                            else:
+                                for this_line in new_stripes.splitlines():
+                                    this_time_str = this_line.split(separator)[0]
+                                    if int(this_time_str) < int(stream_duration / (10 ** base_sample_unit_exponent)):
+                                        f.write(this_line + '\r\n')  # Put the CR back on the end
+                                    else:
+                                        stream_complete = True
+                                        break
+                        # Default to writing all stripes
+                        else:
+                            f.write(new_stripes)
+                    # If we have no data
+                    else:
+                        if stream_overrun:
+                            break  # Exit stream processing loop
+                        elif "stopped" in stream_status_str:
+                            self.deviceDict[module][0:3] = [True, 'Stopped', 'User halted stream']
+                            break  # Exit stream processing loop
+                # End of stream data processing loop
+
+                # Ensure the stream is fully stopped, though standard exit cases should have ended it already
+                self.send_command('rec stop', device=module, qis_socket=self.streamSock)
+                stream_state = self.send_command('stream?', device=module, qis_socket=self.streamSock)
+                while "stopped" not in stream_state.lower():
+                    logger.debug("waiting for stream? to return stopped")
+                    time.sleep(0.1)
+                    stream_state = self.send_command('stream?', device=module, qis_socket=self.streamSock)
+
+                if stream_overrun:
+                    self.deviceDict[module][0:3] = [True, 'Stopped', 'Device buffer overrun - QIS buffer empty']
+                elif not max_file_exceeded:
+                    self.deviceDict[module][0:3] = [False, 'Stopped', 'Stream stopped']
+
+                is_run = False  # Exit main while loop
+            except IOError as err:
+                logger.error(f"IOError in startStreamThread for module {module}: {err}")
+
+                # Check if this error might be related to GZIP performance
+                if use_gzip:
+                    logger.warning(f"An IOError occurred while writing GZIP data for {module}.")
+                    logger.warning("This can happen at high data rates if compression is too slow for the I/O buffer.")
+                    logger.warning(f"Current compression level is {gzip_compress_level}. "
+                                    f"Consider re-running with a lower 'gzip_compress_level' (e.g., 6 or 1) "
+                                    "if this error persists.")
+
+                # File might have been closed by the system if it's a pipe and the other end closed or other severe errors.
+                # Attempt to close only if this function opened it, and it seems like it might be openable/closable.
+                if file_opened_by_function and f is not None:
+                    try:
+                        if not f.closed:
+                            f.close()
+                    except Exception as e_close:
+                        logger.error(f"Error closing file {file_name} during IOError handling: {e_close}")
+                    f = None  # Avoid trying to close again in finally if error persists
+
+                time.sleep(0.5)
+                open_attempts += 1
+                if open_attempts > 4:
+                    logger.error(f"Too many IOErrors in QisInterface for module {module}. Raising error.")
+                    # Set device status before raising, if possible
+                    self.deviceDict[module][0:3] = [True, 'Stopped', f'IOError limit exceeded: {err}']
+                    raise  # Re-raise the last IOError
+            finally:
+                if file_opened_by_function and f is not None:
+                    try:
+                        if not f.closed:  # Check if not already closed (e.g. in IOError block)
+                            f.close()
+                    except Exception as e_close:
+                        logger.error(f"Error closing file {file_name} in finally block: {e_close}")
+                # If output_file_handle was passed, the caller is responsible for closing.
+                # If inMemoryData was passed, it's managed by the caller.
+
+    def get_device_list(self, sock=None) -> filter:
+        """
+        returns a list of device IDs that are available for connection
+
+        Args:
+            sock:
+                Optional connection socket
+
+        Returns:
+            A filtered iterable list of devices
+
+        """
+
+        if sock is None:
+            sock = self.sock
+
+        dev_string = self.sendAndReceiveText(sock, '$list')
+        dev_string = dev_string.replace('>', '')
+        dev_string = dev_string.replace(r'\d+\) ', '')
+        dev_string = dev_string.split('\r\n')
+        dev_string = filter(None, dev_string) #remove empty elements
+
+        return dev_string
+
+    def get_list_details(self, sock=None) -> list:
+        """
+        Extended version of get_device_list which also returns the additional details
+        fields for each module
+
+        Args:
+            sock:
+                Optional connection socket
+        Returns:
+                Iterable list of strings containing the details of each device available for connection.
+
+        """
+        if sock is None:
+            sock = self.sock
+
+        dev_string = self.sendAndReceiveText(sock, '$list details')
+        dev_string = dev_string.replace('>', '')
+        dev_string = dev_string.replace(r'\d+\) ', '')
+        dev_string = dev_string.split('\r\n')
+        dev_string = [x for x in dev_string if x]  # remove empty elements
+        return dev_string
+
+    def scan_ip(self, qis_connection, ip_address) -> bool:
+        """
+        Triggers QIS to look at a specific IP address for a module
+
+        Arguments
+
+        QisConnection : QpsInterface
+            The interface to the instance of QIS you would like to use for the scan.
+        ipAddress : str
+            The IP address of the module you are looking for eg '192.168.123.123'
+        """
+
+        logger.debug("Starting QIS IP Address Lookup at " + ip_address)
+        if not ip_address.lower().__contains__("tcp::"):
+            ip_address = "TCP::" + ip_address
+        response = "No response from QIS Scan"
+        try:
+            response = qis_connection.send_command("$scan " + ip_address)
+            # The valid response is "Located device: 192.168.1.2"
+            if "located" in response.lower():
+                logger.debug(response)
+                # return the valid response
+                return True
+            else:
+                logger.warning("No module found at " + ip_address)
+                logger.warning(response)
+                return False
+
+        except Exception as e:
+            logger.warning("No module found at " + ip_address)
+            logger.warning(e)
+            return False
+
+
+    def get_qis_module_selection(self, preferred_connection_only=True, additional_options="DEF_ARGS", scan=True) -> str:
+        """
+        Scans for available modules and allows the user to select one through an interactive selection process.
+        Can also handle additional custom options and some built-in ones such as rescanning
+
+        Arguments:
+            preferred_connection_only : bool
+                by default (True), returns only one preferred connection eg: USB for simplicity
+            additional_options: list
+                Additional operational options provided during module selection, such as rescan,
+                all connection types, and IP scan. Defaults to ['rescan', 'all con types', 'ip scan']. These allow the
+                additional options to be given to the user and handled in the top level script
+            scan : bool
+                Indicates whether to initiate a rescanning process for devices before listing. Defaults to True and
+                will take longer to return
+
+        Returns:
+            str: The identifier of the selected module, or the action selected from the additional options.
+
+        Raises:
+            KeyError: Raised when unexpected keys are found in the scanned device data.
+            ValueError: Raised if no valid selection is made or the provided IP address is invalid.
+        """
+
+        # Avoid mutable warning by adding the argument list in the function rather than the header
+        if additional_options == "DEF_ARGS":
+            additional_options = ['rescan', 'all con types', 'ip scan']
+
+        table_headers = ["Modules"]
+        ip_address = None
+        favourite = preferred_connection_only
+        while True:
+            printText("Scanning for modules...")
+            found_devices = None
+            if scan and ip_address is None:
+                found_devices = self.qis_scan_devices(scan=scan, preferred_connection_only=favourite)
+            elif scan and ip_address is not None:
+                found_devices = self.qis_scan_devices(scan=scan, preferred_connection_only=favourite, ip_address=ip_address)
+
+            my_device_id = listSelection(title="Select a module",message="Select a module",
+                                          selectionList=found_devices, additionalOptions= additional_options,
+                                          nice=True, tableHeaders=table_headers, indexReq=True)
+
+            if my_device_id.lower() == 'rescan':
+                favourite = True
+                ip_address = None
+                continue
+            elif my_device_id.lower() == 'all con types':
+                favourite = False
+                printText("Displaying all connection types...")
+                continue
+            elif my_device_id.lower() == 'ip scan':
+                ip_address = requestDialog(title="Please input the IP Address you would like to scan")
+                favourite = False
+                continue
+            break
+
+        return my_device_id
+
+    def qis_scan_devices(self, scan=True, preferred_connection_only=True, ip_address=None) -> list:
+        """
+        Begins a scan for devices and returns a simple list of devices
+
+        Args:
+            scan:
+                Should a scan be initiated?  If False, the function will return immediately with the list
+            preferred_connection_only:
+                The default (True), returns only one preferred connection eg: USB for simplicity
+            ip_address:
+                IP address of the module you are looking for eg '192.168.123.123'
+
+        Returns:
+            list: List of module strings found during scan
+        """
+
+        device_list = []
+        found_devices = "1"
+        found_devices2 = "2"  # this is used to check if new modules are being discovered or if all have been found.
+        scan_wait = 2  # The number of seconds waited between the scan and the initial list
+        list_wait = 1  # The time between checks for new devices in the list
+
+        if scan:
+            # Perform the initial scan attempt
+            if ip_address is None:
+                dev_string = self.sendAndReceiveText(self.sock, '$scan')
+            else:
+                dev_string = self.sendAndReceiveText(self.sock, '$scan TCP::' + ip_address)
+            # Wait for devices to enumerate
+            time.sleep(scan_wait)
+            # While new devices are being found, extend the wait time
+            while found_devices not in found_devices2:
+                found_devices = self.sendAndReceiveText(self.sock, '$list')
+                time.sleep(list_wait)
+                found_devices2 = self.sendAndReceiveText(self.sock, '$list')
+        else:
+            found_devices = self.sendAndReceiveText(self.sock, '$list')
+
+        # If we found devices, process them into a list to return
+        if not "no devices found" in found_devices.lower():
+            found_devices = found_devices.replace('>', '')
+            found_devices = found_devices.split('\r\n')
+            # Can't stream over REST. Removing all REST connections.
+            temp_list= list()
+            for item in found_devices:
+                if item is None or "rest" in item.lower() or item == "":
+                    pass
+                else:
+                    temp_list.append(item.split(")")[1].strip())
+            found_devices = temp_list
+
+            # If the preferred connection only flag is True, then only show one connection type for each module connected.
+            # First, order the devices by their preference type and then pick the first con type found for each module.
+            if preferred_connection_only:
+                found_devices = self.sort_favourite(found_devices)
+        else:
+            found_devices = ["***No Devices Found***"]
+
+        return found_devices
+
+    def sort_favourite(self, found_devices) -> list:
+        """
+        Reduces the list of located devices by referencing to the preferred type of connection.  Only
+        one connection type will be returned for each module for easier user selection. ie: A module connected
+        on both USB and TCP will now only return with USB
+
+        Args:
+            found_devices:
+                List of located devices from a scan operation
+
+        Returns:
+            List of devices filtered/sorted devices
+        """
+
+        index = 0
+        sorted_found_devices = []
+        con_pref = ["USB", "TCP", "SERIAL", "REST", "TELNET"]
+        while len(sorted_found_devices) != len(found_devices):
+            for device in found_devices:
+                if con_pref[index] in device.upper():
+                    sorted_found_devices.append(device)
+            index += 1
+        found_devices = sorted_found_devices
+
+        # new dictionary only containing one favourite connection to each device.
+        fav_con_found_devices = []
+        index = 0
+        for device in sorted_found_devices:
+            if fav_con_found_devices == [] or not device.split("::")[1] in str(fav_con_found_devices):
+                fav_con_found_devices.append(device)
+        found_devices = fav_con_found_devices
+        return found_devices
+
+    def stream_running_status(self, device, sock=None) -> str:
+        """
+        returns a single word status string for a given device.  Generally this will be running, overrun, or stopped
+
+        Arguments
+
+        device : str
+            The device ID to target
+        sock:
+            The socket to communicate over, or None to use the default.
+
+        Returns:
+            str: Single word status string to show the operation of streaming
+        """
+        if sock is None:
+            sock = self.sock
+
+        index = 0
+        stream_status = self.sendAndReceiveText(sock, 'stream?', device)
+
+        # Split the response, select the first time and trim the colon
+        status_parts = stream_status.split('\r\n')
+        stream_status = re.sub(r':', '', status_parts[index])
+        return stream_status
+
+    def stream_buffer_status(self, device, sock=None) -> str:
+        """
+        returns the info on the stripes buffered during the stream
+
+        Arguments
+
+        device : str
+            The device ID to target
+        sock:
+            The socket to communicate over, or None to use the default.
+
+        Returns:
+            str: String with the numbers of stripes buffered
+        """
+        if sock is None:
+            sock = self.sock
+
+        index = 1
+        stream_status = self.sendAndReceiveText(sock, 'stream?', device)
+
+        # Split the response, select the second the info on the stripes buffered
+        status_lines = stream_status.split('\r\n')
+        stream_status = re.sub(r'^Stripes Buffered: ', '', status_lines[index])
+        return stream_status
+
+    # TODO: MD - This function should be replaced with a more generic method of accessing the header
+    # The return of a string with concatenated value and units should be replaced with something easier to parse
+    def stream_header_average(self, device, sock=None) -> str:
+        """
+        Gets the averaging used on the current stream, required for processing the stripe data returned from QIS
+
+        Arguments
+
+        device : str
+            The device ID to target
+        sock:
+            The socket to communicate over, or None to use the default.
+
+        Returns:
+            str: String with the rate and unit
+        """
+        try:
+            if sock is None:
+                sock = self.sock
+
+            index = 2 # index of relevant line in split string
+            stream_status = self.send_and_receive_text(sock, send_text='stream text header', device=device)
+
+            self.qps_stream_header = stream_status
+
+            # Check for the header format.  If XML, process here
+            if self.is_xml_header(stream_status):
+                # Get the basic averaging rate (V3 header)
+                xml_root = self.get_stream_xml_header(device=device, sock=sock)
+                self.module_xml_header = xml_root
+
+                # Return the time-based averaging string
+                device_period = xml_root.find('.//devicePeriod')
+                if device_period is None:
+                    device_period = xml_root.find('.//devicePerioduS')
+                    if device_period is None:
+                        device_period = xml_root.find('.//mainPeriod')
+                average_str = device_period.text
+                return average_str
+            # For legacy text headers, process here
+            else:
+                status_lines = stream_status.split('\r\n')
+                if 'Header Not Available' in status_lines[0]:
+                    dummy = status_lines[0] + '. Check stream has been run on device.'
+                    return dummy
+                average_str = re.sub(r'^Average: ', '', status_lines[index])
+                avg = average_str
+                avg = 2 ** int(avg)
+                return '{}'.format(avg)
+        except Exception as e:
+            logger.error(device + ' Unable to get stream average.' + self.host + ':' + str(self.port))
+            raise e
+
+    def stream_header_format(self, device, sock=None) -> str:
+        """
+        Formats the stream header for use at the top of a CSV file.  This adds the appropriate time column and
+        each of the channel data columns
+
+        Arguments
+
+        device:
+            The device ID to target
+        sock:
+            The socket to communicate over, or None to use the default.
+
+        Returns:
+            str: Get the CSV formatted header string for the current stream
+        """
+        try:
+            if sock is None:
+                sock = self.sock
+
+            index = 1
+            stream_status = self.sendAndReceiveText(sock,'stream text header', device)
+            # Check if this is an XML form header
+            if self.is_xml_header (stream_status):
+               # Get the basic averaging rate (V3 header)
+               xml_root = self.get_stream_xml_header (device=device, sock=sock)
+               # Return the time-based averaging string
+               device_period = xml_root.find('.//devicePeriod')
+               time_unit = 'uS'
+               if device_period is None:
+                   device_period = xml_root.find('.//devicePerioduS')
+                   if device_period is None:
+                       device_period = xml_root.find('.//mainPeriod')
+                       if 'ns' in  device_period.text:
+                        time_unit = 'nS'
+
+               # The time column always first
+               format_header = 'Time ' + time_unit + ','
+               # Find the channels section of each group and iterate through it to add the channel columns
+               for group in xml_root.iter():
+                   if group.tag == "channels":
+                       for chan in group:
+                        # Avoid children that are not named channels
+                            if (chan.find('.//name') is not None):
+                                name_str = chan.find('.//name').text
+                                group_str = chan.find('.//group').text
+                                unit_str = chan.find('.//units').text
+                                format_header = format_header +  name_str + " " + group_str + " " + unit_str + ","
+               format_header = format_header.rstrip(",")
+               return format_header
+            else:
+                stream_status = stream_status.split('\r\n')
+                if 'Header Not Available' in stream_status[0]:
+                    err_str = stream_status[0] + '. Check stream has been ran on device.'
+                    logger.error(err_str)
+                    return err_str
+                output_mode = self.sendAndReceiveText(sock,'Config Output Mode?', device)
+                power_mode = self.sendAndReceiveText(sock,'stream mode power?', device)
+                data_format = int(re.sub(r'^Format: ', '', stream_status[index]))
+                b0 = 1              #12V_I
+                b1 = 1 << 1         #12V_V
+                b2 = 1 << 2         #5V_I
+                b3 = 1 << 3         #5V_V
+                format_header = 'StripeNum, Trig, '
+                if data_format & b3:
+                    if '3V3' in output_mode:
+                        format_header = format_header +  '3V3_V,'
+                    else:
+                        format_header = format_header +  '5V_V,'
+                if data_format & b2:
+                    if '3V3' in output_mode:
+                        format_header = format_header +  ' 3V3_I,'
+                    else:
+                        format_header = format_header +  ' 5V_I,'
+
+                if data_format & b1:
+                    format_header = format_header + ' 12V_V,'
+                if data_format & b0:
+                    format_header = format_header + ' 12V_I'
+                if 'Enabled' in power_mode:
+                    if '3V3' in output_mode:
+                        format_header = format_header + ' 3V3_P'
+                    else:
+                        format_header = format_header + ' 5V_P'
+                    if (data_format & b1) or (data_format & b0):
+                        format_header = format_header + ' 12V_P'
+                return format_header
+        except Exception as e:
+            logger.error(device + ' Unable to get stream  format.' + self.host + ':' + '{}'.format(self.port))
+            raise e
+
+    def stream_get_stripes_text(self, sock, device: str) -> Tuple[str, str]:
+        """
+        Retrieve and process text data from a QIS stream.
+        We try to ready a block of data and also check for end of data and error cases
+
+        Args:
+            sock:
+                The socket instance used for communication with the device.
+            device:
+                The device ID string
+
+        Returns:
+            A tuple containing:
+            - The status of the data stream as a comma seperated list of status items
+            - The retrieved text data from the stream.
+        """
+
+        stream_status = "running"
+        is_end_of_block = False
+
+        # Try and read the next blocks of stripes from QIS
+        stripes = self.sendAndReceiveText(sock, 'stream text all', device)
+
+        # The 'eof' marker ONLY indicates that the full number of requested stripes was not available.
+        # More may be found later.
+        if stripes.endswith("eof\r\n>"):
+            is_end_of_block = True
+            stripes = stripes.rstrip("eof\r\n>")
+        if stripes.endswith("\r\n>"):
+            stripes= stripes[:-1] # remove the trailing ">"
+        # The current reader seems to lose the final line feeds, so check for this
+        if len(stripes) > 0:
+            if not stripes.endswith("\r\n"):
+                stripes += "\r\n"
+
+        # If there is an unusually small data set, check the stream status to make sure data is coming
+        # 7 is a little arbitrary, but smaller than any possible stripe size.  Over calling will not matter anyway
+        if len(stripes) < 7 or is_end_of_block:
+            current_status = self.sendAndReceiveText(sock, 'stream?', device).lower()
+            if "running" in current_status:
+                stream_status = "running"
+            elif "overrun" in current_status or "out of buffer" in current_status:
+                stream_status = "overrun"
+            elif "stopped" in current_status:
+                stream_status = "stopped"
+                # If the stream is stopped and at end of block, we have read all the data
+                if is_end_of_block:
+                    stream_status = stream_status + "eof"
+
+        return stream_status, stripes
+
+    def device_control_index(self, device) -> int:
+        """
+        Returns the index of the device in the control lists.  If the device is not
+        registered, then it is added first.  This is a key part of allowing us to
+        track the status of multiple streaming devices and manage them from outside
+        their streaming thread
+
+        Args:
+            device:
+                Device ID string
+        Returns:
+            Index of the device in the various control lists
+
+        """
+        if device in self.deviceList:
+            return self.deviceList.index(device)
+        else:
+            self.listSemaphore.acquire()
+            self.deviceList.append(device)
+            self.stopFlagList.append(True)
+            self.listSemaphore.release()
+            return self.deviceList.index(device)
+
+    def device_dict_setup(self, module) -> None:
+        """
+        Adds a dictionary entry for a new module we are connecting to (including the base QIS connection)
+        This is used for tracking the status of modules throughout the streaming process
+
+        Args:
+            module:
+
+        Returns:
+            None
+        """
+        if module in self.deviceDict.keys():
+            return
+        elif module == 'QIS':
+            self.dictSemaphore.acquire()
+            self.deviceDict[module] = [False, 'Disconnected', "No attempt to connect to QIS yet"]
+            self.dictSemaphore.release()
+        else:
+            self.dictSemaphore.acquire()
+            self.deviceDict[module] = [False, 'Stopped', "User hasn't started stream"]
+            self.dictSemaphore.release()
+
+    # Pass in a stream header and we check if it is XML or legacy format
+    def is_xml_header (self, header_text) -> bool:
+        """
+        Checks if the given header string is in XML format (as apposed to legacy text format) or an invalid string
+
+        Args:
+            header_text:
+                The header string to evaluate
+        Returns:
+            True if the header is in XML form
+
+        """
+        if '?xml version=' not in header_text:
+            return False
+        else:
+            return True
+
+    # Internal function.  Gets the stream header and parses it into useful information
+    def get_stream_xml_header (self, device, sock=None) -> ET.Element:
+        """
+        Gets the XML format header from an attached device (which must have run or be running a stream)
+        Parses the string into XML and returns the root element
+
+        Args:
+            device:
+                Device ID to return from
+            sock:
+                Optional QIS socket to use for communication.
+
+        Returns:
+
+        """
+        header_data = None
+
+        try:
+            if sock is None:
+                sock = self.sock
+            count = 0
+            while True:
+                if count > 5:
+                    break
+                count += 1
+                # Get the raw data
+                header_data = self.send_and_receive_text(sock, send_text='stream text header', device=device)
+
+                # Check for no header (no stream started)
+                if 'Header Not Available' in header_data:
+                    logger.error(device + ' Stream header not available.' + self.host + ':' + str(self.port))
+                    continue
+
+                # Check for XML format
+                if '?xml version=' not in header_data:
+                    logger.error(device + ' Header not in XML form.' + self.host + ':' + str(self.port))
+                    continue
+
+                break
+            # Parse XML into a structured format
+            xml_root = ET.fromstring(header_data)
+
+            # Check header format is supported by quarchpy
+            version_str = xml_root.find('.//version').text
+            if 'V3' not in version_str:
+                logger.error(device + ' Stream header version not compatible: ' + xml_root.find('version').text + '.' + self.host + ':' + str(self.port))
+                raise Exception ("Stream header version not supported")
+
+            # Return the XML structure for the code to use
+            return xml_root
+
+        except Exception as e:
+            logger.error(device + ' Exception while parsing stream header XML.' + self.host + ':' + str(self.port))
+            raise e
+
+    def send_command (self, command: str, device: str = '', qis_socket: socket.socket=None, no_cursor_expected: bool=False, no_response_expected: bool=False, command_delay: float=0.0) -> str:
+        """
+        Sends a command and returns the response as a string.  Multiple lines are escaped with CRLF.
+        The command is sent to the QIS socket, and depending on the command will be replied by either QIS
+        or the hardware module.
+
+        Args:
+            command:
+                Command string
+            device:
+                Optional Device ID string to send the command to. Use default/blank for QIS direct commands
+            qis_socket:
+                Optional Socket to use for the command, if the default is not wanted
+            no_cursor_expected:
+                Optional Flag true if the command does not return a cursor, so we should not wait for it
+            no_response_expected:
+                Optional Flag true if the command does not return a response, so we should not wait for it.
+            command_delay:
+                Optional delay to prevent commands running in close succession.  Timed in seconds.
+        Returns:
+            Command response string or None if no response expected
+        """
+        if qis_socket is None:
+            qis_socket = self.sock
+
+        if no_response_expected:
+            self.send_text(qis_socket, command, device)
+            return ""
+        else:
+            if not (device == ''):
+                self.device_dict_setup(device)
+            res = self.send_and_receive_text(qis_socket, command, device, not no_cursor_expected)
+
+            # This is a poor sleep mechanism!  Better would be to track time since the last command
+            if command_delay > 0:
+                time.sleep(command_delay)
+
+            # Trim the expected cursor at the end of the response
+            if res[-3:] == '\r\n>':
+                res = res[:-3]  # remove last three chars - '\r\n>'
+            elif res[-2:] == '\n>':
+                    res = res[:-2]  # remove last 2 chars - '\n>'
+            return res
+
+    def send_and_receive_text(self, sock, send_text='$help', device='', read_until_cursor=True) -> str:
+        """
+        Internal function for command handling.  This handles complex cases such as timeouts and XML
+        response formatting, which conflicts with the default cursor
+
+        Args:
+            sock:
+                The socket to communicate over
+            send_text:
+                The command text to send
+            device:
+                Optional device ID to send the command to
+            read_until_cursor:
+                Flag to indicate if we should read until the cursor is returned
+
+        Returns:
+            Response string from the module
+        """
+
+        # Avoid multiple threads trying to send at once. QIS only has a single socket for all devices
+        self.sockSemaphore.acquire()
+        try:
+            # Send the command
+            self.send_text(sock, send_text, device)
+            # Receive Response
+            res = self.receive_text(sock)
+            # If we get no response, log an error and try to flush using a simple stream query command
+            # If that works, we retry our command.  In fail cases we raise an exception and abort as
+            # the connection is bad
+            if len(res) == 0:
+                logger.error("Empty response from QIS for cmd: " + send_text + ". To device: " + device)
+                self.send_text(sock, "stream?", device)
+                res = self.receive_text(sock)
+                if len(res) != 0:
+                    self.send_text(sock, send_text, device)
+                    res = self.receive_text(sock)
+                    if len(res) == 0:
+                        raise (Exception("Empty response from QIS. Sent: " + send_text))
+                else:
+                    raise (Exception("Empty response from QIS. Sent: " + send_text))
+
+            if res[0] == self.cursor:
+                logger.error('Only returned a cursor from QIS. Sent: ' + send_text)
+                raise (Exception("Only returned a cursor from QIS. Sent: " + send_text))
+            if 'Create Socket Fail' == res[0]: # If create socked fail (between QIS and tcp/ip module)
+                logger.error(res[0])
+                raise (Exception("Failed to open QIS to module socked. Sent: " + send_text))
+            if 'Connection Timeout' == res[0]:
+                logger.error(res[0])
+                raise (Exception("Connection timeout from QIS. Sent: " + send_text))
+
+            # If reading until a cursor comes back, then keep reading until a cursor appears or max tries exceeded
+            # Because large XML responses are possible, we need to validate them as complete before looking
+            # for a final cursor
+            if read_until_cursor:
+
+                max_reads = 1000
+                count = 1
+                is_xml = False
+
+                while True:
+
+                    # Determine if the response is XML based on its start
+                    if count == 1:  # Only check this on the first read
+                        if res.startswith("<?xml"):  # Likely XML if it starts with '<'
+                            is_xml = True
+                        elif res.startswith("<XmlResponse"):
+                            is_xml = True
+
+
+                    if is_xml:
+                        # Try to parse the XML to check if it's complete
+                        try:
+                            ET.fromstring(res[:-1])  # If it parses, the response is complete
+                            return res[:-1]  # Exit the loop, valid XML received
+                        except ET.ParseError:
+                            pass  # Keep reading until XML is complete
+                    else:
+                        # Handle normal strings
+                        if res[-1:] == self.cursor:  # If the last character is '>', stop reading
+                            break
+
+                    # Receive more data
+                    res += self.receive_text(sock)
+
+                    # Increment count and check for max reads
+                    count += 1
+                    if count >= max_reads:
+                        raise Exception('Count = Error: max reads exceeded before response was complete')
+
+            return res
+
+        except Exception as e:
+            # Something went wrong during send qis cmd
+            logger.error("Error! Unable to retrieve response from QIS. Command: " + send_text)
+            logger.error(e)
+            raise e
+        finally:
+            self.sockSemaphore.release()
+
+    def receive_text(self, sock) -> str:
+        """
+        Received bytes from the socket and converts to a test string
+        Args:
+            sock:
+                Socket to communicate over
+
+        Returns:
+
+        """
+        res = bytearray()
+        res.extend(self.rx_bytes(sock))
+        res = res.decode()
+
+        return res
+
+    def send_text(self, sock, message='$help', device='') -> bool:
+        """
+
+        Args:
+            sock:
+                Socket to communicate over
+            message:
+                text command to send
+            device:
+                Optional device ID to target with the command
+
+        Returns:
+
+        """
+        # Send text to QIS, don't read its response
+        if device != '':
+            message = device + ' ' + message
+
+        conv_mess = message + '\r\n'
+        sock.sendall(conv_mess.encode('utf-8'))
+        return True
+
+    def rx_bytes(self,sock) -> bytes:
+        """
+        Reads an array of bytes from the socket as part of handling a command response
+
+        Args:
+            sock:
+                Socket to communicate over
+        Returns:
+            Bytes read
+
+        """
+
+        max_exceptions=10
+        exceptions=0
+        max_read_repeats=50
+        read_repeats=0
+        timeout_in_seconds = 10
+
+        #Keep trying to read bytes until we get some, unless the number of read repeats or exceptions is exceeded
+        while True:
+            try:
+                # Select.select returns a list of waitable objects which are ready. On Windows, it has to be sockets.
+                # The first argument is a list of objects to wait for reading, second writing, third 'exceptional condition'
+                # We only use the read list and our socket to check if it is readable. if no timeout is specified,
+                # then it blocks until it becomes readable.
+                # TODO: AN: It is very unclear why we try to open a new socket if data is not ready.
+                #   This would seem like a hard failure case!
+                ready = select.select([sock], [], [], timeout_in_seconds)
+                if ready[0]:
+                    ret = sock.recv(self.maxRxBytes)
+                    return ret
+                # If the socket is not ready for read, open a new one
+                else:
+                    logger.error("Timeout: No bytes were available to read from QIS")
+                    logger.debug("Opening new QIS socket")
+                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                    sock.connect((self.host, self.port))
+                    sock.settimeout(5)
+
+                    try:
+                        welcome_string = self.sock.recv(self.maxRxBytes).rstrip()
+                        welcome_string = 'Connected@' + self.host + ':' + str(self.port) + ' ' + '\n    ' + welcome_string
+                        logger.debug("Socket opened: " + welcome_string)
+                    except Exception as e:
+                        logger.error('Timeout: Failed to open new QIS socket and get the welcome message')
+                        raise e
+
+                    read_repeats=read_repeats+1
+                    time.sleep(0.5)
+
+            except Exception as e:
+                raise e
+
+            # If we read no data, its probably an error, but there may be cases where an empty response is valid
+            if read_repeats >= max_read_repeats:
+                logger.error('Max read repeats exceeded')
+                return b''
+
+    def closeConnection(self, sock=None, conString: str=None) -> str:
+        """
+        deprecated:: 2.2.13
+        Use `close_connection` instead.
+        """
+        return self.close_connection (sock=sock, con_string=conString)
+
+    def startStream(self, module: str, fileName: str, fileMaxMB: int, releaseOnData: bool, separator: str,
+                    streamDuration: int = None, inMemoryData=None, outputFileHandle=None, useGzip: bool = None,
+                    gzipCompressLevel: int = 9):
+        """
+        deprecated:: 2.2.13
+        Use `start_stream` instead.
+        """
+        return self.start_stream(module, fileName, fileMaxMB, releaseOnData, separator, streamDuration, inMemoryData,
+                                 outputFileHandle, useGzip, gzipCompressLevel)
+
+    def stopStream(self, module, blocking=True):
+        """
+        deprecated:: 2.2.13
+        Use `stop_stream` instead.
+        """
+        return self.stop_stream(module, blocking)
+
+    def getDeviceList(self, sock=None):
+        """
+        deprecated:: 2.2.13
+        Use `start_stream_thread_qps` instead.
+        """
+        return self.get_device_list(sock)
+
+    def scanIP(self, QisConnection, ipAddress):
+        """
+        deprecated:: 2.2.13
+        Use `scan_ip` instead.
+        """
+        return self.scan_ip(QisConnection, ipAddress)
+
+    def GetQisModuleSelection(self, favouriteOnly=True, additionalOptions=['rescan', 'all con types', 'ip scan'],
+                          scan=True):
+        """
+        deprecated:: 2.2.13
+        Use `get_qis_module_selection` instead.
+        """
+        return self.get_qis_module_selection(favouriteOnly, additionalOptions, scan)
+
+    def sendCommand(self, cmd, device="", timeout=20,sock=None,readUntilCursor=True, betweenCommandDelay=0.0, expectedResponse=True) -> str:
+        """
+        deprecated:: 2.2.13
+        Use `send_command` instead.
+        """
+        return self.send_command(cmd, device, sock, False, not expectedResponse, betweenCommandDelay)
+
+    def sendCmd(self, device='', cmd='$help', sock=None, readUntilCursor=True, betweenCommandDelay=0.0, expectedResponse = True) -> str:
+        """
+        deprecated:: 2.2.13
+        Use `send_command` instead.
+        """
+        return self.send_command(cmd, device, sock, not readUntilCursor, not expectedResponse, betweenCommandDelay)
+
+    def sendAndReceiveCmd(self, sock=None, cmd='$help', device='', readUntilCursor=True, betweenCommandDelay=0.0) -> str:
+        """
+        deprecated:: 2.2.13
+        Use `send_command` instead.
+        """
+        return self.send_command(cmd, device, sock, not readUntilCursor, no_response_expected=False, command_delay=betweenCommandDelay)
+
+    def streamRunningStatus(self, device: str) -> str:
+        """
+        deprecated:: 2.2.13
+        Use `stream_running_status` instead.
+        """
+        return self.stream_running_status(device)
+
+    def streamBufferStatus(self, device: str) -> str:
+        """
+        deprecated:: 2.2.13
+        Use `stream_buffer_status` instead.
+        """
+        return self.stream_buffer_status(device)
+
+    def streamHeaderFormat(self, device, sock=None) -> str:
+        """
+        deprecated:: 2.2.13
+        Use `stream_header_format` instead.
+        """
+        return self.stream_header_format(device, sock)
+
+    def streamInterrupt(self) -> bool:
+        """
+        deprecated:: 2.2.13
+        No indication this is used anywhere
+        """
+        for key in self.deviceDict.keys():
+            if self.deviceDict[key][0]:
+                return True
+        return False
+
+    def interruptList(self):
+        """
+        deprecated:: 2.2.13
+        No indication this is used anywhere
+        """
+        streamIssueList = []
+        for key in self.deviceDict.keys():
+            if self.deviceDict[key][0]:
+                streamIssue = [key]
+                streamIssue.append(self.deviceDict[key][1])
+                streamIssue.append(self.deviceDict[key][2])
+                streamIssueList.append(streamIssue)
+        return streamIssueList
+
+    def waitStop(self):
+        """
+        deprecated:: 2.2.13
+        No indication this is used anywhere
+        """
+        running = 1
+        while running != 0:
+            threadNameList = []
+            for t1 in threading.enumerate():
+                threadNameList.append(t1.name)
+            running = 0
+            for module in self.deviceList:
+                if (module in threadNameList):
+                    running += 1
+                    time.sleep(0.5)
+            time.sleep(1)
+
+    def convertStreamAverage (self, streamAveraging):
+        """
+        deprecated:: 2.2.13
+        No indication this is used anywhere
+        """
+        returnValue = 32000
+        if ("k" in streamAveraging):
+            returnValue = streamAveraging.replace("k", "000")
+        else:
+            returnValue = streamAveraging
+
+        return returnValue
+
+    def sendAndReceiveText(self, sock, sendText='$help', device='', readUntilCursor=True) -> str:
+        """
+        deprecated:: 2.2.13
+        Use `send_and_receive_text` instead.
+        """
+        return self.send_and_receive_text(sock, send_text=sendText, device=device, read_until_cursor=readUntilCursor)