Python Formatter.format方法代码示例

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
    def format(self, record):
        if not getattr(record, 'session', None):
            record.session =  ''
            record.sessionLS = ' %s' % record.session
            record.sessionRS = '%s ' % record.session
        else:
            record.sessionLS = ' %s' % record.session
            record.sessionRS = '%s ' % record.session

        if not getattr(record, 'classname', None):
            record.classname = ''
        if not getattr(record, 'method', None):
            record.method = record.funcName
        if not getattr(record, 'classAndmethod', None):
            if record.method and record.classname:
                record.classAndMethod = '%s::%s' % (record.classname, record.method)
            else:
                record.classAndMethod = ''

        created = localtime(record.created)
        record.date = strftime('%Y-%m-%d', created)
        record.time = strftime('%H:%M:%S', created)
        record.asctimeshort = '%s %s' % (record.date, record.time)

        #return Formatter.format(self, record)

        ## splits the record and formats every line
        msg = record.getMessage()
        res = []
        for line in msg.split("\n"):
            record.msg, record.args = line, None
            res.append(Formatter.format(self, record))
        return "\n".join(res)

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
 def format(self, record):
     record = deepcopy(record)
     if self.usesColor:
         color_end = '\033[00m'
         try:
             color_begin= {
                  logging.DEBUG    : '',
                  logging.INFO     : '\033[01;32m',
                  logging.WARNING  : '\033[01;33m',
                  logging.ERROR    : '\033[01;31m',
                  logging.CRITICAL : '\033[01;31m',
                  logging.FATAL    : '\033[00;31m'
                 }[record.levelno]
         except:
             color_begin = ''
             color_end = ''
             
         record.levelname = color_begin+'*'+color_end
         
         #record.levelno == logging.ERROR or 
         if record.levelno == logging.CRITICAL or record.levelno == logging.FATAL:
             record.msg = color_begin+record.msg+color_end
     if self.useIdents:
         ident = len(inspect.stack())
         if ident<self.minIdent:
             self.minIdent = ident
         record.msg=' '*(ident-self.minIdent)+record.msg
     return Formatter.format(self, record)

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
    def format(self, record):
        try:
            msg = super(ANSIFormatter, self).format(record)
        except:
            # for python2.6
            # Formatter is old-style class in python2.6 and type is classobj
            # another trick: http://stackoverflow.com/a/18392639/1276501
            msg = Formatter.format(self, record)

        lvl2color = {
            "DEBUG": "blue",
            "INFO": "green",
            "WARNING": "yellow",
            "ERROR": "red",
            "CRITICAL": "bgred"
        }

        rln = record.levelname
        if rln in lvl2color:
            return "[{0}]: {1}".format(
                utils.color_msg(lvl2color[rln], rln),
                msg
            )
        else:
            return msg

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
    def format (self, record):
        # Add the color codes to the record
        record.__dict__.update(escape_codes)

        # If we recognise the level name,
        # add the levels color as `log_color`
        if record.levelname in self.log_colors:
            color = self.log_colors[record.levelname]
            record.log_color = escape_codes[color]
        else:
            record.log_color = ""

        #NOTE: caller_name is very slow
        #record.__dict__['caller_name'] = caller_name(9)
        record.__dict__['abbr_levelname'] = record.levelname[0]
        record.__dict__['pathname2'] = '.'.join(record.pathname.split('/')[-2:]).rstrip('.py')

        # Format the message
        if version_info > (2, 7):
            message = super(ColoredFormatter, self).format(record)
        else:
            message = Formatter.format(self, record)

        # Add a reset code to the end of the message (if it wasn't explicitly added in format str)
        if self.reset and not message.endswith(escape_codes['reset']):
            message += escape_codes['reset']

        return message

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
 def format(self, record):
     plain_result = Formatter.format(self, record)
     for severity_threshold, severity_color in self.SEVERITY_COLOR_THRESHOLDS:
         if record.levelno >= severity_threshold:
             color = severity_color
         else:
             break
     return colorize(plain_result, color=color)

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
class QTextHandler(QtGui.QTextEdit):
    def __init__(self, parent=None):
        super(QTextHandler, self).__init__(parent)

    def setFormatter(self, fmt=None):
        self.formatter = Formatter(fmt)

    def handle(self, record):
        self.append(self.formatter.format(record))

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
class CustomSMTPHandler(SMTPHandler):
    def __init__(self, mailhost, fromaddr, toaddrs, subject):
        super(CustomSMTPHandler, self).__init__(
            mailhost, fromaddr, toaddrs, subject
        )
        self.subject_formatter = Formatter(subject)

    def getSubject(self, record):  # noqa: N802
        return self.subject_formatter.format(record).replace('\n', '')

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
 def format(self, record):
     levelname = record.levelname
     msg = Formatter.format(self, record)
     if levelname in COLORS:
         if stdout.isatty():
             msg = COLORS[levelname] % msg
     else:
         print ("*" * 100, levelname, "(%s)" % type(levelname), "not in",
                 COLORS.keys())
     return msg

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
    def format(self, record):
        try:
            msg = super(NonANSIFormatter, self).format(record)
        except:
            # for python2.6
            # Formatter is old-style class in python2.6 and type is classobj
            # another trick: http://stackoverflow.com/a/18392639/1276501
            msg = Formatter.format(self, record)

        rln = record.levelname
        return "[{0}]: {1}".format(rln, msg)

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
 def format(self, record):
     rv = []
     length = 0
     for piece in _ws_re.split(Formatter.format(self, record)):
         length += len(piece)
         if length > 140:
             if length - len(piece) < 140:
                 rv.append(u'…')
             break
         rv.append(piece)
     return u''.join(rv)

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
 def format(self, record):
     """Format the record with colors."""
     color = self.color_seq % (30 + self.colors[record.levelname])
     message = Formatter.format(self, record)
     message = message.replace('$RESET', self.reset_seq)\
         .replace('$BOLD', self.bold_seq)\
         .replace('$COLOR', color)
     for color, value in self.colors.items():
         message = message.replace(
             '$' + color, self.color_seq % (value + 30))\
             .replace('$BG' + color, self.color_seq % (value + 40))\
             .replace('$BG-' + color, self.color_seq % (value + 40))
     return message + self.reset_seq

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
    def format(self, record):
        colored_record = copy(record)

        # Add colors to levelname
        levelname = colored_record.levelname
        color = MAPPING.get(levelname, 'white')
        colored_record.levelname = COLORIZE(levelname, color)

        # Add colors to tagged message text
        msg = colored_record.getMessage()
        plain_msg, color_msg = self.color_words(msg)
        record.msg = plain_msg
        colored_record.msg = color_msg

        return Formatter.format(self, colored_record)

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
class SysLogHandler(_SysLogHandler):
    """ 扩展标准库的SysLogHandler，使用loggername作为tag """

    def __init__(self, tag=None, withpid=False, **kwargs):
        super(SysLogHandler, self).__init__(**kwargs)
        # 产生tag的formatter
        fmt = tag or "%(name)s"
        if withpid:
            fmt += "[%(process)d]"
        self.tag_formatter = Formatter(fmt)

    def format(self, record):
        msg = super(SysLogHandler, self).format(record)
        tag = self.tag_formatter.format(record)
        return "%s: %s" % (tag, msg)

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
    def format(self, record):
        try:
            message = super(SecureFormatter, self).format(record)
        except TypeError:
            # In pyhton 2.6 the Formatter does not seem to 
            # be defined as 
            # class Formatter(object)
            # Using it in the super-statement this will raise a TypeError
            message = Formatter.format(self, record)
        secured = False

        s = ""
        for c in message:
            if c in string.printable:
                s += c
            else:
                s += '.'
                secured = True

        if secured:
            s = "!!!Log Entry Secured by SecureFormatter!!! " + s

        return s

# 需要导入模块: from logging import Formatter [as 别名]
# 或者: from logging.Formatter import format [as 别名]
	def format (self, record):
		# Add the color codes to the record
		record.__dict__.update(escape_codes)

		# If we recognise the level name,
		# add the levels color as `log_color`
		if record.levelname in self.log_colors:
			color = self.log_colors[record.levelname]
			record.log_color = escape_codes[color]
		else:
			record.log_color = ""

		# Format the message
		if version_info > (2, 7):
			message = super(ColoredFormatter, self).format(record)
		else:
			message = Formatter.format(self, record)

		# Add a reset code to the end of the message (if it wasn't explicitly added in format str)
		if self.reset and not message.endswith(escape_codes['reset']):
			message += escape_codes['reset']

		return message