h5 UdZddlmZddlZddlZddlZddlmZmZm Z m Z m Z m Z ddl mZddlmZddlmZdd lmZmZmZdd lmZmZmZdd lmZmZmZmZ eeeeed d eej dddkoSej dddkp4eo2ej!duo)e"ej!doej!#gZ$de%d<e e ee&Z'edZ(eZ)d Z*GddZ+e+Z, d6dZ-d7dZ.d8d Z/e/Z0 d9d:d-Z1 d9d;d1Z2 d9d;d2Z3d>> from structlog import get_logger >>> log = get_logger(y=23) >>> log.info("hello", x=42) y=23 x=42 event='hello' Arguments: args: *Optional* positional arguments that are passed unmodified to the logger factory. Therefore it depends on the factory what they mean. initial_values: Values that are used to pre-populate your contexts. Returns: A proxy that creates a correctly configured bound logger when necessary. The type of that bound logger depends on your configuration and is `structlog.BoundLogger` by default. See `configuration` for details. If you prefer CamelCase, there's an alias for your reading pleasure: `structlog.getLogger`. .. versionadded:: 0.4.0 *args* Nlogger_factory_argsN) wrap_logger)r>r?s r4 get_loggerrDls>  H H H H HHr3loggerWrappedLogger | Noner:Iterable[Processor] | Noner<type[BindableLogger] | Noner;type[Context] | Noner( bool | NonerAIterable[Any] | Nonec .t|||||||S)aJ Create a new bound logger for an arbitrary *logger*. Default values for *processors*, *wrapper_class*, and *context_class* can be set using `configure`. If you set an attribute here, `configure` calls have *no* effect for the *respective* attribute. In other words: selective overwriting of the defaults while keeping some *is* possible. Arguments: initial_values: Values that are used to pre-populate your contexts. logger_factory_args: Values that are passed unmodified as ``*logger_factory_args`` to the logger factory if not `None`. Returns: A proxy that creates a correctly configured bound logger when necessary. See `configure` for the meaning of the rest of the arguments. .. versionadded:: 0.4.0 *logger_factory_args* )r<r:r;r(r?rA)BoundLoggerLazyProxy)rEr:r<r;r(rAr?s r4rCrCs1L ##";%/   r3r'#Callable[..., WrappedLogger] | NoneNonecdt_| |t_| |t_| |t_| |t_||t_dSdS)a  Configures the **global** defaults. They are used if `wrap_logger` or `get_logger` are called without arguments. Can be called several times, keeping an argument at `None` leaves it unchanged from the current setting. After calling for the first time, `is_configured` starts returning `True`. Use `reset_defaults` to undo your changes. Arguments: processors: The processor chain. See :doc:`processors` for details. wrapper_class: Class to use for wrapping loggers instead of `structlog.BoundLogger`. See `standard-library`, :doc:`twisted`, and `custom-wrappers`. context_class: Class to be used for internal context keeping. The default is a `dict` and since dictionaries are ordered as of Python 3.6, there's few reasons to change this option. logger_factory: Factory to be called to create a new logger that shall be wrapped. cache_logger_on_first_use: `wrap_logger` doesn't return an actual wrapped logger but a proxy that assembles one when it's first used. If this option is set to `True`, this assembled logger is cached. See `performance`. .. versionadded:: 0.3.0 *cache_logger_on_first_use* TN)r7r#r$r&r%r'r(r:r<r;r'r(s r4 configurerRsaX!G%/" (5% (5%!!/ ,,E)))-,r3ctjst|||||dStjdt ddS)z Configures if structlog isn't configured yet. It does *not* matter whether it was configured using `configure` or `configure_once` before. Raises: RuntimeWarning: if repeated configuration is attempted. rQz!Repeated configuration attempted.) stacklevelN)r7r#rRwarningswarnRuntimeWarningrQs r4configure_oncerYsk"   !'')&?         /A      r3cdt_tddt_tt_t t_tt_ tt_ dS)zu Resets global default values to builtin defaults. `is_configured` starts returning `False` afterwards. FN) r7r#rr$r/r&r.r%r0r'r1r(r2r3r4reset_defaultsr[!sC "G!sK +%+*C'-3$7$=2!!!r3strc hd|jd|jd|jd|jd|jd|jd S)Nz)r_r`rarbrdrerfs r4__repr__zBoundLoggerLazyProxy.__repr__Ps CDL C C" C C373C C C!0 C C#2 C C$(#<  C C C r3 new_valuesrc |jr||j}nt|j}|j}|stj|j}|j tj}n|j}|j p tj }||||d fd }|j dus|j tj dur||_ |d i|S) zN Assemble a new BoundLogger from arguments and configuration. N)r:contextrlrr5rc&|r jdi|SS)zU Use cached assembled logger to bind potentially new values. r2)bind)rlrEs r4finalized_bindz1BoundLoggerLazyProxy.bind..finalized_bindrs* 1"v{00Z000Mr3Trlrr5rr2)rbrdr7r%r_r'rerar$r`r&rcr(rp)rfrlctxr_procsclsrqrEs @r4rpzBoundLoggerLazyProxy.bindYs    F%%d&:;;CC//0DEEC, I,d.GHG   #.EE$E!BW%B s           *d 2 2  + 31T99&DI~++ +++r3keysc:|j|S)zs Same as bind, except unbind *keys* first. In our case that could be only initial values. )rpunbindrfrvs r4rxzBoundLoggerLazyProxy.unbinds "tyy{{!4((r3c:|j|SrB)rp try_unbindrys r4r{zBoundLoggerLazyProxy.try_unbinds%tyy{{%t,,r3c |jr'|n+t|jdi|S)z+ Clear context, then bind. r2)rbclearr7r%rp)rfrls r4newzBoundLoggerLazyProxy.newsf   4    ! ! ' ' ) ) ) )  ) ) + + 1 1 3 3 3ty&&:&&&r3namecd|dkrt|}t||S)zz If a logging method if called on a lazy proxy, we have to create an ephemeral BoundLogger first. __isabstractmethod__)AttributeErrorrpgetattr)rfrbls r4 __getattr__z BoundLoggerLazyProxy.__getattr__s3 ) ) ) YY[[r4   r3r8c|jS)= Our __getattr__ magic makes this necessary. )__dict__rjs r4 __getstate__z!BoundLoggerLazyProxy.__getstate__s }r3statec\|D]\}}t|||dS)rN)itemssetattr)rfrkvs r4 __setstate__z!BoundLoggerLazyProxy.__setstate__s>KKMM  DAq D!Q      r3)NNNNNN)rErFr<rHr:rGr;rIr(rJr?r]rArr5rO)r5rhrr)rvrhr5r)rrhr5rr5r8)rr8r5rO) r)r*r+r,rgrkrprxr{r~rrrr2r3r4rMrM/s  "6:15.21504#'>>>>>$    (,(,(,(,T))))---- ' ' ' ' ! ! ! !       r3rM)r5r"r)r>rr?rr5r)NNNNN)rErFr:rGr<rHr;rIr(rJrArKr?rr5r) r:rGr<rHr;rIr'rNr(rJr5rO)r5rO)6r, __future__rossysrVtypingrrrrrr _log_levelsr _outputr contextvarsr devrrrr:rrrrrrrenvirongetstdouthasattrrrr-dictr.r/r0r1r!r7r#r=rD getLoggerrCrRrYr[rMr2r3r4rs #""""" @@@@@@@@@@@@@@@@444444''''''******;;;;;;;;;;EEEEEEEEEEEEEEEEEEEEEEK'U333Oz~~j"--3  JNN=" - - 3 (Jd*(GCJ11(J%%''    4&"&d7mT!:!:!-1 7F7F7F7F7Fv.215*.:>-1      > K K K KA A A A A A A A A A r3