o ADiE6 @sUdZddlmZddlZddlZddlZddlmZmZm Z m Z m Z m Z ddl mZddlmZddlmZdd lmZmZmZdd lmZmZmZdd lmZmZmZmZ eeeeed d deej dddkoej dddkpeoej!duoe"ej!doej!#dgZ$de%d<e e ee&Z'edZ(eZ)d Z*GdddZ+e+Z, d=ddZ-d>ddZ.d?d"d#Z/e/Z0     d@dAd0d1Z1     d@dBd5d6Z2     d@dBd7d8Z3dCd9d:Z4Gd;d<d<Z5dS)DzJ 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_PROCESSORSc@sbeZdZUdZdZded<eddZded<eZ ded <e Z d ed <e Z d ed <eZded<dS)_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&r0r0J/var/www/Datamplify/venv/lib/python3.10/site-packages/structlog/_config.pyr9s     rreturnr cCstjS)z Return whether *structlog* has been configured. If `False`, *structlog* is running with builtin defaults. .. versionadded: 18.1.0 )_CONFIGr!r0r0r0r1r!Nsr!dict[str, Any]cCstjtjtjtjtjdS)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&)r3r"r#r$r%r&r0r0r0r1 get_configYs  r8argsrinitial_valuescOstdd|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* Nlogger_factory_argsN) wrap_logger)r9r:r0r0r1 get_loggerlsr>loggerWrappedLogger | Noner5Iterable[Processor] | Noner7type[BindableLogger] | Noner6type[Context] | Noner& bool | Noner;Iterable[Any] | Nonec Kst|||||||dS)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* )r7r5r6r&r:r;)BoundLoggerLazyProxy)r?r5r7r6r&r;r:r0r0r1r=s$r=r%#Callable[..., WrappedLogger] | NoneNonecCsTdt_|dur |t_|dur|t_|dur|t_|dur|t_|dur(|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. 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)r3r!r"r$r#r%r&r5r7r6r%r&r0r0r1 configures+ rJcCs0tjst|||||ddStjdtdddS)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. rIz!Repeated configuration attempted.) stacklevelN)r3r!rJwarningswarnRuntimeWarningrIr0r0r1configure_onces  rPcCs0dt_tddt_tt_tt_tt_ t t_ dS)zu Resets global default values to builtin defaults. `is_configured` starts returning `False` afterwards. FN) r3r!rr"r-r$r,r#r.r%r/r&r0r0r0r1reset_defaultss  rQc@seZdZdZed/ddZ      d0d1ddZd2ddZd3ddZd4d d!Z d4d"d#Z d3d$d%Z d5d'd(Z d6d*d+Z d7d-d.ZdS)8rFa Instantiates a bound logger on first usage. Takes both configuration and instantiation parameters into account. The only points where a bound logger changes state are ``bind()``, ``unbind()``, and ``new()`` and that return the actual ``BoundLogger``. If and only if configuration says so, that actual bound logger is cached on first usage. .. versionchanged:: 0.4.0 Added support for *logger_factory_args*. r2dict[str, str]cC|jSr<)_initial_valuesselfr0r0r1_context9szBoundLoggerLazyProxy._contextNr?r@r7rBr5rAr6rCr&rDr:dict[str, Any] | Noner;rrHcCs6||_||_||_||_||_|pi|_|pd|_dS)Nr0)_logger_wrapper_class _processors_context_class_cache_logger_on_first_userT_logger_factory_args)rVr?r7r5r6r&r:r;r0r0r1__init__=s  zBoundLoggerLazyProxy.__init__strc Cs6d|jd|jd|jd|jd|jd|jd S)Nz)rYrZr[r\rTr^rUr0r0r1__repr__Os zBoundLoggerLazyProxy.__repr__ new_valuesrc s|jr ||j}nt|j}|j}|stj|j}|jdur$tj}n|j}|j p,tj }||||dd fdd }|j d usJ|j durMtj d urM||_ |d i|S) zN Assemble a new BoundLogger from arguments and configuration. N)r5contextrbrr2rcs|r jdi|SS)zU Use cached assembled logger to bind potentially new values. Nr0)bind)rbr?r0r1finalized_bindssz1BoundLoggerLazyProxy.bind..finalized_bindTrbrr2rr0)r\rTr3r#rYr%r^r[r"rZr$r]r&rd)rVrbctxrYprocsclsrfr0rer1rdXs*      zBoundLoggerLazyProxy.bindkeyscG|j|S)zs Same as bind, except unbind *keys* first. In our case that could be only initial values. )rdunbindrVrkr0r0r1rmszBoundLoggerLazyProxy.unbindcGrlr<)rd try_unbindrnr0r0r1roszBoundLoggerLazyProxy.try_unbindcKs0|jr |nt|jdi|S)z+ Clear context, then bind. Nr0)r\clearr3r#rd)rVrbr0r0r1news zBoundLoggerLazyProxy.newnamecCs|dkrt|}t||S)zz If a logging method if called on a lazy proxy, we have to create an ephemeral BoundLogger first. __isabstractmethod__)AttributeErrorrdgetattr)rVrrblr0r0r1 __getattr__s z BoundLoggerLazyProxy.__getattr__r4cCrS)= Our __getattr__ magic makes this necessary. )__dict__rUr0r0r1 __getstate__sz!BoundLoggerLazyProxy.__getstate__statecCs"|D] \}}t|||qdS)rxN)itemssetattr)rVr{kvr0r0r1 __setstate__sz!BoundLoggerLazyProxy.__setstate__)r2rR)NNNNNN)r?r@r7rBr5rAr6rCr&rDr:rXr;rr2rH)r2r`rg)rkr`r2r)rrr`r2rr2r4)r{r4r2rH)r'r(r)r*propertyrWr_rardrmrorqrwrzrr0r0r0r1rF)s&   ,   rF)r2r r)r9rr:rr2r)NNNNN)r?r@r5rAr7rBr6rCr&rDr;rEr:rr2r) r5rAr7rBr6rCr%rGr&rDr2rH)r2rH)6r* __future__rossysrMtypingrrrrrr_nativer _outputr contextvarsr devr rrr5rrrrrrrenvirongetstdouthasattrrrr+dictr,r-r.r/rr3r!r8r> getLoggerr=rJrPrQrFr0r0r0r1sz             0 :