o Fh@s:UdZddlmZddlZddlZddlZddlZddlmZm Z ddlm Z m Z ddl Z ddl Z ddl mZddlmZmZmZmZmZmZmZmZmZmZdd lmZdd lmZmZdd lm Z dd l!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)ddlm*Z*ej+rddl,m-Z-ddl.m/Z/ddl m0Z0m1Z1m2Z2ddl m3Z3m4Z4ddl5m6Z6m7Z7ddl8m9Z:ddl;mZ>ddl;m?Z@ejAejBeCe fddfZDejEdddZFdZGdeHd<ne*ZIdZJejKZLGdddejMdZNejOdddePddd d=d2d3ZQejOddePddd4d>d7d3ZQdddddddd8d?dj?Z?e=j>j@Z@e=j>jAZAe=j>jBZBd.ddZCeeDjEdeFdd0ddĄZGeeDjEdeFddddDŽZHeDjEdeFdd9d9dddddɜd1dd̄ZIeDjEdeFdd9d9ddddeJeJdΜd2ddԄZKeeDjEdeFdd3ddׄZLeeDjEdeFdd9dd9ddڜd4ddZMeeDjEdeFdd9dd9ddڜd5ddZNeeDjEdeFdd3ddZOeeDjEdeFdddddZPeDjEdeFdd9d9d9ddd6ddZQeeDjEdeFdd1e#fd7ddZReeDjEdeFdd1e#dd8ddZSeeDjEdeFdd9ddZTeeDjEdeFdd:ddZUeDjEdeFdd;ddZVeDjEdeFdd;d d ZWeeDjEd eFdd;d d ZXeDjEdeFdd;ddZYZZS(<r/a}Usage docs: https://docs.pydantic.dev/2.5/concepts/models/ A base class for creating Pydantic models. Attributes: __class_vars__: The names of classvars defined on the model. __private_attributes__: Metadata about the private attributes of the model. __signature__: The signature for instantiating the model. __pydantic_complete__: Whether model building is completed, or if there are still undefined fields. __pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer. __pydantic_custom_init__: Whether the model has a custom `__init__` function. __pydantic_decorators__: Metadata containing the decorators defined on the model. This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1. __pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these. __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models. __pydantic_post_init__: The name of the post-init method for the model, if defined. __pydantic_root_model__: Whether the model is a `RootModel`. __pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model. __pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model. __pydantic_extra__: An instance attribute with the values of extra fields from validation when `model_config['extra'] == 'allow'`. __pydantic_fields_set__: An instance attribute with the names of fields explicitly set. __pydantic_private__: Instance attribute with the values of private attributes set on the model instance. zClassVar[ConfigDict] model_configzClassVar[dict[str, FieldInfo]] model_fieldszClassVar[set[str]]__class_vars__z%ClassVar[dict[str, ModelPrivateAttr]]__private_attributes__zClassVar[Signature] __signature__zClassVar[bool]__pydantic_complete__zClassVar[CoreSchema]__pydantic_core_schema____pydantic_custom_init__z$ClassVar[_decorators.DecoratorInfos]__pydantic_decorators__z+ClassVar[_generics.PydanticGenericMetadata]__pydantic_generic_metadata__zClassVar[dict[str, Any] | None]__pydantic_parent_namespace__z+ClassVar[None | Literal['model_post_init']]__pydantic_post_init____pydantic_root_model__zClassVar[SchemaSerializer]__pydantic_serializer__zClassVar[SchemaValidator]__pydantic_validator__F)initdict[str, Any] | None__pydantic_extra__set[str]__pydantic_fields_set____pydantic_private__zXPydantic models should inherit from BaseModel, BaseModel cannot be instantiated directly validatorzbase-model-instantiated) val_or_sercode serializer)__dict__rFrDrGdatarreturnNonecKsd}|jj||ddS)ajCreate a new model by parsing and validating input data from keyword arguments. Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model. `__init__` uses `__pydantic_self__` instead of the more common `self` for the first arg to allow `self` as a field name. T) self_instanceNrAvalidate_python)__pydantic_self__rM__tracebackhide__rUZ/var/www/html/HyperOracle/crypto_trader/venv/lib/python3.10/site-packages/pydantic/main.py__init__s zBaseModel.__init__Tdict[str, ComputedFieldInfo]cCsdd|jjDS)zGet the computed fields of this model instance. Returns: A dictionary of computed field names and their corresponding `ComputedFieldInfo` objects. cSsi|]\}}||jqSrU)info.0kvrUrUrV sz3BaseModel.model_computed_fields..)r;computed_fieldsitemsselfrUrUrVmodel_computed_fieldsszBaseModel.model_computed_fieldscC|jS)zGet extra fields set during validation. Returns: A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. )rDrarUrUrV model_extraszBaseModel.model_extracCrd)zReturns the set of fields that have been explicitly set on this model instance. Returns: A set of strings representing the fields that have been set, i.e. that were not filled from defaults. )rFrarUrUrVmodel_fields_setszBaseModel.model_fields_setNcls type[Model] _fields_setset[str] | Nonevaluesr.c Ks(||}i}i}|jD]-\}}|jr#|j|vr#||j||<q||vr/||||<q|s;|jdd||<q|durFt|}| |d}|j ddkrei}|D]\} } | || <q[n| |t |d|t |d||j st |d||jr|d|S|j st |d d|S) aSCreates a new instance of the `Model` class with validated data. Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed. Behaves as if `Config.extra = 'allow'` was set since it adds all passed values Args: _fields_set: The set of field names accepted for the Model instance. values: Trusted or pre-validated data dictionary. Returns: A new instance of the `Model` class with validated data. T)call_default_factoryNextraallowrLrFrDrG)__new__r4r`aliaspop is_required get_defaultsetkeysupdater3get_object_setattrr?r>model_post_init) rgrirkm fields_valuesdefaultsnamefield_extrar\r]rUrUrVmodel_constructs>          zBaseModel.model_construct)rvdeeprbrvrboolcCs|r|n|}|rD|jddkr6|D]\}}||jvr'||j|<q|jdur/i|_||j|<qn|j||j | |S)aUsage docs: https://docs.pydantic.dev/2.5/concepts/serialization/#model_copy Returns a copy of the model. Args: update: Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data. deep: Set to `True` to make a deep copy of the model. Returns: New model instance. rmrnN) __deepcopy____copy__r3rwr`r4rLrDrvrFru)rbrvrcopiedr\r]rUrUrV model_copys      zBaseModel.model_copypython) modeincludeexcludeby_alias exclude_unsetexclude_defaults exclude_none round_tripwarningsrLiteral['json', 'python'] | strrr1rrrrrrrdict[str, Any]c Cs |jj|||||||||| d S)aUsage docs: https://docs.pydantic.dev/2.5/concepts/serialization/#modelmodel_dump Generate a dictionary representation of the model, optionally specifying which fields to include or exclude. Args: mode: The mode in which `to_python` should run. If mode is 'json', the dictionary will only contain JSON serializable types. If mode is 'python', the dictionary may contain any Python objects. include: A list of fields to include in the output. exclude: A list of fields to exclude from the output. by_alias: Whether to use the field's alias in the dictionary key if defined. exclude_unset: Whether to exclude fields that have not been explicitly set. exclude_defaults: Whether to exclude fields that are set to their default value from the output. exclude_none: Whether to exclude fields that have a value of `None` from the output. round_trip: Whether to enable serialization and deserialization round-trip support. warnings: Whether to log warnings when invalid fields are encountered. Returns: A dictionary representation of the model. ) rrrrrrrrr)r@ to_python) rbrrrrrrrrrrUrUrV model_dumps!zBaseModel.model_dump indentrrrrrrrrr int | Nonestrc Cs$|jj|||||||||| d S)aIUsage docs: https://docs.pydantic.dev/2.5/concepts/serialization/#modelmodel_dump_json Generates a JSON representation of the model using Pydantic's `to_json` method. Args: indent: Indentation to use in the JSON output. If None is passed, the output will be compact. include: Field(s) to include in the JSON output. Can take either a string or set of strings. exclude: Field(s) to exclude from the JSON output. Can take either a string or set of strings. by_alias: Whether to serialize using field aliases. exclude_unset: Whether to exclude fields that have not been explicitly set. exclude_defaults: Whether to exclude fields that have the default value. exclude_none: Whether to exclude fields that have a value of `None`. round_trip: Whether to use serialization/deserialization between JSON and class instance. warnings: Whether to show any warnings that occurred during serialization. Returns: A JSON string representation of the model. r)r@to_jsondecode) rbrrrrrrrrrrUrUrVmodel_dump_jsonAs zBaseModel.model_dump_json validation ref_templateschema_generatortype[GenerateJsonSchema]rcCst|||||dS)aGenerates a JSON schema for a model class. Args: by_alias: Whether to use attribute aliases or not. ref_template: The reference template. schema_generator: To override the logic used to generate the JSON schema, as a subclass of `GenerateJsonSchema` with your desired modifications mode: The mode in which to generate the schema. Returns: The JSON schema for the given model class. )rrrr)r)rgrrrrrUrUrVrms zBaseModel.model_json_schemaparamstuple[type[Any], ...]cCs>t|tjs tddd|D}d|}|jd|dS)a}Compute the class name for parametrizations of generic classes. This method can be overridden to achieve a custom naming scheme for generic BaseModels. Args: params: Tuple of types of the class. Given a generic class `Model` with 2 type variables and a concrete model `Model[str, int]`, the value `(str, int)` would be passed to `params`. Returns: String representing the new class where `params` are passed to `cls` as type variables. Raises: TypeError: Raised when trying to generate concrete names for non-generic models. z;Concrete names should only be generated for generic models.cSs$g|]}t|tr |nt|qSrU) isinstancerrdisplay_as_typer[paramrUrUrV s$z5BaseModel.model_parametrized_name.., []) issubclasstypingGeneric TypeErrorjoin__name__)rgr param_namesparams_componentrUrUrVmodel_parametrized_names  z!BaseModel.model_parametrized_name_BaseModel__contextcCdS)zOverride this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. NrU)rbrrUrUrVryszBaseModel.model_post_init)force raise_errors_parent_namespace_depth_types_namespacerrrintr bool | Nonec Cs|s|jrdSd|jvrt|d|dur|}n-|dkr;tj|dp%i}t|jp-i}i||}t ||_nt|j}t ||}i|j ddi}tj ||j tj|dd||dS) a1Try to rebuild the pydantic-core schema for the model. This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails. Args: force: Whether to force the rebuilding of the model schema, defaults to `False`. raise_errors: Whether to raise errors, defaults to `True`. _parent_namespace_depth: The depth level of the parent namespace, defaults to 2. _types_namespace: The types namespace, defaults to `None`. Returns: Returns `None` if the schema is already "complete" and rebuilding was not required. If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. Nr9r) parent_depth defer_buildF)check)rtypes_namespace)r8rLdelattrrrparent_frame_namespacerunpack_lenient_weakvaluedictr=build_lenient_weakvaluedictget_cls_types_namespacer3complete_model_classrr ConfigWrapper) rgrrrrrframe_parent_ns cls_parent_nsconfigrUrUrV model_rebuilds0       zBaseModel.model_rebuildstrictfrom_attributescontextobjrrrcCsd}|jj||||dS)aValidate a pydantic model instance. Args: obj: The object to validate. strict: Whether to raise an exception on invalid fields. from_attributes: Whether to extract data from object attributes. context: Additional context to pass to the validator. Raises: ValidationError: If the object could not be validated. Returns: The validated model instance. TrrQ)rgrrrrrTrUrUrVmodel_validateszBaseModel.model_validaterr json_datastr | bytes | bytearraycCd}|jj|||dS)aUsage docs: https://docs.pydantic.dev/2.5/concepts/json/#json-parsing Validate the given JSON data against the Pydantic model. Args: json_data: The JSON data to validate. strict: Whether to enforce types strictly. context: Extra variables to pass to the validator. Returns: The validated Pydantic model. Raises: ValueError: If `json_data` is not a JSON string. Tr)rA validate_json)rgrrrrTrUrUrVmodel_validate_jsonszBaseModel.model_validate_jsoncCr)aRValidate the given object contains string data against the Pydantic model. Args: obj: The object contains string data to validate. strict: Whether to enforce types strictly. context: Extra variables to pass to the validator. Returns: The validated Pydantic model. Tr)rAvalidate_strings)rgrrrrTrUrUrVmodel_validate_stringssz BaseModel.model_validate_strings_BaseModel__sourcetype[BaseModel]_BaseModel__handlerrr"cCs"d|jvr |jds |jS||S)aHook into generating the model's CoreSchema. Args: __source: The class we are generating a schema for. This will generally be the same as the `cls` argument if this is a classmethod. __handler: Call into Pydantic's internal JSON schema generation. A callable that calls into Pydantic's internal CoreSchema generation logic. Returns: A `pydantic-core` `CoreSchema`. r9origin)rLr<r9)rgrrrUrUrV__get_pydantic_core_schema__,s  z&BaseModel.__get_pydantic_core_schema___BaseModel__core_schemarrcCs||S)acHook into generating the model's JSON schema. Args: __core_schema: A `pydantic-core` CoreSchema. You can ignore this argument and call the handler with a new CoreSchema, wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`), or just call the handler with the original schema. __handler: Call into Pydantic's internal JSON schema generation. This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema generation fails. Since this gets called by `BaseModel.model_json_schema` you can override the `schema_generator` argument to that function to change JSON schema generation globally for a type. Returns: A JSON schema, as a Python object. rU)rgrrrUrUrV__get_pydantic_json_schema__Dsz&BaseModel.__get_pydantic_json_schema__kwargscKr)aThis is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after the class is actually fully initialized. In particular, attributes like `model_fields` will be present when this is called. This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized. This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by pydantic. Args: **kwargs: Any keyword arguments passed to the class definition that aren't used internally by pydantic. NrUrgrrUrUrV__pydantic_init_subclass__]sz$BaseModel.__pydantic_init_subclass__typevar_values!type[Any] | tuple[type[Any], ...]3type[BaseModel] | _forward_ref.PydanticRecursiveRefc st||}|dur |S|turtdt|ds t|d|jds2tj|jvr2t|dt |t s:|f}t ||t t |jd|trara|}t||||S|jd}|sk|}n t fdd|D}|jd p||}||}t d d tD}t||N} | dur| WdSt||||}|dur|WdSz|jd d Wn tyYnwt||||}t|||||Wd|S1swY|S)NzAType parameters should be placed on typing.Generic, not BaseModel__parameters__zG cannot be parametrized because it does not inherit from typing.Generic parametersz is not a generic classargsc3s|] }t|VqdSN)r replace_types)r[arg typevars_maprUrV z.BaseModel.__class_getitem__..rcSsi|]}|dqSrrUrrUrUrVr^sz/BaseModel.__class_getitem__..)r)rget_cached_generic_type_earlyr/rhasattrr<rr __bases__rtuplecheck_parameters_countdictzipr all_identicalrurkset_cached_generic_typeriter_contained_typevarsgeneric_recursion_self_typeget_cached_generic_type_laterrcreate_generic_submodel) rgrcachedsubmodel parent_argsrr model_namermaybe_self_typerUrrV__class_getitem__ps^    %     zBaseModel.__class_getitem__cCst|}||}t|dt|jt|dt|jt|dt|j|jdur1t|dd|St|ddd|jD|S)z$Returns a shallow copy of the model.rLrDrFNrGcSi|] \}}|tur||qSrUrrZrUrUrVr^z&BaseModel.__copy__..) typerorxrrLrDrFrGr`)rbrgrzrUrUrVrs   zBaseModel.__copy__memodict[int, Any] | NonecCst|}||}t|dt|j|dt|dt|j|dt|dt|j|jdur5t|dd|St|dtdd|j D|d|S) z!Returns a deep copy of the model.rL)rrDrFNrGcSrrUrrZrUrUrVr^rz*BaseModel.__deepcopy__..) rrorxrrLrDrrFrGr`)rbrrgrzrUrUrVrs   zBaseModel.__deepcopy__itemc st|d}||vr;||}t|dr||t|Sz|j|WSty:}z tt|jd||d}~wwzt|d}Wn tyNd}Ynw|durrz||WStyq}z tt|jd||d}~wwt|j |r~t |Stt|jd|)Nr6__get__ object has no attribute rD) object__getattribute__rr rrGKeyErrorAttributeErrorr __class__super)rbr private_attributes attributeexcpydantic_extrarrUrV __getattr__s4       zBaseModel.__getattr__r}valuec Cs||jvrt|d|jjd|jjd|dt|sI|jdus(||jvr0t|||dS|j|}t |drB| ||dS||j|<dS| ||t |j|d}t |trc| ||dS|jddrt|j|||dS|jddkr||jvrtd |jjd |d |jddkr||jvr|jr||jvr||j|<dSzt ||Wnty||j|<YdSwt|||dS||j|<|j|dS) Nz is a ClassVar of `zR` and cannot be set on an instance. If you want to set a value on the class, use `.z = value`.__set__validate_assignmentrmrn"z" object has no field ")r5rrrr is_valid_field_namerGr6rxrr _check_frozengetattrrpropertyr3rwrArr4 ValueErrorrerDrLrFadd)rbr}rrattrrUrUrV __setattr__sJ          zBaseModel.__setattr__c Cs||jvr7|j|}t|dr||dSz|j|=WdSty6}z tt|jd||d}~ww||d||j vrJt ||dS|j durZ||j vrZ|j |=dSz t ||WdStyvtt|jd|w)N __delete__r ) r6rr%rGrrrrrr4r  __delattr__rD)rbr rrrUrUrVr&&s,        zBaseModel.__delattr__cCsT|jddr d}nt|j|ddrd}ndS||f|d}tj|jj|g)Nfrozenfrozen_instanceF frozen_fieldrlocinput) r3rwrr4 pydantic_coreValidationErrorfrom_exception_datarr)rbr}rtyperrorrUrUrVr@szBaseModel._check_frozendict[Any, Any]cCs0|j}|rdd|D}|j|j|j|dS)NcSrrUrrZrUrUrVr^Qrz*BaseModel.__getstate__..)rLrDrFrG)rGr`rLrDrF)rbprivaterUrUrV __getstate__NszBaseModel.__getstate__statecCsDt|d|dt|d|dt|d|dt|d|ddS)NrFrDrGrL)rx)rbr5rUrUrV __setstate__YszBaseModel.__setstate__othercCsZt|tr+|jdp |j}|jdp|j}||ko*|j|jko*|j|jko*|j|jkStS)Nr)rr/r<rrLrGrDNotImplemented)rbr7 self_type other_typerUrUrV__eq___s    zBaseModel.__eq__Unpack[ConfigDict]cKr)aThis signature is included purely to help type-checkers check arguments to class declaration, which provides a way to conveniently set model_config key/value pairs. ```py from pydantic import BaseModel class MyModel(BaseModel, extra='allow'): ... ``` However, this may be deceiving, since the _actual_ calls to `__init_subclass__` will not receive any of the config arguments, and will only receive any keyword arguments passed during class initialization that are _not_ expected keys in ConfigDict. (This is due to the way `ModelMetaclass.__new__` works.) Args: **kwargs: Keyword arguments passed to the class definition, which set model_config Note: You may want to override `__pydantic_init_subclass__` instead, which behaves similarly but is called *after* the class is fully initialized. NrUrrUrUrV__init_subclass__uszBaseModel.__init_subclass__TupleGeneratorccs<dd|jDEdH|j}|r|EdHdSdS)zSo `dict(model)` works.cSs"g|] \}}|ds||fqS)_) startswithrZrUrUrVrs"z&BaseModel.__iter__..N)rLr`rD)rbrmrUrUrV__iter__s zBaseModel.__iter__cCs|d|ddS)N(r)) __repr_name__ __repr_str__rarUrUrV__repr__szBaseModel.__repr___repr.ReprArgsc#sjD]\}}j|}|r|jr||fVqztd}Wn ty.d}Ynw|dur?dd|DEdHfddjDEdHdS)NrDcss|] \}}||fVqdSrrUrZrUrUrVrrz*BaseModel.__repr_args__..c3s(|]\}}|jr|t|fVqdSr)reprrrZrarUrVrs&) rLr`r4rwrHr r rrc)rbr\r]r~rrUrarV __repr_args__s    "zBaseModel.__repr_args__cCs |dS)N )rErarUrUrV__str__s zBaseModel.__str__EThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]cCtdt|jS)NrL)rwarnDeprecationWarningr4rarUrUrV __fields__s zBaseModel.__fields__MThe `__fields_set__` attribute is deprecated, use `model_fields_set` instead.cCrO)NrS)rrPrQrFrarUrUrV__fields_set__szBaseModel.__fields_set__:The `dict` method is deprecated; use `model_dump` instead.rrrrrrtyping.Dict[str, Any]cCs"tdt|j||||||dS)NrUrV)rrPrQr)rbrrrrrrrUrUrVrs zBaseModel.dict?The `json` method is deprecated; use `model_dump_json` instead.)rrrrrrencodermodels_as_dictrY"typing.Callable[[Any], Any] | NonerZ dumps_kwargsc KsNtdt|turtd|turtd| rtd|j||||||dS)NrXzMThe `encoder` argument is no longer supported; use field serializers instead.zUThe `models_as_dict` argument is no longer supported; use a model serializer instead.z9`dumps_kwargs` keyword arguments are no longer supported.rV)rrPrQrrr) rbrrrrrrrYrZr\rUrUrVjsons zBaseModel.jsonCThe `parse_obj` method is deprecated; use `model_validate` instead.cCtdt||S)Nr^rrPrQrrgrrUrUrV parse_obj  zBaseModel.parse_objThe `parse_raw` method is deprecated; if your data is JSON use `model_validate_json`, otherwise load the data then use `model_validate` instead.utf8) content_typeencodingproto allow_pickleb str | bytesrf str | NonergrhDeprecatedParseProtocol | Noneric Cstdtddlm}z |j|||||d}WnBttfyZ}z4ddl} t |t r.d} nt || j r7d} n t |tr?d} nd } t | t|d |d } t j|j| gd}~ww||S) Nrdr parserhrfrgrirzvalue_error.unicodedecodezvalue_error.jsondecode value_error type_error)__root__r*)rrPrQ deprecatedroload_str_bytesr!rr]rUnicodeDecodeErrorJSONDecodeErrorr-PydanticCustomErrorrr.r/rr) rgrjrfrgrhrirorrr]type_strr1rUrUrV parse_raws<      zBaseModel.parse_rawzThe `parse_file` method is deprecated; load the data from file, then if your data is JSON use `model_validate_json`, otherwise `model_validate` instead.path str | PathcCs6tdtddlm}|j|||||d}||S)NzThe `parse_file` method is deprecated; load the data from file, then if your data is JSON use `model_validate_json` otherwise `model_validate` instead.r rnrp)rrPrQrtro load_filerb)rgr{rfrgrhrirorrUrUrV parse_file:s  zBaseModel.parse_filezqThe `from_orm` method is deprecated; set `model_config['from_attributes']=True` and use `model_validate` instead.cCs0tdt|jddstddd||S)NzqThe `from_orm` method is deprecated; set `model_config["from_attributes"]=True` and use `model_validate` instead.rzHYou must set the config attribute `from_attributes=True` to use from_ormrJ)rrPrQr3rwrrrarUrUrVfrom_ormYs zBaseModel.from_ormDThe `construct` method is deprecated; use `model_construct` instead.cKs tdt|jdd|i|S)NrrirU)rrPrQr)rgrirkrUrUrV constructks zBaseModel.constructz8The copy method is deprecated; use `model_copy` instead.)rrrvr+AbstractSetIntStr | MappingIntStrAny | Nonetyping.Dict[str, Any] | Nonec Cstdtddlm}t|j|dd||ddfi|pi}|jdur'd}n dd|jD}|j dur9d}n)|j }t |j D] } | |vrN| | qCt |D]} | |j vra| | || <qS|rl|j |B} nt|j } |ry| t|8} |j||| |||d S) aReturns a copy of the model. !!! warning "Deprecated" This method is now deprecated; use `model_copy` instead. If you need `include` or `exclude`, use: ```py data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ``` Args: include: Optional set or mapping specifying which fields to include in the copied model. exclude: Optional set or mapping specifying which fields to exclude in the copied model. update: Optional dictionary of field-value pairs to override field values in the copied model. deep: If True, the values of fields that are Pydantic models will be deep copied. Returns: A copy of the model with included, excluded and updated fields as specified. zThe `copy` method is deprecated; use `model_copy` instead. See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.r copy_internalsF)to_dictrrrrNcSrrUrrZrUrUrVr^rz"BaseModel.copy..)r)rrPrQrtrr_iterrGr`rDrlistrqrFrurt_copy_and_set_values) rbrrrvrrrkr3rmr\ fields_setrUrUrVrss@$          zBaseModel.copyCThe `schema` method is deprecated; use `model_json_schema` instead.cCstdt|j||dS)Nrrr)rrPrQr)rgrrrUrUrVschemas zBaseModel.schemaWThe `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.rcKs@ddl}tdtddlm}|j|j||dfd|i|S)Nrrr )pydantic_encoderrdefault)r]rrPrQdeprecated.jsonrdumpsr)rgrrr\r]rrUrUrV schema_jsons  zBaseModel.schema_jsonBThe `validate` method is deprecated; use `model_validate` instead.cCr_)Nrr`)rgrrUrUrVvalidaterczBaseModel.validateLThe `update_forward_refs` method is deprecated; use `model_rebuild` instead.localnscKs(tdt|r td|jdddS)Nrz,`localns` arguments are not longer accepted.T)r)rrPrQrr)rgrrUrUrVupdate_forward_refss zBaseModel.update_forward_refsHThe private method `_iter` will be removed and should no longer be used.rcO0tdtddlm}|j|g|Ri|S)Nrr r)rrPrQrtrrrbrrrrUrUrVrs  zBaseModel._iterzWThe private method `_copy_and_set_values` will be removed and should no longer be used.cOr)NzXThe private method `_copy_and_set_values` will be removed and should no longer be used.r r)rrPrQrtrrrrUrUrVrs  zBaseModel._copy_and_set_valueszMThe private method `_get_value` will be removed and should no longer be used.cOr)NzNThe private method `_get_value` will be removed and should no longer be used.r r)rrPrQrtr _get_value)rgrrrrUrUrVr s  zBaseModel._get_valueRThe private method `_calculate_keys` will be removed and should no longer be used.cOr)Nrr r)rrPrQrtr_calculate_keysrrUrUrVrs  zBaseModel._calculate_keys)rMrrNrO)rNrX)rNrC)rNrEr)rgrhrirjrkrrNr.)rbr.rvrCrrrNr.)rrrr1rr1rrrrrrrrrrrrrNr)rrrr1rr1rrrrrrrrrrrrrNr) rrrrrrrrrNr)rrrNr)rrrNrO) rrrrrrrrCrNr) rgrhrrrrrrrrCrNr.) rgrhrrrrrrCrNr.) rgrhrrrrrrCrNr.)rrrrrNr")rr"rrrNr)rrrNrO)rrrNr)rbr.rNr.)rbr.rrrNr.)r rrNr)r}rrrrNrO)rNr2)r5r2rNrO)r7rrNr)rr<)rNr>)rNr)rNrG)rNrN)rr1rr1rrrrrrrrrNrW)rr1rr1rrrrrrrrrYr[rZrr\rrNr)rgrhrrrNr.)rgrhrjrkrfrlrgrrhrmrirrNr.)rgrhr{r|rfrlrgrrhrmrirrNr.) rbr.rrrrrvrrrrNr.)rrrrrNrW)rrrrr\rrNr)rgrhrrrNr.)rrrNrO)rrrrrNr)[r __module__ __qualname____doc__r TYPE_CHECKING__annotations___FieldrDrFrGr4r DecoratorInfosr;r MockValSerrAr@ __slots__rr3r8r?rW__pydantic_base_init__r rcrerf classmethodrrrrrrrrryrrrrrrrrrrrr$r&rr4r6r;r=rArFrIrRepresentationrDrE __pretty__ __rich_repr__rKtyping_extensionsrtrrRrTrrr]rbrzr~rrrrrrrrrrr __classcell__rUrUrrVr/<s   11, 7  @ +         /  J  ) metaclass) __config__r__base__r__validators____cls_kwargs__ __model_namerrConfigDict | NonerrlrrOrrdict[str, classmethod] | NonerrCfield_definitionsrrNrcKdSrrUrrrrrrrrrUrUrVr2( r2)rrrrr%type[Model] | tuple[type[Model], ...]rhcKrrrUrrUrUrVr27r)rrrrrrr,type[Model] | tuple[type[Model], ...] | Nonertuple[str, ...] | Nonec Ks|dur tdt|dur!|durtdddt|ts |f}n ttjdt f}|p.i}i} i} | D]G\} } t | sJtd| dtt| trotd | } z| \} }Wnt yn}ztd d d|d}~wwd| } }| rz| | | <|| | <q7|durtd }|jd }| |d}|r|d|i|r|||| |rt|j|d<t|}tj|||d\}}}||ur||d<||||||fd|d|S)a+Dynamically creates and returns a new Pydantic model, in other words, `create_model` dynamically creates a subclass of [`BaseModel`][pydantic.BaseModel]. Args: __model_name: The name of the newly created model. __config__: The configuration of the new model. __doc__: The docstring of the new model. __base__: The base class for the new model. __module__: The name of the module that the model belongs to, if `None` the value is taken from `sys._getframe(1)` __validators__: A dictionary of methods that validate fields. __cls_kwargs__: A dictionary of keyword arguments for class creation. __slots__: Deprecated. Should not be passed to `create_model`. **field_definitions: Attributes of the new model. They should be passed in the format: `=(, )` or `=(, )`. Returns: The new [model][pydantic.BaseModel]. Raises: PydanticUserError: If `__base__` and `__config__` are both passed. Nz.__slots__ should not be passed to create_modelzFto avoid confusion `__config__` and `__base__` cannot be used togetherzcreate-model-config-baserr.z3fields may not start with an underscore, ignoring "rztuple[str, Any]z4Field definitions should be a `(, )`.zcreate-model-field-definitionsr r)rrrr3)kwds__orig_bases__F)#__pydantic_reset_parent_namespace___create_model_module)rrPRuntimeWarningrrrrcastTyper/r`r rr!sys _getframe f_globalsrvr r config_dicttypes resolve_bases prepare_class)rrrrrrrrrfieldsrf_namef_def f_annotationf_valueef namespaceresolved_basesmetansrrUrUrVr2Fsz"               )rrrrrrlrrOrrrrrrCrrrNr)rrrrrrlrrrrrrrrCrrrNrh)rrrrrrlrrrrlrrrrCrrrrrNrh)Sr __future__r _annotationsrrrrrrrrr-rr _internalr r r r rrrrrr _migrationrannotated_handlersrrrrerrorsrr json_schemarrrrrrrinspectr pathlibr!r"r#r$r%r&_internal._utilsr'r(deprecated.parser)DeprecatedParseProtocolrr*r+r,r-r GeneratorTuplerr>TypeVarr.r1rrQ__all__object_setattrrxModelMetaclassr/overloadrr2rrUrUrUrVs  0       u e