Lines Matching refs:self
292 def __init__(self, name, level, pathname, lineno,
298 self.name = name
299 self.msg = msg
307 # 'if self.args:'. If the event being logged is e.g. 'Value is %d'
308 # and if the passed arg fails 'if self.args:' then no formatting
321 self.args = args
322 self.levelname = getLevelName(level)
323 self.levelno = level
324 self.pathname = pathname
326 self.filename = os.path.basename(pathname)
327 self.module = os.path.splitext(self.filename)[0]
329 self.filename = pathname
330 self.module = "Unknown module"
331 self.exc_info = exc_info
332 self.exc_text = None # used to cache the traceback text
333 self.stack_info = sinfo
334 self.lineno = lineno
335 self.funcName = func
336 self.created = ct
337 self.msecs = int((ct - int(ct)) * 1000) + 0.0 # see gh-89047
338 self.relativeCreated = (self.created - _startTime) * 1000
340 self.thread = threading.get_ident()
341 self.threadName = threading.current_thread().name
343 self.thread = None
344 self.threadName = None
346 self.processName = None
348 self.processName = 'MainProcess'
356 self.processName = mp.current_process().name
360 self.process = os.getpid()
362 self.process = None
364 def __repr__(self):
365 return '<LogRecord: %s, %s, %s, %s, "%s">'%(self.name, self.levelno,
366 self.pathname, self.lineno, self.msg)
368 def getMessage(self):
375 msg = str(self.msg)
376 if self.args:
377 msg = msg % self.args
428 def __init__(self, fmt, *, defaults=None):
429 self._fmt = fmt or self.default_format
430 self._defaults = defaults
432 def usesTime(self):
433 return self._fmt.find(self.asctime_search) >= 0
435 def validate(self):
437 if not self.validation_pattern.search(self._fmt):
438 raise ValueError("Invalid format '%s' for '%s' style" % (self._fmt, self.default_format[0]))
440 def _format(self, record):
441 if defaults := self._defaults:
445 return self._fmt % values
447 def format(self, record):
449 return self._format(record)
462 def _format(self, record):
463 if defaults := self._defaults:
467 return self._fmt.format(**values)
469 def validate(self):
473 for _, fieldname, spec, conversion in _str_formatter.parse(self._fmt):
475 if not self.field_spec.match(fieldname):
480 if spec and not self.fmt_spec.match(spec):
493 def __init__(self, *args, **kwargs):
495 self._tpl = Template(self._fmt)
497 def usesTime(self):
498 fmt = self._fmt
499 return fmt.find('$asctime') >= 0 or fmt.find(self.asctime_search) >= 0
501 def validate(self):
504 for m in pattern.finditer(self._fmt):
515 def _format(self, record):
516 if defaults := self._defaults:
520 return self._tpl.substitute(**values)
576 def __init__(self, fmt=None, datefmt=None, style='%', validate=True, *,
596 self._style = _STYLES[style][0](fmt, defaults=defaults)
598 self._style.validate()
600 self._fmt = self._style._fmt
601 self.datefmt = datefmt
606 def formatTime(self, record, datefmt=None):
624 ct = self.converter(record.created)
628 s = time.strftime(self.default_time_format, ct)
629 if self.default_msec_format:
630 s = self.default_msec_format % (s, record.msecs)
633 def formatException(self, ei):
643 #if getattr(self, 'fullstack', False):
652 def usesTime(self):
656 return self._style.usesTime()
658 def formatMessage(self, record):
659 return self._style.format(record)
661 def formatStack(self, stack_info):
674 def format(self, record):
688 if self.usesTime():
689 record.asctime = self.formatTime(record, self.datefmt)
690 s = self.formatMessage(record)
695 record.exc_text = self.formatException(record.exc_info)
703 s = s + self.formatStack(record.stack_info)
715 def __init__(self, linefmt=None):
721 self.linefmt = linefmt
723 self.linefmt = _defaultFormatter
725 def formatHeader(self, records):
731 def formatFooter(self, records):
737 def format(self, records):
743 rv = rv + self.formatHeader(records)
745 rv = rv + self.linefmt.format(record)
746 rv = rv + self.formatFooter(records)
764 def __init__(self, name=''):
772 self.name = name
773 self.nlen = len(name)
775 def filter(self, record):
782 if self.nlen == 0:
784 elif self.name == record.name:
786 elif record.name.find(self.name, 0, self.nlen) != 0:
788 return (record.name[self.nlen] == ".")
795 def __init__(self):
799 self.filters = []
801 def addFilter(self, filter):
805 if not (filter in self.filters):
806 self.filters.append(filter)
808 def removeFilter(self, filter):
812 if filter in self.filters:
813 self.filters.remove(filter)
815 def filter(self, record):
828 for f in self.filters:
882 def __init__(self, level=NOTSET):
887 Filterer.__init__(self)
888 self._name = None
889 self.level = _checkLevel(level)
890 self.formatter = None
891 self._closed = False
893 _addHandlerRef(self)
894 self.createLock()
896 def get_name(self):
897 return self._name
899 def set_name(self, name):
902 if self._name in _handlers:
903 del _handlers[self._name]
904 self._name = name
906 _handlers[name] = self
912 def createLock(self):
916 self.lock = threading.RLock()
917 _register_at_fork_reinit_lock(self)
919 def _at_fork_reinit(self):
920 self.lock._at_fork_reinit()
922 def acquire(self):
926 if self.lock:
927 self.lock.acquire()
929 def release(self):
933 if self.lock:
934 self.lock.release()
936 def setLevel(self, level):
940 self.level = _checkLevel(level)
942 def format(self, record):
949 if self.formatter:
950 fmt = self.formatter
955 def emit(self, record):
965 def handle(self, record):
974 rv = self.filter(record)
976 self.acquire()
978 self.emit(record)
980 self.release()
983 def setFormatter(self, fmt):
987 self.formatter = fmt
989 def flush(self):
998 def close(self):
1010 self._closed = True
1011 if self._name and self._name in _handlers:
1012 del _handlers[self._name]
1016 def handleError(self, record):
1063 def __repr__(self):
1064 level = getLevelName(self.level)
1065 return '<%s (%s)>' % (self.__class__.__name__, level)
1076 def __init__(self, stream=None):
1082 Handler.__init__(self)
1085 self.stream = stream
1087 def flush(self):
1091 self.acquire()
1093 if self.stream and hasattr(self.stream, "flush"):
1094 self.stream.flush()
1096 self.release()
1098 def emit(self, record):
1110 msg = self.format(record)
1111 stream = self.stream
1113 stream.write(msg + self.terminator)
1114 self.flush()
1118 self.handleError(record)
1120 def setStream(self, stream):
1128 if stream is self.stream:
1131 result = self.stream
1132 self.acquire()
1134 self.flush()
1135 self.stream = stream
1137 self.release()
1140 def __repr__(self):
1141 level = getLevelName(self.level)
1142 name = getattr(self.stream, 'name', '')
1147 return '<%s %s(%s)>' % (self.__class__.__name__, name, level)
1156 def __init__(self, filename, mode='a', encoding=None, delay=False, errors=None):
1164 self.baseFilename = os.path.abspath(filename)
1165 self.mode = mode
1166 self.encoding = encoding
1168 self.encoding = io.text_encoding(encoding)
1169 self.errors = errors
1170 self.delay = delay
1174 self._builtin_open = open
1178 Handler.__init__(self)
1179 self.stream = None
1181 StreamHandler.__init__(self, self._open())
1183 def close(self):
1187 self.acquire()
1190 if self.stream:
1192 self.flush()
1194 stream = self.stream
1195 self.stream = None
1202 # self._closed being set to True there
1203 StreamHandler.close(self)
1205 self.release()
1207 def _open(self):
1212 open_func = self._builtin_open
1213 return open_func(self.baseFilename, self.mode,
1214 encoding=self.encoding, errors=self.errors)
1216 def emit(self, record):
1226 if self.stream is None:
1227 if self.mode != 'w' or not self._closed:
1228 self.stream = self._open()
1229 if self.stream:
1230 StreamHandler.emit(self, record)
1232 def __repr__(self):
1233 level = getLevelName(self.level)
1234 return '<%s %s (%s)>' % (self.__class__.__name__, self.baseFilename, level)
1243 def __init__(self, level=NOTSET):
1247 Handler.__init__(self, level)
1250 def stream(self):
1267 def __init__(self, alogger):
1271 self.loggerMap = { alogger : None }
1273 def append(self, alogger):
1277 if alogger not in self.loggerMap:
1278 self.loggerMap[alogger] = None
1308 def __init__(self, rootnode):
1312 self.root = rootnode
1313 self.disable = 0
1314 self.emittedNoHandlerWarning = False
1315 self.loggerDict = {}
1316 self.loggerClass = None
1317 self.logRecordFactory = None
1320 def disable(self):
1321 return self._disable
1324 def disable(self, value):
1325 self._disable = _checkLevel(value)
1327 def getLogger(self, name):
1343 if name in self.loggerDict:
1344 rv = self.loggerDict[name]
1347 rv = (self.loggerClass or _loggerClass)(name)
1348 rv.manager = self
1349 self.loggerDict[name] = rv
1350 self._fixupChildren(ph, rv)
1351 self._fixupParents(rv)
1353 rv = (self.loggerClass or _loggerClass)(name)
1354 rv.manager = self
1355 self.loggerDict[name] = rv
1356 self._fixupParents(rv)
1361 def setLoggerClass(self, klass):
1369 self.loggerClass = klass
1371 def setLogRecordFactory(self, factory):
1376 self.logRecordFactory = factory
1378 def _fixupParents(self, alogger):
1388 if substr not in self.loggerDict:
1389 self.loggerDict[substr] = PlaceHolder(alogger)
1391 obj = self.loggerDict[substr]
1399 rv = self.root
1402 def _fixupChildren(self, ph, alogger):
1415 def _clear_cache(self):
1422 for logger in self.loggerDict.values():
1425 self.root._cache.clear()
1447 def __init__(self, name, level=NOTSET):
1451 Filterer.__init__(self)
1452 self.name = name
1453 self.level = _checkLevel(level)
1454 self.parent = None
1455 self.propagate = True
1456 self.handlers = []
1457 self.disabled = False
1458 self._cache = {}
1460 def setLevel(self, level):
1464 self.level = _checkLevel(level)
1465 self.manager._clear_cache()
1467 def debug(self, msg, *args, **kwargs):
1476 if self.isEnabledFor(DEBUG):
1477 self._log(DEBUG, msg, args, **kwargs)
1479 def info(self, msg, *args, **kwargs):
1488 if self.isEnabledFor(INFO):
1489 self._log(INFO, msg, args, **kwargs)
1491 def warning(self, msg, *args, **kwargs):
1500 if self.isEnabledFor(WARNING):
1501 self._log(WARNING, msg, args, **kwargs)
1503 def warn(self, msg, *args, **kwargs):
1506 self.warning(msg, *args, **kwargs)
1508 def error(self, msg, *args, **kwargs):
1517 if self.isEnabledFor(ERROR):
1518 self._log(ERROR, msg, args, **kwargs)
1520 def exception(self, msg, *args, exc_info=True, **kwargs):
1524 self.error(msg, *args, exc_info=exc_info, **kwargs)
1526 def critical(self, msg, *args, **kwargs):
1535 if self.isEnabledFor(CRITICAL):
1536 self._log(CRITICAL, msg, args, **kwargs)
1538 def fatal(self, msg, *args, **kwargs):
1542 self.critical(msg, *args, **kwargs)
1544 def log(self, level, msg, *args, **kwargs):
1558 if self.isEnabledFor(level):
1559 self._log(level, msg, args, **kwargs)
1561 def findCaller(self, stack_info=False, stacklevel=1):
1595 def makeRecord(self, name, level, fn, lno, msg, args, exc_info,
1610 def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False,
1622 fn, lno, func, sinfo = self.findCaller(stack_info, stacklevel)
1632 record = self.makeRecord(self.name, level, fn, lno, msg, args,
1634 self.handle(record)
1636 def handle(self, record):
1643 if (not self.disabled) and self.filter(record):
1644 self.callHandlers(record)
1646 def addHandler(self, hdlr):
1652 if not (hdlr in self.handlers):
1653 self.handlers.append(hdlr)
1657 def removeHandler(self, hdlr):
1663 if hdlr in self.handlers:
1664 self.handlers.remove(hdlr)
1668 def hasHandlers(self):
1678 c = self
1690 def callHandlers(self, record):
1700 c = self
1715 elif raiseExceptions and not self.manager.emittedNoHandlerWarning:
1717 " \"%s\"\n" % self.name)
1718 self.manager.emittedNoHandlerWarning = True
1720 def getEffectiveLevel(self):
1727 logger = self
1734 def isEnabledFor(self, level):
1738 if self.disabled:
1742 return self._cache[level]
1746 if self.manager.disable >= level:
1747 is_enabled = self._cache[level] = False
1749 is_enabled = self._cache[level] = (
1750 level >= self.getEffectiveLevel()
1756 def getChild(self, suffix):
1771 if self.root is not self:
1772 suffix = '.'.join((self.name, suffix))
1773 return self.manager.getLogger(suffix)
1775 def __repr__(self):
1776 level = getLevelName(self.getEffectiveLevel())
1777 return '<%s %s (%s)>' % (self.__class__.__name__, self.name, level)
1779 def __reduce__(self):
1780 if getLogger(self.name) is not self:
1783 return getLogger, (self.name,)
1792 def __init__(self, level):
1796 Logger.__init__(self, "root", level)
1798 def __reduce__(self):
1809 def __init__(self, logger, extra=None):
1820 self.logger = logger
1821 self.extra = extra
1823 def process(self, msg, kwargs):
1833 kwargs["extra"] = self.extra
1839 def debug(self, msg, *args, **kwargs):
1843 self.log(DEBUG, msg, *args, **kwargs)
1845 def info(self, msg, *args, **kwargs):
1849 self.log(INFO, msg, *args, **kwargs)
1851 def warning(self, msg, *args, **kwargs):
1855 self.log(WARNING, msg, *args, **kwargs)
1857 def warn(self, msg, *args, **kwargs):
1860 self.warning(msg, *args, **kwargs)
1862 def error(self, msg, *args, **kwargs):
1866 self.log(ERROR, msg, *args, **kwargs)
1868 def exception(self, msg, *args, exc_info=True, **kwargs):
1872 self.log(ERROR, msg, *args, exc_info=exc_info, **kwargs)
1874 def critical(self, msg, *args, **kwargs):
1878 self.log(CRITICAL, msg, *args, **kwargs)
1880 def log(self, level, msg, *args, **kwargs):
1885 if self.isEnabledFor(level):
1886 msg, kwargs = self.process(msg, kwargs)
1887 self.logger.log(level, msg, *args, **kwargs)
1889 def isEnabledFor(self, level):
1893 return self.logger.isEnabledFor(level)
1895 def setLevel(self, level):
1899 self.logger.setLevel(level)
1901 def getEffectiveLevel(self):
1905 return self.logger.getEffectiveLevel()
1907 def hasHandlers(self):
1911 return self.logger.hasHandlers()
1913 def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False):
1917 return self.logger._log(
1927 def manager(self):
1928 return self.logger.manager
1931 def manager(self, value):
1932 self.logger.manager = value
1935 def name(self):
1936 return self.logger.name
1938 def __repr__(self):
1939 logger = self.logger
1941 return '<%s %s (%s)>' % (self.__class__.__name__, logger.name, level)
2223 def handle(self, record):
2226 def emit(self, record):
2229 def createLock(self):
2230 self.lock = None
2232 def _at_fork_reinit(self):