U

�
bb.�@s�
dZd
dl
mZ
d
dlmZ
d
dlmZmZm	Z	mZm
Z
mZmZ
d
dl
mZ
d
dlmZ
d
dlmZ
d
dlmZ
d	d
lmZmZ
d	dlmZ
dZeed
�dd�Zeeed�dd�Zedfe
ee
eeed�dd�Z e f
eee
eg
efe
ed�dd�Z!Gdd�de�Z"eeeefed�dd�Z#eed
�dd �Z$eed!�d"d#�Z%eed
�d$d%�Z&d&d&d&e fee'e'e'eeg
efed'�d(d)�Z(d*S)+z&
Tools for formatting logging events.
�)
�Mapping)
�datetime)�Any�Callable�Iteratorr�Optional�Union�cast)
�
NamedConstant)
�FixedOffsetTimeZone)
�Failure)
�	safe_repr�
)�
aFormatter�
flatFormat)
�LogEventz%Y-%m-%dT%H:%M:%S%z)�event�returnc

Cst|d
d
d
d�S)aa

    Formats an event as text, using the format in C{event["log_format"]}.

    This implementation should never raise an exception; if the formatting
    cannot be done, the returned string will describe the event generically so
    that a useful message is emitted regardless.

    @param event: A logging event.

    @return: A formatted string.
    F)�includeTraceback�includeTimestamp�
includeSystem)
�eventAsText)
r�r�8/usr/lib/python3/dist-packages/twisted/logger/_format.py�formatEvents



�r)r�errorrcCs\zd
j||
d�WSt
k
rV


t�}d�dd�|��D�
�
}djt|
�
||d�YSXdS)	z�
    Formats an event as text that describes the event generically and a
    formatting error.

    @param event: A logging event.
    @param error: The formatting error.

    @return: A formatted string.
    z)Unable to format event {event!r}: {error})rrz, c
ss(|] \}
}d�t
|
�
t
|�
f�
V
qd
S)z = N)�joinr
)�.0�key�valuerrr�	<genexpr>Bs�z+formatUnformattableEvent.<locals>.<genexpr>zrMESSAGE LOST: unformattable object logged: {error}
Recoverable data: {text}
Exception during formatting:
{failure})r�failure�textN)�format�
BaseExceptionrr�itemsr
)rrr!r"rrr�formatUnformattableEvent,s 


�
���r&�
-)�when�
timeFormat�defaultrcCs<|
d
ks|d
kr|St�
|�
}t�||�}t|�|
�
�
Sd
S)a�

    Format a timestamp as text.

    Example::

        >>> from time import time
        >>> from twisted.logger import formatTime
        >>>
        >>> t = time()
        >>> formatTime(t)
        u'2013-10-22T14:19:11-0700'
        >>> formatTime(t, timeFormat="%Y/%W")  # Year and week number
        u'2013/42'
        >>>

    @param when: A timestamp.
    @param timeFormat: A time format.
    @param default: Text to return if C{when} or C{timeFormat} is L{None}.

    @return: A formatted time.
    N)rZfromLocalTimeStamp�DateTime�
fromtimestamp�str�strftime)r(r)r*�tzrrrr�
formatTimePs




r0)rr0rcCs(t||
d
�}|sdS|�
dd�}|dS)a&
    Format an event as a line of human-readable text for, e.g. traditional log
    file output.

    The output format is C{"{timeStamp} [{system}] {event}\n"}, where:

        - C{timeStamp} is computed by calling the given C{formatTime} callable
          on the event's C{"log_time"} value

        - C{system} is the event's C{"log_system"} value, if set, otherwise,
          the C{"log_namespace"} and C{"log_level"}, joined by a C{"#"}.  Each
          defaults to C{"-"} is not set.

        - C{event} is the event, as formatted by L{formatEvent}.

    Example::

        >>> from time import time
        >>> from twisted.logger import formatEventAsClassicLogText
        >>> from twisted.logger import LogLevel
        >>>
        >>> formatEventAsClassicLogText(dict())  # No format, returns None
        >>> formatEventAsClassicLogText(dict(log_format="Hello!"))
        u'- [-#-] Hello!\n'
        >>> formatEventAsClassicLogText(dict(
        ...     log_format="Hello!",
        ...     log_time=time(),
        ...     log_namespace="my_namespace",
        ...     log_level=LogLevel.info,
        ... ))
        u'2013-10-22T17:30:02-0700 [my_namespace#info] Hello!\n'
        >>> formatEventAsClassicLogText(dict(
        ...     log_format="Hello!",
        ...     log_time=time(),
        ...     log_system="my_system",
        ... ))
        u'2013-11-11T17:22:06-0800 [my_system] Hello!\n'
        >>>

    @param event: an event.
    @param formatTime: A time formatter

    @return: A formatted event, or L{None} if no output is appropriate.
    )
r0N�

z
	)r�replace)rr0�	eventTextrrr�formatEventAsClassicLogTextrs
/



r4c@sTeZ
dZd
Zeeefdd�dd�Zed�
dd�Z	e
d�
d	d
�Zeed�dd
�ZdS)�CallMappingz�
    Read-only mapping that turns a C{()}-suffix in key names into an invocation
    of the key rather than a lookup of the key.

    Implementation support for L{formatWithCall}.
    N)�
submappingrcCs
|
|_d
S)zo
        @param submapping: Another read-only mapping which will be used to look
            up items.
        N)
�_submapping)�selfr6rrr�__init__�szCallMapping.__init__)
rc

Cs
t|j
�
S�
N)�iterr7�
r8rrr�__iter__�s
zCallMapping.__iter__c

Cs
t|j
�
Sr:)�lenr7r<rrr�__len__�s
zCallMapping.__len__)rrcCs6|
�d
�
}|r|
dd�n|
}|j
|}|r2|�}|S)z|
        Look up an item in the submapping for this L{CallMapping}, calling it
        if C{key} ends with C{"()"}.
        z()N���)�endswithr7)r8r�callitZrealKeyrrrr�__getitem__�s






zCallMapping.__getitem__)
�__name__�
__module__�__qualname__�__doc__rr-rr9rr=�intr?rCrrrrr5�s

r5)�formatString�mappingrcCstt
�|d
t|
�
��
S)a�
    Format a string like L{str.format}, but:

        - taking only a name mapping; no positional arguments

        - with the additional syntax that an empty set of parentheses
          correspond to a formatting item that should be called, and its result
          C{str}'d, rather than calling C{str} on the element directly as
          normal.

    For example::

        >>> formatWithCall("{string}, {function()}.",
        ...                dict(string="just a string",
        ...                     function=lambda: "a function"))
        'just a string, a function.'

    @param formatString: A PEP-3101 format string.
    @param mapping: A L{dict}-like object to format.

    @return: The string with formatted values interpolated.
    r)r-r�vformatr5)rIrJrrr�formatWithCall�srLc

Cs�zzd
|krt|�
WSt
ttttf|�dd��}
|
dkr@WdSt|
t�rLn$t|
t�rb|
�d�
}
nt	d|
���
�
t
|
|�WStk
r�
}
zt||�WY�Sd}~XYnXdS)ae

    Formats an event as a string, using the format in C{event["log_format"]}.

    This implementation should never raise an exception; if the formatting
    cannot be done, the returned string will describe the event generically so
    that a useful message is emitted regardless.

    @param event: A logging event.

    @return: A formatted string.
    �
log_flattened�
log_formatN�zutf-8zLog format must be str, not )
rr	rrr-�bytes�get�
isinstance�decode�	TypeErrorrLr$r&)rr#�
errr�_formatEvent�s










rV)r!rc

Cs@z|��}
Wn.t
k
r:
}
zd
t|�
}
W5d}~XYnX|
S)a^

    Format a failure traceback, assuming UTF-8 and using a replacement
    strategy for errors.  Every effort is made to provide a usable
    traceback, but should not that not be possible, a message and the
    captured exception are logged.

    @param failure: The failure to retrieve a traceback from.

    @return: The formatted traceback.
    z((UNABLE TO OBTAIN TRACEBACK FROM EVENT):N)�getTracebackr$r-)r!�	tracebackrUrrr�_formatTraceback
s




rYc
Cs�tt
t|�d
d��}
|
dkrftt
t|�dd��}|dkrBd}n|j}djtt|�dd��|d�}
n&zt|
�
}
Wntk
r�


d}
YnX|
S)	a�

    Format the system specified in the event in the "log_system" key if set,
    otherwise the C{"log_namespace"} and C{"log_level"}, joined by a C{"#"}.
    Each defaults to C{"-"} is not set.  If formatting fails completely,
    "UNFORMATTABLE" is returned.

    @param event: The event containing the system specification.

    @return: A formatted string representing the "log_system" key.
    Z
log_systemNZ	log_levelr'z{namespace}#{level}Z
log_namespace)�	namespace�levelZ
UNFORMATTABLE)r	rr-rQr
�namer#�	Exception)r�systemr[Z	levelNamerrr�
_formatSystem
s





�




r_T)rrrrr0rc
	Cs�t|�
}|
r2d
|kr2|d
}t
|�
}d�||f�
}|s:|Sd}|rbd�|tt|�dd���
dg�
}d}	|r�d�dt|�
ddg�
}	d	j||	|d
�S)ah
    Format an event as text.  Optionally, attach timestamp, traceback, and
    system information.

    The full output format is:
    C{"{timeStamp} [{system}] {event}\n{traceback}\n"} where:

        - C{timeStamp} is the event's C{"log_time"} value formatted with
          the provided C{formatTime} callable.

        - C{system} is the event's C{"log_system"} value, if set, otherwise,
          the C{"log_namespace"} and C{"log_level"}, joined by a C{"#"}.  Each
          defaults to C{"-"} is not set.

        - C{event} is the event, as formatted by L{formatEvent}.

        - C{traceback} is the traceback if the event contains a
          C{"log_failure"} key.  In the event the original traceback cannot
          be formatted, a message indicating the failure will be substituted.

    If the event cannot be formatted, and no traceback exists, an empty string
    is returned, even if includeSystem or includeTimestamp are true.

    @param event: A logging event.
    @param includeTraceback: If true and a C{"log_failure"} key exists, append
        a traceback.
    @param includeTimestamp: If true include a formatted timestamp before the
        event.
    @param includeSystem:  If true, include the event's C{"log_system"} value.
    @param formatTime: A time formatter

    @return: A formatted string with specified options.

    @since: Twisted 18.9.0
    Zlog_failurer1rOZlog_timeN�
 �
[�
]z{timeStamp}{system}{eventText})�	timeStampr^r3)rVrYrr	�floatrQr_r#)
rrrrr0r3�
frXrcr^rrrr7
s$*






 




�rN))rG�collections.abcrZ
MappingABCrr+�typingrrrrrr	�
constantlyr
Ztwisted.python._tzhelperr�twisted.python.failurerZtwisted.python.reflectr
�_flattenrr�_interfacesr�timeFormatRFC3339r-rr$r&rdr0r4r5rLrVrYr_�boolrrrrr�<module>sV

$



&
�



�#�

�6""!


�





�