source: trunk/Puzzlebox/Synapse/Session.py @ 393

Last change on this file since 393 was 393, checked in by sc, 8 years ago
  • updates for exporting ThinkGear? and Emotiv custom data headers
File size: 21.7 KB
Line 
1# -*- coding: utf-8 -*-
2
3# Copyright Puzzlebox Productions, LLC (2010-2012)
4#
5# This code is released under the GNU Pulic License (GPL) version 2
6# For more information please refer to http://www.gnu.org/copyleft/gpl.html
7
8__changelog__ = """\
9Last Update: 2012.05.07
10"""
11
12__todo__ = """
13"""
14
15### IMPORTS ###
16import os, sys, time
17
18import Puzzlebox.Synapse.Configuration as configuration
19
20if configuration.ENABLE_PYSIDE:
21        try:
22                import PySide as PyQt4
23                from PySide import QtCore, QtGui
24        except Exception, e:
25                print "ERROR: [Synapse:Session] Exception importing PySide:",
26                print e
27                configuration.ENABLE_PYSIDE = False
28        else:
29                print "INFO: [Synapse:Session] Using PySide module"
30
31if not configuration.ENABLE_PYSIDE:
32        print "INFO: [Synapse:Session] Using PyQt4 module"
33        from PyQt4 import QtCore, QtGui
34
35
36try:
37        import cPickle as pickle
38except:
39        import pickle
40
41
42#####################################################################
43# Globals
44#####################################################################
45
46DEBUG = configuration.DEBUG
47
48DEFAULT_SIGNAL_LEVEL_MESSAGE = \
49        {"poorSignalLevel": 0}
50                # A quantifier of the quality of the brainwave signal.
51                # This is an integer value that is generally in the
52                # range of 0 to 200, with 0 indicating a
53                # good signal and 200 indicating an off-head state.
54
55DEFAULT_EEG_POWER_MESSAGE = \
56        {"eegPower": { \
57                'delta': 0, \
58                'theta': 0, \
59                'lowAlpha': 0, \
60                'highAlpha': 0, \
61                'lowBeta': 0, \
62                'highBeta': 0, \
63                'lowGamma': 0, \
64                'highGamma': 0, \
65                }, \
66        } # A container for the EEG powers. These may
67          # be either integer or floating-point values.
68          # Maximum values are undocumented but assumed to be 65535
69
70DEFAULT_ESENSE_MESSAGE = \
71        {"eSense": { \
72                'attention': 0, \
73                'meditation': 0, \
74                }, \
75        } # A container for the eSense™ attributes.
76          # These are integer values between 0 and 100,
77          # where 0 is perceived as a lack of that attribute
78          # and 100 is an excess of that attribute.
79
80DEFAULT_BLINK_MESSAGE = {"blinkStrength": 255}
81        # The strength of a detected blink. This is
82        # an integer in the range of 0-255.
83
84DEFAULT_RAWEEG_MESSAGE = {"rawEeg": 255}
85        # The raw data reading off the forehead sensor.
86        # This may be either an integer or a floating-point value.
87
88DEFAULT_PACKET = {}
89DEFAULT_PACKET.update(DEFAULT_EEG_POWER_MESSAGE)
90DEFAULT_PACKET.update(DEFAULT_SIGNAL_LEVEL_MESSAGE)
91DEFAULT_PACKET.update(DEFAULT_ESENSE_MESSAGE)
92
93PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD = 0.75
94
95#####################################################################
96# Classes
97#####################################################################
98
99class puzzlebox_synapse_session(QtGui.QWidget):
100       
101        def __init__(self, log, \
102                     DEBUG=DEBUG, \
103                     parent=None, \
104                     ):
105               
106                self.log = log
107                self.DEBUG = DEBUG
108                self.parent=parent
109               
110                if self.parent == None:
111                        QtGui.QWidget.__init__(self, parent)
112                        #self.setupUi(self)
113               
114                        self.configureSettings()
115                        self.connectWidgets()
116               
117                self.name = "Synapse:Session"
118               
119               
120                if (sys.platform == 'win32'):
121                        self.homepath = os.path.join( \
122                           os.environ['HOMEDRIVE'], \
123                           os.environ['HOMEPATH'], \
124                           'Desktop')
125                elif (sys.platform == 'darwin'):
126                        desktop = os.path.join(os.environ['HOME'], 'Documents')
127                        if os.path.exists(desktop):
128                                self.homepath = desktop
129                        else:
130                                self.homepath = os.environ['HOME']
131                else:
132                        desktop = os.path.join(os.environ['HOME'], 'Desktop')
133                        if os.path.exists(desktop):
134                                self.homepath = desktop
135                        else:
136                                self.homepath = os.environ['HOME']
137               
138               
139                if not os.path.exists(self.homepath):
140                        if self.DEBUG:
141                                print "WARNING: [Synapse:Session] User default path not found"
142                        self.homepath = os.getcwd()
143       
144       
145        ##################################################################
146       
147        def configureSettings(self):
148               
149                pass
150       
151       
152        ##################################################################
153       
154        def connectWidgets(self):
155               
156                pass
157       
158       
159        ##################################################################
160       
161        def updateProfileSessionStatus(self, source=None, target=None):
162               
163                session_time = self.calculateSessionTime()
164               
165                #if source == None:
166                        #if self.parent == None:
167                                #source = self
168                        #else:
169                                #source = self.parent
170               
171                #if target == None:
172                        #if self.parent == None:
173                                #target = self
174                        #else:
175                                #target = self.parent
176               
177                #target.textLabelSessionTime.setText(session_time)
178                self.textLabelSessionTime.setText(session_time)
179               
180                try:
181                        #target.textLabelPacketsReceived.setText( "%i" % \
182                                #source.synapseServer.protocol.packet_count)
183                        self.textLabelPacketsReceived.setText( "%i" % \
184                                self.synapseServer.protocol.packet_count)
185                except:
186                        pass
187               
188                try:
189                        #target.textLabelPacketsDropped.setText( "%i" % \
190                                #source.synapseServer.protocol.bad_packets)
191                        self.textLabelPacketsDropped.setText( "%i" % \
192                                self.synapseServer.protocol.bad_packets)
193                except:
194                        pass
195       
196       
197        ##################################################################
198       
199        def calculateSessionTime(self):
200               
201                session_time = self.getSessionTime()
202               
203                session_time = time.time() - session_time
204                session_time = int(session_time)
205                session_time = self.convert_seconds_to_datetime(session_time)
206               
207                return (session_time)
208       
209       
210        ##################################################################
211       
212        def getSessionTime(self):
213               
214                return (self.synapseServer.session_start_timestamp)
215       
216       
217        ##################################################################
218       
219        def collectData(self, source=None, target=None):
220               
221                if source == None:
222                        if self.parent == None:
223                                source = self
224                        else:
225                                source = self.parent
226               
227                if target == None:
228                        if self.parent == None:
229                                target = self
230                        else:
231                                target = self.parent
232               
233                data = {}
234               
235                data['rawEeg'] = source.packets['rawEeg']
236                data['signals'] = source.packets['signals']
237               
238                data['sessionTime'] = self.calculateSessionTime()
239               
240                data['profileName'] = str(target.lineEditSessionProfile.text())
241               
242                return(data)
243       
244       
245        ##################################################################
246       
247        def parseTimeStamp(self, timestamp, local_version=False, truncate_time_zone=False):
248               
249                try:
250                        decimal = '%f' % timestamp
251                        decimal = decimal.split('.')[1]
252                except:
253                        decimal = '0'
254               
255                localtime = time.localtime(timestamp)
256               
257                if local_version:
258                        date = time.strftime('%x', localtime)
259                        localtime = time.strftime('%X', localtime)
260               
261                elif truncate_time_zone:
262                        date = time.strftime('%Y-%m-%d', localtime)
263                        localtime = time.strftime('%H:%M:%S', localtime)
264                        localtime = '%s.%s' % (localtime, decimal[:3])
265               
266                else:
267                        date = time.strftime('%Y-%m-%d', localtime)
268                        localtime = time.strftime('%H:%M:%S', localtime)
269                        localtime = '%s.%s %s' % (localtime, decimal, \
270                                       time.strftime('%Z', time.localtime(timestamp)))
271               
272               
273                return(date, localtime)
274       
275       
276        ##################################################################
277       
278        def saveData(self, source=None, target=None, output_file=None, use_default=False):
279               
280                if source == None:
281                        if self.parent == None:
282                                source = self
283                        else:
284                                source = self.parent
285               
286                if target == None:
287                        if self.parent == None:
288                                target = self
289                        else:
290                                target = self.parent
291               
292                data = self.collectData(source=source, target=target)
293               
294                (date, localtime) = self.parseTimeStamp(time.time())
295               
296                default_filename = '%s %s.synapse' % (date, \
297                                      target.lineEditSessionProfile.text())
298                                     
299                default_filename = os.path.join(self.homepath, default_filename)
300               
301                if output_file == None:
302                       
303                        # use_default controls whether or not a file is automatically saves using the
304                        # default name and path (as opposed to raising a GUI file selection menu)
305                        # whenever an explicit filepath is not defined
306                        if use_default:
307                                       
308                                        output_file = default_filename
309                       
310                        else:
311                       
312                                output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \
313                                                 caption="Save Session Data to File", \
314                                                 dir=default_filename, \
315                                                 filter="Puzzlebox Synapse Data File (*.synapse)")
316                               
317                                try:
318                                        output_file = output_file[0]
319                                except:
320                                        output_file = ''
321               
322               
323                if output_file == '':
324                        return
325               
326                file = open(str(output_file), 'w')
327                pickle.dump(data, file)
328                file.close()
329       
330       
331        ##################################################################
332       
333        def exportData(self, parent=None, source=None, target=None, output_file=None, use_default=False):
334               
335                if parent == None:
336                        if self.parent == None:
337                                parent = self
338                        else:
339                                parent = self.parent
340               
341                if source == None:
342                        if self.parent == None:
343                                source = self
344                        else:
345                                source = self.parent
346               
347                if target == None:
348                        if self.parent == None:
349                                target = self
350                        else:
351                                target = self.parent
352               
353               
354                (date, localtime) = self.parseTimeStamp(time.time())
355               
356                default_filename = '%s %s.csv' % (date, \
357                                      target.lineEditSessionProfile.text())
358               
359                default_filename = os.path.join(target.homepath, default_filename)
360               
361               
362                if output_file == None:
363                       
364                        # use_default controls whether or not a file is automatically saves using the
365                        # default name and path (as opposed to raising a GUI file selection menu)
366                        # whenever an explicit filepath is not defined
367                        if use_default:
368                                       
369                                        output_file = default_filename
370                       
371                        else:
372                                output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \
373                                                 caption="Export Session Data to File", \
374                                                 dir=default_filename, \
375                                                 filter="CSV File (*.csv);;Text File (*.txt)")
376                               
377                                try:
378                                        output_file = output_file[0]
379                                except:
380                                        output_file = ''
381               
382               
383                if output_file == '':
384                        return
385               
386               
387                if str(output_file).endswith('.csv'):
388                       
389                        outputData = self.exportDataToCSV(parent=parent, source=source, target=target)
390               
391               
392                else:
393                       
394                        try:
395                                outputData = self.textEditDebugConsole.toPlainText()
396                        except:
397                                outputData = self.exportDataToCSV()
398               
399               
400                file = open(str(output_file), 'w')
401                file.write(outputData)
402                file.close()
403       
404       
405        ##################################################################
406       
407        #def exportDataToCSV(self, parent=None, source=None, target=None):
408               
409                #output = ''
410               
411                #if self.synapseServer != None:
412                        ##output = self.synapseServer.exportDataToCSV(parent=self.parent, source=self)
413                        #output = self.synapseServer.exportDataToCSV(parent=parent, source=source, target=target)
414               
415                #else:
416                       
417                        #if self.DEBUG:
418                                #print "ERROR: exportDataToCSV exists in synapseServer object which is not in use"
419               
420                #return(output)
421       
422       
423        ##################################################################
424       
425        def exportDataToCSV(self, parent=None, source=None, target=None):
426               
427                # handle importing class from multiple sources
428                if parent == None:
429                        if self.parent == None:
430                                parent = self
431                        else:
432                                parent = self.parent
433               
434                if source == None:
435                        if self.parent == None:
436                                source = self
437                        else:
438                                source = self.parent
439               
440                if target == None:
441                        if self.parent == None:
442                                target = self
443                        else:
444                                target = self.parent
445               
446                try:
447                        truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE
448                except:
449                        truncate_csv_timezone = False
450               
451               
452                # NOTE: no need to scrub emulated data
453                try:
454                        scrub_data = target.configuration.EXPORT_CSV_SCRUB_DATA
455                except:
456                        scrub_data = False
457               
458                try:
459                        if self.parent.plugin_eeg.emulate_headset_data:
460                                scrub_data = False
461                except:
462                        pass
463               
464               
465                headers = 'Date,Time'
466                #headers = headers + ','
467                #headers = 'Date,Time,Attention,Meditation,Signal Level,Delta,Theta,Low Alpha,High Alpha,Low Beta,High Beta,Low Gamma,Mid Gamma'
468                #headers = headers + 'Attention,Meditation,Signal Level,Delta,Theta,Low Alpha,High Alpha,Low Beta,High Beta,Low Gamma,Mid Gamma'
469                #headers = self.customDataHeaders
470               
471                customDataHeaders = []
472                for header in parent.customDataHeaders:
473                        customDataHeaders.append(header)
474                for plugin in parent.activePlugins:
475                        print plugin.name
476                        for header in plugin.customDataHeaders:
477                                customDataHeaders.append(header)
478               
479                for each in customDataHeaders:
480                        headers = headers + ',%s' % each
481               
482                headers = headers + '\n'
483               
484               
485                csv = {}
486               
487                for packet in source.packets['signals']:
488                       
489                       
490                        # NOTE: Move this to ThinkGear Server object
491                        if 'rawEeg' in packet.keys():
492                                continue
493                       
494                       
495                        if packet['timestamp'] not in csv.keys():
496                               
497                                #if 'blinkStrength' in packet.keys():
498                                        ## Skip any blink packets from log
499                                        #continue
500                               
501                               
502                                timestamp = packet['timestamp']
503                                #(date, localtime) = self.parseTimeStamp(timestamp, \
504                                                    #truncate_time_zone=truncate_csv_timezone)
505                                (date, localtime) = source.parseTimeStamp(timestamp, \
506                                                    truncate_time_zone=truncate_csv_timezone)
507                               
508                                csv[timestamp] = {}
509                                csv[timestamp]['Date'] = date
510                                csv[timestamp]['Time'] = localtime
511                               
512                               
513                                for plugin in parent.activePlugins:
514                                        if plugin.customDataHeaders != []:
515                                                #try:
516                                                csv[timestamp] = plugin.processPacketForExport(output=csv[timestamp], packet=packet)
517
518                                                #print "csv[timestamp]:",
519                                                #print csv[timestamp]
520                                                #except Exception, e:
521                                                        #if self.DEBUG:
522                                                                #print "ERROR: [Synapse:Session] Exception calling processPacketForExport on",
523                                                                #print plugin.name
524                               
525                               
526                                #csv[timestamp]['Attention'] = ''
527                                #csv[timestamp]['Meditation'] = ''
528                                #csv[timestamp]['Signal Level'] = ''
529                                #csv[timestamp]['Delta'] = ''
530                                #csv[timestamp]['Theta'] = ''
531                                #csv[timestamp]['Low Alpha'] = ''
532                                #csv[timestamp]['High Alpha'] = ''
533                                #csv[timestamp]['Low Beta'] = ''
534                                #csv[timestamp]['High Beta'] = ''
535                                #csv[timestamp]['Low Gamma'] = ''
536                                #csv[timestamp]['Mid Gamma'] = ''
537                               
538                                #for header in customDataHeaders:
539                                        #csv[timestamp][header] = ''
540                       
541                       
542                        #if 'eSense' in packet.keys():
543                                #if 'attention' in packet['eSense'].keys():
544                                        #csv[timestamp]['Attention'] = packet['eSense']['attention']
545                                #if 'meditation' in packet['eSense'].keys():
546                                        #csv[timestamp]['Meditation'] = packet['eSense']['meditation']
547                       
548                        #if 'poorSignalLevel' in packet.keys():
549                                #csv[timestamp]['Signal Level'] = packet['poorSignalLevel']
550                       
551                        #if 'eegPower' in packet.keys():
552                                #if 'delta' in packet['eegPower'].keys():
553                                        #csv[timestamp]['Delta'] = packet['eegPower']['delta']
554                                #if 'theta' in packet['eegPower'].keys():
555                                        #csv[timestamp]['Theta'] = packet['eegPower']['theta']
556                                #if 'lowAlpha' in packet['eegPower'].keys():
557                                        #csv[timestamp]['Low Alpha'] = packet['eegPower']['lowAlpha']
558                                #if 'highAlpha' in packet['eegPower'].keys():
559                                        #csv[timestamp]['High Alpha'] = packet['eegPower']['highAlpha']
560                                #if 'lowBeta' in packet['eegPower'].keys():
561                                        #csv[timestamp]['Low Beta'] = packet['eegPower']['lowBeta']
562                                #if 'highBeta' in packet['eegPower'].keys():
563                                        #csv[timestamp]['High Beta'] = packet['eegPower']['highBeta']
564                                #if 'lowGamma' in packet['eegPower'].keys():
565                                        #csv[timestamp]['Low Gamma'] = packet['eegPower']['lowGamma']
566                                #if 'highGamma' in packet['eegPower'].keys():
567                                        #csv[timestamp]['Mid Gamma'] = packet['eegPower']['highGamma']
568                       
569                       
570                        for header in customDataHeaders:
571                               
572                                #if header in packet.keys():
573                                        #csv[timestamp][header] = packet[header]
574                               
575                                if 'custom' in packet.keys() and \
576                                   header in packet['custom'].keys():
577                                        csv[timestamp][header] = packet['custom'][header]
578               
579               
580                #print csv
581               
582               
583                if scrub_data:
584                        csv = self.scrubData(csv, truncate_csv_timezone, source=source)
585               
586               
587                output = headers
588               
589                timestamps = csv.keys()
590                timestamps.sort()
591               
592                for timestamp in timestamps:
593                       
594                        #row = '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s' % \
595                              #(csv[timestamp]['Date'], \
596                               #csv[timestamp]['Time'], \
597                               #csv[timestamp]['Attention'], \
598                               #csv[timestamp]['Meditation'], \
599                               #csv[timestamp]['Signal Level'], \
600                               #csv[timestamp]['Delta'], \
601                               #csv[timestamp]['Theta'], \
602                               #csv[timestamp]['Low Alpha'], \
603                               #csv[timestamp]['High Alpha'], \
604                               #csv[timestamp]['Low Beta'], \
605                               #csv[timestamp]['High Beta'], \
606                               #csv[timestamp]['Low Gamma'], \
607                               #csv[timestamp]['Mid Gamma'])
608                       
609                       
610                        #print csv[timestamp]
611                       
612                        row = '%s,%s' % \
613                              (csv[timestamp]['Date'], \
614                               csv[timestamp]['Time'])
615                       
616                        for header in customDataHeaders:
617                                row = row + ',%s' % csv[timestamp][header]
618                       
619                        row = row + '\n'
620                       
621                        output = output + row
622               
623               
624                return(output)
625       
626       
627        ##################################################################
628       
629        def scrubData(self, csv, truncate_csv_timezone=False, source=None):
630               
631                # If there are missing packets, repeat a given packet once per missing
632                # second until there is a gap between 1 and 2 seconds, in which case
633                # produce a final duplicate packet at the mid-point between the packets
634               
635                if self.DEBUG:
636                        print "INFO: Scrubbing Data"
637               
638                if source == None:
639                        if self.parent == None:
640                                source = self
641                        else:
642                                source = self.parent
643               
644                last_time = None
645                last_recorded_time = None
646               
647                output = {}
648               
649                csv_keys = csv.keys()
650                csv_keys.sort()
651               
652                for key in csv_keys:
653                       
654                        timestamp = key
655                       
656                        if last_time == None:
657                                # First entry in log
658                                last_time = timestamp
659                                last_recorded_time = timestamp
660                                #output[key] = csv[key]
661                                if key not in output.keys():
662                                        output[key] = DEFAULT_PACKET.copy()
663                                output[key].update(csv[key])
664                                continue
665                       
666                        else:
667                               
668                                #time_difference = timestamp - last_time
669                                #time_difference = timestamp - last_recorded_time
670                                time_difference = abs(timestamp - last_recorded_time)
671                               
672                                if (time_difference <= 1) and \
673                                   (time_difference >= PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD):
674                                        # Skip packets within the correct time threshold
675                                        last_time = timestamp
676                                        last_recorded_time = timestamp
677                                        #output[key] = csv[key]
678                                        if key not in output.keys():
679                                                output[key] = DEFAULT_PACKET.copy()
680                                        output[key].update(csv[key])
681                                       
682                                        #print "<=1 and >=min"
683                                        continue
684                               
685                                else:
686                                       
687                                        if self.DEBUG > 1:
688                                                print "time_difference:",
689                                                print time_difference
690                                                print "timestamp:",
691                                                print source.parseTimeStamp(timestamp)[-1].split(' ')[0]
692                                                print "last_time:",
693                                                print source.parseTimeStamp(last_time)[-1].split(' ')[0]
694                                                print "last_recorded_time:",
695                                                print source.parseTimeStamp(last_recorded_time)[-1].split(' ')[0]
696                                       
697                                       
698                                        #new_packet = csv[key].copy()
699                                        if key not in output.keys():
700                                                new_packet = DEFAULT_PACKET.copy()
701                                        new_packet.update(csv[key])
702                                       
703                                        if time_difference >= 2:
704                                               
705                                                ##new_time = last_time + 1
706                                                #new_time = last_recorded_time + 1
707                                               
708                                                count = int(time_difference)
709                                                while count >= 1:
710                                                        #new_packet = csv[key].copy()
711                                                        if key not in output.keys():
712                                                                new_packet = DEFAULT_PACKET.copy()
713                                                        new_packet.update(csv[key])
714                                                       
715                                                        new_time = last_recorded_time + 1
716                                                        (date, formatted_new_time) = source.parseTimeStamp(new_time, \
717                                                         truncate_time_zone=truncate_csv_timezone)
718                                                        new_packet['Time'] = formatted_new_time
719                                                        last_recorded_time = new_time
720                                                        last_time = timestamp
721                                                        if key not in output.keys():
722                                                                output[new_time] = new_packet
723                                                        else:
724                                                                output[new_time].update(new_packet)
725                                                        count = count - 1
726                                                continue
727                                       
728                                                #print ">=2"
729                                       
730                                       
731                                        elif time_difference < PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD:
732                                                # Spread out "bunched up" packets
733                                                #new_time = last_time + 1
734                                                new_time = last_recorded_time + 1
735                                                #new_time = last_recorded_time
736                                                #print "<min"
737                                       
738                                       
739                                        elif (time_difference < 2) and (time_difference > 1):
740                                               
741                                                #new_time = last_time + ((last_time - timestamp) / 2)
742                                                #new_time = last_recorded_time + ((last_recorded_time - timestamp) / 2)
743                                                #new_time = last_time + 1
744                                                #new_time = last_recorded_time + 1
745                                                new_time = last_recorded_time
746                                                #print "<2"
747                                       
748                                       
749                                        (date, formatted_new_time) = source.parseTimeStamp(new_time, \
750                                           truncate_time_zone=truncate_csv_timezone)
751                                       
752                                        new_packet['Time'] = formatted_new_time
753                                       
754                                        #last_time = new_time
755                                        last_recorded_time = new_time
756                                        #last_time = timestamp
757                                        last_time = new_time
758                                        try:
759                                                output[new_time].update(new_packet)
760                                        except Exception, e:
761                                                output[new_time] = new_packet
762                                                #print e
763                                       
764                                        if self.DEBUG > 1:
765                                                print "WARN: Scrubbing new packet:",
766                                                print new_packet
767                                                print
768               
769               
770                return(output)
771       
772       
773        ##################################################################
774       
775        def resetData(self, source=None):
776               
777                if source == None:
778                        if self.parent == None:
779                                source = self
780                        else:
781                                source = self.parent
782               
783                source.packets['rawEeg'] = []
784                source.packets['signals'] = []
785               
786                if self.synapseServer != None:
787                        self.synapseServer.protocol.resetSessionStartTime()
788                else:
789                        self.resetSessionStartTime()
790               
791                if self.synapseServer != None:
792                        source.synapseServer.protocol.packet_count = 0
793                        source.synapseServer.protocol.bad_packets = 0
794                else:
795                        source.packet_count = 0
796                        source.bad_packets = 0
797               
798                self.updateProfileSessionStatus()
799               
800                try:
801                        source.textEditDebugConsole.setText("")
802                except:
803                        pass
804       
805       
806        #####################################################################
807       
808        def resetSessionStartTime(self, source=None):
809               
810                self.session_start_timestamp = time.time()
811               
812               
813        #####################################################################
814       
815        def convert_seconds_to_datetime(self, duration):
816               
817                duration_hours = duration / (60 * 60)
818                duration_minutes = (duration - (duration_hours * (60 * 60))) / 60
819                duration_seconds = (duration - (duration_hours * (60 * 60)) - (duration_minutes * 60))
820               
821                duration_hours = '%i' % duration_hours
822                if (len(duration_hours) == 1):
823                        duration_hours = "0%s" % duration_hours
824               
825                duration_minutes = '%i' % duration_minutes
826                if (len(duration_minutes) == 1):
827                        duration_minutes = "0%s" % duration_minutes
828               
829                duration_seconds = '%i' % duration_seconds
830                if (len(duration_seconds) == 1):
831                        duration_seconds = "0%s" % duration_seconds
832               
833                datetime = '%s:%s:%s' % (duration_hours, duration_minutes, duration_seconds)
834               
835                return(datetime)
836
Note: See TracBrowser for help on using the repository browser.