Python Logging.group方法代码示例

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
 def init(self):
   if type(self.collectiveGroup) is int:
     parent = groupDict[self.collectiveGroup]
     if not isinstance(parent, CollectiveGroup):
       raise TypeError("collectiveGroup must be a CollectiveGroup object, not " + str(type(parent)))
     self.collectiveGroup = parent #Forms the actual in-memory conncetion to the parent group
   log.group("Group", self.ID," has collectiveGroup", self.collectiveGroup)
   
   super().init()

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
def groupDailyDuties():
  log.group("Starting daily duties!")
  for group in getGroupList(MainGroup): #Go through all the MainGroups to check for events that have ended
    group.checkForEndedEvents()
    
  if Network.hasIPChanged():
    log.group("IP has changed! Updating bots of all groups")
    for group in getGroupList():
      if group.bot:
        group.handler.updateBots(group.bot)
        

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
 def _handleMessage(self, message):
   
   self.checkForEndedEvents()
   
   ### Everything to do with modifying events and their users ###
   if message.hasAttachments("event"):
     log.command("Running Event Code")
     originalEvent = message.getAttachments("event")[0]['event_id']
     if message.isUser() and "created event" in message.text: #This should be sent by a user
       eventData = self.handler.getEventData(originalEvent)
       if eventData:
         self.newEventGroup(eventData)
         return
       log.group.error("No event found in group for event ID",originalEvent['event_id'])
     elif message.isSystem(): #System informs people are going to/not going to/undecided about events
       if "canceled" in message.text:
         try:
           log.group.debug("Event cancelled. Deleting group associated with",originalEvent)
           self.eventGroups[originalEvent].deleteSelf()
           log.group.debug("Deletion succeeded")
         except KeyError:
           log.group.debug("Deletion Failed. Group is not a child of receiver")
         return
       else:
         for string in ['is going to', 'is not going to']:
           if string in message.text:
             userString = message.text[:message.text.rfind(string)]
             try:
               group = self.eventGroups[originalEvent]
             except KeyError:
               log.group.error("ERROR: No event group for event " + originalEvent + " not adding/removing users")
               return
             log.group("Removing" if "not" in string else "Adding","user '"+userString+"' for event",group)
             if "not" in string:
               #User may not exist in other group due to timing delays or what not, but should definitely exist in this group
               user = group.users.getUserFromID(self.users.getUser(userString).ID)
               if user:
                 group.removeEventUser(user)
               else:
                 log.group.debug("Could not find user '"+userString+"' in event group, not removing")
             else:
               group.addEventUsers(self.users.getUser(userString))
             break #Don't bother with other one if not done
         return
     elif message.isCalendar(): #Calendar sends event update notifications
       eventData = self.handler.getEventData(originalEvent)
       if eventData:
         try:
           self.eventGroups[eventData['event_id']].updateEvent(eventData)
         except KeyError:
           log.group.error("Tried updating event but event did not exist. Creating new instead")
           self.newEventGroup(eventData)
       
   super()._handleMessage(message)

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
 def removeUser(self, userObj):
   #First check all our subgroups and make user objects for them
   log.group(self,"removing user",userObj,"from all eventGroups")
   for group in self.eventGroups.values():
     userMimic = group.users.getUserFromID(userObj.ID)
     if userMimic and isinstance(userMimic, Users.UserMimic): #If we have a userMimic of our user in eventGroup
       webUsers = group.handler.getUsers()
       for user in webUsers:
         if user['user_id'] == userObj.ID:
           log.group.web("Found user in",group, "making new user for them")
           group.users.removeUser(userMimic)
           group.users.updateUser(user, allowMimics = False)
   
   super().removeUser(userObj)

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
def loadGroup(folder):
  if type(folder) == int:
    folder = "Group "+str(folder)
  try:
    loadedGroup = _folderCache[folder]
    log.group("Group already loaded, returning group:", loadedGroup)
    return loadedGroup
  except KeyError:
    pass #Just continue loading
  try:
    groupNumber = int(re.search("\d+", folder).group())
    log.group("Loading Group:", groupNumber)
  except AttributeError:
    raise RuntimeError("Group Folder '"+folder+"' does not have a group number")
  try:
    with open(Files.getFileName(Files.join(folder, SAVE_FILE_NAME))) as file:
      groupType = Files.read(file)
      log.group("Group Type:",groupType)
      newGroup = globals()[groupType](groupNumber).load(file) #Load arbitrary class
      _folderCache[folder] = newGroup #Save it to a cache so we cannot load twice
      return newGroup
      #except (KeyError, TypeError, AttributeError) as Error: #I actually think I want this to be a halting error.
      #  log.error("Failed to properly load group file:", Error)
  except FileNotFoundError: #The group was improperly initialized/saved
    log.group.error("Group had no load file. Deleting folder")
    Files.deleteFolder(folder)

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
 def removeEventUser(self, user):
   if user.group == self:
     log.group("Removing user",user,"from event group",self)
     if self.handler.removeUser(user):
       self.users.removeUser(user)
       log.group("Remove succeeded")
     else:
       log.group("Removal failed")

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
 def deleteSelf(self):
   super().deleteSelf()
   if self.groupID:
     #Note: This also deletes any bots associated with the group
     log.group("Removing GroupMe Group")
     if self.handler.deleteGroup(self.groupID).code == 200:
       log.group("GroupMe group successfully deleted")
     else:
       log.group("GroupMe group deletion failed")

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
 def postInit(self): #We want group data to be loaded by "load" before we initialize all users
   if self.groupID:
     groupRegister(self) #Register new connections
     #Set up handler with groupID and info
     self.handler.postInit()
     try:
       #Must be done after handler initialized
       self.loadUsersFromWeb()
       if self.markedForDeletion:
         raise AssertionError("Group is marked for deletion, not trying to update bots")
        #If the IP address has changed since the last server restart
       if self.bot != None: #We don't do getBot here because that could actually create a new bot
         response = self.handler.getBotData()
         if response:
           try: #Filter out the bots for the one we have registered to this group
             ownBot = [bot for bot in response if bot['bot_id'] == self.getBot()][0]
           except IndexError: #If we haven't found one, we don't have a bot, and our data is faulty
             log.group.web("No external bot found, rectifying/creating new bot")
             if not self.handler.rectifyBot(response):
               self.bot = self.handler.createBotsly()
               if not self.bot:
                 log.error("Could not get bot for", self)
                 raise RuntimeError("BOT SHOULD EXIST FOR " + repr(self) + " BUT COULD NOT BE FOUND")
           else: #If the bot we found doesn't have the proper ip address, update it's ip address
             if ownBot['callback_url'] != Network.getIPAddress():
               log.group("IP has changed! Updating bot id")
               self.handler.updateBots(self.getBot())
         
       #After all that is done, update the message list
       MsgSearch.getSearcher(self).GenerateCache()
     except ConnectionError: #Indicates internet is down
       log.group.error("Failed to update users from web")
   else:
     log.group.error("WARNING: Group", self.ID,"has no groupID")
   
   self.save()

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
  def newEventGroup(self, eventData):
    if eventData['event_id'] in self.eventGroups:
      log.group("We already have a group for this event. Not creating group")
      return self.eventGroups[eventData['event_id']] #Group has been created. it just already exists
    #else
    
    if Events.IS_TESTING:
      return None #If testing we can't create
    
    log.group("Creating new event group!")
    groupOwner = self.getSubGroupMaster()
    self.handler.poster = groupOwner #A little hacky, but whatevs
    response = self.handler.createGroup(eventData['name'])
    self.handler.poster = self.getBotMaster()
    if response.code == 201: #If group was created successfully
      try:
        eventGroup = EventGroup(ID = self.ID, groupMeID = response['id'], parent = self)
        eventGroup.setOwner(groupOwner) #This just sets which token to use if there is a group with multiple
        eventGroup.postInit()
        
        if not random.randint(0,10):  #If the number is 0. 10% chance
          eventGroup.handler.changePosterName("Tester McTestosterone")
          
        post = eventGroup.handler.write
        post(("Description: "+eventData['description']) if "description" in eventData else "Welcome to the new event group! I'm here too!")
        try:
          locDict = eventData["location"]
          post("Location: " + (locDict["address"] if "address" in locDict else locDict["name"]))
        except KeyError:
          log.group("Event has no location")
        post("Have a joke!")
        Jokes.joke.postJoke(eventGroup)

        eventGroup.updateEvent(eventData) #Add in users that are going to group
        
        self.eventGroups[eventData['event_id']] = eventGroup
        self.save()
        log.group("Finished new event group!")
        return eventGroup
      except Exception as e:
        log.group.error("FATAL ERROR IN EVENT GROUP CREATION. Deleting group")
        eventGroup.deleteSelf()
        raise e
    else:
      raise RuntimeError("Could not create event group: " + str(response.code))

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
 def updateEvent(self, eventData):
   log.group("Updating",self,"from event data")
   
   self.end_at = dateutil.parser.parse(eventData['end_at']).timestamp() #This is an integer similar to time.time()
   
   log.group("Searching for users to add")
   toAdd = []
   for id in eventData['going']:
     if not self.users.getUserFromID(id):
       toAdd.append(self.parent.users.getUserFromID(id))
      
   self.addEventUsers(toAdd)
   
   log.group("Searching for users to delete")
   for id in eventData['not_going']:
     if self.users.getUserFromID(id):
       self.removeEventUser(self.users.getUserFromID(id)) #Just remove them straight out. We cannot do multiple calls
   
   log.group("Checking for group attribute changes")
   toAdd = {}
   if 'name' in eventData:
     if eventData['name'] != self.name: #We don't need to update it if we already have this name
       toAdd['name'] = eventData['name']
   if 'image_url' in eventData: 
     if eventData['image_url'] != self.image:
       toAdd['image'] = eventData['image_url']
   if toAdd:
     if self.handler.updateGroup(**toAdd).code == 200: #Unpack the name and image_url if they exist
       #Then if we were setting them above, set them here
       if 'name' in toAdd:
         self.setName(toAdd['name'])
       if 'image' in toAdd:
         self.image = toAdd['image']
   
   
   self.save()

# 需要导入模块: import Logging [as 别名]
# 或者: from Logging import group [as 别名]
 def getSubGroupMaster(self):
   log.group("Getting subgroup BotMaster. Has Overlord: ", bool(Group.overlord))
   if Group.overlord:
     return Group.overlord
     
   return self.getBotMaster()