֛h?SrSSKJr SSKJr SSKJr SSKJrJrJ r J r J r J r SSK Jr SSKJr SS KJrJr SS KJrJr "S S \ 5r"S S5r"SS5r"SS5r\"5rSSjrg)z Logger class. ) annotations)time) TracebackType)AnyCallableContextManagerOptionalProtocolcast) currentframe)Failure) ILogObserverLogTrace)InvalidLogLevelErrorLogLevelcT\rSrSrSr\SSj5r\S Sj5r\SSj5rSr g) Operationz An L{Operation} represents the success (or lack thereof) of code performed within the body of the L{Logger.failureHandler} context manager. cg)z Did the operation succeed? C{True} iff the code completed without raising an exception; C{False} while the code is running and C{False} if it raises an exception. Nselfs ZC:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/logger/_logger.py succeededOperation.succeededcg)zR Did the operation raise an exception? If so, this L{Failure} is that exception. Nrrs rfailureOperation.failure#rrcg)z Did the operation fail? C{True} iff the code raised an exception; C{False} while the code is running and C{False} if it completed without error. Nrrs rfailedOperation.failed*rrrNreturnbool)r&Failure | None) __name__ __module__ __qualname____firstlineno____doc__propertyrr r#__static_attributes__rrrrrsC       rrct\rSrSr%SrS\S'SrS\S'S Sjr\SS j5r SS jr SS jr S r g) _FailCtxMgr3Fr'rNr(r cXlgN_failrfails r__init___FailCtxMgr.__init__7 rcURSL$r4r rs rr#_FailCtxMgr.failed:s||4''rcU$r4rrs r __enter___FailCtxMgr.__enter__>s rc\Ub"[5nX@lURU5 gSUlgNT)r r r6rrexc_type exc_value tracebackr s r__exit___FailCtxMgr.__exit__As3  iG"L JJw "DNr)r6r rr8zCallable[[Failure], None]r&Noner%)r&rrEztype[BaseException] | NonerFzBaseException | NonerGzTracebackType | Noner&r') r)r*r+r,r__annotations__r r9r.r#r@rHr/rrrr1r13s_It"G^"(( , ( (   rr1cB\rSrSrSSjrSSjrS SjrSrg) _FastFailCtxMgrQcXlgr4r5r7s rr9_FastFailCtxMgr.__init__Rr;rcgr4rrs rr@_FastFailCtxMgr.__enter__Us rcLUb![5nX@lURU5 grC)r r r6rDs rrH_FastFailCtxMgr.__exit__Xs%  iG"L JJw r)r6r NrJ)r&rKrL)r)r*r+r,r9r@rHr/rrrrOrOQs7  , ( (   rrOcb\rSrSrSr\SSj5rSSSjjrSSSjjrSSjr SSSjjr S\ R4SS jjr SSS jjrSSS jjrSSS jjrSSS jjrSSSjjr \ R4SSjjr\ R4SSjjrSrg)Loggerfab A L{Logger} emits log messages to an observer. You should instantiate it as a class or module attribute, as documented in L{this module's documentation }. @ivar namespace: the namespace for this logger @ivar source: The object which is emitting events via this logger @ivar observer: The observer that this logger will send events to. cp[[[S5RS5$![a gf=f)z{ Derive a namespace from the module containing the caller's caller. @return: the fully qualified python name of a module. r)z )r strr f_globalsKeyErrorrrr_namespaceFromCallingContext#Logger._namespaceFromCallingContextqs5 \!_66zBC C  s %( 55NcnUcUR5nXlX lUc SSKJn X@lgX0lg)a @param namespace: The namespace for this logger. Uses a dotted notation, as used by python modules. If not L{None}, then the name of the module of the caller is used. @param source: The object which is emitting events via this logger; this is automatically set on instances of a class if this L{Logger} is an attribute of that class. @param observer: The observer that this logger will send events to. If L{None}, use the L{global log publisher }. Nr)globalLogPublisher)r_ namespacesource_globalrbobserver)rrcrdrfrbs rr9Logger.__init__}s5  99;I"   3*)rjr)rcrs r__repr__Logger.__repr__s'4>>**+1T^^,>a@@rc lU[R"5;a%URS[[ U55UUS9 gUnUR UUUR URU[5S9 SU;a-[[US5RXR45 URU5 g)a Emit a log event to all log observers at the given level. @param level: a L{LogLevel} @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. z:Got invalid log level {invalidLevel!r} in {logger}.emit().) invalidLevelloggerN) log_logger log_level log_namespace log_source log_formatlog_time log_trace) r iterconstantsr r rupdatercrdrr rappendrf)rlevelformatkwargsevents remit Logger.emits ..0 0 LLL,U34"    ..{{V   %  5- . 5 5t]]6K L erc HUc [5nUR"X14SU0UD6 g)au Log a failure and emit a traceback. For example:: try: frob(knob) except Exception: log.failure("While frobbing {knob}", knob=knob) or:: d = deferredFrob(knob) d.addErrback(lambda f: log.failure("While frobbing {knob}", f, knob=knob)) This method is meant to capture unexpected exceptions in code; an exception that is caught and handled somehow should be logged, if appropriate, via L{Logger.error} instead. If some unknown exception occurs and your code doesn't know how to handle it, as in the above example, then this method provides a means to describe the failure. This is done at L{LogLevel.critical} by default, since no corrective guidance can be offered to an user/administrator, and the impact of the condition is unknown. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param failure: a L{Failure} to log. If L{None}, a L{Failure} is created from the exception in flight. @param level: a L{LogLevel} to use. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. @see: L{Logger.failureHandler} @see: L{Logger.failuresHandled} N log_failure)r r)rrr rrs rr Logger.failures'd ?iG %?W??rc HUR"[RU40UD6 g)a Emit a log event at log level L{LogLevel.debug}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrdebugrrrs rr Logger.debug (..&3F3rc HUR"[RU40UD6 g)a Emit a log event at log level L{LogLevel.info}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrinfors rr Logger.info* (--262rc HUR"[RU40UD6 g)a Emit a log event at log level L{LogLevel.warn}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrwarnrs rr Logger.warn9rrc HUR"[RU40UD6 g)a Emit a log event at log level L{LogLevel.error}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrerrorrs rr Logger.errorHrrc HUR"[RU40UD6 g)a Emit a log event at log level L{LogLevel.critical}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrcriticalrs rrLogger.criticalWs (##V6v6rc .^^^^[UUUU4Sj5$)a? Run some application code, logging a failure and emitting a traceback in the event that any of it fails, but continuing on. For example:: log = Logger(...) def frameworkCode() -> None: with log.failuresHandled("While frobbing {knob}:", knob=knob) as op: frob(knob) if op.succeeded: log.info("frobbed {knob} successfully", knob=knob) This method is meant to capture unexpected exceptions from application code; an exception that is caught and handled somehow should be logged, if appropriate, via L{Logger.error} instead. If some unknown exception occurs and your code doesn't know how to handle it, as in the above example, then this method provides a means to describe the failure. This is done at L{LogLevel.critical} by default, since no corrective guidance can be offered to an user/administrator, and the impact of the condition is unknown. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param level: a L{LogLevel} to use. @param kwargs: additional key/value pairs to include in the event, if it is emitted. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. @see: L{Logger.failure} @see: L{Logger.failureHandler} @return: A context manager which yields an L{Operation} which will have either its C{succeeded} or C{failed} attribute set to C{True} upon completion of the code within the code within the C{with} block. c.>TR"TUT40TD6$r4r=)frrrrs r(Logger.failuresHandled..sT\\&!U%Mf%Mr)r1)rrrrs````rfailuresHandledLogger.failuresHandledfsTMNNrc*^^^[UUU4Sj5$)a For performance-sensitive frameworks that needs to handle potential failures from frequently-called application code, and do not need to include detailed structured information about the failure nor inspect the result of the operation, this method returns a context manager that will log exceptions and continue, that can be shared across multiple invocations. It should be instantiated at module scope to avoid additional object creations. For example:: log = Logger(...) ignoringFrobErrors = log.failureHandler("while frobbing:") def hotLoop() -> None: with ignoringFrobErrors: frob() This method is meant to capture unexpected exceptions from application code; an exception that is caught and handled somehow should be logged, if appropriate, via L{Logger.error} instead. If some unknown exception occurs and your code doesn't know how to handle it, as in the above example, then this method provides a means to describe the failure in nerd-speak. This is done at L{LogLevel.critical} by default, since no corrective guidance can be offered to an user/administrator, and the impact of the condition is unknown. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param level: a L{LogLevel} to use. @see: L{Logger.failure} @return: A context manager which does not return a value, but will always exit from exceptions. c*>TRTUT5$r4r=)rrr staticMessages rr'Logger.failureHandler..smQ)Nr)rO)rrrs```rfailureHandlerLogger.failureHandlersVNOOr)rcrfrd)r&r\)NNN)rc Optional[str]rdzOptional[object]rfzOptional['ILogObserver']r&rKr4)rlobjectrmzOptional[type]r&z'Logger')rrrrrrr&rK) rr\r zOptional[Failure]rrrrr&rK)rrrrr&rK)rr\rrrrr&zContextManager[Operation])rr\rrr&zContextManager[None])r)r*r+r,r- staticmethodr_r9rnrtrrrr rrrrrrr/rrrrXrXfsW  $(#'-1 % %!%+ %  %: @A8<%%'4%GM% %T&*"++ 5@5@#5@ 5@  5@  5@n 4 3 3 4 7 .6->->*O*O"**OJP*O "*O^#+++P+P+P  +P+PrrXc@[RXR5$)z7 Get a L{Logger} instance attached to the given class. )_logrnrj)objs r _loggerForrs <<]] ++rN)rrr&rX)r- __future__rrtypesrtypingrrrr r r twisted.python.compatr twisted.python.failurer _interfacesrr_levelsrrrr1rOrXrrrrrrsd #JJ.*/3  <<*WPWPt x,r