Python LOGGER.warn方法代码示例

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
    def gimmeTrame(self,daNewState):
        """
            Return the update trame to be sent
        """
        if (str(daNewState)=="toggle"):
            if self.current_state=="off":
                #on met à on
                rawTrame="A55A6B0570000000"+ "FF9F1E0"+"7" +"30"
                self.current_state="on"
            elif(self.current_state=="on"):
                #on met à off
                rawTrame="A55A6B0550000000"+ "FF9F1E0"+"7" +"30"
                self.current_state="off"
            else:
                rawTrame="A55A6B0550000000"+ "FF9F1E0"+"7" +"30"
                self.current_state="off"
        else:
            LOGGER.warn("Strange new state : {}. Trram not send".format(daNewState))

            return ""
        LOGGER.info("State after : {}".format(self.current_state))
        myTrame=Trame.trame(rawTrame)
        myTrame.calculateChecksum()
        LOGGER.info("Actuator trame generated, to be send : {}".format(myTrame.lessRawView()))
        self.save()
        return myTrame.rawView()

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
 def updateIdentSet(self):
     """
         Safely update the identifier set of the traductor
     """
     for anUpdate in lazzyUpdate.objects:
         LOGGER.warn("id : {} || state : {}".format(anUpdate.idToUpdate,anUpdate.newState))
         if(anUpdate.idToUpdate==""):
             with self.lock:
                 self.identSet=set([])
                 for lsensor in sensor.Sensor.objects:
                     self.identSet.add(lsensor.physic_id)
                     LOGGER.info(lsensor.physic_id)
                 LOGGER.info("Traductor's set of captors updated")
         elif(anUpdate.newState==""):
             with self.lock:
                 if (anUpdate.idToUpdate in things.physic_id for things in sensor.Sensor.objects):
                     self.identSet.add(anUpdate.idToUpdate)
                     LOGGER.info("{} added".format(anUpdate.idToUpdate))
         else:
             #send a trame from a captor with a newState
             LOGGER.error("Sensor to update : {} ||new state : {}".format(anUpdate.idToUpdate,anUpdate.newState))
             self.sendTrame(anUpdate.idToUpdate,anUpdate.newState)
         anUpdate.delete()
         LOGGER.warn(" {} update           GROS delete de : {} || {}".format(lazzyUpdate.objects.count(),anUpdate.idToUpdate,anUpdate.newState))
         return 
     LOGGER.debug("nothing to update")

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
 def get_custom_field(self, field_key):
     result = ''
     try:
         result = self.custom_fields[field_key]
     except KeyError:
         LOGGER.warn('Issue %s does not have value for field %s' % (self.key, field_key))
     return result

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
def format_date(date_string):
    result = date_string
    try:
        time_struct = strptime(date_string, "%d/%b/%y")
        result = date.fromtimestamp(mktime(time_struct))
    except (TypeError, ValueError):
        LOGGER.warn('[%s] is not valid date' % date_string)
    return result

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
def retro_browse_points(request):

    selected_team_name = 'allteams'
    selected_sprint_number = 'allsprints'
    selected_sticker_type = 'alltypes'
    count = 15

    teams = Team.objects.all().order_by('name')
    sprints = Sprint.objects.all().order_by('-number')
    types = BoardSticker.TYPE_CHOICES

    stickers = BoardSticker.objects.all().order_by('-creation_date')

    try:
        selected_team_name = request.GET["team"]
        selected_sprint_number = request.GET["sprint"]
        selected_sticker_type = request.GET["type"]
        count = request.GET["count"]
    except KeyError:
        LOGGER.warn('Request with incorrect parameters. Using defaults.')

    if selected_team_name != 'allteams':
        selected_team = Team.objects.get(name=selected_team_name)
        board = RetroBoard.objects.filter(team=selected_team)
        stickers = stickers.filter(retroBoard__in=board)

    if selected_sprint_number != 'allsprints':
        selected_sprint = Sprint.objects.get(number=selected_sprint_number)
        boards = RetroBoard.objects.filter(sprint=selected_sprint)
        stickers = stickers.filter(retroBoard__in=boards)

    if selected_sticker_type != 'alltypes':
        stickers = stickers.filter(type=selected_sticker_type)

    stickers = stickers[:count]

    types_dict = {}
    for item in BoardSticker.TYPE_CHOICES:
        types_dict[item[0]] = item[1]

    for point in stickers:
        point.type_str = types_dict[point.type]

    if selected_sprint_number != 'allsprints':
        selected_sprint_number = int(selected_sprint_number)

    return render_to_response('retro/dpq_retro_action_points.html',
                              RequestContext(request, {'stickers': stickers,
                                                       'teams': teams,
                                                       'sprints': sprints,
                                                       'types': types,
                                                       'selected_team': selected_team_name,
                                                       'selected_sprint': selected_sprint_number,
                                                       'selected_type': selected_sticker_type,
                                                       'count': int(count),
                                                       'count_options': [15, 30, 45, 60],
                                                       'active_branches': get_active_branches()}))

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
 def gimmeTrame(self,daNewState):
     """
         Return the update trame to be sent
     """
     if daNewState=="close":
         data="00000009"
     elif daNewState=="open":
         data="00000008"
     else :
         LOGGER.warn("Strange state : {}. Trame not sent".format(daNewState))
         return ""
     strTrame=elf.trameStart+data+self.physic_id+self.trameEnd
     myTrame=Trame.trame(strTrame)
     myTrame.calculateChecksum()
     LOGGER.debug("Trame returned : {}".format(myTrame.rawView()))
     return myTrame.rawView()

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
 def translateTrame(self,inTrame):
     """
     return  close if data0=09, 
             open if data0=08 
             else nothing
     """
     if (inTrame.data0=='09'):
                     LOGGER.info("Door sensor {} with state [close]".format(inTrame.ident))
                     dataToRet = "close"
     elif(inTrame.data0=='08'):
         LOGGER.info("Door sensor {} with state [open]".format(inTrame.ident))
         dataToRet = "open"
     else:
         LOGGER.warn("Door sensor {}Strange state : {}".format(inTrame.ident, inTrame.data2))
         dataToRet=''
     return dataToRet

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
    def checkTrame(self):
        if self.trameUsed:
            LOGGER.debug("Trame received : {}".format(self.trameUsed.lessRawView()))
            if ("A55A" not in self.trameUsed.sep):
                LOGGER.warn("Wrong separator, rejected")

            if (self.doChecksum(self.trameUsed) not in self.trameUsed.checkSum):     
                #Mauvais checkSum
                LOGGER.warn("Wrong checksum, expected : {}, rejected".format(self.doChecksum(self.trameUsed)))

            with self.lock:
                if (self.trameUsed.ident in self.identSet):
                    #Recuperer le capteur en bdd
                    sensorUsed = sensor.Sensor.objects(physic_id=self.trameUsed.ident)[0]
                    newData = '' #la nouvelle data a entrer en base, type dynamique
                    if (sensorUsed.__class__.__name__=="Switch"):
                        newData=sensorUsed.translateTrame(self.trameUsed)
                    elif (sensorUsed.__class__.__name__=="Temperature"):
                        newData = sensorUsed.translateTrame(self.trameUsed)

                    elif (sensorUsed.__class__.__name__=="Position"):
                        newData = sensorUsed.translateTrame(self.trameUsed)
                    else :
                        LOGGER.warn("Other Captor (not handle (YET !) )")
                    # Update de la trame au niveau de la base
                    if newData :
                        sensorUsed.update(newData)
                        LOGGER.info(" Sensor {} ||New data {}".format(sensorUsed.physic_id, sensorUsed.current_state))
            self.trameUsed=''

# 需要导入模块: from logger import LOGGER [as 别名]
# 或者: from logger.LOGGER import warn [as 别名]
 def get_issue(key):
     try:
         db_record = DbJiraIssues.get(DbJiraIssues.key == key)
         return DatabaseWrapper.__record_to_issue(db_record)
     except DoesNotExist:
         LOGGER.warn('Issue %s does not exist in database' % key)