Exemple #1
0
def getmainInfo(dataframe):
    length = max(dataframe['dist'])
    tottime = max(dataframe['duration'])
    dateandtime = dataframe['time'][0] 
    
    stopframe = (dataframe[dataframe['speed']<0.50][['duration']].index)
    stoptime = sum(dataframe['duration'].diff()[stopframe])
    walktime = tottime - stoptime
    average_speed = length/walktime
    pausefaktor = stoptime/tottime
    ele_min = min(dataframe['ele'])
    ele_max = max(dataframe['ele'])
    elediff = ele_max-ele_min
    climbing = reducedElePoints(dataframe)
    steepness = climbing/(length/2)
    climbingrate = climbing/(walktime/2)
    kupert_faktor = climbing/elediff
    topptur_faktor = elediff/ele_max
    
    info = dict()
    info['length'] = round(length/1000,2) #km 
    info['dateandtime'] = dateandtime
    info['tottime'] = dtt(seconds=tottime)
    info['stop_time'] = dtt(seconds=stoptime)
    info['walk_time'] = dtt(seconds=walktime)
    info['pause_faktor'] = round(pausefaktor*100,1)
    info['avg_speed'] = round(average_speed*3.6,2)
    
    info['elediff'] = round(elediff,1)
    info['climbing'] = round(climbing,1)
    info['steepness'] = round(steepness*1000,1)
    info['climbingrate'] = round(climbingrate*60,1)
    info['kupert_faktor'] = round(kupert_faktor,2)
    info['topptur_faktor'] = round(topptur_faktor*100,1)
    return info
Exemple #2
0
def copyGPX(filename):
    """ Reads a GPX file, renames the file and saves it in a different folder """

    f = open(filename, encoding='utf-8')
    ns = findNamespace(f)
    xml = etree.parse(f)
    f.close()

    point = xml.find(ns + "trk/" + ns + "trkseg/" + ns + "trkpt")
    startlat = float(point.attrib['lat'])
    startlon = float(point.attrib['lon'])
    starttime = normalizetimedata(point.find(ns + 'time').text)

    loc = googleLocation(startlat, startlon)
    timezone = googleTimezone(startlat, startlon, starttime)

    newfilename = createfilename(loc, starttime, timezone, 'gpx')

    trkname = xml.find(ns + "trk/" + ns + "name")
    trkname.text = str(starttime + dtt(seconds=timezone))[:16]

    fullFilePath = 'C:\\python\\testdata\\tcxnew\\{}'.format(newfilename)

    f = open(fullFilePath, 'wb')
    f.write(etree.tostring(xml))
    f.close()

    return fullFilePath
Exemple #3
0
def copyGPX2(originalFile, saveFilepath, newFilename):
    """ Reads a GPX file, renames the file and saves it in a different folder """

    f = open(originalFile, encoding='utf-8')
    ns = findNamespace(f)
    xml = etree.parse(f)
    f.close()

    point = xml.find(ns + "trk/" + ns + "trkseg/" + ns + "trkpt")
    startlat = float(point.attrib['lat'])
    startlon = float(point.attrib['lon'])
    starttime = normalizetimedata(point.find(ns + 'time').text)
    timezone = googleTimezone(startlat, startlon, starttime)
    try:
        trkname = xml.find(ns + "trk/" + ns + "name")
        trkname.text = str(starttime + dtt(seconds=timezone))[:16]
    except:
        pass

    fullFilePath = saveFilepath + '\\' + newFilename

    f = open(fullFilePath, 'wb')
    f.write(etree.tostring(xml))
    f.close()

    return 0  #fullFilePath
    def init_powersaving(self):
        self.brightness = Config.get("settings.brightness")
        self.normal_brightness = self.brightness

        self.finish_init = datetime.now() + timedelta(seconds=5)

        start = Config.get("settings.powersaving.start", "01:00")
        end = Config.get("settings.powersaving.end", "07:00")
        self.powersaving_brightness = Config.get(
            "settings.powersaving.brightness", 0)

        self.powersaving_start = dtt(hour=int(start[:2]),
                                     minute=int(start[3:5]))
        self.powersaving_end = dtt(hour=int(end[:2]), minute=int(end[3:5]))

        self.update_powersaving(datetime.now())
Exemple #5
0
def createTotStat():
    """ Creates a placeholder for total stat data. """
    totstat = dict()
    totstat['tot_length'] = 0
    totstat['tot_antall_besteget'] = 0
    totstat['tot_elevation'] = 0
    totstat['tot_tottid'] = dtt(seconds=0)
    return totstat
Exemple #6
0
def get_simulation_time(sim_min):
    time = '09:00'
    h, m = map(int, time.split(':'))
    init_time = dtt(hour=h, minute=m)
    timdelta = td(minutes=sim_min)
    tmp_datetime = datetime.datetime.combine(datetime.date(1, 1, 1), init_time)
    time2 = (tmp_datetime + timdelta).time()
    return time2.strftime("%I:%M %p")
Exemple #7
0
def getmainInfo(dataframe):
    print('Number of points:', len(dataframe))
    length = dataframe['dist'].max()
    tottime = max(dataframe['duration'])
    length = dataframe['dist'].max()
    tottime = max(dataframe['duration'])
    dateandtime = dataframe['time'][0]

    stopframe = (dataframe[dataframe['speed'] < 0.2777][['duration']].index)
    stoptime = sum(dataframe['duration'].diff()[stopframe])
    walktime = tottime - stoptime
    average_speed = length / walktime
    pausefaktor = stoptime / tottime
    ele_min = dataframe['ele'].min()
    ele_max = dataframe['ele'].max()
    elediff = calcEleDiff(ele_min, ele_max)
    climbing = getClimbingHeightGPS(dataframe)
    steepness = climbing / (length / 2)
    climbingrate = climbing / (walktime / 2)

    try:
        kupert_faktor = climbing / elediff
        topptur_faktor = elediff / ele_max
    except:
        kupert_faktor = 0
        topptur_faktor = 0

    info = dict()
    info['length'] = round(length / 1000, 2)  #km
    info['dateandtime'] = dateandtime
    info['tottime'] = dtt(seconds=tottime)
    info['stop_time'] = dtt(seconds=stoptime)
    info['walk_time'] = dtt(seconds=walktime)
    info['pause_faktor'] = round(pausefaktor * 100, 1)
    info['avg_speed'] = round(average_speed * 3.6, 2)

    info['elediff'] = round(elediff, 1)
    info['climbing'] = round(climbing, 1)
    info['steepness'] = round(steepness * 1000, 1)
    info['climbingrate'] = round(climbingrate * 60, 1)
    info['kupert_faktor'] = round(kupert_faktor, 2)
    info['topptur_faktor'] = round(topptur_faktor * 100, 1)
    return info
Exemple #8
0
def getmainInfoTCX(dataframe):
    length = max(dataframe['dist'])
    tottime = dataframe['time'].max() - dataframe['time'].min()
    dateandtime = dataframe['time'][0]
    climbing = gpxtricks.getClimbingHeightGPS(dataframe)

    stopframe = (dataframe[dataframe['speed'] < 0.4167][['duration']].index)
    stoptime = sum(dataframe['duration'].diff()[stopframe])
    walktime = tottime.total_seconds() - stoptime

    info = dict()
    info['length'] = round(length / 1000, 2)  #km
    info['dateandtime'] = dateandtime
    info['tottime'] = tottime
    info['walk_time'] = dtt(seconds=walktime)
    info['avg_speed'] = length / walktime * 3.6
    info['climbing'] = round(climbing, 1)
    info['activity'] = ''
    info['health'] = ''
    info['comment'] = ''
    info['sone1'], info['sone2'], info['sone3'], info['sone4'], info[
        'sone5'] = getTCXheartzone(dataframe)
    return info
Exemple #9
0
def copyTCX2(originalFile, saveFilepath, newFilename):
    """ Reads a TCX file, renames the file and saves it in a different folder """
    f = open(originalFile, encoding='utf-8')
    ns = findNamespace(f)
    xml = etree.parse(f)
    f.close()

    rawdata = findTCXFirstPoint(xml, ns)
    pdata = normalizedata(rawdata['rawlat'], rawdata['rawlon'],
                          rawdata['rawtime'])

    loc = googleLocation(pdata['lat'], pdata['lon'])
    timezone = googleTimezone(pdata['lat'], pdata['lon'], pdata['time'])

    trkname = xml.find(ns + "Activities/" + ns + "Activity/" + ns + "Id")
    trkname.text = str(pdata['time'] + dtt(seconds=timezone))[:16]

    fullFilePath = saveFilepath + '\\' + newFilename

    f = open(fullFilePath, 'wb')
    f.write(etree.tostring(xml))
    f.close()

    return fullFilePath
Exemple #10
0
def copyTCX(filename):
    """ Reads a TCX file, renames the file and saves it in a different folder """
    f = open(filename, encoding='utf-8')
    ns = findNamespace(f)
    xml = etree.parse(f)
    f.close()

    rawdata = findTCXFirstPoint(xml, ns)
    pdata = normalizedata(rawdata['rawlat'], rawdata['rawlon'],
                          rawdata['rawtime'])

    loc = googleLocation(pdata['lat'], pdata['lon'])
    timezone = googleTimezone(pdata['lat'], pdata['lon'], pdata['time'])

    newfilename = createfilename(loc, pdata['time'], timezone, 'tcx')

    trkname = xml.find(ns + "Activities/" + ns + "Activity/" + ns + "Id")
    trkname.text = str(pdata['time'] + dtt(seconds=timezone))[:16]

    fullFilePath = 'C:\\python\\testdata\\tcxnew\\{}'.format(newfilename)
    f = open(fullFilePath, 'wb')
    f.write(etree.tostring(xml))
    f.close()
    return fullFilePath
Exemple #11
0
 def handle (self, message):
     # there are three things this app deals with primarily:
     # registration, pin setup, and testing
     
     # but we'll also use it to circumvent some logic in the tree
     # app with a few custom codes.
     if message.text.lower() == "iavi uganda" or message.text.lower() == "iavi kenya":
         # if they are allowed to participate, return false so 
         # that the message propagates to the tree app.  If they
         # aren't this will come back as handled and the tree app
         # will never see it.  
         # ASSUMES ORDERING OF APPS AND THAT THIS IS BEFORE TREE
         return not self._allowed_to_participate(message)
     
     # we'll be using the language in all our responses so
     # keep it handy
     language = get_language_code(message.persistant_connection)
     
     # check pin conditions and process if they match
     if message.reporter and message.reporter.pk in self.pending_pins:
         return self._process_pin(message)
         
     # registration block
     # first make sure the string starts and ends with the *# - #* combination
     match = re.match(r"^\*\#(.*?)\#\*$", message.text)
     if match:
         self.info("Message matches! %s", message)
         body_groups = match.groups()[0].split("#")
         if len(body_groups)== 3 and body_groups[0] == "8377":
             # this is the testing format
             # this is the (extremely ugly) format of testing
             # *#8377#<Site Number>#<Last 4 Digits of Participant ID>#*
             # TODO: implement testing
             
             code, site, id = body_groups
             alias = IaviReporter.get_alias(site, id)
             try: 
                 # lookup the user in question and initiate the tree
                 # sequence for them.  If there are errors, respond
                 # with them
                 user = IaviReporter.objects.get(alias=alias)
                 
                 errors = self._initiate_tree_sequence(user, message.persistant_connection)
                 if errors:
                     message.respond(errors)
             except IaviReporter.DoesNotExist:
                 message.respond(_(strings["unknown_user"], language) % {"alias":id})
             return True
         
         else:
             # assume this is the registration format
             # this is the (extremely ugly) format of registration
             # time is optional
             # *#<Country/Language Group>#<Site Number>#<Last 3 Digits of Participant ID>#<time?>#*
             if len(body_groups) == 3:
                 language, site, id = body_groups
                 study_time = "1600"
             elif len(body_groups) == 4:
                 language, site, id, study_time = body_groups
             else:
                 message.respond(_(strings["unknown_format"], get_language_code(message.persistant_connection)))
             
             # validate the format of the id, existence of location
             if not re.match(r"^\d{3}$", id):
                 message.respond(_(strings["id_format"], get_language_code(message.persistant_connection)) % {"alias" : id})
                 return True
             try:
                 location = Location.objects.get(code=site)
             except Location.DoesNotExist:
                 message.respond(_(strings["unknown_location"], get_language_code(message.persistant_connection)) % {"alias" : id, "location" : site})
                 return True
             
             # TODO: validate the language
             
             # validate and get the time object
             if re.match(r"^\d{4}$", study_time):
                 hour = int(study_time[0:2])
                 minute = int(study_time[2:4])
                 if hour < 0 or hour >= 24 or minute < 0 or minute >= 60:
                     message.respond(_(strings["time_format"], get_language_code(message.persistant_connection)) % {"alias" : id, "time" : study_time})
                     return
                 real_time = dtt(hour, minute)
             else:
                 message.respond(_(strings["time_format"], get_language_code(message.persistant_connection)) % {"alias" : id, "time" : study_time})
                 return 
             
             # user ids are unique per-location so use location-id
             # as the alias
             alias = IaviReporter.get_alias(location.code, id)
             
             # make sure this isn't a duplicate alias
             if len(IaviReporter.objects.filter(alias=alias)) > 0:
                 message.respond(_(strings["already_registered"], language) % {"alias": id, "location":location.code})
                 return True
             
             # create the reporter object for this person 
             reporter = IaviReporter(alias=alias, language=language, location=location, registered=message.date)
             reporter.save()
             
             # create the study participant for this too.  Assume they're starting
             # tomorrow and don't set a stop date.  
             start_date = (datetime.today() + timedelta(days=1)).date()
             participant = StudyParticipant.objects.create(reporter=reporter, 
                                                           start_date = start_date,
                                                           notification_time = real_time)
             
             # also attach the reporter to the connection 
             message.persistant_connection.reporter=reporter
             message.persistant_connection.save()
             
             message.respond(_(strings["registration_complete"], language) % {"alias": id })
             
             # also send the PIN request and add this user to the 
             # pending pins
             self.pending_pins[reporter.pk] = None
             message.respond(_(strings["pin_request"], language))
     else:
         self.info("Message doesn't match. %s", message)
Exemple #12
0
    lotname = 'wustl_millbrook'

def space_list(min, max, items) :
    for i in range(items) :
        yield random.randint(min,max)

simulating = True
while simulating :
    host = httplib.HTTPConnection(hostname)
    print 'PUT to',hostname,'in lot',lotname,'...',

    # generage a random number of spaces to change
    spaces = []
    changed = random.randint(1, 10)
    now = dtdt.now()
    six_oclock = dtdt.combine(now.date(), dtt(6, 00))
    seven_oclock = dtdt.combine(now.date(), dtt(7, 00))
    twelve_oclock = dtdt.combine(now.date(), dtt(12, 00))
    thirteen_oclock = dtdt.combine(now.date(), dtt(13, 00))
    eighteen_oclock = dtdt.combine(now.date(), dtt(18, 00))
    nineteen_oclock = dtdt.combine(now.date(), dtt(19, 00))
    twentytwo_oclock = dtdt.combine(now.date(), dtt(22, 00))
    five_oclock = dtdt.combine(now.date(), dtt(5, 00))
    if six_oclock <= now <= seven_oclock :
        weight = 3
    elif twelve_oclock <= now <= thirteen_oclock :
        changed *= 2
        weight = 3
    elif eighteen_oclock <= now <= nineteen_oclock :
        weight = 3
    elif now >= twentytwo_oclock or now <= five_oclock :
Exemple #13
0
def createfilename(location, time, timezone=0, fileextension='.gpx'):
    normtime = str(time + dtt(seconds=timezone))
    normtime = normtime[:16]
    normtime = normtime.replace(':', '')
    newfilename = '{0} {1}{2}'.format(normtime, location, fileextension)
    return newfilename
    def handle(self, message):
        # there are three things this app deals with primarily:
        # registration, pin setup, and testing

        # but we'll also use it to circumvent some logic in the tree
        # app with a few custom codes.
        if message.text.lower() == "iavi uganda" or message.text.lower(
        ) == "iavi kenya":
            # if they are allowed to participate, return false so
            # that the message propagates to the tree app.  If they
            # aren't this will come back as handled and the tree app
            # will never see it.
            # ASSUMES ORDERING OF APPS AND THAT THIS IS BEFORE TREE
            return not self._allowed_to_participate(message)

        # we'll be using the language in all our responses so
        # keep it handy
        language = get_language_code(message.persistant_connection)

        # check pin conditions and process if they match
        if message.reporter and message.reporter.pk in self.pending_pins:
            return self._process_pin(message)

        # registration block
        # first make sure the string starts and ends with the *# - #* combination
        match = re.match(r"^\*\#(.*?)\#\*$", message.text)
        if match:
            self.info("Message matches! %s", message)
            body_groups = match.groups()[0].split("#")
            if len(body_groups) == 3 and body_groups[0] == "8377":
                # this is the testing format
                # this is the (extremely ugly) format of testing
                # *#8377#<Site Number>#<Last 4 Digits of Participant ID>#*
                # TODO: implement testing

                code, site, id = body_groups
                alias = IaviReporter.get_alias(site, id)
                try:
                    # lookup the user in question and initiate the tree
                    # sequence for them.  If there are errors, respond
                    # with them
                    user = IaviReporter.objects.get(alias=alias)

                    errors = self._initiate_tree_sequence(
                        user, message.persistant_connection)
                    if errors:
                        message.respond(errors)
                except IaviReporter.DoesNotExist:
                    message.respond(
                        _(strings["unknown_user"], language) % {"alias": id})
                return True

            else:
                # assume this is the registration format
                # this is the (extremely ugly) format of registration
                # time is optional
                # *#<Country/Language Group>#<Site Number>#<Last 3 Digits of Participant ID>#<time?>#*
                if len(body_groups) == 3:
                    language, site, id = body_groups
                    study_time = "1600"
                elif len(body_groups) == 4:
                    language, site, id, study_time = body_groups
                else:
                    message.respond(
                        _(strings["unknown_format"],
                          get_language_code(message.persistant_connection)))

                # validate the format of the id, existence of location
                if not re.match(r"^\d{3}$", id):
                    message.respond(
                        _(strings["id_format"],
                          get_language_code(message.persistant_connection)) %
                        {"alias": id})
                    return True
                try:
                    location = Location.objects.get(code=site)
                except Location.DoesNotExist:
                    message.respond(
                        _(strings["unknown_location"],
                          get_language_code(message.persistant_connection)) % {
                              "alias": id,
                              "location": site
                          })
                    return True

                # TODO: validate the language

                # validate and get the time object
                if re.match(r"^\d{4}$", study_time):
                    hour = int(study_time[0:2])
                    minute = int(study_time[2:4])
                    if hour < 0 or hour >= 24 or minute < 0 or minute >= 60:
                        message.respond(
                            _(strings["time_format"],
                              get_language_code(message.persistant_connection))
                            % {
                                "alias": id,
                                "time": study_time
                            })
                        return
                    real_time = dtt(hour, minute)
                else:
                    message.respond(
                        _(strings["time_format"],
                          get_language_code(message.persistant_connection)) % {
                              "alias": id,
                              "time": study_time
                          })
                    return

                # user ids are unique per-location so use location-id
                # as the alias
                alias = IaviReporter.get_alias(location.code, id)

                # make sure this isn't a duplicate alias
                if len(IaviReporter.objects.filter(alias=alias)) > 0:
                    message.respond(
                        _(strings["already_registered"], language) % {
                            "alias": id,
                            "location": location.code
                        })
                    return True

                # create the reporter object for this person
                reporter = IaviReporter(alias=alias,
                                        language=language,
                                        location=location,
                                        registered=message.date)
                reporter.save()

                # create the study participant for this too.  Assume they're starting
                # tomorrow and don't set a stop date.
                start_date = (datetime.today() + timedelta(days=1)).date()
                participant = StudyParticipant.objects.create(
                    reporter=reporter,
                    start_date=start_date,
                    notification_time=real_time)

                # also attach the reporter to the connection
                message.persistant_connection.reporter = reporter
                message.persistant_connection.save()

                message.respond(
                    _(strings["registration_complete"], language) %
                    {"alias": id})

                # also send the PIN request and add this user to the
                # pending pins
                self.pending_pins[reporter.pk] = None
                message.respond(_(strings["pin_request"], language))
        else:
            self.info("Message doesn't match. %s", message)
    def validate(self, *args, **kwargs):
        message = args[0]
        form_entry = args[1]
        
        data = form_entry.to_dict()
        
        if form_entry.form.code.abbreviation == "register": 
            language = data["language"]
            site = data["location"]
            id = data["study_id"]
            # time is optional
            study_time = data["time"]
            if not study_time:
                study_time = "1600" 

            # validate the format of the id, existence of location
            if not re.match(r"^\d{3}$", id):
                return [(_(strings["id_format"], get_language_code(message.persistant_connection)) % {"alias" : id})]
            try:
                location = Location.objects.get(code=site)
            except Location.DoesNotExist:
                return[(_(strings["unknown_location"], get_language_code(message.persistant_connection)) % {"alias" : id, "location" : site})]
                
            # TODO: validate the language
            
            # validate and get the time object
            if re.match(r"^\d{4}$", study_time):
                hour = int(study_time[0:2])
                minute = int(study_time[2:4])
                if hour < 0 or hour >= 24 or minute < 0 or minute >= 60:
                    return [(_(strings["time_format"], get_language_code(message.persistant_connection)) % {"alias" : id, "time" : study_time})]
                real_time = dtt(hour, minute)
            else:
                return [(_(strings["time_format"], get_language_code(message.persistant_connection)) % {"alias" : id, "time" : study_time})]
                
            # user ids are unique per-location so use location-id
            # as the alias
            alias = IaviReporter.get_alias(location.code, id)
            
            # make sure this isn't a duplicate alias
            if len(IaviReporter.objects.filter(alias=alias)) > 0:
                return [(_(strings["already_registered"], language) % {"alias": id, "location":location.code})]
                return True
            
            data["alias"] = alias
            data["location"] = location
            data["time"] = real_time
            # all fields were present and correct, so copy them into the
            # form_entry, for "actions" to pick up again without re-fetching
            form_entry.reg_data = data
            
            return []
            
        elif form_entry.form.code.abbreviation == "test":
            print "test!"
            print data
            site = data["location"]
            id = data["study_id"]
            alias = IaviReporter.get_alias(site, id)
            try: 
                # make sure the user in question exists.  If not,
                # respond with an error
                user = IaviReporter.objects.get(alias=alias)
                
                # set some data in the form_entry so we have easy
                # access to it from within actions  
                data["reporter"] = user
                data["alias"] = alias
                form_entry.test_data = data
            except IaviReporter.DoesNotExist:
                return [(_(strings["unknown_user"], language) % {"alias":id})]