How to use the colorlog.default_log_colors function in colorlog

self.logger.setLevel(self.log_level)

        if self.raven_client:
            sentry_handler = SentryHandler(client=self.raven_client, level=logging.ERROR)
            root_logger.addHandler(sentry_handler)

        if self.logfile:
            formatter = logging.Formatter(fmt=self.logfile_format)
            log_handler = logging.FileHandler(self.logfile)
            log_handler.setFormatter(formatter)
            root_logger.addHandler(log_handler)

        stream_handler = logging.StreamHandler()

        from colorlog import ColoredFormatter, default_log_colors
        colors = default_log_colors.copy()
        colors['DEBUG'] = 'purple'

        stream_handler.setFormatter(ColoredFormatter(self.log_format, datefmt='%H:%M:%S', log_colors=colors))
        root_logger.addHandler(stream_handler)

        self.logger.info('Logging setup ready')

logging.STATS = logging.INFO + 1
    logging.DIRS  = logging.INFO - 1
    logging.FILES = logging.INFO - 2
    logging.MSGS  = logging.INFO - 3
    logging.addLevelName(logging.STATS, "STAT")
    logging.addLevelName(logging.FILES, "FILE")
    logging.addLevelName(logging.DIRS,  "DIR")
    logging.addLevelName(logging.MSGS,  "MSG")

    levels = [logging.STATS, logging.INFO, logging.DIRS, logging.FILES, logging.MSGS, logging.DEBUG] #, logging.TRACE]

    # Don't want logging complaining within it's own runs.
    logging.raiseExceptions = False

    # Create some default colors
    colors = colorlog.default_log_colors.copy()
    colors.update({
                    'STAT': 'cyan',
                    'DIR':  'cyan,bold',
                    'FILE': 'cyan',
                    'DEBUG': 'green'
                  })

    msgOnlyFmt = '%(message)s'
    if args.logtime:
        #formatter = MessageOnlyFormatter(levels=[logging.STATS], fmt='%(asctime)s %(levelname)s: %(message)s')
        formats = { logging.STATS: msgOnlyFmt }
        defaultFmt = '%(asctime)s %(levelname)s: %(message)s'
        cDefaultFmt = '%(asctime)s %(log_color)s%(levelname)s%(reset)s: %(message)s'
    else:
        formats = { logging.INFO: msgOnlyFmt, logging.STATS: msgOnlyFmt }
        defaultFmt = '%(levelname)s: %(message)s'

def setupLogging(verbosity=1, levels=None, format=None, stream=sys.stdout):
    if levels is None:
        levels = [logging.WARNING, logging.INFO, logging.DEBUG]

    loglevel = levels[verbosity] if verbosity < len(levels) else logging.DEBUG

    if format is None:
        if loglevel <= logging.DEBUG:
            format = "%(log_color)s%(levelname)s%(reset)s : %(filename)s:%(lineno)d: %(message)s"
        else:
            format = "%(log_color)s%(levelname)s%(reset)s : %(message)s"

    colors = colorlog.default_log_colors.copy()
    colors.update({ 'DEBUG': 'green' })

    formatter = colorlog.TTYColoredFormatter(format, log_colors=colors, stream=stream)
    handler = logging.StreamHandler()
    handler.setFormatter(formatter)
    logging.root.addHandler(handler)

    logging.raiseExceptions = False

    logger = logging.getLogger("")
    logger.setLevel(loglevel)
    return logger

def make_formatter():
    # Prefix log messages unobtrusively with "log" to distinguish log
    # messages more obviously from other text sent to the error stream.
    format_string = ("%(bg_black)s%(log_color)slog: %(display_name)s: "
                     "[%(levelname)s]%(reset)s %(message)s")
    colors = colorlog.default_log_colors
    colors['DEBUG'] = 'white'
    formatter = colorlog.ColoredFormatter(format_string, log_colors=colors)
    return formatter

from azure.servicemanagement import ServiceManagementService, ConfigurationSetInputEndpoint
from azure.common import AzureHttpError

log = logging.getLogger(__name__)

logging.getLogger("requests").setLevel(logging.WARNING)
logging.getLogger('urllib3').setLevel(logging.WARNING)
logging.getLogger('boto').setLevel(logging.CRITICAL)

# Debug formatter
formatter = colorlog.ColoredFormatter(
    '%(log_color)s%(levelname)-8s%(reset)s [%(asctime)s] [%(blue)s%(name)s.%(funcName)s%(reset)s:%(bold)s%(lineno)d%(reset)s] %(message)s',
    datefmt="%H:%M:%S",
    reset=True,
    log_colors=colorlog.default_log_colors)

# Debug logger
debug = logging.getLogger('debug')
debug.setLevel(logging.DEBUG)
debug.propagate = False
debug_logfile = os.path.join(os.path.expanduser("~"), ".storm", 'debug.log')
debuglog = logging.handlers.RotatingFileHandler(debug_logfile, backupCount=5, delay=True)
if os.path.exists(debug_logfile):
    debuglog.doRollover()
debuglog.setLevel(logging.DEBUG)
debuglog.setFormatter(formatter)
debug.addHandler(debuglog)

# Get AWS credentials
try:
    path = os.path.join(os.path.expanduser("~"), ".storm", "aws")

def init_logging(level: str, package_name: str):
    level = level.upper()
    logging.addLevelName(TRACE, 'TRACE')
    log_colors = dict(colorlog.default_log_colors, **dict(TRACE='cyan'))

    # formatter and handler
    formatter = colorlog.ColoredFormatter(
        log_colors=log_colors,
        fmt='%(asctime)s %(log_color)s%(levelname)-8s%(reset)s'
            ' %(cyan)s{%(threadName)s} %(blue)s[%(name)s]%(reset)s %(message)s',
    )

    package_logger = logging.getLogger(package_name)
    package_logger.handlers.clear()

    # do not attache the same handler twice
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(formatter)

    counting_handler = CountingHandler(_module_record_counters)

import logging
import logging.config

try:
    import colorlog
    use_color = True
except ImportError:
    use_color = False

from website import settings

handler = logging.StreamHandler()

if settings.DEBUG_MODE and use_color:
    log_colors = colorlog.default_log_colors
    log_colors['DEBUG'] = 'cyan'

    formatter = colorlog.ColoredFormatter(
        '%(log_color)s[%(name)s]  %(levelname)s:%(reset)s %(message)s',
        reset=True,
        log_colors=log_colors,
    )
else:
    formatter = logging.Formatter(
        '[%(name)s]  %(levelname)s: %(message)s',
    )

handler.setFormatter(formatter)

logger = logging.getLogger()
logger.addHandler(handler)