Warning: session_start(): Session cannot be started after headers have already been sent in /home/tvrreohg/public_html/manga.php on line 13
3
2jPC @ s d dl Z d dlZd dlZd dlmZ d dlmZmZ d dlZd dlm Z ej
Z ddddZ G dd d ej
Zd
d Zd d
dZG dd deZG dd dejZG dd dejZG dd deZefddZefddZedkrd dl Z e j e j e j d j dS ) N)wraps)MappingCallable) PercentStylez%(levelname)s: %(message)sz %(message)s)*INFODEBUGc s. e Zd ZdZd fdd Z fddZ ZS ) LevelFormatteray Log 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%c s |dkrt d|d kr t}t|tr0|}i }n,t|trPt|}|jdd }n td| tt | j
|| | j | _ i | _
x(|j D ] \}}tj|}|| j
|< qW d S )Nr
z:only '%' percent style is supported in both python 2 and 3r z&fmt must be a str or a dict of str: %r)
ValueErrorDEFAULT_FORMATS
isinstancestrr dictpop TypeErrorsuperr __init___fmtdefault_formatcustom_formatsitemslogging _checkLevel)selffmtdatefmtstyler r level) __class__ @/tmp/pip-build-_d5lkt3n/fonttools/fontTools/misc/loggingTools.pyr 8 s$
zLevelFormatter.__init__c sF | j r6| j j|j| j}| j|kr6|| _tr6t|| _tt| j |S )N)
r getlevelnor r r _styler r format)r recordr )r r r! r% M s
zLevelFormatter.format)NNr
)__name__
__module__ __qualname____doc__r r%
__classcell__r r )r r! r s r c K s | j dd}|dkr.d| krFd| krFtdnd| ks>d| krFtd|dkr| j dd}| j dd}|rxtj||}n| j dd}tj|}|g}| j d d
}| st|trtj|}t|j d | j d d}| j d
d}| j dd} t
||| }
| j dg } xP|D ]H}|j dkr"|j |
|j
sDx| D ]} |j| q0W |j| qW |j dkrn| j dd|_| j dd}
|
dk r|j|
| rdj| j }td| dS )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'filemodealoggerZ fontTools)parentr% r r r
filtersroot propagateFr z, z Unrecognised argument(s): %s)r r r FileHandler
StreamHandlerr
r getLogger_resetExistingLoggersnamer formatter setFormatterr3 addFilter
addHandlerr5 setLeveljoinkeys)kwargsr, r. modehr- r1 fsdfsr r r3 fr rA r r r! configLoggerX sL -
rH r4 c C sB t j}t|jjj }| dkr*| g| }nx| |kr6dS | |kr| g}|j| d }| d }t|}t|}x6||k r|| d| |kr|j|| |d7 }qlW x|D ]}|dkr|j t j
x |j dd D ]} |j | qW x |j
dd D ]}
|j|
qW d|_q|jj| } t j| _g | _ g | _
d| _d| _qW dS )z Reset the logger named 'parent' and all its children to their initial
state, if they already exist in the current configuration.
r4 N .FT)r r4 sortedmanager
loggerDictrA indexlenappendr? WARNINGr,
removeHandlerr3 Z
removeFiltersdisabledNOTSETr r5 ) r2 r4 existingZloggers_to_resetiprefixedpflen num_existingr: rD rG r1 r r r! r9 s<
r9 c @ s| e Zd ZdZejZdZdZdddZ d ddZ
d d
Z d d Z d
d Z
dd Zdd Zd ddZdd Zdd Zdd ZdS ) 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)sNc C s^ | j | |d kr s zTimer.formatTimec C s | j | _d| _| S )z Start a new lap g )ra rb rc )r r r r! __enter__O s
zTimer.__enter__c C sJ | j }| jdks|rdS | j| j|}| j|d}| jj| 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 )rf r1 rj r[ logr )r exc_type exc_value tracebackrd messageZ msg_partsr r r! __exit__U s zTimer.__exit__c sj t |tr:| js d j _t fdd}|S |pF|jd}|jdj}jj||S dS )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 | |S Q R X d S )Nr )argskwds)funcr r r! wrapperq s z Timer.__call__..wrapperr[ r N) r
r r[ r' r r" r r r1 )r Z func_or_msgrB ru r[ r r )rt r r! __call__d s
zTimer.__call__c C s | j S )N)rc )r r r r! __float__{ s zTimer.__float__c C s
t | jS )N)intrc )r r r r! __int__~ s z
Timer.__int__c C s
d| j S )Nz%.3f)rc )r r r r! __str__ s z
Timer.__str__)NNNN)N)N)r' r( r) r* timeitZ
default_timerra rg r r r\ rd rf rj rk rq rv rw ry rz r r r r! rZ s 7
rZ c @ s e Zd ZdZdd Zdd ZdS )ChannelsFiltera Provides 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 G s$ || _ t|| _dd |D | _d S )Nc S s i | ]}t ||qS r )rO ).0nr r r!
s z+ChannelsFilter.__init__..)namesrO numlengths)r r r r r! r s
zChannelsFilter.__init__c C s` | j dkrdS xL| jD ]B}| j| }||jkr2dS |jj|d|dkr|j| dkrdS qW dS )Nr TrJ F)r r r r: rh )r r& r: nlenr r r! filter s
zChannelsFilter.filterN)r' r( r) r* r r r r r r! r| s r| c s> e Zd Z fddZdd Zdd Zdd Zd d
d Z ZS )
CapturingLogHandlerc s: t t| j|d g | _t|tr0tj|| _n|| _d S )N)r ) r r r recordsr
r r r8 r1 )r r1 r )r r r! r s
z CapturingLogHandler.__init__c C sL | j j| _| j j| _| j j| _| j j| | j j| j d| j _d| j _| S )NF) r1 rS original_disabledr original_levelr5 original_propagater> r? )r r r r! rk s
z CapturingLogHandler.__enter__c C s2 | j j| | j j| j | j| j _| j| j _| S )N)r1 rR r? r r rS r r5 )r typevaluero r r r! rq s
z CapturingLogHandler.__exit__c C s | j j| d S )N)r rP )r r& r r r! emit s zCapturingLogHandler.emitNc C sT dd l }|j|}x | jD ]}|j|j rdS qW |d krDd| }dsPt|d S )Nr Tz(Pattern '%s' not found in logger records)recompiler search
getMessageAssertionError)r regexpr[ r patternrr r r! assertRegex s
z CapturingLogHandler.assertRegex)N) r' r( r) r rk rq r r r+ r r )r r! r s
r c @ s e Zd ZdZedd ZdS )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
c C s2 t | ds,dj| jj| jjf}tj|| _| jS )N_logrJ )hasattrr@ r r( r' r r8 r )r r: r r r! rl s
z LogMixin.logN)r' r( r) r* propertyrl r r r r! r s r c C s t jd| |f |dd dS )z< Raise a warning about deprecated function argument 'name'. z%r is deprecated; %s )category
stacklevelN)warningswarn)r: r[ r r r r! deprecateArgument s r c s fdd}|S )zD Decorator to raise a warning when a deprecated function is called. c s t fdd}|S )Nc s$ t jdjf dd | |S )Nz%r is deprecated; %s )r r )r r r' )rr rB )r rt r[ r r! ru s
z5deprecateFunction..decorator..wrapper)r )rt ru )r r[ )rt r! decorator s z$deprecateFunction..decoratorr )r[ r r r )r r[ r! deprecateFunction s r __main__)Z optionflags)r4 )!sysr r{ functoolsr collections.abcr r r r r r^ r Formatterr rH r9 objectrZ Filterr| Handlerr r UserWarningr r r' doctestexittestmodELLIPSISfailedr r r r! s. B`
) %-+&