parameters: (self)
docstring: Do the configuration.
docstring_summary: Do the configuration.
docstring_tokens: Do the configuration .
function: def configure(self):
          """Do the configuration."""
  
          config = self.config
          if 'version' not in config:
              raise ValueError("dictionary doesn't specify a version")
          if config['version'] != 1:
              raise ValueError("Unsupported version: %s" % config['version'])
          incremental = config.pop('incremental', False)
          EMPTY_DICT = {}
          logging._acquireLock()
          try:
              if incremental:
                  handlers = config.get('handlers', EMPTY_DICT)
                  for name in handlers:
                      if name not in logging._handlers:
                          raise ValueError('No handler found with '
                                           'name %r'  % name)
                      else:
                          try:
                              handler = logging._handlers[name]
                              handler_config = handlers[name]
                              level = handler_config.get('level', None)
                              if level:
                                  handler.setLevel(logging._checkLevel(level))
                          except StandardError, e:
                              raise ValueError('Unable to configure handler '
                                               '%r: %s' % (name, e))
                  loggers = config.get('loggers', EMPTY_DICT)
                  for name in loggers:
                      try:
                          self.configure_logger(name, loggers[name], True)
                      except StandardError, e:
                          raise ValueError('Unable to configure logger '
                                           '%r: %s' % (name, e))
                  root = config.get('root', None)
                  if root:
                      try:
                          self.configure_root(root, True)
                      except StandardError, e:
                          raise ValueError('Unable to configure root '
                                           'logger: %s' % e)
              else:
                  disable_existing = config.pop('disable_existing_loggers', True)
  
                  logging._handlers.clear()
                  del logging._handlerList[:]
  
                  # Do formatters first - they don't refer to anything else
                  formatters = config.get('formatters', EMPTY_DICT)
                  for name in formatters:
                      try:
                          formatters[name] = self.configure_formatter(
                                                              formatters[name])
                      except StandardError, e:
                          raise ValueError('Unable to configure '
                                           'formatter %r: %s' % (name, e))
                  # Next, do filters - they don't refer to anything else, either
                  filters = config.get('filters', EMPTY_DICT)
                  for name in filters:
                      try:
                          filters[name] = self.configure_filter(filters[name])
                      except StandardError, e:
                          raise ValueError('Unable to configure '
                                           'filter %r: %s' % (name, e))
  
                  # Next, do handlers - they refer to formatters and filters
                  # As handlers can refer to other handlers, sort the keys
                  # to allow a deterministic order of configuration
                  handlers = config.get('handlers', EMPTY_DICT)
                  for name in sorted(handlers):
                      try:
                          handler = self.configure_handler(handlers[name])
                          handler.name = name
                          handlers[name] = handler
                      except StandardError, e:
                          raise ValueError('Unable to configure handler '
                                           '%r: %s' % (name, e))
                  # Next, do loggers - they refer to handlers and filters
  
                  #we don't want to lose the existing loggers,
                  #since other threads may have pointers to them.
                  #existing is set to contain all existing loggers,
                  #and as we go through the new configuration we
                  #remove any which are configured. At the end,
                  #what's left in existing is the set of loggers
                  #which were in the previous configuration but
                  #which are not in the new configuration.
                  root = logging.root
                  existing = root.manager.loggerDict.keys()
                  #The list needs to be sorted so that we can
                  #avoid disabling child loggers of explicitly
                  #named loggers. With a sorted list it is easier
                  #to find the child loggers.
                  existing.sort(key=_encoded)
                  #We'll keep the list of existing loggers
                  #which are children of named loggers here...
                  child_loggers = []
                  #now set up the new ones...
                  loggers = config.get('loggers', EMPTY_DICT)
                  for name in loggers:
                      if name in existing:
                          i = existing.index(name)
                          prefixed = name + "."
                          pflen = len(prefixed)
                          num_existing = len(existing)
                          i = i + 1 # look at the entry after name
                          while (i < num_existing) and\
                                (existing[i][:pflen] == prefixed):
                              child_loggers.append(existing[i])
                              i = i + 1
                          existing.remove(name)
                      try:
                          self.configure_logger(name, loggers[name])
                      except StandardError, e:
                          raise ValueError('Unable to configure logger '
                                           '%r: %s' % (name, e))
  
                  #Disable any old loggers. There's no point deleting
                  #them as other threads may continue to hold references
                  #and by disabling them, you stop them doing any logging.
                  #However, don't disable children of named loggers, as that's
                  #probably not what was intended by the user.
                  for log in existing:
                      logger = root.manager.loggerDict[log]
                      if log in child_loggers:
                          logger.level = logging.NOTSET
                          logger.handlers = []
                          logger.propagate = True
                      elif disable_existing:
                          logger.disabled = True
  
                  # And finally, do the root logger
                  root = config.get('root', None)
                  if root:
                      try:
                          self.configure_root(root)
                      except StandardError, e:
                          raise ValueError('Unable to configure root '
                                           'logger: %s' % e)
          finally:
              logging._releaseLock()
function_tokens: def configure ( self ) : config = self . config if 'version' not in config : raise ValueError ( "dictionary doesn't specify a version" ) if config [ 'version' ] != 1 : raise ValueError ( "Unsupported version: %s" % config [ 'version' ] ) incremental = config . pop ( 'incremental' , False ) EMPTY_DICT = { } logging . _acquireLock ( ) try : if incremental : handlers = config . get ( 'handlers' , EMPTY_DICT ) for name in handlers : if name not in logging . _handlers : raise ValueError ( 'No handler found with ' 'name %r' % name ) else : try : handler = logging . _handlers [ name ] handler_config = handlers [ name ] level = handler_config . get ( 'level' , None ) if level : handler . setLevel ( logging . _checkLevel ( level ) ) except StandardError , e : raise ValueError ( 'Unable to configure handler ' '%r: %s' % ( name , e ) ) loggers = config . get ( 'loggers' , EMPTY_DICT ) for name in loggers : try : self . configure_logger ( name , loggers [ name ] , True ) except StandardError , e : raise ValueError ( 'Unable to configure logger ' '%r: %s' % ( name , e ) ) root = config . get ( 'root' , None ) if root : try : self . configure_root ( root , True ) except StandardError , e : raise ValueError ( 'Unable to configure root ' 'logger: %s' % e ) else : disable_existing = config . pop ( 'disable_existing_loggers' , True ) logging . _handlers . clear ( ) del logging . _handlerList [ : ] # Do formatters first - they don't refer to anything else formatters = config . get ( 'formatters' , EMPTY_DICT ) for name in formatters : try : formatters [ name ] = self . configure_formatter ( formatters [ name ] ) except StandardError , e : raise ValueError ( 'Unable to configure ' 'formatter %r: %s' % ( name , e ) ) # Next, do filters - they don't refer to anything else, either filters = config . get ( 'filters' , EMPTY_DICT ) for name in filters : try : filters [ name ] = self . configure_filter ( filters [ name ] ) except StandardError , e : raise ValueError ( 'Unable to configure ' 'filter %r: %s' % ( name , e ) ) # Next, do handlers - they refer to formatters and filters # As handlers can refer to other handlers, sort the keys # to allow a deterministic order of configuration handlers = config . get ( 'handlers' , EMPTY_DICT ) for name in sorted ( handlers ) : try : handler = self . configure_handler ( handlers [ name ] ) handler . name = name handlers [ name ] = handler except StandardError , e : raise ValueError ( 'Unable to configure handler ' '%r: %s' % ( name , e ) ) # Next, do loggers - they refer to handlers and filters #we don't want to lose the existing loggers, #since other threads may have pointers to them. #existing is set to contain all existing loggers, #and as we go through the new configuration we #remove any which are configured. At the end, #what's left in existing is the set of loggers #which were in the previous configuration but #which are not in the new configuration. root = logging . root existing = root . manager . loggerDict . keys ( ) #The list needs to be sorted so that we can #avoid disabling child loggers of explicitly #named loggers. With a sorted list it is easier #to find the child loggers. existing . sort ( key = _encoded ) #We'll keep the list of existing loggers #which are children of named loggers here... child_loggers = [ ] #now set up the new ones... loggers = config . get ( 'loggers' , EMPTY_DICT ) for name in loggers : if name in existing : i = existing . index ( name ) prefixed = name + "." pflen = len ( prefixed ) num_existing = len ( existing ) i = i + 1 # look at the entry after name while ( i < num_existing ) and ( existing [ i ] [ : pflen ] == prefixed ) : child_loggers . append ( existing [ i ] ) i = i + 1 existing . remove ( name ) try : self . configure_logger ( name , loggers [ name ] ) except StandardError , e : raise ValueError ( 'Unable to configure logger ' '%r: %s' % ( name , e ) ) #Disable any old loggers. There's no point deleting #them as other threads may continue to hold references #and by disabling them, you stop them doing any logging. #However, don't disable children of named loggers, as that's #probably not what was intended by the user. for log in existing : logger = root . manager . loggerDict [ log ] if log in child_loggers : logger . level = logging . NOTSET logger . handlers = [ ] logger . propagate = True elif disable_existing : logger . disabled = True # And finally, do the root logger root = config . get ( 'root' , None ) if root : try : self . configure_root ( root ) except StandardError , e : raise ValueError ( 'Unable to configure root ' 'logger: %s' % e ) finally : logging . _releaseLock ( )