�

�
bb.�
�
�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Zd
edefd�Zd
ededefd�Zedfde
ede
ededefd�Z e f
d
edee
eg
efde
efd�Z!Gd�de�Z"dedeeefdefd�Z#d
edefd�Z$dedefd �Z%d
edefd!�Z&d"d"d"e fd
ed#e'd$e'd%e'deeg
efdefd&�Z(y')(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
� �t
|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)
rs
 �8/usr/lib/python3/dist-packages/twisted/logger/_format.py�formatEventrs���
����	���errorc���	d
j
||
��S#t$rP
t�}djd�|j	�D��
}dj
t|
�
||��cYSwxYw
)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
3�lK
�|],\}
}dj
t|
�
t|�
f�
�
�

�.y
�w
)z = N)�joinr)�.0�key�values   r�	<genexpr>z+formatUnformattableEvent.<locals>.<genexpr>Bs3����
�+�
��U�
�J�J�	�#��	�%�(8�9�:�+�s�24
zrMESSAGE LOST: unformattable object logged: {error}
Recoverable data: {text}
Exception during formatting:
{failure})r�failure�text)�format�
BaseExceptionr
r �itemsr)rrr%r&s    r�formatUnformattableEventr*,s���
�:�A�A��u�B
�
�	
���
��)���y�y�
�#�k�k�m�
�
��
6�6<�f���&��d�7=�7�	
�
�s��AA.�-
A.�
-�when�
timeFormat�defaultc��|
�|�|St
j|�
}tj||�}t	|j|
�
�
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.
    )r�fromLocalTimeStamp�DateTime�
fromtimestamp�str�strftime)r,r-r.�tzrs     r�
formatTimer6PsK��4��T�\���
 �
3�
3�D�
9���)�)�$��3���8�$�$�Z�0�1�1rr6c�P�t
||
�
�}|s
y|jdd�}|dzS)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.
    )
r6N�

z
	)r�replace)rr6�	eventTexts   r�formatEventAsClassicLogTextr;rs4��^
�E�j�9�I����!�!�$��/�I��t��rc�R�eZ
dZd
Zdeeefddfd�Zdefd�Z	de
fd�Zdedefd	�Zy)
�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}.
    �
submappingrNc��|
|_y
)zo
        @param submapping: Another read-only mapping which will be used to look
            up items.
        N)
�_submapping)�selfr>s  r�__init__zCallMapping.__init__�s��
&��rc
�,�t
|j�
S�
N)�iterr@�
rAs
 r�__iter__zCallMapping.__iter__�s���D�$�$�%�%rc
�,�t
|j�
SrD)�lenr@rFs
 r�__len__zCallMapping.__len__�s���4�#�#�$�$rr"c�j�|
j
d
�
}|r|
ddn
|
}|j|}|r|�}|S)z|
        Look up an item in the submapping for this L{CallMapping}, calling it
        if C{key} ends with C{"()"}.
        z()N���)�endswithr@)rAr"�callit�realKeyr#s     r�__getitem__zCallMapping.__getitem__�s@��
���d�#��$�#�c�r�(�#��� � ��)����G�E��r)
�__name__�
__module__�__qualname__�__doc__rr3rrBrrG�intrJrP�rrr=r=�sN���&�7�3��8�#4�&��&�
&�(�
&�
%��
%�
�s�
�s�
rr=�formatString�mappingc	�T�t
tj|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.
    rV)r3r�vformatr=)rWrXs  r�formatWithCallr[�s#��.�z�!�!�,��K��4H�I�J�Jrc
�n
�	d
|vrt
|�
Sttttt
f|j
dd��}
|
�
yt|
t�r
n0t|
t
�r|
jd�
}
ntd|
���
�
t|
|�S#t$r}t||�cYd}~Sd}~w
wxYw
)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
rr	r3�bytes�get�
isinstance�decode�	TypeErrorr[r(r*)rr'�
es   r�_formatEventrf�s���2��e�#��e�$�$��h�u�S�%�Z�0�1�5�9�9�\�4�3P�Q���>���f�c�"��
���
&��]�]�7�+�F��:�6�*�E�F�F��f�e�,�,���
2�'��q�1�1��
2�s)�B�6B�AB�	B4�B/�)
B4�/B4r%c
�r�	|j
�}
|
S#t$r}d
t|�
z}
Yd}~|
Sd}~w
wxYw
)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(r3)r%�	tracebackres   r�_formatTracebackrj
sF��H
��(�(�*�	�����
H
�>��Q��G�	����
H
�s��	6�1�6c
	�j
�t
tt|jd
d��}
|
�kt
tt|jdd��}|�d}n|j
}dj
t
t|jdd��|��}
|
S	t|
�
}
|
S#t$r
d}
Y|
SwxYw
)	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.
    �
log_systemN�	log_levelr+z{namespace}#{level}�
log_namespace)�	namespace�level�
UNFORMATTABLE)r
rr3rar�namer'�	Exception)r�systemrp�	levelNames    r�
_formatSystemrv
s����(�3�-����<��!>�
?�F�
�~��X�m�,�e�i�i��T�.J�K���=��I��
�
�I�&�-�-��3��	�	�/�3� ?�@��.�
���M�		%���[�F��M���
	%�$�F��M�
	%�s�B#�#B2�1
B2Trrrc�T
�t
|�
}|
r'd
|vr#|d
}t|�
}dj||f�
}|s|Sd}|r7dj|tt|jdd���
dg�
}d}	|rdjdt
|�
ddg�
}	d	j||	|�
�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
    �log_failurer8r_�log_timeN�
 �
[�
]z{timeStamp}{system}{eventText})�	timeStamprtr:)rfrjr r
�floatrarvr')
rrrrr6r:�
frir}rts
          rrr7
s���T
�U�#�I��M�U�2��-� �
�$�Q�'�	��I�I�y�)�4�5�	�����I���G�G�Z��U�E�I�I�j�$�4O�(P�Q�SV�W�X�	�
�F�����#�}�U�3�S�#�>�?��+�2�2����3��rN))rT�collections.abcr�
MappingABCrr1�typingrrrrr	r
�
constantlyr�twisted.python._tzhelperr�twisted.python.failurer
�twisted.python.reflectr�_flattenrr�_interfacesr�timeFormatRFC3339r3rr(r*r~r6r;r=r[rfrjrv�boolrrVrr�<module>r�
s�
�


�

�
2�)�J�J�J�$�8�*�,�,�!�)��
�x�
�C�
�(!

�H�!

�]�!

�s�!

�L
!2��
2�
�5�/�
2���
�
2��
2�	�	
2�F
E
O
�3
��3
�!)�8�E�?�*;�S�*@�!A�3
�
�c�]�3
�l

�*�
�D

K
��
K
�w�s�C�x�/@�
K
�S�
K
�4
2��
2�S�
2�D

�g�
�#�
�$
��
�c�
�B
"�!��)3�?
��?
��?
��?
��	?
�
�%��#��&�?
�	�
?
r