"hE6 UdZddlmZddlZddlZddlZddlmZmZm Z m Z m Z m Z ddl mZddlmZddlmZdd lmZmZmZdd lmZmZmZdd lmZmZmZmZ eeeeed d eej>jAdddk(xrdej>jAdddk7xsCexr?ejBduxr/e"ejBdxrejBjGgZ$de%d<e e ee&Z'edZ(eZ)d Z*GddZ+e+Z, d!dZ-d"dZ.d#dZ/e/Z0 d$ d%dZ1 d$ d&dZ2 d$ d&dZ3d'dZ4Gdd Z5y)(zJ Global state department. Don't reload this module or everything breaks. ) annotationsN)AnyCallableIterableSequenceTypecast)make_filtering_bound_logger)PrintLoggerFactory)merge_contextvars)ConsoleRenderer _has_colors set_exc_info)StackInfoRenderer TimeStamper add_log_level)BindableLoggerContext Processor WrappedLoggerz%Y-%m-%d %H:%M:%SF)fmtutcNO_COLOR FORCE_COLORisatty)colorszSequence[Processor]_BUILTIN_DEFAULT_PROCESSORScleZdZUdZdZded<eddZded<eZ ded <e Z d ed <e Z d ed <eZded<y)_Configurationz Global defaults. Fbool is_configuredNzIterable[Processor]default_processorsz type[Context]default_context_classrdefault_wrapper_classzCallable[..., WrappedLogger]logger_factorycache_logger_on_first_use)__name__ __module__ __qualname____doc__r#__annotations__rr$_BUILTIN_DEFAULT_CONTEXT_CLASSr%_BUILTIN_DEFAULT_WRAPPER_CLASSr&_BUILTIN_DEFAULT_LOGGER_FACTORYr'"_BUILTIN_CACHE_LOGGER_ON_FIRST_USEr(N/var/www/html/sandstorm/venv/lib/python3.12/site-packages/structlog/_config.pyr!r!9sX M4.I!.L+L+I=I!?3?'0'ItHr3r!c"tjS)z Return whether *structlog* has been configured. If `False`, *structlog* is running with builtin defaults. .. versionadded: 18.1.0 )_CONFIGr#r2r3r4r#r#Ns   r3ctjtjtjtjtj dS)z Get a dictionary with the current configuration. .. note:: Changes to the returned dictionary do *not* affect *structlog*. .. versionadded: 18.1.0 ) processors context_class wrapper_classr'r()r6r$r%r&r'r(r2r3r4 get_configr;Ys;00 66 66!00%,%F%F  r3ctdd|i|S)ak Convenience function that returns a logger according to configuration. >>> from structlog import get_logger >>> log = get_logger(y=23) >>> log.info("hello", x=42) y=23 x=42 event='hello' Args: 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* logger_factory_argsN) wrap_logger)argsinitial_valuess r4 get_loggerrBls:  H H HHr3c &t|||||||S)aC 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. Args: 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:r8r9r(rAr=)BoundLoggerLazyProxy)loggerr8r:r9r(r=rAs r4r?r?s'H ##";%/ r3cdt_| |t_| |t_| |t_| |t_| |t_yy)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. Args: 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)r6r#r$r&r%r'r(r8r:r9r'r(s r4 configurerHsXV!G%/" (5% (5%!!/ ,,E)-r3c~tjst|||||ytjdt dy)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. rGz!Repeated configuration attempted.) stacklevelN)r6r#rHwarningswarnRuntimeWarningrGs r4configure_oncerOs9  !'')&?    /A r3cdt_tddt_tt_t t_tt_ tt_ y)zu Resets global default values to builtin defaults. `is_configured` starts returning `False` afterwards. FN) r6r#rr$r/r&r.r%r0r'r1r(r2r3r4reset_defaultsrQs9 "G!)_initial_valuesselfs r4_contextzBoundLoggerLazyProxy._context9s###r3Ncv||_||_||_||_||_|xsi|_|xsd|_y)Nr2)_logger_wrapper_class _processors_context_class_cache_logger_on_first_userT_logger_factory_args)rVrEr:r8r9r(rAr=s r4__init__zBoundLoggerLazyProxy.__init__=sE +%+*C'-3$7$=2!r3c d|jd|jd|jd|jd|jd|j d S)Nz)rYrZr[r\rTr^rUs r4__repr__zBoundLoggerLazyProxy.__repr__Osk+DLL+;;K""%]43C3C2FG!0034"2256##'#<#<"?r  C r3c  |jr|j|j}ntj|j}|j}|stj |j }|jtj}n |j}|jxstj}||||dfd }|jdus|jtjdur||_ |di|S)zN Assemble a new BoundLogger from arguments and configuration. )r8contextc0|rjdi|SS)zU Use cached assembled logger to bind potentially new values. r2)bind) new_valuesrEs r4finalized_bindz1BoundLoggerLazyProxy.bind..finalized_bindss!"v{{0Z00Mr3Trfrreturnrr2)r\rTr6r%rYr'r^r[r$rZr&r]r(re)rVrfctxrYprocsclsrgrEs @r4rezBoundLoggerLazyProxy.bindXs   %%d&:&:;C//0D0DEC,,,,d.G.GHG    #..E$$E!!BW%B%B      * *d 2  + + 311T9&DI+ ++r3c<|jj|S)zs Same as bind, except unbind *keys* first. In our case that could be only initial values. )reunbindrVkeyss r4rnzBoundLoggerLazyProxy.unbinds "tyy{!!4((r3c<|jj|Sr>)re try_unbindros r4rrzBoundLoggerLazyProxy.try_unbinds%tyy{%%t,,r3c |jr|jjn"tjj|jdi|S)z+ Clear context, then bind. r2)r\clearr6r%re)rVrfs r4newzBoundLoggerLazyProxy.newsK       ! ' ' )  ) ) + 1 1 3tyy&:&&r3cP|dk(rt|j}t||S)zz If a logging method if called on a lazy proxy, we have to create an ephemeral BoundLogger first. __isabstractmethod__)AttributeErrorregetattr)rVnamebls r4 __getattr__z BoundLoggerLazyProxy.__getattr__s+ ) ) YY[r4  r3c|jS)= Our __getattr__ magic makes this necessary. )__dict__rUs r4 __getstate__z!BoundLoggerLazyProxy.__getstate__s}}r3cN|jD]\}}t|||y)r~N)itemssetattr)rVstatekvs r4 __setstate__z!BoundLoggerLazyProxy.__setstate__s)KKM DAq D!Q  r3)rizdict[str, str])NNNNNN)rEWrappedLogger | Noner:type[BindableLogger] | Noner8Iterable[Processor] | Noner9type[Context] | Noner( bool | NonerAzdict[str, Any] | Noner=rriNone)ristrrh)rprrir)rzrrirridict[str, Any])rrrir)r)r*r+r,propertyrWr_rarernrrrur|rrr2r3r4rDrD)s $$ 6:15.21504#'>$>3>/ > , > $/ >.>!> >$ *,X)- ' !  r3rD)rir"r)r@rrArrir)NNNNN)rErr8rr:rr9rr(rr=zIterable[Any] | NonerArrir) r8rr:rr9rr'z#Callable[..., WrappedLogger] | Noner(rrir)rir)6r, __future__rossysrLtypingrrrrrr _nativer _outputr contextvarsr devrrrr8rrrrrrrenvirongetstdouthasattrrrr-dictr.r/r0r1r!r6r#r;rB getLoggerr?rHrOrQrDr2r3r4rsf # @@0'*;;EEEE'U3zz~~j"-3  JJNN=" - 3 (JJd*(CJJ1(JJ%%'  40&"&d7mT!:!-1 6F*6F.6F(6F8 6F + 6F  6Ft.215*.:>-1  * . ( 8  +    < KH H r3