o ¥ÜÓh¶ã@shdZddlmZddlmZmZmZmZddlm Z ddlm Z m Z m Z m Z Gdd„dƒZdd d„ZdS)z" Logger wrapper and helper class. é)Ú annotations)ÚAnyÚIterableÚMappingÚSequence)Ú DropEventé)ÚBindableLoggerÚContextÚ ProcessorÚ WrappedLoggerc@s„eZdZUdZded< d,d d „Zd-d d„Zd.dd„Zd.dd„Zd/dd„Z d0dd„Z d0dd„Z d/dd „Z d1d'd(„Z )d2d3d*d+„Zd)S)4ÚBoundLoggerBasea Immutable context carrier. Doesn't do any actual logging; examples for useful subclasses are: - the generic `BoundLogger` that can wrap anything, - `structlog.stdlib.BoundLogger`. - `structlog.twisted.BoundLogger`, See also `custom-wrappers`. r Ú_loggerÚloggerÚ processorsúIterable[Processor]Úcontextr cCs||_||_||_dS©N)rÚ _processorsÚ_context)Úselfrrr©rúE/var/www/html/ai/venv/lib/python3.10/site-packages/structlog/_base.pyÚ__init__+s zBoundLoggerBase.__init__ÚreturnÚstrcCsd |jj|j|j¡S)Nz#<{}(context={!r}, processors={!r})>)ÚformatÚ __class__Ú__name__rr)rrrrÚ__repr__5sÿzBoundLoggerBase.__repr__ÚotherÚobjectÚboolcCs$z|j|jkWStyYdSw)NF)rÚAttributeError©rr rrrÚ__eq__:s  ÿzBoundLoggerBase.__eq__cCs | |¡ Sr)r%r$rrrÚ__ne__@s zBoundLoggerBase.__ne__Ú new_valuesrcKs$| |j|j|jj|jfi|¤Ž¡S)zS Return a new logger with *new_values* added to the existing ones. )rrrr©rr'rrrÚbindCs ýzBoundLoggerBase.bindÚkeyscGs| ¡}|D]}|j|=q|S)zš Return a new logger with *keys* removed from the context. Raises: KeyError: If the key is not part of the context. )r)r©rr*ÚblÚkeyrrrÚunbindMs zBoundLoggerBase.unbindcGs$| ¡}|D] }|j |d¡q|S)zs Like :meth:`unbind`, but best effort: missing keys are ignored. .. versionadded:: 18.2.0 N)r)rÚpopr+rrrÚ try_unbind[szBoundLoggerBase.try_unbindcKs|j ¡|jdi|¤ŽS)zï Clear context and binds *new_values* using `bind`. Only necessary with dict implementations that keep global state like those wrapped by `structlog.threadlocal.wrap_dict` when threads are re-used. Nr)rÚclearr)r(rrrÚnewgs zBoundLoggerBase.newÚ method_nameÚeventú str | NoneÚevent_kwúdict[str, Any]ú'tuple[Sequence[Any], Mapping[str, Any]]cCsŠ|j ¡}|jdi|¤Ž|dur||d<|jD] }||j||ƒ}qt|tttfƒr/|fifSt|t ƒr6|St|t ƒr?d|fSd}t |ƒ‚)a' Combines creates an ``event_dict`` and runs the chain. Call it to combine your *event* and *context* into an event_dict and process using the processor chain. Arguments: method_name: The name of the logger method. Is passed into the processors. event: The event -- usually the first positional argument to a logger. event_kw: Additional event keywords. For example if someone calls ``log.info("foo", bar=42)``, *event* would to be ``"foo"`` and *event_kw* ``{"bar": 42}``. Raises: structlog.DropEvent: if log entry should be dropped. ValueError: if the final processor doesn't return a str, bytes, bytearray, tuple, or a dict. Returns: `tuple` of ``(*args, **kw)`` .. note:: Despite underscore available to custom wrapper classes. See also `custom-wrappers`. .. versionchanged:: 14.0.0 Allow final processor to return a `dict`. .. versionchanged:: 20.2.0 Allow final processor to return `bytes`. .. versionchanged:: 21.2.0 Allow final processor to return a `bytearray`. Nr4rzLast processor didn't return an appropriate value. Valid return values are a dict, a tuple of (args, kwargs), bytes, or a str.) rÚcopyÚupdaterrÚ isinstancerÚbytesÚ bytearrayÚtupleÚdictÚ ValueError)rr3r4r6Ú event_dictÚprocÚmsgrrrÚ_process_eventus 0    ÿzBoundLoggerBase._process_eventNcKs@z| |||¡\}}t|j|ƒ|i|¤ŽWStyYdSw)aÞ Run processor chain on event & call *method_name* on wrapped logger. DRY convenience method that runs :func:`_process_event`, takes care of handling :exc:`structlog.DropEvent`, and finally calls *method_name* on :attr:`_logger` with the result. Arguments: method_name: The name of the method that's going to get called. Technically it should be identical to the method the user called because it also get passed into processors. event: The event -- usually the first positional argument to a logger. event_kw: Additional event keywords. For example if someone calls ``log.info("foo", bar=42)``, *event* would to be ``"foo"`` and *event_kw* ``{"bar": 42}``. .. note:: Despite underscore available to custom wrapper classes. See also `custom-wrappers`. N)rDÚgetattrrr)rr3r4r6ÚargsÚkwrrrÚ_proxy_to_logger¾s  ÿz BoundLoggerBase._proxy_to_logger)rr rrrr )rr)r r!rr")r'rrr )r*rrr )r3rr4r5r6r7rr8r)r3rr4r5r6rrr)rÚ __module__Ú __qualname__Ú__doc__Ú__annotations__rrr%r&r)r.r0r2rDrHrrrrr s       Jÿr Ú bound_loggerr rr cCs|jS)aK Return *bound_logger*'s context. The type of *bound_logger* and the type returned depend on your configuration. Arguments: bound_logger: The bound logger whose context you want. Returns: The *actual* context from *bound_logger*. It is *not* copied first. .. versionadded:: 20.2.0 )r)rMrrrÚ get_contextäsrNN)rMr rr )rKÚ __future__rÚtypingrrrrÚstructlog.exceptionsrr r r r r rNrrrrÚs  R