예제 #1
0
 def set_create_time(self, create_time):
   self.create_time = create_time
   if self.create_time != None:
     self.create_ts = TimeStamp()
     self.create_ts.from_secs(create_time)
   else:
     self.create_ts = None
예제 #2
0
 def set_mod_time(self, mod_time):
     self.mod_time = mod_time
     if self.mod_time != None:
         self.mod_ts = TimeStamp()
         self.mod_ts.from_secs(mod_time)
     else:
         self.mod_ts = None
예제 #3
0
 def set_disk_time(self, disk_time):
   self.disk_time = disk_time
   if self.disk_time != None:
     self.disk_ts = TimeStamp()
     self.disk_ts.from_secs(disk_time)
   else:
     self.disk_ts = None
예제 #4
0
def newTimeStamp(old=None,
                 TimeStamp=TimeStamp.TimeStamp,
                 time=time.time, gmtime=time.gmtime):
    t = time()
    ts = TimeStamp(gmtime(t)[:5]+(t%60,))
    if old is not None:
        return ts.laterThan(old)
    return ts
예제 #5
0
파일: run.py 프로젝트: dibrian/poolsensor
def logValues():
    if count == len(sensors) - 1:
        log.temp(str(sensors[count].temp) + ";\n")
    else:
        log.temp(str(sensors[count].temp) + ";")
    log.prnt(TS.most(1) + ". " + sensors[count].name + ", homersekleti erteke: " + "{:.3f}".format(
        sensors[count].temp / float(1000)))
예제 #6
0
 def set_mod_time(self, mod_time):
   self.mod_time = mod_time
   if self.mod_time != None:
     self.mod_ts = TimeStamp()
     self.mod_ts.from_secs(mod_time)
   else:
     self.mod_ts = None
예제 #7
0
        #   GPIO.output(id,state)
        # #  GPIO.output(id,False);
        #  time.sleep(2)
        #  GPIO.output(id,True)
        return True
    except:
        return False


def mizu(id):
    try:
        # GPIO.setwarnings(False);
        # GPIO.setmode(GPIO.BCM);
        # GPIO.setup(id,GPIO.OUT);
        # state = GPIO.input(id)
        return True
    except:
        return str("lofasz")


if __name__ == '__main__':
    #time.sleep(5)
    id = 17

    if kapcs(id, True) == 1:
        print(TS.most(1) + "Rele kikapcsolva")
    else:
        print(
            TS.most(1) +
            "Gaz van, relet nem sikerult kikapcsolni, pedig megprobaltam")
예제 #8
0
파일: MetaInfo.py 프로젝트: moggen/amitools
class MetaInfo:
  def __init__(self, protect=None, mod_ts=None, comment=None):
    self.set_protect(protect)
    self.set_mod_ts(mod_ts)
    self.set_comment(comment)
  
  def __str__(self):
    res = []
    res.append(self.get_protect_str())
    res.append(self.get_time_str())
    res.append(self.get_comment_str())
    return "  ".join(res)
    
  def get_time_str(self):
    if self.mod_ts != None:
      return str(self.mod_ts)
    else:
      return ts_empty_string
      
  def get_protect_str(self):
    if self.protect_flags != None:
      return str(self.protect_flags)
    else:
      return ProtectFlags.empty_string
      
  def get_comment_str(self):
    if self.comment != None:
      return self.comment
    else:
      return ""
  
  def set_protect(self, protect):
    self.protect = protect
    if self.protect != None:
      self.protect_flags = ProtectFlags(protect)
    else:
      self.protect_flags = None
  
  def set_default_protect(self):
    self.protect = 0
    self.protect_flags = ProtectFlags(self.protect)
  
  def set_current_time(self):
    mod_time = time.mktime(time.localtime())
    self.set_mod_time(mod_time)
    
  def set_mod_time(self, mod_time):
    self.mod_time = mod_time
    if self.mod_time != None:
      self.mod_ts = TimeStamp()
      self.mod_ts.from_secs(mod_time)
    else:
      self.mod_ts = None
  
  def set_mod_ts(self, mod_ts):
    self.mod_ts = mod_ts
    if self.mod_ts != None:
      self.mod_time = self.mod_ts.get_secsf()
    else:
      self.mod_time = None
  
  def set_comment(self, comment):
    self.comment = comment
  
  def get_protect(self):
    return self.protect
  
  def get_protect_flags(self):
    return self.protect_flags
  
  def get_mod_time(self):
    return self.mod_time

  def get_mod_ts(self):
    return self.mod_ts
  
  def get_comment(self):
    return self.comment
예제 #9
0
class MetaInfo:
    def __init__(self, protect=None, mod_ts=None, comment=None):
        self.set_protect(protect)
        self.set_mod_ts(mod_ts)
        self.set_comment(comment)

    def __str__(self):
        res = []
        res.append(self.get_protect_str())
        res.append(self.get_time_str())
        res.append(self.get_comment_str())
        return "  ".join(res)

    def get_time_str(self):
        if self.mod_ts != None:
            return str(self.mod_ts)
        else:
            return ts_empty_string

    def get_protect_str(self):
        if self.protect_flags != None:
            return str(self.protect_flags)
        else:
            return ProtectFlags.empty_string

    def get_comment_str(self):
        if self.comment != None:
            return self.comment
        else:
            return ""

    def set_protect(self, protect):
        self.protect = protect
        if self.protect != None:
            self.protect_flags = ProtectFlags(protect)
        else:
            self.protect_flags = None

    def set_default_protect(self):
        self.protect = 0
        self.protect_flags = ProtectFlags(self.protect)

    def set_current_time(self):
        mod_time = time.mktime(time.localtime())
        self.set_mod_time(mod_time)

    def set_mod_time(self, mod_time):
        self.mod_time = mod_time
        if self.mod_time != None:
            self.mod_ts = TimeStamp()
            self.mod_ts.from_secs(mod_time)
        else:
            self.mod_ts = None

    def set_mod_ts(self, mod_ts):
        self.mod_ts = mod_ts
        if self.mod_ts != None:
            self.mod_time = self.mod_ts.get_secsf()
        else:
            self.mod_time = None

    def set_comment(self, comment):
        self.comment = comment

    def get_protect(self):
        return self.protect

    def get_protect_flags(self):
        return self.protect_flags

    def get_mod_time(self):
        return self.mod_time

    def get_mod_ts(self):
        return self.mod_ts

    def get_comment(self):
        return self.comment
예제 #10
0
    sensor = Sensor()
    sensor.id = '28-0417c2d68cff'
    sensor.name = "Medence (1)"
    sensor.temp = GetTemp.gettemp(sensor.id)
    sensors.append(sensor)

    sensor = Sensor()
    sensor.id = '28-0417c3b93dff'
    sensor.name = "Panel (1)"
    sensor.temp = GetTemp.gettemp(sensor.id)
    sensors.append(sensor)

    count = 0
    while count < len(sensors):
        log.prnt(
            TS.most(1) + sensors[count].name +
            " szenzor inicializálva, hőmérsékleti értéke: " +
            "{:.3f}".format(sensors[count].temp / float(1000)))
        count += 1

#  count = 0
#  while count < 2:
#      id = "28-0417c2d68cff"
#      sensor_new = Sensor(id,"ciklusbol_generalt %s" %(count),GetTemp.gettemp(id))
#      sensors.append(sensor_new)
#      count += 1

#print(sensor[0]name)

#  id = '28-0417c2d68cff'
#  mytemp_1 = GetTemp.gettemp(id);
예제 #11
0
def main():
    """Main body."""
    global timestamp_pattern

    # capture timing information
    cputime_0 = psutil.cpu_times()

    # Self-identification for the run
    # This gives us YYYY-MM-DDTHH:MM:SS+HH:MM
    ts0 = ts.TimeStamp()
    timestamp_pattern = ts0.get_recognizer_re()

    print "# analyze_pings.py"
    print "# analyze_pings.py: start: timestamp: " + ts0.get_timestamp()

    parser = argparse.ArgumentParser(description='Analyze a ping log')
    parser.add_argument('-f', nargs='?',\
            default='stdin', help="input file name")
    parser.add_argument('-v', nargs='?', default='command line',\
            help="git information about build state")
    parser.add_argument('-D', type=int, nargs='?',\
            default=0, help="Debug flag (int: default to 0)")
    args = parser.parse_args()
    input_file_name = args.f
    build_version = args.v

    print "# analyze_pings.py: build version:" + build_version
    print "# analyze_pings.py: input_file_name: " + input_file_name

    line_queue = LineQueue(4, input_file_name)
    # LineQueue returns a comment-structured self identification
    print line_queue.signature()

    # Initialize the counters
    classifications = [
                       "Comment",
                       "Down",
                       "GWFailure",
                       "Initialization",
                       "NegativeRTT",
                       "Normal",
                       "Route",
                       "RTTTooLong",
                       "Timeout",
                       "Timestamp",
                       "Unexpected"]

    down_classifications = [
                       "Down",
                       "GWFailure",
                       "NegativeRTT",
                       "Route",
                       "RTTTooLong",
                       "Timeout"
                       ]
    counters = {}
    for key in classifications:
        counters[key] = 0

    linecount = 0
    
    line = line_queue.get_line()
    recent_num = 0

    # variables used for online mean and standard deviation
    current = {}
    previous = {}
    
    previous['rtt'] = None
    current['rtt'] = None

    previous['mean'] = 0.0
    current['mean'] = 0.0

    previous['variance'] = 0.0
    current['variance'] = 0.0

    normal_ping_count = 0

    sequence_number = -1
    sequence_offset = 0

    # duration and state variables
    network_state = "None"
    up_start = -1
    up_end = -1
    down_start = -1
    down_end = -1

    previous['time'] = "unknown"
    current['time'] = "unknown"

    previous['timestamp'] = None
    current['timestamp'] = None

    previous['sequence'] = sequence_number
    current['sequence'] = sequence_number

    current['linenumber'] = linecount

    # reference_linenumber = linecount
    
    rtt_stats = None
    zrtt = None

    explanation = ""
    while line:
        linecount += 1
        # print "linecount: '" + str(linecount)
        # print "line: '" + line.strip() + "'"
        # TODO threshold should be dynamically calculated
        (kind, seq_num) = classify(line_queue, line.strip(), linecount, 250)
        # print "   kind: " + kind
        if kind:
            counters[kind] += 1
            if kind == "Timestamp":
                # oops - seq_num is not a number, it's a string!
                previous['time'] = current['time']
                previous['timestamp'] = current['timestamp']
                previous['sequence'] = current['sequence']
                # 
                current['time'] = seq_num
                current['timestamp'] = ts.TimeStamp(current['time'])
                current['sequence'] = sequence_number
                current['linenumber'] = linecount
                #
                # if previous_time != "unknown":
                if previous['time'] != "unknown":
                    delta_t = current['timestamp'].minus_small(\
                            previous['timestamp'])
                    delta_r = current['sequence'] - previous['sequence']
                    print "# time check: delta_r: " + str(delta_r) +\
                           " delta_t: " + str(delta_t)
            elif kind == "Initialization":
                pass
            elif kind == "Normal":
                (ip, num, rtt) = \
                        parse_normal_return(line.strip(), linecount)

                # result is a tuple of strings:
                #     (ip_address, sequence_number, rtt)
                # ping sends pings once per second, so sequence_number
                # is roughly a count of seconds.

                if not zrtt:
                    rtt_stats = ss.SequenceStats(float(rtt), False)
                    current['mean'] = float(rtt)
                zrtt = float(rtt)

                inum = int(num)
                if inum == 0 and network_state != "None":
                    # The sequence number only goes to 65535, so we
                    # will keep track of the rolls
                    sequence_offset += 65536
                sequence_number = inum + sequence_offset

                # Handle network state stuff
                if network_state == "None":
                    up_start = sequence_number
                    up_end = sequence_number
                    # print "Network state initialization: Up"
                    # print "   sequence_number: " + str(sequence_number)
                elif network_state == "Down":
                    down_end = sequence_number - 1
                    up_start = sequence_number
                    up_end = sequence_number
                    #
                    print "Down: " + str(down_start) +\
                            " - " + str(down_end) + \
                            "[ " + str(down_end - down_start - 1) + " ]"
                    if explanation == "RTTTooLong":
                        explanation += " RTT: " + str(zrtt)
                    print "   explanation: " + explanation
                    if current['time'] != "unknown":
                        print "   current['time']: " +\
                            str(current['time'])
                        print "   plus (~seconds): " +\
                            str(sequence_number - current['sequence'])
                    # print "linecount: " + str(linecount)
                else:
                    up_end = sequence_number
                network_state = "Up"

# We use the online algorithm documented in Wikipedia article:
# https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance

                # Use the new stats class to accumulate the data
                rtt_stats.accumulate(zrtt)

                normal_ping_count += 1
                if previous['rtt'] > 0.0:
                    temp = current['mean']
                    current['mean'] += \
                        (zrtt - previous['mean']) /\
                        float(normal_ping_count)
                    previous['mean'] = temp
                previous['rtt'] = zrtt
                # previous_rtt = zrtt
                # This works because the first time through 
                # previous_variance is zero
                # this is the population variance
                temp = current['variance']
                current['variance'] = \
                    ( (normal_ping_count - 1) * previous['variance'] + \
                      (zrtt - previous['mean']) * \
                      (zrtt - current['mean'])
                    ) / normal_ping_count
                previous['variance'] = temp

            elif kind in down_classifications:
                # Handle network state stuff
                explanation = kind
                if network_state == "None":
                    down_start = sequence_number
                    down_end = sequence_number
                    # print "Network state initialization: Down"
                    # print "   sequence_number: " + str(sequence_number)
                elif network_state == "Up":
                    up_end = sequence_number - 1
                    down_start = sequence_number
                    down_end = sequence_number
                    #
                    print "Up:   " + str(up_start) +\
                            " - " + str(up_end) + \
                            " [ " + str(up_end - up_start - 1) + " ]"
                    if current['time'] != "unknown":
                        print "   current['time']: " +\
                            str(current['time'])
                        print "   plus (~seconds): " +\
                            str(sequence_number - current['sequence'])
                else:
                    down_end = sequence_number
                network_state = "Down"
                # print "kind: " + kind
            elif kind == "Comment":
                pass
            else:
                # Failed to classify:
                print "Failed to classify:"
                print "   kind: " + kind
                print "   linecount: " + str(linecount)
                print "   line: '" + line.strip() + "'"
                counters["Unexpected"] += 1
        line = line_queue.get_line()

    print "linecount", linecount
    for key in classifications:
        print key + ": " + str(counters[key])

    print "sequence_number: " + str(sequence_number)
    print "sequence_offset: " + str(sequence_offset)
    print "normal_ping_count: " + str(normal_ping_count)
    print "Mean: " + str(current['mean'])
    print "Mean RTT (two ways): " + str(rtt_stats.get_mean())
    print "Variance: " + str(current['variance'])
    print "Variance RTT (two ways): " + str(rtt_stats.get_variance())
    print "rtt_stats: " + str(rtt_stats)

    checksum = linecount
    for key in classifications:
        checksum -= counters[key]
    print "checksum: " + str(checksum)

    cputime_1 = psutil.cpu_times()
    print
    # index 0 is user
    # index 1 is nice
    # index 2 is system
    # index 3 is idle

    ts1 = ts.TimeStamp()
    print "# analyze_pings.py: end: timestamp: " + ts1.get_timestamp()
    print "# analyze_pings.py: User time: " +\
            str(cputime_1[0] - cputime_0[0]) + " S"
    print "# analyze_pings.py: User time per record: " +\
            str(1e6 * (cputime_1[0] - cputime_0[0]) / linecount) +\
            " uS"
    print "# analyze_pings.py: System time: " +\
            str(cputime_1[2] - cputime_0[2]) + " S"
    print "# analyze_pings.py: System time per record: " +\
            str(1e6 * (cputime_1[2] - cputime_0[2]) / linecount) +\
            " uS"
예제 #12
0
파일: run.py 프로젝트: dibrian/poolsensor
from model import Relay

if __name__ == '__main__':



  time_start=10
  time_stop=18
  sleep_timer = 30
  dif_temp_be = 15000
  dif_temp_ki = 5000


  # Script has been called directly
  
  log.prnt(TS.most(1) + "---------------Rendszerinditas------------------")
  
  #Init sensors
  
  log.prnt(TS.most(1) + ". Szenzorok inicializalasa...")
  
  global sensors=[]

  medence = Sensor()
  medence.id = '28-0417c2d68cff'
  medence.name = "Medence (1)"
  medence.temp = GetTemp.gettemp(medence.id);
   # sensors.append(medence)


  sensor1 = Sensor()
예제 #13
0
class MetaInfo:
    def __init__(self,
                 protect=None,
                 mod_ts=None,
                 comment=None,
                 protect_flags=None):
        if protect_flags != None:
            self.set_protect_flags(protect_flags)
        else:
            self.set_protect(protect)
        self.set_mod_ts(mod_ts)
        self.set_comment(comment)

    def get_str_line(self):
        """Return a unicode string with protect flags, mod time and (optional) comment"""
        res = []
        res.append(self.get_protect_str())
        res.append(self.get_mod_time_str())
        comment = self.get_comment()
        if comment == None:
            res.append(u'')
        else:
            res.append(self.get_comment().get_unicode())
        return u'  '.join(res)

    def get_mod_time_str(self):
        if self.mod_ts != None:
            return str(self.mod_ts)
        else:
            return ts_empty_string

    def get_protect_str(self):
        if self.protect_flags != None:
            return str(self.protect_flags)
        else:
            return ProtectFlags.empty_string

    def get_protect_short_str(self):
        if self.protect_flags != None:
            return self.protect_flags.short_str()
        else:
            return ""

    def set_protect(self, protect):
        self.protect = protect
        if self.protect != None:
            self.protect_flags = ProtectFlags(protect)
        else:
            self.protect_flags = None

    def set_protect_flags(self, pf):
        self.protect_flags = pf
        self.protect = pf.mask

    def set_default_protect(self):
        self.protect = 0
        self.protect_flags = ProtectFlags(self.protect)

    def set_current_as_mod_time(self):
        mod_time = time.mktime(time.localtime())
        self.set_mod_time(mod_time)

    def set_mod_time(self, mod_time):
        self.mod_time = mod_time
        if self.mod_time != None:
            self.mod_ts = TimeStamp()
            self.mod_ts.from_secs(mod_time)
        else:
            self.mod_ts = None

    def set_mod_ts(self, mod_ts):
        self.mod_ts = mod_ts
        if self.mod_ts != None:
            self.mod_time = self.mod_ts.get_secsf()
        else:
            self.mod_time = None

    def set_comment(self, comment):
        """Set comment as a FSString"""
        if comment != None and not isinstance(comment, FSString):
            raise ValueError("Comment must be a FSString")
        self.comment = comment

    def get_protect(self):
        return self.protect

    def get_protect_flags(self):
        return self.protect_flags

    def get_mod_time(self):
        return self.mod_time

    def get_mod_ts(self):
        return self.mod_ts

    def get_comment(self):
        return self.comment

    def get_comment_ami_str(self):
        if self.comment != None:
            return self.comment.get_ami_str()
        else:
            return ""

    def get_comment_unicode_str(self):
        if self.comment != None:
            return self.comment.get_unicode()
        else:
            return u""
예제 #14
0
class RootMetaInfo:
  def __init__(self, create_ts=None, disk_ts=None, mod_ts=None):
    self.set_create_ts(create_ts)
    self.set_disk_ts(disk_ts)
    self.set_mod_ts(mod_ts)
  
  def __str__(self):
    res = []
    res.append(self.get_create_time_str())
    res.append(self.get_disk_time_str())
    res.append(self.get_mod_time_str())
    return "  ".join(res)
      
  # create_ts
  def set_create_time(self, create_time):
    self.create_time = create_time
    if self.create_time != None:
      self.create_ts = TimeStamp()
      self.create_ts.from_secs(create_time)
    else:
      self.create_ts = None
  
  def set_create_ts(self, create_ts):
    self.create_ts = create_ts
    if self.create_ts != None:
      self.create_time = self.create_ts.get_secsf()
    else:
      self.create_time = None
  
  def get_create_time(self):
    return self.create_time
  
  def get_create_ts(self):
    return self.create_ts

  def get_create_time_str(self):
    if self.create_ts != None:
      return str(self.create_ts)
    else:
      return ts_empty_string

  def set_current_as_create_time(self):
    create_time = time.mktime(time.localtime())
    self.set_create_time(create_time)

  # disk_ts
  def set_disk_time(self, disk_time):
    self.disk_time = disk_time
    if self.disk_time != None:
      self.disk_ts = TimeStamp()
      self.disk_ts.from_secs(disk_time)
    else:
      self.disk_ts = None
  
  def set_disk_ts(self, disk_ts):
    self.disk_ts = disk_ts
    if self.disk_ts != None:
      self.disk_time = self.disk_ts.get_secsf()
    else:
      self.disk_time = None
  
  def get_disk_time(self):
    return self.disk_time
  
  def get_disk_ts(self):
    return self.disk_ts

  def get_disk_time_str(self):
    if self.disk_ts != None:
      return str(self.disk_ts)
    else:
      return ts_empty_string

  def set_current_as_disk_time(self):
    disk_time = time.mktime(time.localtime())
    self.set_disk_time(disk_time)

  # mod_ts
  def set_mod_time(self, mod_time):
    self.mod_time = mod_time
    if self.mod_time != None:
      self.mod_ts = TimeStamp()
      self.mod_ts.from_secs(mod_time)
    else:
      self.mod_ts = None
  
  def set_mod_ts(self, mod_ts):
    self.mod_ts = mod_ts
    if self.mod_ts != None:
      self.mod_time = self.mod_ts.get_secsf()
    else:
      self.mod_time = None
  
  def get_mod_time(self):
    return self.mod_time
  
  def get_mod_ts(self):
    return self.mod_ts
  
  def get_mod_time_str(self):
    if self.mod_ts != None:
      return str(self.mod_ts)
    else:
      return ts_empty_string
 
  def set_current_as_mod_time(self):
    mod_time = time.mktime(time.localtime())
    self.set_mod_time(mod_time)
예제 #15
0
class MetaInfo:
  def __init__(self, protect=None, mod_ts=None, comment=None, protect_flags=None):
    if protect_flags != None:
      self.set_protect_flags(protect_flags)
    else:
      self.set_protect(protect)
    self.set_mod_ts(mod_ts)
    self.set_comment(comment)
  
  def get_str_line(self):
    """Return a unicode string with protect flags, mod time and (optional) comment"""
    res = []
    res.append(self.get_protect_str())
    res.append(self.get_mod_time_str())
    comment = self.get_comment()
    if comment == None:
      res.append(u'')
    else:
      res.append(self.get_comment().get_unicode())
    return u'  '.join(res)
    
  def get_mod_time_str(self):
    if self.mod_ts != None:
      return str(self.mod_ts)
    else:
      return ts_empty_string
      
  def get_protect_str(self):
    if self.protect_flags != None:
      return str(self.protect_flags)
    else:
      return ProtectFlags.empty_string
      
  def get_protect_short_str(self):
    if self.protect_flags != None:
      return self.protect_flags.short_str()
    else:
      return ""
      
  def set_protect(self, protect):
    self.protect = protect
    if self.protect != None:
      self.protect_flags = ProtectFlags(protect)
    else:
      self.protect_flags = None
  
  def set_protect_flags(self, pf):
    self.protect_flags = pf
    self.protect = pf.mask
  
  def set_default_protect(self):
    self.protect = 0
    self.protect_flags = ProtectFlags(self.protect)
  
  def set_current_as_mod_time(self):
    mod_time = time.mktime(time.localtime())
    self.set_mod_time(mod_time)
    
  def set_mod_time(self, mod_time):
    self.mod_time = mod_time
    if self.mod_time != None:
      self.mod_ts = TimeStamp()
      self.mod_ts.from_secs(mod_time)
    else:
      self.mod_ts = None
  
  def set_mod_ts(self, mod_ts):
    self.mod_ts = mod_ts
    if self.mod_ts != None:
      self.mod_time = self.mod_ts.get_secsf()
    else:
      self.mod_time = None
  
  def set_comment(self, comment):
    """Set comment as a FSString"""
    if comment != None and not isinstance(comment, FSString):
      raise ValueError("Comment must be a FSString")
    self.comment = comment
  
  def get_protect(self):
    return self.protect
  
  def get_protect_flags(self):
    return self.protect_flags
  
  def get_mod_time(self):
    return self.mod_time

  def get_mod_ts(self):
    return self.mod_ts

  def get_comment(self):
    return self.comment

  def get_comment_ami_str(self):
    if self.comment != None:
      return self.comment.get_ami_str()
    else:
      return ""
  
  def get_comment_unicode_str(self):
    if self.comment != None:
      return self.comment.get_unicode()
    else:
      return u""
예제 #16
0
def main():
    """Main body."""

    # capture timing information
    cputime_0 = psutil.cpu_times()

    # Self-identification for the run
    # This gives us YYYY-MM-DDTHH:MM:SS+HH:MM
    ts0 = ts.TimeStamp()
    timestamp_pattern = ts0.get_recognizer_re()

    print "# SequenceStats.py"
    print "# SequenceStats.py: start: timestamp: " + ts0.get_timestamp()

    # Some data pulled from Matt Teachout's page
    # (http://www.matt-teachout.org/data-sets-for-stats.html) page
    # ANOVA Data / Sheet 1 / Column O (Social Media Minutes - Instagram)
    #  Excel results:
    #  N: 124
    #  Mean: 83.20564516
    #  Variance(P): 6803.274242
    #  Variance(S): 6858.585415

    excel_mean = 83.20564516
    excel_variance_p = 6803.274242
    excel_variance_s = 6858.585415

    data1 = [\
        300, 60, 60, 30, 45, 60, 100, 120, 45, 30, 45, 120, 40,
        10, 180, 90, 240, 60, 3, 30, 190, 5, 60, 60, 120, 5, 60,
        45, 20, 120, 200, 180, 180, 35, 120, 120, 1.5, 120, 10, 120,
        60, 2, 120, 30, 60, 60, 120, 60, 30, 15, 90, 2, 60, 120, 60,
        30, 60, 25, 150, 90, 180, 20, 30, 3, 100, 60, 20, 60, 65, 120,
        180, 60, 120, 180, 30, 60, 30, 60, 190, 300, 25, 60, 60, 120,
        3, 200, 65, 2, 2, 2, 2, 2, 2, 2, 120, 4, 30, 1, 120, 120, 120,
        65, 60, 120, 1, 420, 90, 60, 60, 180, 300, 180, 500, 3, 3, 80,
        90, 80, 45, 5, 2, 120, 120, 120
        ]
    n1 = len(data1)

    np_data1 = np.array(data1)
    np_mean1 = np.mean(np_data1)
    np_variance1 = np.var(np_data1)

    print "n1: " + str(n1)

    print "excel_mean: " + str(excel_mean)
    print "excel_variance_p: " + str(excel_variance_p)
    print "excel_variance_s: " + str(excel_variance_s)

    print

    print "np_mean1: " + str(np_mean1)
    print "np_variance1: " + str(np_variance1)
    print "np_variance (to sample): " +\
            str(np_variance1 * float(n1) / float(n1 - 1))

    # Now we run the incremental code
    print
    ss1 = SequenceStats(data1[0])
    for j in range(1, 124):
        # print "accumulate(data1[" + str(j) + "]: " + str(data1[j])
        ss1.accumulate(data1[j])
    print "incremental mean1: " + str(ss1.get_mean())
    print "incremental variance1: " + str(ss1.get_variance())

    data2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    n2 = len(data2)
    print "n2: " + str(n2)
    np_data2 = np.array(data2)
    np_mean2 = np.mean(np_data2)
    np_variance2 = np.var(np_data2)
    print "np_mean2: " + str(np_mean2)
    print "np_variance2: " + str(np_variance2)

    print
    ss2 = SequenceStats(data2[0])
    for j in range(1, 10):
        # print "accumulate(data2[" + str(j) + "]: " + str(data2[j])
        ss2.accumulate(data2[j])
    print "incremental mean2: " + str(ss2.get_mean())
    print "incremental variance2: " + str(ss2.get_variance())

    cputime_1 = psutil.cpu_times()
    print
    # index 0 is user
    # index 1 is nice
    # index 2 is system
    # index 3 is idle

    ts1 = ts.TimeStamp()
    print "# SequenceStats.py: end: timestamp: " + ts1.get_timestamp()
    print "# SequenceStats.py: User time: " +\
            str(cputime_1[0] - cputime_0[0]) + " S"
    print "# SequenceStats.py: System time: " +\
            str(cputime_1[2] - cputime_0[2]) + " S"
예제 #17
0
 def __init__(self):
     self._os = OS.OS()
     self._ts = TimeStamp.TimeStamp()
     self._existing_log_file = "mocks/test.log"