o _jk?@sddlmZddlZddlZddlmZddlmZm Z m Z m Z ddl m Z mZmZmZmZddlmZmZddlmZddlmZdd lmZd d lmZd d lmZd dlm Z m!Z!d dlm"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*erzddl+m,Z,dddZ-GdddeZ.dgZ/dS)) annotationsN)Mapping) TYPE_CHECKINGAnyget_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_model_fields_literal_has_numeric_enum_union_has_strict_types_union_is_complexparse_env_vars) BaseSettingsreturnboolcCstjdko 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_Environr*r*b/home/dinkstrade/pdmp/venv/lib/python3.10/site-packages/pydantic_settings/sources/providers/env.py_environ_is_case_insensitive&sr,cseZdZdZ         d9d:fdd Zd;ddZdd)d*Zd?d,d-Z d@dAd/d0Z dBd3d4Z dCd5d6Z dDd7d8Z ZS)EEnvSettingsSourcezN Source class for loading settings values from environment variables. N settings_clstype[BaseSettings]case_sensitive bool | None env_prefix str | Noneenv_prefix_targetEnvPrefixTarget | Noneenv_nested_delimiterenv_nested_max_split int | Noneenv_ignore_emptyenv_parse_none_strenv_parse_enums _init_stateInitState | Noner"Nonec sxt||||||| | |dur|n|jd|_|dur |n|jd|_|jp+dd|_t|j|_ | |_ dS)Nr6r7r) super__init__configgetr6r7maxsplitlenr2env_prefix_len_load_env_varsenv_vars) selfr.r0r2r4r6r7r9r:r;r< __class__r*r+rA4s"   zEnvSettingsSource.__init__Mapping[str, str | None]cCs(|jr tr d|_ttj|j|j|jS)NF)r0r,r r%r(r9r:rIr*r*r+rGVs z EnvSettingsSource._load_env_varsfieldr field_namestrtuple[Any, str, bool]cCs>d}|||D]\}}}|j|}|durnq|||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_inforHrC)rIrNrOenv_val field_keyenv_namevalue_is_complexr*r*r+get_field_value`s   z!EnvSettingsSource.get_field_valuevaluerrVr#c Cs||\}}|jrt|j|}|dur|n|}|s|r]t|tr#|S|dur5||||j}|r3|SdSz ||||}Wn t yJ|sHYnwt|t r[t |||||jS|S|durg| ||SdS)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_complexr;r annotationr'rexplode_env_varsrHdecode_complex_value ValueErrordictr _coerce_env_val_strict) rIrOrNrXrV is_complexallow_parse_failureenum_val env_val_builtr*r*r+prepare_field_valueus2     z%EnvSettingsSource.prepare_field_valueFieldInfo | Any | NonekeycCst|tsdS|j}g}t|tr|t|jnt|tr*|dd|j D|D]}|d}t |dkrGt|t rG| ||krGdSq,dS)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``. Fcss$|] }t|trt|jVqdSN)r'r tuplepath).0choicer*r*r+ s"z=EnvSettingsSource._matches_alias_path_head..rr?T) r'rvalidation_aliasr appendrhrirextendchoicesrErP_apply_case_sensitive)rIrNrfv_aliaspathsriheadr*r*r+_matches_alias_path_heads   $z*EnvSettingsSource._matches_alias_path_headtuple[bool, bool]cCsF||r d}d|fStt|jr!t|j|j|jr!d}d|fSdS)za Find out if a field is complex, and if so whether JSON errors should be ignored FT)FF)field_is_complexrrrZrmetadatar<)rIrNrar*r*r+rYs  z#EnvSettingsSource._field_is_complexFieldInfo | Nonec Cs|sdSt|tr |jn|}t|D]}||||}|r!|Sqtt|tr/t|dSt|s7t |r{t |}| D];\}} | | |D]0\} } } |dusT|rc||ks\| |krb| SqI| | kss| | kry| SqIq?dS)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'rrZr next_fieldrrr^rrritemsrRlower) rIrNrfr0rZtype_ type_has_keyfieldsrOf_rUr*r*r+r{s.       zEnvSettingsSource.next_fieldrHdict[str, Any]c sjsiS|j}|tuptt|t}fdd||D}i}|D]\}z tfdd|D} Wn ty@Yq&wt | d} | jj ^} } |} |}| D]} ||j }t| tro| |i} qZ || j }|s||r|rt|tr|\}}|s|| rd\}}jrt|j|}|dur|n|}n|rt|gj}d}nd\}}|rzt|tr|nd}| ||}Wn ty|sւYnwt| tr| | vst|tr| | ikr||| | <q&|S)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. cs g|] \}}}|jqSr*)r6)rjrrUrMr*r+ sz6EnvSettingsSource.explode_env_vars..c3s|] }|r|VqdSrg) startswith)rjprefix)rUr*r+rl%sz5EnvSettingsSource.explode_env_vars..N)TTT)r6rZr^rrrRr|next StopIterationrEsplitrDr{r0r' setdefaultrrYrur;rrr<r\r]rr_)rIrOrNrHannis_dictprefixesresultrSrenv_name_without_prefixkeyslast_keyenv_var target_fieldrfr`allow_json_failurerb field_infor*)rUrIr+r[ sf          z"EnvSettingsSource.explode_env_varsc Cszo|jd}|st|trtt|jot|jpt|j}|rdt|t rgt|trj||j kr3|WSt |jt fddsmz t |j|WWStyct|}t|t sbt |j|YWSwW|SW|SW|SW|Sttjfy|Y|Sw)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. strictT) is_instance)rBrCr'rrrrZrrrPr:rr r validate_pythonr jsonloadsJSONDecodeError)rIrNrX should_coercedecodedr*r*r+r_Ts>      z(EnvSettingsSource._coerce_env_val_strictcCs|jjd|jd|jdS)Nz(env_nested_delimiter=z, env_prefix_len=))rK__name__r6rFrMr*r*r+__repr__wszEnvSettingsSource.__repr__) NNNNNNNNN)r.r/r0r1r2r3r4r5r6r3r7r8r9r1r:r3r;r1r<r=r"r>)r"rL)rNrrOrPr"rQ) rOrPrNrrXrrVr#r"r)rNrerfrPr"r#)rNrr"rvrg)rNrerfrPr0r1r"ry)rOrPrNrrHrLr"r)rNryrXrr"r)r"rP)r __module__ __qualname____doc__rArGrWrdrurYr{r[r_r __classcell__r*r*rJr+r-/s, "  .  8 I#r-)r"r#)0 __future__r _annotationsrr%collections.abcrtypingrrrrpydanticrr r r r pydantic._internal._utilsr rpydantic.dataclassesrpydantic.fieldsrtyping_inspection.introspectionrutilsrbasertypesrrrrrrrrrrr pydantic_settings.mainr!r,r-__all__r*r*r*r+s*       ,    Q