rPj*H0ddlmZddlZddlZddlmZddlmZm Z m Z m Z m Z ddl mZmZmZmZmZddlmZmZddlmZddlmZdd lmZd d lmZd d lmZd dl m!Z!m"Z"d dlm#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/erddl0m1Z1ddZ2GddeZ3dgZ4y)) annotationsN)Mapping) TYPE_CHECKINGAnycastget_args get_origin) AliasChoices AliasPathJson TypeAdapterValidationError) deep_updateis_model_class)is_pydantic_dataclass) FieldInfo)is_union_origin)_lenient_issubclass)PydanticBaseEnvSettingsSource) EnvNoneTypeEnvPrefixTarget) InitState_annotation_contains_types_annotation_enum_name_to_val_annotation_is_complex"_get_field_annotation_and_metadata_get_model_config_get_model_fields_literal_has_numeric_enum_resolve_type_alias_union_has_strict_types_union_is_complex_unwrap_union_memberparse_env_vars) BaseSettingsc|tjdk(xr(ttjtjS)zWhether ``os.environ`` is the OS-backed, case-insensitive mapping (i.e. on Windows). When ``os.environ`` has been replaced (e.g. patched to a plain ``dict`` in tests), the requested case sensitivity is honored as-is. nt)osname isinstanceenviron_Environl/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/pydantic_settings/sources/providers/env.py_environ_is_case_insensitiver2+s& 77d? Bz"**bkkBBr0ceZdZdZ d dfd ZddZddZddZddZddZ ddZ dd Z d dd Z dd Z dd Zdd ZxZS)EnvSettingsSourcezN Source class for loading settings values from environment variables. c Pt |||||||| | ||n|jjd|_||n|jjd|_|j xsddz |_t|j|_ |j|_ y)Nenv_nested_delimiterenv_nested_max_splitr) super__init__configgetr6r7maxsplitlen env_prefixenv_prefix_len_load_env_varsenv_vars) self settings_clscase_sensitiver?env_prefix_targetr6r7env_ignore_emptyenv_parse_none_strenv_parse_enums _init_state __class__s r1r:zEnvSettingsSource.__init__9s          %9$D $++//ZpJq !%9$D $++//ZpJq !227a1< !$//2++- r0c|jrtrd|_ttj|j|j |j S)NF)rEr2r&r*r-rGrHrCs r1rAz EnvSettingsSource._load_env_vars[sC   #?#A"'D bjj$*=*=t?T?TVZVmVmnnr0cd}|j||D]%\}}}|jj|}|%n|fS)ah Gets the value for field from environment variables and a flag to determine whether value is complex. Args: field: The field. field_name: The field name. Returns: A tuple that contains the value (`None` if not found), key, and a flag to determine whether value is complex. N)_extract_field_inforBr<)rCfield field_nameenv_val field_keyenv_namevalue_is_complexs r1get_field_valuez!EnvSettingsSource.get_field_valuees]#6:5M5MeU_5`  1Ix!1mm''1G"   #333r0c|j|\}}|jrt|j|}||n|}|s|rt |t r|S|!|j |||j}|rO|S |j|||}t |tr't||j |||jS|Sy||j||Sy#t$r|sY]wxYw)a Prepare value for the field. * Extract value for nested field. * Deserialize value to python object for complex field. Args: field: The field. field_name: The field name. Returns: A tuple contains prepared value for the field. Raises: ValuesError: When There is an error in deserializing value for complex field. N) _field_is_complexrIr annotationr,rexplode_env_varsrBdecode_complex_value ValueErrordictr_coerce_env_val_strict) rCrQrPvaluerU is_complexallow_parse_failureenum_val env_val_builts r1prepare_field_valuez%EnvSettingsSource.prepare_field_value|s "+/*@*@*G' '   3E4D4DeLH%-E8E )%- } $ 5 5j% W  (( 55j%OE eT*&ud.C.CJPUW[WdWd.eff   ..ue< <"./s7C C('C(ct|tsy|j}g}t|tr%|j t |j n2t|tr"|jd|jD|D]=}|d}t|dkDst|ts(|j||k(s=yy)a Whether ``key`` matches the first element of a multi-part ``AliasPath`` on ``field``. When a nested field is aliased via e.g. ``AliasPath('path', 0)``, the env value found under ``path`` is a container that must be JSON-decoded before pydantic can navigate into it (see #670). This mirrors the complexity that ``_extract_field_info`` already reports for top-level ``AliasPath`` fields. Args: field: The field (or raw type) matched for ``key``. key: The (case-normalized) env name segment matched for the field. Returns: Whether ``key`` is the head of a multi-element ``AliasPath``. Fc3hK|]*}t|tst|j,ywN)r,r tuplepath).0choices r1 z=EnvSettingsSource._matches_alias_path_head..s$kZX^`iMjv{{+ks22rr8T) r,rvalidation_aliasr appendrhrir extendchoicesr>str_apply_case_sensitive)rCrPkeyv_aliaspathsriheads r1_matches_alias_path_headz*EnvSettingsSource._matches_alias_path_heads %+((-/ gy ) LLw||, -  . LLk'//k k D7D4y1}D#!64;U;UVZ;[_b;b r0ct|\}}|j|rd}d|fStt|rt |||j rd}d|fSy)za Find out if a field is complex, and if so whether JSON errors should be ignored FT)FF)rfield_is_complexrr r$rJ)rCrPrYmetadataras r1rXz#EnvSettingsSource._field_is_complexsr B%H H   '"'  ((( Z 3 49J:W_aeaqaq9r"& ((( r0ctt|}tt|xrt |g|j S)zf Find out if a raw type (e.g. a dict value type) is a union containing complex types. )r%r"rr r$rJ)rCrYunions r1_raw_union_is_complexz'EnvSettingsSource._raw_union_is_complexs:%%8%DEz%01d6GrSWScSc6ddr0c |j|||}t|ttfr|S|S#t$r|cYSwxYw)a Decode a value whose raw type is a union containing complex types, e.g. `list[str] | str`. Only JSON arrays and objects are used, any other value is kept as the original string so that values like `123` or `true` still validate against the scalar members of the union. Decoding follows the `NoDecode`/`ForceDecode` metadata of the containing `field` and the `enable_decoding` config. )r[r\r,listr])rCrQrPr_decodeds r1_decode_union_valuez%EnvSettingsSource._decode_union_valuesK // E5IG%WtTl;wFF L s / ==cl|syt|tr |jn|}tt |t rt |}|r|dSdSt |D]}|j|||}|s|cSt|s t|rt|}t|} |jD]~\} } |j| | | D]c\} } } ||r| |k(s| |k(s| ccS| j|jk(s"| j|jk(s_| ccSy)aK Find the field in a sub model by key(env name) By having the following models: ```py class SubSubModel(BaseSettings): dvals: Dict class SubModel(BaseSettings): vals: list[str] sub_sub_model: SubSubModel class Cfg(BaseSettings): sub_model: SubModel ``` Then: next_field(sub_model, 'vals') Returns the `vals` field of `SubModel` class next_field(sub_model, 'sub_sub_model') Returns `sub_sub_model` field of `SubModel` class Args: field: The field. key: The key (env name). case_sensitive: Whether to search for key case sensitively. Returns: Field if it finds the next field otherwise `None`. N)r,rrYrr r]r next_fieldrrr ritemsrOlower)rCrPrsrErYargstype_ type_has_keyfields model_configrQf_rTs r1rzEnvSettingsSource.next_fields3@)3E9)EU%%5 z*5t <J'D#48 - -j) $E??5#~FL## $ * %)>z)J&z2F,Z8L"( ! A&*&>&>q*l&[!NAx%-%,C#$H#))+syy{:hnn>NRUR[R[R]>]  ! !r0cD|jsiS|j}|tuxstt |t}|j ||Dcgc]\}}}||j}}}i} |j D]\} tfd|D} t| d} | j|j|j^} }| }|}|}| D]T}|j|||j}t|tr|}t|tsC|j!|i}V|j|||j}|s|r| rt|trV|j#|\}}|s|j%||rd\}}|j&rdt)|j| }|| n|} nG|r@t+|g|j,}d}|s*|j/|r|j1||| } nd\}}|r( t|tr|nd}|j3||| } t|ts||vst| t6r ||ik(s|j9|| ||<| Scc}}w#t$rYwxYw#t4$r|sYnwxYw)a Process env_vars and extract the values of keys containing env_nested_delimiter into nested dictionaries. This is applied to a single field, hence filtering by env_var prefix. Args: field_name: The field name. field: The field. env_vars: Environment variables. Returns: A dictionary contains extracted values from nested env values. c3FK|]}j|s|ywrg) startswith)rjprefixrTs r1rlz5EnvSettingsSource.explode_env_vars..Es[x?R?RSY?Zf[s!!N)TTT)r6rYr]rr rOrnext StopIterationr>splitr=rrEr,r setdefaultrXrwrIrrrJr}rr[r\rr^)rCrQrPrBannis_dictrrTprefixesresultrRrenv_name_without_prefixkeyslast_keyenv_var target_field parent_fieldrsr`allow_json_failurerb field_infos ` r1rZz"EnvSettingsSource.explode_env_vars+s((I+K!4Z_d!KLPKcKcdikuKv 9GHaxj223 4  "$!)!14 W Hg [8[['/s6{}&= #5;;Dt |\}}|s.t t |xr t|xs t|}|rt|trwt|trg||jk(r|StdD}|sBttfds/ ttd|j j#|S|S#t$$rWt'j(|}t|ts0ttd|j j#|cYSwxYw#t$t&j*f$rY|SwxYw)a Coerce environment string values based on field annotation if model config is `strict=True` or if the field annotation contains strict-annotated types (e.g. Optional[StrictBool]). Args: field: The field. value: The value to coerce. Returns: The coerced value if successful, otherwise the original value. strictc3<K|]}t|tywrg)r,r )rjmds r1rlz;EnvSettingsSource._coerce_env_val_strict..sGz"d3GsT) is_instancer)r;r<r,rrrr r#r!rqrHanyrr r rrYvalidate_pythonrjsonloadsJSONDecodeError)rCrPr_ should_coercerYrzhas_jsonrs r1r^z(EnvSettingsSource._coerce_env_val_strictzsP  KKOOH5M%+'I%'P$ H$' :(>?gD[\fDg%?2:>"E3!7Jui~~&&''=d>W>W=Z["114A 7 r0) NNNNNNNNN)rDztype[BaseSettings]rE bool | Noner? str | NonerFzEnvPrefixTarget | Noner6rr7z int | NonerGrrHrrIrrJzInitState | NonereturnNone)rMapping[str, str | None])rPrrQrqrztuple[Any, str, bool]) rQrqrPrr_rrUboolrr)rPFieldInfo | Any | Nonersrqrr)rPrrztuple[bool, bool])rYrrr)rQrqrPrr_rqrrrg)rPrrsrqrErrFieldInfo | None)rQrqrPrrBrrzdict[str, Any])rPrr_rrr)rrq)r __module__ __qualname____doc__r:rArVrdrwrXr}rrrZr^r __classcell__)rKs@r1r4r44s'+!%48+/+/(,)-'+(, .( .$ . . 2 . ) .) .& .' .% .& .  .Do4..`< )e G&VZ8+8258GR8 8tM^$L r0r4)rr)5 __future__r _annotationsrr*collections.abcrtypingrrrrr pydanticr r r r rpydantic._internal._utilsrrpydantic.dataclassesrpydantic.fieldsrtyping_inspection.introspectionrutilsrbasertypesrrrrrrrrr r!r"r#r$r%r&pydantic_settings.mainr'r2r4__all__r/r0r1rsu2 #QPA6%;(00 3Cp 5p f  r0