o:iMSSKrSSKrSSKrSSKJr SSKJrJr SSKrSSKJ r \Rr SSSS.r "SS \R5rS rSS jr"S S \5r"SS\R&5r"SS\R*5r"SS\5r\4Sjr\4Sjr\S:Xa9SSKr\R:"\R<"\R>S9R@5 gg)Nwraps)MappingCallable) PercentStylez%(levelname)s: %(message)sz %(message)s)*INFODEBUGc<^\rSrSrSrSU4SjjrU4SjrSrU=r$)LevelFormatteraLog formatter with level-specific formatting. Formatter class which optionally takes a dict of logging levels to format strings, allowing to customise the log records appearance for specific levels. Attributes: fmt: A dictionary mapping logging levels to format strings. The ``*`` key identifies the default format string. datefmt: As per py:class:`logging.Formatter` style: As per py:class:`logging.Formatter` >>> import sys >>> handler = logging.StreamHandler(sys.stdout) >>> formatter = LevelFormatter( ... fmt={ ... '*': '[%(levelname)s] %(message)s', ... 'DEBUG': '%(name)s [%(levelname)s] %(message)s', ... 'INFO': '%(message)s', ... }) >>> handler.setFormatter(formatter) >>> log = logging.getLogger('test') >>> log.setLevel(logging.DEBUG) >>> log.addHandler(handler) >>> log.debug('this uses a custom format string') test [DEBUG] this uses a custom format string >>> log.info('this also uses a custom format string') this also uses a custom format string >>> log.warning("this one uses the default format string") [WARNING] this one uses the default format string c>US:wa [S5eUc[n[U[5(aUn0nOA[U[5(a[ U5nUR SS5nO[SU-5e[[U]+XB5 URUl 0Ul UR5H)upa[R "U5nXRU'M+ g)N%z:only '%' percent style is supported in both python 2 and 3rz&fmt must be a str or a dict of str: %r) ValueErrorDEFAULT_FORMATS isinstancestrrdictpop TypeErrorsuperr __init___fmtdefault_formatcustom_formatsitemslogging _checkLevel)selffmtdatefmtstylerrlevel __class__s ^/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/fontTools/misc/loggingTools.pyrLevelFormatter.__init__8s C<L  ;!C c3   NN W % %!#YN+//T:NDsJK K nd,^E"ii (..0JE''.E),   &1c>UR(aaURRURUR5nURU:wa!X l[ (a[ U5Ul[[U]'U5$N) rgetlevelnorrr_stylerr format)rrecordr r$s r%r-LevelFormatter.formatNsb   %%))&..$:M:MNCyyC <".s"3DK^T1&99r')rr,rr)NNr) __name__ __module__ __qualname____firstlineno____doc__rr-__static_attributes__ __classcell__r$s@r%r r sB-,::r'r c URSS5nUcSU;aSU;a [S5eOSU;dSU;a [S5eUcmURSS5nURSS5nU(a[R"X#5nO(URSS5n[R"U5nU/nURS S 5nU(a[ U[ 5(a[R"U5n[URS 9 URS S5nURS S5nURSS5n [XxU 5n URS/5n UH]nURcURU 5 UR(dU Hn URU 5 M URU5 M_ URS:waURSS5UlURSS5n U bUR#U 5 U(a-SR%UR'55n[SU-5eg)a A more sophisticated logging system configuation manager. This is more or less the same as :py:func:`logging.basicConfig`, with some additional options and defaults. The default behaviour is to create a ``StreamHandler`` which writes to sys.stderr, set a formatter using the ``DEFAULT_FORMATS`` strings, and add the handler to the top-level library logger ("fontTools"). A number of optional keyword arguments may be specified, which can alter the default behaviour. Args: logger: Specifies the logger name or a Logger instance to be configured. (Defaults to "fontTools" logger). Unlike ``basicConfig``, this function can be called multiple times to reconfigure a logger. If the logger or any of its children already exists before the call is made, they will be reset before the new configuration is applied. filename: Specifies that a ``FileHandler`` be created, using the specified filename, rather than a ``StreamHandler``. filemode: Specifies the mode to open the file, if filename is specified. (If filemode is unspecified, it defaults to ``a``). format: Use the specified format string for the handler. This argument also accepts a dictionary of format strings keyed by level name, to allow customising the records appearance for specific levels. The special ``'*'`` key is for 'any other' level. datefmt: Use the specified date/time format. level: Set the logger level to the specified level. stream: Use the specified stream to initialize the StreamHandler. Note that this argument is incompatible with ``filename`` - if both are present, ``stream`` is ignored. handlers: If specified, this should be an iterable of already created handlers, which will be added to the logger. Any handler in the list which does not have a formatter assigned will be assigned the formatter created in this function. filters: If specified, this should be an iterable of already created filters. If the ``handlers`` do not already have filters assigned, these filters will be added to them. propagate: All loggers have a ``propagate`` attribute which determines whether to continue searching for handlers up the logging hierarchy. If not provided, the "propagate" attribute will be set to ``False``. handlersNstreamfilenamez8'stream' and 'filename' should not be specified togetherzG'stream' or 'filename' should not be specified together with 'handlers'filemodealogger fontTools)parentr-r!r"rfiltersroot propagateFr#z, zUnrecognised argument(s): %s)rrr FileHandler StreamHandlerrr getLogger_resetExistingLoggersnamer formatter setFormatterrA addFilter addHandlerrCsetLeveljoinkeys)kwargsr9r;modehr:r>fsdfsr"r rAfr#rOs r% configLoggerrVYsZzz*d+H v *"6M  v v!55 ::j$/zz*c* ##H3AZZ$/F%%f-A3 ZZ+ .F Z,,""6*- Hd #B **Y %C JJw $E % (CjjB'G  ;;  NN3 yy A! {{f!::k59 JJw %E  yy'7$>??r'c[Rn[URRR 55nUS:XaU/U-nOlX;agX;aaU/nUR U5S-nUS-n[U5n[U5nXG:a*X$SUU:XaURX$5 US- nXG:aM*WHnUS:XavUR[R5 URSSHn URU 5 M URSSHn URU 5 M SUlMURRUn [R U l/U l /U l SU lSU lM g)zReset the logger named 'parent' and all its children to their initial state, if they already exist in the current configuration. rBN.FT)rrBsortedmanager loggerDictrOindexlenappendrMWARNINGr9 removeHandlerrA removeFiltersdisabledNOTSETr#rC) r@rBexistingloggers_to_resetiprefixedpflen num_existingrHrRrUr>s r%rGrGsc < MM'// *]]1%""1%&\\!_""1%%!DM\\,,T2F">>FL FOFN#F #FO!r'c\rSrSr%Sr\"\R5r\ /\ 4\ S'Sr Sr SSjrSSjrS rS rS rS rS rSSjrSrSrSrSrg)TimeraKeeps track of overall time and split/lap times. >>> import time >>> timer = Timer() >>> time.sleep(0.01) >>> print("First lap:", timer.split()) First lap: ... >>> time.sleep(0.02) >>> print("Second lap:", timer.split()) Second lap: ... >>> print("Overall time:", timer.time()) Overall time: ... Can be used as a context manager inside with-statements. >>> with Timer() as t: ... time.sleep(0.01) >>> print("%0.3f seconds" % t.elapsed) 0... seconds If initialised with a logger, it can log the elapsed time automatically upon exiting the with-statement. >>> import logging >>> log = logging.getLogger("my-fancy-timer-logger") >>> configLogger(logger=log, level="DEBUG", format="%(message)s", stream=sys.stdout) >>> with Timer(log, 'do something'): ... time.sleep(0.01) Took ... to do something The same Timer instance, holding a reference to a logger, can be reused in multiple with-statements, optionally with different messages or levels. >>> timer = Timer(log) >>> with timer(): ... time.sleep(0.01) elapsed time: ...s >>> with timer('redo it', level=logging.INFO): ... time.sleep(0.02) Took ... to redo it It can also be used as a function decorator to log the time elapsed to run the decorated function. >>> @timer() ... def test1(): ... time.sleep(0.01) >>> @timer('run test 2', level=logging.INFO) ... def test2(): ... time.sleep(0.02) >>> test1() Took ... to run 'test1' >>> test2() Took ... to run test 2 _timezelapsed time: %(time).3fszTook %(time).3fs to %(msg)sNcURU5 Uc1SH+n[5RU5cM[SU-5e XlUbUO[ UlX lg)N)msgr#z*'%s' can't be specified without a 'logger')resetlocalsr*rr> TIME_LEVELr#rp)rr>rpr#startargs r%rTimer.__init__#sZ 5 >'8<<$0$%QTW%WXX( #/UZ r'crUcUR5UlOXlURUlSUlg)z0Reset timer to 'start_time' or the current time.N)rnrtlastelapsed)rrts r%rq Timer.reset-s+ =DJJJJ  r'c<UR5UR- $)z=Return the overall time (in seconds) since the timer started.)rnrtrs r%time Timer.time6szz|djj((r'clUR5nXR- UlXlUR$)z=Split and return the lap time (in seconds) in between splits.rnryrz)rcurrents r%split Timer.split:s***,*  ||r'cU(d URnURS5S:aURXS.-nU$USU0-nU$![[4a U$f=f)zFormat 'time' value in 'msg' and return formatted string. If 'msg' contains a '%(time)' format string, try to use that. Otherwise, use the predefined 'default_format'. If 'msg' is empty or None, fall back to 'default_msg'. z%(time)rrpr~r~) default_msgfindrKeyErrorr)rrpr~s r% formatTimeTimer.formatTimeAsu ""C 88I  "%%(BBC   VTN* j)   sAAAc>UR5UlSUlU$)zStart a new laprxrr}s r% __enter__Timer.__enter__RsJJL   r'cUR5nURbU(agURURU5nURUS.nURR UR XV5 g)z|End the current lap. If timer has a logger, log the time elapsed, using the format string in self.msg (or the default one). Nr)rr>rrplogr#)rexc_type exc_value tracebackr~message msg_partss r%__exit__Timer.__exit__XsZzz| ;; ( //$((D1!HHd3   G7r'c P^^[U[5(a>UmTR(dSTR-Tl[ T5UU4Sj5nU$U=(d UR S5nUR STR 5nTRTRXE5$)a.If the first argument is a function, return a decorator which runs the wrapped function inside Timer's context manager. Otherwise, treat the first argument as a 'msg' string and return an updated Timer instance, referencing the same logger. A 'level' keyword can also be passed to override self.level. zrun '%s'cN>T T"U0UD6sSSS5 $!,(df  g=fr))argskwdsfuncrs r%wrapperTimer.__call__..wrapperts..TTs $rpr#) rrrpr0rr*r#r$r>)r func_or_msgrPrrpr#rs` @r%__call__Timer.__call__gs k8 , ,D88% 5 4[ / /N2E!2CJJw 3E>>$++s: :r'cUR$r)rzr}s r% __float__Timer.__float__s ||r'c,[UR5$r))intrzr}s r%__int__ Timer.__int__s4<<  r'c SUR-$)Nz%.3frr}s r%__str__ Timer.__str__s $$r')rzryr#r>rprt)NNNNr))r0r1r2r3r4 staticmethodtimeit default_timerrnrfloat__annotations__rrrrqr~rrrrrrrrr5rr'r%rlrlsi6r".f.B.B!CE8BI C-K2N)" 8;0!%r'rlc$\rSrSrSrSrSrSrg)ChannelsFilteriaProvides a hierarchical filter for log entries based on channel names. Filters out records emitted from a list of enabled channel names, including their children. It works the same as the ``logging.Filter`` class, but allows the user to specify multiple channel names. >>> import sys >>> handler = logging.StreamHandler(sys.stdout) >>> handler.setFormatter(logging.Formatter("%(message)s")) >>> filter = ChannelsFilter("A.B", "C.D") >>> handler.addFilter(filter) >>> root = logging.getLogger() >>> root.addHandler(handler) >>> root.setLevel(level=logging.DEBUG) >>> logging.getLogger('A.B').debug('this record passes through') this record passes through >>> logging.getLogger('A.B.C').debug('records from children also pass') records from children also pass >>> logging.getLogger('C.D').debug('this one as well') this one as well >>> logging.getLogger('A.B.').debug('also this one') also this one >>> logging.getLogger('A.F').debug('but this one does not!') >>> logging.getLogger('C.DE').debug('neither this one!') c|Xl[U5UlUVs0sHo"[U5_M snUlgs snfr))namesr^numlengths)rrns r%rChannelsFilter.__init__s1 u:+015a3q6 51 1s9cURS:XagURH[nURUnX!R:Xa gURR USU5S:XdMFURUS:XdM[ g g)NrTrYF)rrrrHr)rr.rHnlens r%filterChannelsFilter.filtersl 88q=JJD<<%D{{"!!$40A5&++d:Ks:R  r')rrrN)r0r1r2r3r4rrr5rr'r%rrs42 r'rcD^\rSrSrU4SjrSrSrSrSSjrSr U=r $) CapturingLogHandleric>[[U] US9 /Ul[ U[ 5(a[ R"U5UlgXlg)N)r#) rrrrecordsrrrrFr>)rr>r#r$s r%rCapturingLogHandler.__init__sA !411> fc " "!++F3DK Kr'clURRUlURRUlURR UlURRU5 URRUR5 SURlSURlU$)NF) r>rcoriginal_disabledr#original_levelrCoriginal_propagaterLrMr}s r%rCapturingLogHandler.__enter__s}!%!5!5"kk//"&++"7"7 t$ TZZ($  %  r'cURRU5 URRUR5 URURlUR URlU$r))r>rarMrrrcrrC)rtypevaluers r%rCapturingLogHandler.__exit__sU !!$' T001#55  $ 7 7  r'c:URRU5 gr))rr_)rr.s r%emitCapturingLogHandler.emits F#r'cSSKnURU5nURH)nURUR 55(dM) g UcSU-nU5e)NrTz(Pattern '%s' not found in logger records)recompilersearch getMessage)rregexprprpatternrs r% assertRegexCapturingLogHandler.assertRegexsS**V$A~~alln-- ;rrrrr)) r0r1r2r3rrrrrr5r6r7s@r%rrs!! $  r'rc(\rSrSrSr\S5rSrg)LogMixiniaMixin class that adds logging functionality to another class. You can define a new class that subclasses from ``LogMixin`` as well as other base classes through multiple inheritance. All instances of that class will have a ``log`` property that returns a ``logging.Logger`` named after their respective ``.``. For example: >>> class BaseClass(object): ... pass >>> class MyClass(LogMixin, BaseClass): ... pass >>> a = MyClass() >>> isinstance(a.log, logging.Logger) True >>> print(a.log.name) fontTools.misc.loggingTools.MyClass >>> class AnotherClass(MyClass): ... pass >>> b = AnotherClass() >>> isinstance(b.log, logging.Logger) True >>> print(b.log.name) fontTools.misc.loggingTools.AnotherClass c[US5(dVSRURRURR45n[ R "U5UlUR$)N_logrY)hasattrrNr$r1r0rrFr)rrHs r%r LogMixin.logsRtV$$88T^^668O8OPQD))$/DIyyr')rN)r0r1r2r3r4propertyrr5rr'r%rrs6r'rc>[R"U<SU<3USS9 g)z:Raise a warning about deprecated function argument 'name'. is deprecated; category stacklevelN)warningswarn)rHrprs r%deprecateArgumentrs MMD#6VWXr'c^^UU4SjnU$)zBDecorator to raise a warning when a deprecated function is called.c6>^[T5UUU4Sj5nU$)Ncb>[R"TR<ST<3TSS9 T"U0UD6$)Nrr)rrr0)rrPrrrps r%r5deprecateFunction..decorator..wrappers3 MM*.--=!  (( (r'r)rrrrps` r% decorator$deprecateFunction..decorator s t )  )r'r)rprrs`` r%deprecateFunctionr s  r'__main__) optionflags)rB)!sysrr functoolsrcollections.abcrrrrr rsr Formatterr rVrGobjectrlFilterrHandlerrr UserWarningrrr0doctestexittestmodELLIPSISfailedrr'r%rs  - ]] &  @:W&&@:F`@F&$Ra%Fa%H)W^^)X)'//)X!v!H+6Y %0$ zHHW__)9)9 : A ABr'