B JdPC@sddlZddlZddlZddlmZddlmZmZddlZddlm Z ej Z ddddZ Gdd d ej Zd d Zdd dZGdddeZGdddejZGdddejZGdddeZefddZefddZedkrddlZeejejdj dS)N)wraps)MappingCallable) PercentStylez%(levelname)s: %(message)sz %(message)s)*INFODEBUGcs.eZdZdZdfdd ZfddZZS) LevelFormatterayLog 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 N%cs|dkrtd|dkrt}t|tr0|}i}n,t|trPt|}|dd}n td|tt | |||j |_ i|_ x(|D]\}}t|}||j |<qWdS)Nr 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__M/var/www/html/venv/lib/python3.7/site-packages/fontTools/misc/loggingTools.pyr8s$    zLevelFormatter.__init__csF|jr6|j|j|j}|j|kr6||_tr6t||_tt| |S)N) rgetlevelnorrr_stylerr format)rrecordr)rr r!r%Ms  zLevelFormatter.format)NNr )__name__ __module__ __qualname____doc__rr% __classcell__r r )rr!r s r cKs|dd}|dkr.d|krFd|krFtdnd|ks>d|krFtd|dkr|dd}|dd}|rxt||}n|dd}t|}|g}|d d }|rt|trt|}t|j d |d d}|d d}|dd} t ||| } |dg} xP|D]H}|j dkr | | |j sBx| D]} || q.W||qW|j dkrl|dd|_|dd} | dk r|| |rd|}td|dS)aA 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'filemodealoggerZ fontTools)parentr%rrr filtersroot propagateFrz, zUnrecognised argument(s): %s)rr r FileHandler StreamHandlerr r getLogger_resetExistingLoggersnamer formatter setFormatterr3 addFilter addHandlerr5setLeveljoinkeys)kwargsr,r.modehr-r1fsdfsrrr3frrAr r r! configLoggerXsL-                      rHr4c CsBtj}t|jj}|dkr*|g|}nx||kr6dS||kr|g}||d}|d}t|}t|}x6||kr||d||kr||||d7}qlWx|D]}|dkr| tj x |j ddD]} | | qWx |j ddD]} || qWd|_q|jj|} tj| _g| _ g| _ d| _d| _qWdS)z Reset the logger named 'parent' and all its children to their initial state, if they already exist in the current configuration. r4N.FT)rr4sortedmanager loggerDictrAindexlenappendr?WARNINGr, removeHandlerr3Z removeFiltersdisabledNOTSETrr5) r2r4existingZloggers_to_resetiprefixedpflen num_existingr:rDrGr1r r r!r9s<       r9c@s|eZdZdZejZdZdZdddZ dddZ d d Z d d Z d dZ ddZddZdddZddZddZddZdS)Timera Keeps 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 zelapsed time: %(time).3fszTook %(time).3fs to %(msg)sNcCs^|||dkrszTimer.formatTimecCs||_d|_|S)z Start a new lap g)rarbrc)rr r r! __enter__Os zTimer.__enter__cCsJ|}|jdks|rdS||j|}|j|d}|j|j||dS)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). N)r[rd)rfr1rjr[logr)rexc_type exc_value tracebackrdmessageZ msg_partsr r r!__exit__Us  zTimer.__exit__c sjt|tr:|js dj_tfdd}|S|pF|d}|dj}j||SdS)a9 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'c s ||SQRXdS)Nr )argskwds)funcrr r!wrapperqszTimer.__call__..wrapperr[rN) r rr[r'rr"rrr1)rZ func_or_msgrBrur[rr )rtrr!__call__ds  zTimer.__call__cCs|jS)N)rc)rr r r! __float__{szTimer.__float__cCs t|jS)N)intrc)rr r r!__int__~sz Timer.__int__cCs d|jS)Nz%.3f)rc)rr r r!__str__sz Timer.__str__)NNNN)N)N)r'r(r)r*timeitZ default_timerrargrrr\rdrfrjrkrqrvrwryrzr r r r!rZs7  rZc@s eZdZdZddZddZdS)ChannelsFilteraProvides 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!') cGs$||_t||_dd|D|_dS)NcSsi|]}t||qSr )rO).0nr r r! sz+ChannelsFilter.__init__..)namesrOnumlengths)rrr r r!rs zChannelsFilter.__init__cCs`|jdkrdSxL|jD]B}|j|}||jkr2dS|j|d|dkr|j|dkrdSqWdS)NrTrJF)rrrr:rh)rr&r:nlenr r r!filters    zChannelsFilter.filterN)r'r(r)r*rrr r r r!r|sr|cs>eZdZfddZddZddZddZd d d ZZS) CapturingLogHandlercs:tt|j|dg|_t|tr0t||_n||_dS)N)r) rrrrecordsr rrr8r1)rr1r)rr r!rs  zCapturingLogHandler.__init__cCsL|jj|_|jj|_|jj|_|j||j|jd|j_d|j_|S)NF) r1rSoriginal_disabledroriginal_levelr5original_propagater>r?)rr r r!rks    zCapturingLogHandler.__enter__cCs2|j||j|j|j|j_|j|j_|S)N)r1rRr?rrrSrr5)rtypevalueror r r!rqs    zCapturingLogHandler.__exit__cCs|j|dS)N)rrP)rr&r r r!emitszCapturingLogHandler.emitNcCsTddl}||}x |jD]}||rdSqW|dkrDd|}dsPt|dS)NrTz(Pattern '%s' not found in logger records)recompilersearch getMessageAssertionError)rregexpr[rpatternrr r r! assertRegexs  zCapturingLogHandler.assertRegex)N) r'r(r)rrkrqrrr+r r )rr!rs   rc@seZdZdZeddZdS)LogMixina Mixin 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 cCs2t|ds,d|jj|jjf}t||_|jS)N_logrJ)hasattrr@rr(r'rr8r)rr:r r r!rls   z LogMixin.logN)r'r(r)r*propertyrlr r r r!rsrcCstjd||f|dddS)z< Raise a warning about deprecated function argument 'name'. z%r is deprecated; %s)category stacklevelN)warningswarn)r:r[rr r r!deprecateArgumentsrcsfdd}|S)zD Decorator to raise a warning when a deprecated function is called. cstfdd}|S)Ncs$tjdjfdd||S)Nz%r is deprecated; %s)rr)rrr')rrrB)rrtr[r r!ru s  z5deprecateFunction..decorator..wrapper)r)rtru)rr[)rtr! decorator sz$deprecateFunction..decoratorr )r[rrr )rr[r!deprecateFunction sr__main__)Z optionflags)r4)!sysrr{ functoolsrcollections.abcrrrrrr^r Formatterr rHr9objectrZFilterr|Handlerrr UserWarningrrr'doctestexittestmodELLIPSISfailedr r r r!s.  B` )%-+&