a Sic @sdZddlZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlmZddlmZzddlmZWneyYn0ejZejZejZejZejZej Z!ej"Z#dZ$de %d d d Z&d Z'd Z(ej)*ddZ+da,da-dddddddZ.dddddZ/Gdddej0Z1Gdddej0Z2Gdddej3Z4Gd d!d!e5Z6Gd"d#d#ej0Z7ej8d$d%d&d'd(ej8d)d%d*d'd(ej9d+e:d,d-d.d'd(e;e1d/d0d1d2d'd3e;e2d4id5e;e7d6dd7d'd8e8d9d'd:d;d<ZZ=d?d@Z>dAdZ?dBdZ@dCdZAdDdEZBdFdZCdGdHZDdIdJZEiZFdKdLZGdMdNZHiZIdOdPZJdQdRZKdSdTZLdUdVZMdWdXZNdYdZZOd[d\ZPd]d^ZQd_d`ZRdadbZSdcddZTeTZUdedfZVe!fdgdhZWddidjZXddkdlZYdmdnZZdodpZ[dqdrZ\dsdtZ]d'a^Gdudvdvej_Z`GdwdxdxejaZbGdydzdzejcZdGd{d|d|eeZfd}d~ZgddZhddZidddZjd%akddZlddZmemdS)a%Abseil Python logging module implemented on top of standard logging. Simple usage:: from absl import logging logging.info('Interesting Stuff') logging.info('Interesting Stuff with Arguments: %d', 42) logging.set_verbosity(logging.INFO) logging.log(logging.DEBUG, 'This will *not* be printed') logging.set_verbosity(logging.DEBUG) logging.log(logging.DEBUG, 'This will be printed') logging.warning('Worrying Stuff') logging.error('Alarming Stuff') logging.fatal('AAAAHHHHH!!!!') # Process exits. Usage note: Do not pre-format the strings in your program code. Instead, let the logging module perform argument interpolation. This saves cycles because strings that don't need to be printed are never formatted. Note that this module does not attempt to interpolate arguments when no arguments are given. In other words:: logging.info('Interesting Stuff: %s') does not raise an exception because logging.info() has only one argument, the message string. "Lazy" evaluation for debugging ------------------------------- If you do something like this:: logging.debug('Thing: %s', thing.ExpensiveOp()) then the ExpensiveOp will be evaluated even if nothing is printed to the log. To avoid this, use the level_debug() function:: if logging.level_debug(): logging.debug('Thing: %s', thing.ExpensiveOp()) Per file level logging is supported by logging.vlog() and logging.vlog_is_on(). For example:: if logging.vlog_is_on(2): logging.vlog(2, very_expensive_debug_message()) Notes on Unicode ---------------- The log output is encoded as UTF-8. Don't pass data in other encodings in bytes() instances -- instead pass unicode string instances when you need to (for both the format string and arguments). Note on critical and fatal: Standard logging module defines fatal as an alias to critical, but it's not documented, and it does NOT actually terminate the program. This module only defines fatal but not critical, and it DOES terminate the program. The differences in behavior are historical and unfortunate. N)abc)flags) converter)NoReturnz^(?P[IWEF])(?P\d\d)(?P\d\d) (?P\d\d):(?P\d\d):(?P\d\d)\.(?P\d\d\d\d\d\d) +(?P-?\d+) (?P[a-zA-Z<][\w._<>-]+):(?P\d+)LZ_absl_log_fatalz CRITICAL - loggingz __init__.0123)debuginfowarningwarnerrorfatalrrrr)r r r rcsBeZdZdZfddZeddZejddZddZZ S) _VerbosityFlagzFlag class for -v/--verbosity.cs,tt|jttg|Ri|dSN)superr__init__rZ IntegerParserArgumentSerializerselfargskwargs __class__Q/var/www/html/django/DPS/env/lib/python3.9/site-packages/absl/logging/__init__.pyrs z_VerbosityFlag.__init__cCs|jSr_valuerr r r!valuesz_VerbosityFlag.valuecCs||_|dSr)r#_update_logging_levelsrvr r r!r%scCsftsdS|jtjkr"t|j}ntj|jd}ttjj vrXt tj tj |n t |dS)zZUpdates absl logging levels to the current verbosity. Visibility: module-private Nr ) _absl_loggerr#r ABSL_DEBUGabsl_to_standardr DEBUG _absl_handlerroothandlerssetLevelNOTSET)rZstandard_verbosityr r r!r&s   z%_VerbosityFlag._update_logging_levels) __name__ __module__ __qualname____doc__rpropertyr%setterr& __classcell__r r rr!rs   rcsBeZdZdZfddZeddZejddZddZZ S) _LoggerLevelsFlagzFlag class for --logger_levels.cs(tt|jttg|Ri|dSr)rr9r_LoggerLevelsParser_LoggerLevelsSerializerrrr r!rs z_LoggerLevelsFlag.__init__cCs |jSr)r#copyr$r r r!r%sz_LoggerLevelsFlag.valuecCs|dur in||_|dSr)r#_update_logger_levelsr'r r r!r%scCs(|jD]\}}t||q dSr)r#itemsr getLoggerr0)rnamelevelr r r!r=sz'_LoggerLevelsFlag._update_logger_levels) r2r3r4r5rr6r%r7r=r8r r rr!r9s   r9c@seZdZdZddZdS)r:z Parser for --logger_levels flag.cCsbt|tjr|Sdd|dD}t}|D],}|dd\}}|}|}|||<q0|S)NcSsg|]}|r|qSr )strip).0pairr r r! z-_LoggerLevelsParser.parse..,:r ) isinstancerMappingsplit collections OrderedDictrB)rr%pairslevelsZ name_levelr@rAr r r!parses  z_LoggerLevelsParser.parseN)r2r3r4r5rPr r r r!r:sr:c@seZdZdZddZdS)r;z$Serializer for --logger_levels flag.cCs&t|tr|Sddd|DS)NrGcss|]\}}d||VqdS)z{}:{}N)format)rCr@rAr r r! sz4_LoggerLevelsSerializer.serialize..)rIstrjoinr>)rr%r r r! serializes   z!_LoggerLevelsSerializer.serializeN)r2r3r4r5rUr r r r!r;sr;cs:eZdZdZfddZeddZejddZZS)_StderrthresholdFlagz!Flag class for --stderrthreshold.cs,tt|jttg|Ri|dSr)rrVrrArgumentParserrrrr r!r s z_StderrthresholdFlag.__init__cCs|jSrr"r$r r r!r%sz_StderrthresholdFlag.valuecCs^|tvrt|}t|}n:|tvrH|}|dkr:d}tt|}n td|||_dS)Nrrz--stderrthreshold must be one of (case-insensitive) 'debug', 'info', 'warning', 'error', 'fatal', or '0', '1', '2', '3', not '%s')_CPP_LEVEL_TO_NAMESintlower_CPP_NAME_TO_LEVELS ValueErrorr#)rr(Z cpp_valuer r r!r%s  ) r2r3r4r5rr6r%r7r8r r rr!rVs   rV logtostderrFzShould only log to stderr?T)Zallow_override_cppalsologtostderrzalso log to stderr?log_dirZ TEST_TMPDIRz directory to write logfiles into verbosityzLogging verbosity level. Messages logged at this level or lower will be included. Set to 1 for debug logging. If the flag was not set or supplied, the value will be changed from the default of -1 (warning) to 0 (info) after flags are parsed.r()Z short_nameallow_hide_cpp logger_levelszSpecify log level of loggers. The format is a CSV list of `name:level`. Where `name` is the logger name used with `logging.getLogger()`, and `level` is a level name (INFO, DEBUG, etc). e.g. `myapp.foo:INFO,other.logger:DEBUG`stderrthresholdaMlog messages at this level, or more severe, to stderr in addition to the logfile. Possible values are 'debug', 'info', 'warning', 'error', and 'fatal'. Obsoletes --alsologtostderr. Using --alsologtostderr cancels the effect of this flag. Please also note that this flag is subject to --verbosity and requires logfile not be stderr.)rcshowprefixforinfozIf False, do not prepend prefix to info messages when it's logged to stderr, --verbosity is set to INFO level, and python logging is used.cCs tdjS)zReturns the logging verbosity.ra)FLAGSr%r r r r! get_verbosityPsrhcCs8z t|}Wn ty,tj|}Yn0|t_dS)aoSets the logging verbosity. Causes all messages of level <= v to be logged, and all messages of level > v to be silently discarded. Args: v: int|str, the verbosity level as an integer or string. Legal string values are those that can be coerced to an integer as well as case-insensitive 'debug', 'info', 'warning', 'error', and 'fatal'. N)rYr\r ABSL_NAMESupperrgra)r( new_levelr r r! set_verbosityUs   rlcCsP|tjvrtj|t_n4t|tr8|tjvr8|t_ntd |t |dS)a:Sets the stderr threshold to the value passed in. Args: s: str|int, valid strings values are case-insensitive 'debug', 'info', 'warning', 'error', and 'fatal'; valid integer values are logging.DEBUG|INFO|WARNING|ERROR|FATAL. Raises: ValueError: Raised when s is an invalid value. zset_stderrthreshold only accepts integer absl logging level from -3 to 1, or case-insensitive string values 'debug', 'info', 'warning', 'error', and 'fatal'. But found "{}" ({}).N) r ABSL_LEVELSrgrerIrSrjrir\rQtype)sr r r!set_stderrthresholdgs rpcOstt|g|Ri|dS)zLogs a fatal message.N)logFATALmsgrrr r r!r~scOstt|g|Ri|dS)zLogs an error message.N)rqERRORrsr r r!rscOstt|g|Ri|dS)zLogs a warning message.N)rqWARNINGrsr r r!rscOs*tdtdtt|g|Ri|dS)z"Deprecated, use 'warning' instead.z8The 'warn' function is deprecated, use 'warning' insteadrN)warningsrDeprecationWarningrqrvrsr r r!rsrcOstt|g|Ri|dS)zLogs an info message.N)rqINFOrsr r r!rscOstt|g|Ri|dS)zLogs a debug message.N)rqr,rsr r r!rsrcOs"t|g|Ri|ddidS)z.Logs an exception, with traceback and message.exc_infoTN)rrsr r r! exceptionsr{cCstt|tS)zWrapper for _log_counter_per_token. Thread-safe. Args: token: The token for which to look up the count. Returns: The number of times this function has been called with *token* as an argument (starting at 0). )next_log_counter_per_token setdefault itertoolscount)tokenr r r!_get_next_log_count_per_tokens rcGs,tt}t|||| g|RdS)anLogs ``msg % args`` at level 'level' once per 'n' times. Logs the 1st call, (N+1)st call, (2N+1)st call, etc. Not threadsafe. Args: level: int, the absl logging level at which to log. msg: str, the message to be logged. n: int, the number of times this should be called before it is logged. *args: The args to be substituted into the msg. Nrget_absl_logger findCallerlog_ifrArtnrrr r r! log_every_ns rcCs<t}t|d}|dus(|||kr4|t|<dSdSdS)aTests if 'num_seconds' have passed since 'token' was requested. Not strictly thread-safe - may log with the wrong frequency if called concurrently from multiple threads. Accuracy depends on resolution of 'timeit.default_timer()'. Always returns True on the first call for a given 'token'. Args: token: The token for which to look up the count. num_seconds: The number of seconds to test for. Returns: Whether it has been >= 'num_seconds' since 'token' was last requested. NTF)timeitZ default_timer_log_timer_per_tokenget)rZ num_secondsnowthenr r r!_seconds_have_elapseds  rcGs(tt|}t|||g|RdS)aLogs ``msg % args`` at level ``level`` iff ``n_seconds`` elapsed since last call. Logs the first call, logs subsequent calls if 'n' seconds have elapsed since the last logging call from the same call site (file + line). Not thread-safe. Args: level: int, the absl logging level at which to log. msg: str, the message to be logged. n_seconds: float or int, seconds which should elapse before logging again. *args: The args to be substituted into the msg. N)rrrr)rArtZ n_secondsrZ should_logr r r!log_every_n_secondss rcGs*tt}t||||kg|RdS)a0Logs ``msg % args`` at level ``level`` only first ``n`` times. Not threadsafe. Args: level: int, the absl logging level at which to log. msg: str, the message to be logged. n: int, the maximal number of times the message is logged. *args: The args to be substituted into the msg. Nrrr r r! log_first_ns rcGs|rt||g|RdS)zFLogs ``msg % args`` at level ``level`` only if condition is fulfilled.Nrq)rArt conditionrr r r!rsrcOsb|tjkrtj|d}n|tjkr*tj}t|}tjjsDtt j ||g|Ri|dS)aDLogs ``msg % args`` at absl logging level ``level``. If no args are given just print msg, ignoring any interpolation specifiers. Args: level: int, the absl logging level at which to log the message (logging.DEBUG|INFO|WARNING|ERROR|FATAL). While some C++ verbose logging level constants are also supported, callers should prefer explicit logging.vlog() calls for such purpose. msg: str, the message to be logged. *args: The args to be substituted into the msg. **kwargs: May contain exc_info to add exception traceback to message. r N) rr*STANDARD_DEBUG ABSL_FATALr+r r.r/ basicConfigr)rq)rArtrrstandard_levelr r r!rq s   rqcOst||g|Ri|dS)aLog ``msg % args`` at C++ vlog level ``level``. Args: level: int, the C++ verbose logging level at which to log the message, e.g. 1, 2, 3, 4... While absl level constants are also supported, callers should prefer logging.log|debug|info|... calls for such purpose. msg: str, the message to be logged. *args: The args to be substituted into the msg. **kwargs: May contain exc_info to add exception traceback to message. Nr)rArtrrr r r!vlog-s rcCs>|tjkrtj|d}n|tjkr*tj}t|}t|S)aChecks if vlog is enabled for the given level in caller's source file. Args: level: int, the C++ verbose logging level at which to log the message, e.g. 1, 2, 3, 4... While absl level constants are also supported, callers should prefer level_debug|level_info|... calls for checking those. Returns: True if logging is turned on for that level. r )rr*rrr+r) isEnabledFor)rArr r r! vlog_is_on;s   rcCstdSzFlushes all log files.N)get_absl_handlerflushr r r r!rTsrcCs ttkS)z+Returns True if debug logging is turned on.)rhr,r r r r! level_debugYsrcCs ttkS)z*Returns True if info logging is turned on.)rhryr r r r! level_info^srcCs ttkS)z-Returns True if warning logging is turned on.)rhrvr r r r! level_warningcsrcCs ttkS)z+Returns True if error logging is turned on.)rhrur r r r! level_errorksrcCsN|tjvrtd|tjj}|tjks@|tj ks@t |dsDdS|j SdS)aDReturns the name of the log file. For Python logging, only one file is used and level is ignored. And it returns empty string if it logs to stderr/stdout or the log stream has no `name` attribute. Args: level: int, the absl.logging level. Raises: ValueError: Raised when `level` has an invalid value. zInvalid absl.logging level {}r@r`N) rrmr\rQrpython_handlerstreamsysstderrstdouthasattrr@)rArr r r!get_log_file_nameps  rcCs|s*tjtjtjdd}d|}t|d}z t}Wn.t ynt tdrft t }nd}Yn0t }d|||f}|||fS)aComputes the directory and filename prefix for log file. Args: program_name: str|None, the filename part of the path to the program that is running without its extension. e.g: if your program is called ``usr/bin/foobar.py`` this method should probably be called with ``program_name='foobar`` However, this is just a convention, you can pass in any string you want, and it will be used as part of the log filename. If you don't pass in anything, the default behavior is as described in the example. In python standard logging mode, the program_name will be prepended with ``py_`` if it is the ``program_name`` argument is omitted. log_dir: str|None, the desired log directory. Returns: (log_dir, file_prefix, symlink_prefix) Raises: FileNotFoundError: raised in Python 3 when it cannot find a log directory. OSError: raised in Python 2 when it cannot find a log directory. rzpy_%s)r_getuidunknownz %s.%s.%s.log)ospathsplitextbasenamerargv find_log_dirgetpassgetuserKeyErrorrrSrsocket gethostname) program_namer_actual_log_dirusernamehostname file_prefixr r r!find_log_dir_and_namess     rcCsh|r |g}n tdjr$tdjg}nddg}|D]&}tj|r0t|tjr0|Sq0td|dS)aReturns the most suitable directory to put log files into. Args: log_dir: str|None, if specified, the logfile(s) will be created in that directory. Otherwise if the --log_dir command-line flag is provided, the logfile will be created in that directory. Otherwise the logfile will be created in a standard location. Raises: FileNotFoundError: raised in Python 3 when it cannot find a log directory. OSError: raised in Python 2 when it cannot find a log directory. r_z/tmp/z./z2Can't find a writable directory for logs, tried %sN)rgr%rrisdiraccessW_OKFileNotFoundError)r_dirsdr r r!rs  rc Csrt|j}t|jdd}d}|j}t|r:tj}t}t |}d||j |j |j |j|j|t|j|j|f S)zxReturns the absl log prefix for the log record. Args: record: logging.LogRecord, the record to get prefix for. g?g.Ar`z,%c%02d%02d %02d:%02d:%02d.%06d %5d %s:%d] %s)time localtimecreatedrYlevelno_is_non_absl_fatal_recordr ru_CRITICAL_PREFIXrZget_initial_for_leveltm_montm_mdaytm_hourtm_mintm_sec_get_thread_idfilenamelineno)recordZ created_tupleZcreated_microsecondZcritical_prefixrAZseverityr r r!get_absl_log_prefixs*  rcCstt|r8t|dd}|dur$td|j}|j}|j}n*t|trZt d}|}d}nt dt ||||S)aSkips reporting the prefix of a given function or name by :class:`~absl.logging.ABSLLogger`. This is a convenience wrapper function / decorator for :meth:`~absl.logging.ABSLLogger.register_frame_to_skip`. If a callable function is provided, only that function will be skipped. If a function name is provided, all functions with the same name in the file that this is called in will be skipped. This can be used as a decorator of the intended function to be skipped. Args: func: Callable function or its name as a string. Returns: func (the input, unchanged). Raises: ValueError: The input is callable but does not have a function code object. TypeError: The input is neither callable nor a string. __code__Nz4Input callable does not have a function code object.rz'Input is neither callable nor a string.) callablegetattrr\ co_filenameco_nameco_firstlinenorIrSrr TypeError ABSLLoggerregister_frame_to_skip)func func_code file_name func_nameZ func_linenor r r!skip_log_prefixs  rcCs|jtjko|jtd SNFrr rr__dict__r_ABSL_LOG_FATALZ log_recordr r r!rs rcCs|jtjko|jtdSrrrr r r!_is_absl_fatal_record$s  rcsbeZdZdZdfdd ZdddZdddZd d Zfd d Zfd dZ fddZ Z S) PythonHandlerz?The handler class used by Abseil Python logging implementation.Ncs$tt||||ptdSr)rrr setFormatterPythonFormatter)rr formatterrr r!r0szPythonHandler.__init__c Csdt_t||d\}}}d|tdtttf}tj ||}t |ddd|_ t tdd rtj ||d }z.tj |rt|ttj||WntyYn0d S) z;Starts logging messages to files instead of standard error.Frr_z %s.INFO.%s.%dz %Y%m%d-%H%M%Sazutf-8)encodingsymlinkNz.INFO)rgr]rrstrftimerrgetpidrrTopenrrislinkunlinkrrEnvironmentError) rrr_rrZsymlink_prefixrrrr r r!start_logging_to_file4s&     z#PythonHandler.start_logging_to_filecCs&tdjrtj|_n|j||ddS)z4Conditionally logs to files, based on --logtostderr.r]rN)rgr%rrrrrrr_r r r!use_absl_log_fileQs  zPythonHandler.use_absl_log_filec CsJ|z2z|jWnttfy.Yn0W|n |0dSr)acquirerrrr\releaser$r r r!rXs zPythonHandler.flushcs6|j}tj|_ztt||W||_n||_0dS)zEmits the record to stderr. This temporarily sets the handler stream to stderr, calls StreamHandler.emit, then reverts the stream back. Args: record: logging.LogRecord, the record to log. N)rrrrremit)rr old_streamrr r!_log_to_stderrcs zPythonHandler._log_to_stderrcs|j}ts.tr"tjdda||n^tdjrD||nHt t | |t tdj}tdjsv||kr|jtjkr||t|r|tdS)aPrints a record out to some streams. 1. If ``FLAGS.logtostderr`` is set, it will print to ``sys.stderr`` ONLY. 2. If ``FLAGS.alsologtostderr`` is set, it will print to ``sys.stderr``. 3. If ``FLAGS.logtostderr`` is not set, it will log to the stream associated with the current thread. Args: record: :class:`logging.LogRecord`, the record to emit. z5WARNING: Logging before flag parsing goes to stderr. Fr]rer^N)rrgZ is_parsed_warn_preinit_stderrrrwriterr%rrrrZstring_to_standardrrrrabort)rrrAZstderr_thresholdrr r!rus*     zPythonHandler.emitcs|zx|zBtjtjtjtjf}|j|vrRt|jdrH|j sR|j Wnt yfYn0t t | W|n |0dS)z*Closes the stream to which we are writing.isattyN)rrrrr __stderr__ __stdout__rrrcloser\rrr)rZ user_managedrr r!rs   zPythonHandler.close)NN)NN)NN) r2r3r4r5rrrrrrrr8r r rr!r-s    *rcs|eZdZdZfddZddZddZdd Zd d Zfd d Z ddZ e ddZ ddZ dddZdddZZS) ABSLHandlerz+Abseil Python logging module's log handler.cs&tt|t|d|_|dS)N)r)rrrr_python_handleractivate_python_handler)rpython_logging_formatterrr r!rs zABSLHandler.__init__cCs |j|Sr)_current_handlerrQrrr r r!rQszABSLHandler.formatcCs|j|dSr)rr)rfmtr r r!rszABSLHandler.setFormattercCs|j|dSr)rrrr r r!rszABSLHandler.emitcCs|jdSr)rrr$r r r!rszABSLHandler.flushcstt||jdSr)rrrrr$rr r!rszABSLHandler.closecCs||}|r|j|S|Sr)filterrhandle)rrrvr r r!r s  zABSLHandler.handlecCs|jSr)rr$r r r!rszABSLHandler.python_handlercCs |j|_dS)z?Uses the Python logging handler as the current logging handler.N)rrr$r r r!rsz#ABSLHandler.activate_python_handlerNcCs|j||dSr)rrrr r r!rszABSLHandler.use_absl_log_filecCs|j||dSr)rrrr r r!rsz!ABSLHandler.start_logging_to_file)NN)NN)r2r3r4r5rrQrrrrr r6rrrrr8r r rr!rs    rcs eZdZdZfddZZS)rz=Formatter class used by :class:`~absl.logging.PythonHandler`.csVtdjs:tdjtjkr:|jtjkr:tjj t j kr:d}nt |}|t t||S)zAppends the message from the record to the results of the prefix. Args: record: logging.LogRecord, the record to be formatted. Returns: The formatted string representing the record. rfrar`)rgr%r ABSL_INFOrr ryr-rrrrrrrrQ)rrprefixrr r!rQs   zPythonFormatter.format)r2r3r4r5rQr8r r rr!rsrcs~eZdZdZeZdddZddZdd Zd d Z d d Z ddZ ddZ ddZ fddZddZedddZZS)raA logger that will create LogRecords while skipping some stack frames. This class maintains an internal list of filenames and method names for use when determining who called the currently executing stack frame. Any method names from specific source files are skipped when walking backwards through the stack. Client code should use the register_frame_to_skip method to let the ABSLLogger know which method from which file should be excluded from the walk backwards through the stack. Fr cCstj}td}|r|j}t|jvr|j|j|jf|vr|j|jf|vrd}|r~t }| dt j ||d|d}|j|j|j|fS|j}qdS)aFinds the frame of the calling method on the stack. This method skips any frames registered with the ABSLLogger and any methods from this file, and whatever method is currently being used to generate the prefix for the log line. Then it returns the file name, line number, and method name of the calling method. An optional fourth item may be returned, callers who only need things from the first three are advised to always slice or index the result rather than using direct unpacking assignment. Args: stack_info: bool, when True, include the stack trace as a fourth item returned. On Python 3 there are always four items returned - the fourth will be None when this is False. On Python 2 the stdlib base class API only returns three items. We do the same when this new parameter is unspecified or False for compatibility. Returns: (filename, lineno, methodname[, sinfo]) of the calling method. rNzStack (most recent call last): )file )r_frames_to_skipr _getframef_code_LOGGING_FILE_PREFIXrrrioStringIOr traceback print_stackgetvaluerstripf_linenof_back)r stack_info stacklevelZ f_to_skipframecodesinfooutr r r!rs*   zABSLLogger.findCallercOs |jtj|g|Ri|dS)z/Logs ``msg % args`` with severity ``CRITICAL``.N)rqr CRITICALrrtrrr r r!critical0szABSLLogger.criticalcOs |jtj|g|Ri|dS)z,Logs ``msg % args`` with severity ``FATAL``.N)rqr rrr$r r r!r4szABSLLogger.fatalcOs |jtj|g|Ri|dS)z,Logs ``msg % args`` with severity ``ERROR``.N)rqr rur$r r r!r8szABSLLogger.errorcOs.tdtd|jtj|g|Ri|dS)z+Logs ``msg % args`` with severity ``WARN``.z6The 'warn' method is deprecated, use 'warning' insteadrN)rwrrxrqr WARNr$r r r!r<szABSLLogger.warncOs |jtj|g|Ri|dS)z.Logs ``msg % args`` with severity ``WARNING``.N)rqr rvr$r r r!rBszABSLLogger.warningcOs |jtj|g|Ri|dS)z+Logs ``msg % args`` with severity ``INFO``.N)rqr ryr$r r r!rFszABSLLogger.infocOs |jtj|g|Ri|dS)z,Logs ``msg % args`` with severity ``DEBUG``.N)rqr r,r$r r r!rJszABSLLogger.debugcsB|tjkr|di}d|t<tt|j||g|Ri|dS)aLogs a message at a cetain level substituting in the supplied arguments. This method behaves differently in python and c++ modes. Args: level: int, the standard logging level at which to log the message. msg: str, the text of the message to log. *args: The arguments to substitute in the message. **kwargs: The keyword arguments to substitute in the message. extraTN)r rrr~rrrrq)rrArtrrr'rr r!rqNs  zABSLLogger.logcCs||r||dS)aCalls handlers without checking ``Logger.disabled``. Non-root loggers are set to disabled after setup with :func:`logging.config` if it's not explicitly specified. Historically, absl logging will not be disabled by that. To maintaining this behavior, this function skips checking the ``Logger.disabled`` bit. This logger can still be disabled by adding a filter that filters out everything. Args: record: logging.LogRecord, the record to handle. N)r  callHandlersrr r r!r as zABSLLogger.handleNcCs0|dur|j|||fn|j||fdS)aRegisters a function name to skip when walking the stack. The :class:`~absl.logging.ABSLLogger` sometimes skips method calls on the stack to make the log messages meaningful in their appropriate context. This method registers a function from a particular file as one which should be skipped. Args: file_name: str, the name of the file that contains the function. function_name: str, the name of the function to skip. line_number: int, if provided, only the function with this starting line number will be skipped. Otherwise, all functions with the same name in the file will be skipped. N)radd)clsr function_name line_numberr r r!rrsz!ABSLLogger.register_frame_to_skip)Fr )N)r2r3r4r5setrrr%rrrrrrrqr  classmethodrr8r r rr!rs  * rcCst}|t@S)a[Gets id of current thread, suitable for logging as an unsigned quantity. If pywrapbase is linked, returns GetTID() for the thread ID to be consistent with C++ logging. Otherwise, returns the numeric thread id. The quantities are made unsigned by masking with 2*sys.maxint + 1. Returns: Thread ID unique to this process (unsigned) ) threading get_ident_THREAD_ID_MASK) thread_idr r r!rs rcCstS)z!Returns the absl logger instance.)r)r r r r!rsrcCstS)z"Returns the absl handler instance.)r-r r r r!rsrcCst|stddS)z{Uses the python implementation of the logging code. Args: quiet: No logging message about switching logging type. zRestoring pure python loggingN)rrr)quietr r r!use_python_loggings r4cCsjts0ddtjjD}|D]}tj|qdat}|tjjvrftj|tdtd dS)zUses the ABSL logging handler for logging. This method is called in :func:`app.run()` so the absl handler is used in absl apps. cSs(g|] }t|tjr|jtjkr|qSr )rIr StreamHandlerrrr)rChr r r!rEsz$use_absl_handler..TrardN) +_attempted_to_remove_stderr_stream_handlersr r.r/ removeHandlerr addHandlerrgr&r=)r/r6Z absl_handlerr r r!use_absl_handlers   r:cCs@trdSt}tttdat|t}t|adS)z!Initializes loggers and handlers.Nabsl) r)r getLoggerClasssetLoggerClassrr?rrr-)Zoriginal_logger_classrr r r! _initializes   r>)NN)N)F)nr5rLrrrrr rrstructrr/rrrtypesrwr;rZ absl.loggingrtypingr ImportErrorrgrrrZ ABSL_ERRORruZ ABSL_WARNINGrvr&r ryr*r,ZABSL_LOGGING_PREFIX_REGEXcalcsizer1rrrrTrr)r-r[rXFlagrr9rWr:objectr;rVZDEFINE_booleanZ DEFINE_stringgetenvZ DEFINE_flagrhrlrprrrrrrr{r}rrrrrrrrqrrrrrrZ level_warnrrrrrrrrrr5rHandlerr Formatterrr<rrrrr4r7r:r>r r r r!s@      * "  "  1  '.