nSrSSKJr SSKJr SSKJr SSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK r SSKrSSKrSSKrSSKrSSKrSSKJr SSKJr SSKJr SSKr\R4(aSSKrOSSKrSS KJr \RBr!\RDr#\RHr%\RLr'\RLr(\RRr*\RVr,S r-S \ R\"S 5S --S- r/Sr0Sr1\ RdRgSS5r4Sq5Sq6SSSSSSS.r7SSSSS.r8"SS\Rr5r:"SS \Rr5r;"S!S"\Rx5r="S#S$\>5r?"S%S&\Rr5r@\R"S'S(S)S*S+9 \R"S,S(S-S*S+9 \R"S.\ R"S/S05S1S*S+9 \R"\:"S2S3S4S5S*S695 \R"\;"S70S855 \R"\@"S9SS:S*S;95 \R"SrES?rFS@rGSArHSBrISCrJ\R4(a\JrKOSDrKSErLSFrMSGrN0rOSHrPSIrQ0rRSJrSSKrTSLrUSMrVSNrWSOrXSPrYSQrZSRr[SSr\STr]\]r^SUr_\*4SVjr`SkSWjraSlSXjrbSYrcSZrdS[reS\rfS*qg"S]S^\ R5ri"S_S`\ R5rk"SaSb\ R5rm"ScSd\ R"55roSerpSfrqSgrrSmShjrsS(qtSiruSjrv\v"5 g!\ a GNf=f)naAbseil 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. )absolute_import)division)print_functionN)flags)abc) 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+)L_absl_log_fatalz CRITICAL - loggingz __init__.0123)debuginfowarningwarnerrorfatalrrrr)rrrrcf^\rSrSrSrU4Sjr\S5r\RS5rSr Sr U=r $)_VerbosityFlagzFlag class for -v/--verbosity.c>[[U] "[R"5[R "5/UQ70UD6 gN)superr__init__r IntegerParserArgumentSerializerselfargskwargs __class__s 0platform/bq/third_party/absl/logging/__init__.pyr _VerbosityFlag.__init__s> .$(    " cUR$r_valuer$s r(value_VerbosityFlag.value ;;r*c0XlUR5 gr)r-_update_logging_levelsr$vs r(r/r0sK!r*c[(dgUR[R::a![R"UR5nO [ R URS- - n[[ RR;aC[R[ R5 [ RRU5 g[RU5 g)zRUpdates absl logging levels to the current verbosity. Visibility: module-private Nr ) _absl_loggerr-r ABSL_DEBUGabsl_to_standardrDEBUG _absl_handlerroothandlerssetLevelNOTSET)r$standard_verbositys r(r3%_VerbosityFlag._update_logging_levelss <  {{i***$55dkkB#==DKK!O< ---GNN+ ll././r*r,) __name__ __module__ __qualname____firstlineno____doc__r propertyr/setterr3__static_attributes__ __classcell__r's@r(rrsA&    <<""00r*rcf^\rSrSrSrU4Sjr\S5r\RS5rSr Sr U=r $)_LoggerLevelsFlagzFlag class for --logger_levels.cX>[[U] "[5[ 5/UQ70UD6 gr)rrMr _LoggerLevelsParser_LoggerLevelsSerializerr#s r(r _LoggerLevelsFlag.__init__s3 T+! r*c6URR5$r)r-copyr.s r(r/_LoggerLevelsFlag.values ;;   r*c<Uc0OUUlUR5 gr)r-_update_logger_levelsr4s r(r/rUs "qDK r*cURR5H*up[R"U5R U5 M, gr)r-itemsr getLoggerr>)r$namelevels r(rW'_LoggerLevelsFlag._update_logger_levelss6{{((*  &&u-+r*r,) rBrCrDrErFr rGr/rHrWrIrJrKs@r(rMrMsA'    <<!!..r*rMc\rSrSrSrSrSrg)rPz Parser for --logger_levels flag.c[U[R5(aU$URS5Vs/sH)o"R 5(dMUR 5PM+ nn[ R "5nUH;nURSS5upgUR 5nUR 5nXtU'M= U$s snf)N,:r ) isinstancerMappingsplitstrip collections OrderedDict)r$r/pairpairslevels name_levelr[r\s r(parse_LoggerLevelsParser.parses%%% l&+kk#&6 G&6d**,\TZZ\&6E G $ $ &F $$S!,kd ZZ\dkkmeTl  M Hs B?B?N)rBrCrDrErFrmrIror*r(rPrPs ( r*rPc\rSrSrSrSrSrg)rQz$Serializer for --logger_levels flag.c[U[R5(aU$SRSUR 555$)Nrac3H# UHupSRX5v M g7f)z{}:{}N)format).0r[r\s r( 4_LoggerLevelsSerializer.serialize..s"F7D t##}s ")rcsix string_typesjoinrY)r$r/s r( serialize!_LoggerLevelsSerializer.serializesB%))** l 88F7<{{}F FFr*roN)rBrCrDrErFr{rIror*r(rQrQs ,Fr*rQc`^\rSrSrSrU4Sjr\S5r\RS5rSr U=r $)_StderrthresholdFlagi z!Flag class for --stderrthreshold.c>[[U] "[R"5[R "5/UQ70UD6 gr)rr~r rArgumentParserr"r#s r(r _StderrthresholdFlag.__init__ s? .    " r*cUR$rr,r.s r(r/_StderrthresholdFlag.valuer1r*cU[;a[U5n[UnOQUR5[;a+UR5nUS:XaSn[[U5nO[ SU-5eXlg)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-)r$r5 cpp_values r(r/rsw a&i a a ) ) '')a f )!,-i  ,./ 0 11 Kr*r,) rBrCrDrErFr rGr/rHrIrJrKs@r(r~r~ s7)    <<r*r~ logtostderrFzShould only log to stderr?T)allow_override_cppalsologtostderrzalso log to stderr?log_dir 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.r5) 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.)rshowprefixforinfozIf 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.c([SR$)zReturns the logging verbosity.r)FLAGSr/ror*r( get_verbosityrTs {  ! !!r*c[U5nU[ lg![a$ [RUR 5nN9f=f)aaSets 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)rrr ABSL_NAMESupperrr)r5 new_levels r( set_verbosityrYs@0AI%/ 0$$QWWY/I0s +AAc2U[R;a[RU[lg[ U[ 5(a.UR 5[R;a U[lg[SRU[U555e)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_LEVELSrrrcstrrrrrttype)ss r(set_stderrthresholdrksq)  %11!4E!Saggi9+?+??E   &vaa1  33r*c,[[U/UQ70UD6 g)zLogs a fatal message.N)logFATALmsgr%r&s r(rrseS"4"6"r*c,[[U/UQ70UD6 g)zLogs an error message.N)rERRORrs r(rreS"4"6"r*c,[[U/UQ70UD6 g)zLogs a warning message.N)rWARNINGrs r(rrsgs$T$V$r*cd[R"S[S5 [[U/UQ70UD6 g)z"Deprecated, use 'warning' instead.z8The 'warn' function is deprecated, use 'warning' insteadr N)warningsrDeprecationWarningrrrs r(rrs* MML$a)&t&v&r*c,[[U/UQ70UD6 g)zLogs an info message.N)rINFOrs r(rrsdC!$!&!r*c,[[U/UQ70UD6 g)zLogs a debug message.N)rr:rs r(rrrr*c"[U/UQ7SS06 g)z.Logs an exception, with traceback and message.exc_infoTN)r)rr%s r( exceptionrs"d"T"r*cf[[RU[R"555$)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)tokens r(_get_next_log_count_per_tokenrs$ $//y7HI JJr*cn[[5R55n[XXB-(+/UQ76 g)a\Logs '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_ifr\rnr%rs r( log_every_nrs- ((9(D(D(F G%%)_,t,r*c[R"5n[RUS5nUbX#- U:a U[U'gg)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)timeit default_timer_log_timer_per_tokenget)r num_secondsnowthens r(_seconds_have_elapsedrsC #  ! !% .$ \cj[0"%  r*cb[[5R5U5n[XU/UQ76 g)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)r\r n_secondsr% should_logs r(log_every_n_secondsrs+%_%6%A%A%CYO*Z'$'r*cd[[5R55n[XXB:/UQ76 g)aLogs '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. Nrrs r( log_first_nrs+ ((9(D(D(F G%UY&&r*c,U(a [X/UQ76 gg)zBLogs 'msg % args' at level 'level' only if condition is fulfilled.Nr)r\r conditionr%s r(rr sTr*cjU[R:a[RUS- - nO:U[R:a[Rn[R"U5n[ R R(d[ R"5 [R"XA/UQ70UD6 g)a,Logs '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) rr8STANDARD_DEBUG ABSL_FATALr9rr<r= basicConfigr7r)r\rr%r&standard_levels r(rrs Y ! !!--;N y###""e//6N    >888r*c"[X/UQ70UD6 g)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)r\rr%r&s r(vlogr5se"4"6"r*cU[R:a[RUS- - nO:U[R:a[Rn[R"U5n[ R U5$)aoChecks 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 )rr8rrr9r7 isEnabledFor)r\rs r( vlog_is_onrCsb Y ! !!--;N y###""e//6N  " "> 22r*c4[5R5 gzFlushes all log files.N)get_absl_handlerflushror*r(rr\sr*c$[5[:$)z+Returns True if debug logging is turned on.)rr:ror*r( level_debugra E !!r*c$[5[:$)z*Returns True if info logging is turned on.)rrror*r( level_inforfs D  r*c$[5[:$)z-Returns True if warning logging is turned on.)rrror*r( level_warningrks G ##r*c$[5[:$)z+Returns True if error logging is turned on.)rrror*r( level_errorrsrr*c&U[R;a[SRU55e[ 5R R nU[R:Xd%U[R:Xd[US5(dgUR$)a4Returns 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) rrrrtrpython_handlerstreamsysstderrstdouthasattrr[)r\rs r(get_log_file_namerxsn )''' 4;;EB CC   , , 3 3&  f 2 && ! ! ;;r*cU(dU[RR[RR[R S55SnSU-n[ US9n[R"5n[R"5nU<SU<SU<S3nX%U4$![a: [[S5(a [[R"55nNfSnNjf=f)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)rgetuidunknown.z.log)ospathsplitextbasenamerargv find_log_dirgetpassgetuserKeyErrorrrrsocket gethostname) program_nameractual_log_dirusernamehostname file_prefixs r(find_log_dir_and_namesrs, 77##BGG$4$4SXXa[$AB1EL\)L0. H   !(".(C+ l 22 r8RYY[!hh s'B##=C'"C'&C'cU(aU/nO1[SR(a[SR/nOSS/nUHWn[RR U5(dM)[R "U[R 5(dMUUs $ [R(a[O[nU"SU-5e)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. rz/tmp/z./z2Can't find a writable directory for logs, tried %s) rr/rrisdiraccessW_OKrxPY2OSErrorFileNotFoundError)rdirsdexception_classs r(rrs 9D Y )  " " #D T?D a ww}}QBIIa11 h  #wwG,=/:TA CCr*c [R"UR5n[URS-S-5nSnURn[ U5(a[ Rn[n[R"U5nSUURURURURURU[!5UR"UR$U4 -$)zrReturns the absl log prefix for the log record. Args: record: logging.LogRecord, the record to get prefix for. g?g.Arz,%c%02d%02d %02d:%02d:%02d.%06d %5d %s:%d] %s)time localtimecreatedrlevelno_is_non_absl_fatal_recordrr_CRITICAL_PREFIXrget_initial_for_leveltm_montm_mdaytm_hourtm_mintm_sec_get_thread_idfilenamelineno)record created_tuplecreated_microsecondcritical_prefixr\severitys r(get_absl_log_prefixr.s ..0-FNNS0367/ ..%v&& MME&O  , ,U 3( 7 oo mm ;  r*cf[U5(a@[USS5nUc [S5eURnURnUR nOJ[ U[R5(a [5R5SnUnSnO [S5e[RX#U5 U$)aSkips reporting the prefix of a given function or name by ABSLLogger. This is a convenience wrapper function / decorator for `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_firstlinenorcrxryrr TypeError ABSLLoggerregister_frame_to_skip)func func_code file_name func_name func_linenos r(skip_log_prefixr>s,d^^j$/I M NN%%I!!I**K$(())!,,.q1IIK = >> ##I+F +r*cUR[R:=(a% URR [ S5(+$NFrrr__dict__r_ABSL_LOG_FATAL log_records r(rr(s7    - >!!%%ou= =?r*cUR[R:=(a URR [ S5$r@rArDs r(_is_absl_fatal_recordrG-s4    - :    ! !/5 9;r*cn^\rSrSrSrS U4SjjrS SjrS SjrSrU4Sjr U4Sjr U4S jr S r U=r $) PythonHandleri6z?The handler class used by Abseil Python logging implementation.cp>[[U] U5 URU=(d [ 55 gr)rrIr setFormatterPythonFormatter)r$r formatterr's r(r PythonHandler.__init__9s( -'/i4?#45r*c S[l[XS9up4nSU[R"S[R "[R"555[ R"54-n[ RRX65n[R(a[US5Ul O[USSS9Ul [[ SS 5(a[ RRX5S -5n[ RRU5(a[ R "U5 [ R""[ RR%U5U5 g g ![&a g f=f) z;Starts logging messages to files instead of standard error.Fr rz %s.INFO.%s.%dz %Y%m%d-%H%M%Sazutf-8)encodingsymlinkNz.INFO)rrrrstrftimerrgetpidrrzrxropenrr2islinkunlinkrSrEnvironmentError) r$r rr r symlink_prefixrr'rSs r(start_logging_to_file#PythonHandler.start_logging_to_file=sE2H!34/N ot~~diik'BC "Hww||N5H ww3'dk39dkr9d## ^g-EFg 77>>' " " ))G  277##H-w7 $   s>A.E.. E;:E;c~[SR(a[RUlgUR XS9 g)z4Conditionally logs to files, based on --logtostderr.rrPN)rr/rrrr[r$r rs r(use_absl_log_filePythonHandler.use_absl_log_file]s, ]!!JJdk   l Lr*cUR5 URR5 UR 5 g![[4a N#f=f!UR 5 f=fr)acquirerrrYrreleaser.s r(rPythonHandler.flushdsPLLN kk  lln j )    llns!=A AAAA%c>URn[RUl[[U]U5 X lg!X lf=f)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)rrrrrIemit)r$r) old_streamr's r(_log_to_stderrPythonHandler._log_to_stderros8J**DK M4%f-kJks >Ac>URn[R5(d>[(a![R R S5 SqURU5 O[SR(aURU5 O[[U]/U5 [R"[SR5n[SR(dX#:a/UR[R :waURU5 [U5(a&UR!5 ["R$"5 gg)a<Prints a record out to some streams. If FLAGS.logtostderr is set, it will print to sys.stderr ONLY. If FLAGS.alsologtostderr is set, it will print to sys.stderr. If FLAGS.logtostderr is not set, it will log to the stream associated with the current thread. Args: record: logging.LogRecord, the record to emit. z5WARNING: Logging before flag parsing goes to stderr. FrrrN)rr is_parsed_warn_preinit_stderrrrwriterhr/rrIrfrstring_to_standardrrGrrabort)r$r)r\stderr_thresholdr's r(rfPythonHandler.emits" NNE ??      D F$ &! }  # # &! M4%f-"55 ! " ( (* " # ) )U-F ++ # F#V$$ jjl hhj %r*c>UR5 UR5 [R[R[R [R 4nURU;aT[URS5(aURR5(dURR5 [[U]+5 UR5 g![a N/f=f!UR5 f=f)z*Closes the stream to which we are writing.isattyN)rbrrrr __stderr__ __stdout__rrrscloserrrIrc)r$ user_managedr's r(rvPythonHandler.closesLLN jjl  zz3::s~~s~~M ;;l * X..dkk6H6H6J6J ++    M4&( lln     llns/C9B"C)C9) C63C95C66C99D )rNN)rBrCrDrErFr r[r_rrhrfrvrIrJrKs@r(rIrI6s1G6 @M $(Tr*rIc^\rSrSrSrU4SjrSrSrSrSr U4Sjr S r \ S 5r S rSS jrSS jrSrU=r$) ABSLHandleriz+Abseil Python logging module's log handler.cf>[[U] 5 [US9UlUR 5 g)N)rM)rr{r rI_python_handleractivate_python_handler)r$python_logging_formatterr's r(r ABSLHandler.__init__s* +t%'(3KLD  "r*c8URRU5$r)_current_handlerrtr$r)s r(rtABSLHandler.formats  ' ' //r*c:URRU5 gr)rrK)r$fmts r(rKABSLHandler.setFormatters&&s+r*c:URRU5 gr)rrfrs r(rfABSLHandler.emitsv&r*c8URR5 gr)rrr.s r(rABSLHandler.flushs!r*c^>[[U] 5 URR5 gr)rr{rvr)r$r's r(rvABSLHandler.closes" +t"$!r*clURU5nU(aURRU5$U$r)filterrhandle)r$r)rvs r(rABSLHandler.handles/ V B  " " ) )& 11 Ir*cUR$r)r}r.s r(rABSLHandler.python_handlers   r*c&URUlg)z?Uses the Python logging handler as the current logging handler.N)r}rr.s r(r~#ABSLHandler.activate_python_handlers 00Dr*c:URRX5 gr)rr_r^s r(r_ABSLHandler.use_absl_log_files++LBr*c:URRX5 gr)rr[r^s r(r[!ABSLHandler.start_logging_to_files// Fr*)rr}ry)rBrCrDrErFr rtrKrfrrvrrGrr~r_r[rIrJrKs@r(r{r{sT3# 0,'""     1CGGr*r{c,^\rSrSrSrU4SjrSrU=r$)rLiz&Formatter class used by PythonHandler.cZ>[SR(dr[SR[R:XaMUR[ R :Xa/[RR[R:XaSnO [U5nU[[U]?U5-$)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. rrr)rr/r ABSL_INFOrrrr;rrrrr.rrLrt)r$r)prefixr's r(rtPythonFormatter.formats{ % & , , k  I$7$77',,&$$++szz9f"6*f E/47? ??r*ro)rBrCrDrErFrtrIrJrKs@r(rLrLs.@@r*rLc^\rSrSrSr\"5rSSjrSrSr Sr Sr Sr S r S rU4S jrS r\SS j5rSrU=r$)r7iaA 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. c[Rn[R"S5nU(Ga@URn[ UR ;GaUR URUR4U;aUR UR4U;a[R(a*U(d#UR URUR4$SnU(aY[R"5nURS5 [R "XGS9 UR#5R%S5nUR URURU4$UR&nU(aGM?gg)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. r NzStack (most recent call last): )file )r7_frames_to_skipr _getframef_code_LOGGING_FILE_PREFIXr3r4r5rxrf_linenoioStringIOrm traceback print_stackgetvaluerstripf_back)r$ stack_info stacklevel f_to_skipframecodesinfoouts r(rABSLLogger.findCallers ,**I MM! E  \\d d&6&6 6   T\\    '0 1   T\\ *) ; 77:""ENNDLLA A% ++-C II9 :  ! !% 2LLN))%0E""ENNDLL%H Hlle! %r*cNUR"[RU/UQ70UD6 g)z+Logs 'msg % args' with severity 'CRITICAL'.N)rrCRITICALr$rr%r&s r(criticalABSLLogger.critical?s HHW  s4T4V4r*cNUR"[RU/UQ70UD6 g)z(Logs 'msg % args' with severity 'FATAL'.N)rrrrs r(rABSLLogger.fatalCHHW]]C1$1&1r*cNUR"[RU/UQ70UD6 g)z(Logs 'msg % args' with severity 'ERROR'.N)rrrrs r(rABSLLogger.errorGrr*c[R(a[R"S[S5 UR "[ RU/UQ70UD6 g)z'Logs 'msg % args' with severity 'WARN'.z6The 'warn' method is deprecated, use 'warning' insteadr N)rxPY3rrrrrWARNrs r(rABSLLogger.warnKs9 wwmmL&+HHW\\3000r*cNUR"[RU/UQ70UD6 g)z*Logs 'msg % args' with severity 'WARNING'.N)rrrrs r(rABSLLogger.warningRsHHW__c3D3F3r*cNUR"[RU/UQ70UD6 g)z'Logs 'msg % args' with severity 'INFO'.N)rrrrs r(rABSLLogger.infoVsHHW\\3000r*cNUR"[RU/UQ70UD6 g)z(Logs 'msg % args' with severity 'DEBUG'.N)rrr:rs r(rABSLLogger.debugZrr*c>U[R:aURS05nSU['[[ U]"X/UQ70UD6 g)aqLogs 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)rrrrCrr7r)r$r\rr%r&rr's r(rABSLLogger.log^sH  ,e#eO *d[R"5nU[-$)aOGets 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) ) _thread_lib get_ident_THREAD_ID_MASK) thread_ids r(r&r&s##%) _ $$r*c[$)z!Returns the absl logger instance.)r7ror*r(rrs r*c[$)z"Returns the absl handler instance.)r;ror*r(rrs r*cZ[5R5 U(d [S5 gg)zuUses the python implementation of the logging code. Args: quiet: No logging message about switching logging type. zRestoring pure python loggingN)rr~r)quiets r(use_python_loggingrs$ ,,.  () r*c:[(d[RRVs/sHFn[ U[R 5(dM$UR [R:XdMDUPMH nnUH"n[RRU5 M$ Sq[5nU[RR;aN[RRU5 [SR5 [SR5 ggs snf)zyUses the ABSL logging handler for logging. This method is called in app.run() so the absl handler is used in absl apps. TrrN)+_attempted_to_remove_stderr_stream_handlersrr<r=rc StreamHandlerrrr removeHandlerr addHandlerrr3rW)hr= absl_handlers r(use_absl_handlerrs 5 4 <<((L(a a.. / 45HH 4J ( L ll  #26/!#,... LLL) +--/ /002/Ls#DD/Dc[(ag[R"5n[R"[5 [R "S5q[R"U5 [ 5n[U5qg)z!Initializes loggers and handlers.Nabsl) r7rgetLoggerClasssetLoggerClassr7rZrLr{r;)original_logger_classrs r( _initializers\\ !002 $""6*, ./,.67-r*ryr)F)wrF __future__rrrrgrrrrrrstructrrrrtypesrrrabsl._collections_abcr absl.loggingrrxrthreadr threadingtypingr ImportErrorrrr ABSL_ERRORr ABSL_WARNINGrrrrr8r:ABSL_LOGGING_PREFIX_REGEXcalcsizerrCrrrzrr7r;rrFlagrrMrrPobjectrQr~DEFINE_boolean DEFINE_stringgetenv DEFINE_flagrrrrrrrrrrrrrrrrrrrrrrrrr level_warnrrrrr.r>rrGrlrrIHandlerr{ FormatterrLrr7r&rrrrrrror*r(rs9v'%   %" 77!     7,q01A5$!ww||I{;            '0UZZ'0T. .:%..&FfF5::D]1dL&*tEIIImR06'+-.'4 )* 9:;&w &*+,($34" $3.# # % 77 $'" # #  K -&2 ( ' 9D #32 " ! $  " !..3bCB@$N? ; GG))GT+G'//+G\@g''@,Q:'')Q:h %  */4+32 8  }#s>L**L43L4