o h@stUddlZddlmZddlmZddlmZddlmZddl m Z ddl m Z m Z mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd l m!Z!dd l"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-m.Z.dd l/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlZ>ddl?m@Z@mAZAmBZBddlCmDZDmEZEddlFmGZGmHZHddlImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQddlRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`erddlambZbddl"mcZcddlFmdZdddlImeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmedddZndZoedZpdeeqe7fddfd d!Zrd"esdeeegetffd#d$ZuevewexeyfZzeed%fe{d&<e fezZ|eed%fe{d'<d(Z}e!d)e6fd*Gd+d,d,eZ~ejZGd-ddeWe~d.Zd)Z}eddeddd/d0eqd1eee(d2dd3eqd4eeqd5fd6eeqefd7ededfd8d9Zededdd:d0eqd1eee(d2eedeedd%ffd3eqd4eeqd5fd6eeqefd7ededfd;d9Zddedddd<d0eqd1eee(d2ededeedd%ffd3eqd4eeqd5fd6eeqefd=eeeqd%fd7ededfd>d9ZeZ dGd?eed@dAdBdCdedAdDee.ffdEdFZdS)HN)ABCMeta)deepcopy)Enum)partial)Path) FunctionType prepare_class resolve_bases) TYPE_CHECKING AbstractSetAnyCallableClassVarDictListMappingOptionalTupleTypeTypeVarUnioncast no_type_checkoverload)dataclass_transform)ValidatorGroupextract_root_validatorsextract_validatorsinherit_validators) BaseConfigExtrainherit_configprepare_config) ErrorWrapperValidationError) ConfigError DictError ExtraError MissingError)MAPPING_LIKE_SHAPESField ModelFieldModelPrivateAttr PrivateAttr Undefinedis_finalvar_with_default_val)custom_pydantic_encoderpydantic_encoder)Protocol load_fileload_str_bytes)default_ref_template model_schema)PyObjectStrBytes) AnyCallableget_args get_origin is_classvar is_namedtupleis_unionresolve_annotationsupdate_model_forward_refs)DUNDER_ATTRIBUTESROOT_KEYClassAttribute GetterDictRepresentation ValueItemsgenerate_model_signatureis_valid_fieldis_valid_private_namelenient_issubclass sequence_likesmart_deepcopy unique_listvalidate_field_name) Signature)ValidatorListDict) ModelOrDc) AbstractSetIntStrAnyClassMethodCallableGeneratorDictAny DictStrAnyMappingIntStrAnyReprArgsSetStrTupleGeneratorModel BaseModel)bound)r\ create_modelvalidate_model_TfieldsreturncCst|dkr ttddS)Nz" cannot be mixed with other fields)len ValueErrorrB)rarfd/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/pydantic/v1/main.pyvalidate_custom_root_typeas rhfrozencCsdtdtfdd}|r |SdS)Nself_rbcSst|jtt|jSN)hash __class__tuple__dict__values)rjrfrfrg hash_functiongsz-generate_hash_function..hash_function)r int)rirqrfrfrggenerate_hash_functionfs rs.ANNOTATED_FIELD_UNTOUCHED_TYPESUNTOUCHED_TYPESFT)kw_only_defaultfield_specifierscs6eZdZefddZdedeffdd ZZS)ModelMetaclassc( si}t}i}gg}} i} i} |dd} t| tr| hnt| } t} d}t|D]:}trdt|trd|tkrd| t |j t |j |}t|j|}||j7}| |j7} | |j| |j|j}q*dd}ddt|D}fdd|@D}|d }|r|rtd t ||fi|}tt||}t|}|D]}||||j}|r|j || qt!||t"d t#d t$ffd d }|d|dfdkrt%|di|dd}|&D]o\}}t'|r| (|qt)|||t*r| (|qt+|rQt,||||t*}t-t.|r)t/|n|f}||rA|t0krAt1dd|DsAqt2j3||||||d||<q||vr_|j4r_t5| |<qt6|j7|&D]\}}|| vov|| }t|t8rt9|st:d|d|d|d|| |<qi|j4rt9|r|rt5|d| |<qit+|r||vr|rt,||t2j3||||t*|||d}||vrt;|j<||j<r||j<|_||?|j@rtAtB|j@}!ntC}!tD|\}"}#|dur!tE|jF}|| BdhB||dd|&Dp7ddd|&DpBd|jGtH||"d d!d"tH| |#d#d!d"itI|!| i| | | | B|| d$fd%d|&D}$tJjK||||$fi}%tLd&tM|%jN|||%_OtstP|%diQ|r|%R|&D]\}}&||$vrtP|&d'd}'tS|'r|'|%|q|%S)(N __slots__rf__resolve_forward_refs__TcSs$h|]}|dr|ds|qS)__) startswithendswith.0keyrfrfrg sz)ModelMetaclass.__new__..csi|]}||qSrf)popr~)kwargsrfrg sz*ModelMetaclass.__new__..ConfigzYSpecifying config in two places is ambiguous, use either Config attribute or class kwargsvrbcst|p |jjdkS)Ncython_function_or_method) isinstancerm__name__r)untouched_typesrfrg is_untouchedsz,ModelMetaclass.__new__..is_untouched __module__ __qualname__)z pydantic.mainr\__annotations__css|] }tt|tVqdSrk)rJr;r)r allowed_typerfrfrg s z)ModelMetaclass.__new__..)namevalue annotationclass_validatorsconfigzPrivate attributes "zF" must not be a valid field name; Use sunder or dunder names, e. g. "_z" or "__z__")defaultz The type of .zo differs from the new default value; if you wish to change the type of this field, please use a type annotationcS&i|]\}}|jjdur||jjqSrk) field_infoexcluderrfieldrfrfrgr cSrrk)rincluderrfrfrgrrcSs|jSrkrrrfrfrg sz(ModelMetaclass.__new__..) name_factorycSs |djS)Nrcr)skip_on_failure_and_vrfrfrgrs ) __config__ __fields____exclude_fields____include_fields____validators____pre_root_validators____post_root_validators____schema_cache____json_encoder____custom_root_type____private_attributes__ry__hash____class_vars__csi|] \}}|vr||qSrfrf)rnr)exclude_from_namespacerfrgr __signature__ __set_name__)Trgetrstrsetreversed_is_base_model_class_defined issubclassr\updaterLrr!rrrrrrrrrdirkeys TypeErrorrrrp set_configget_validatorsrrpopulate_validatorsr"rtr boolr?itemsr<addr/r.rHrNr>r;r:r7anyr+inferunderscore_attrs_are_privater-rukeep_untouchedr,rI NameErrorrJtype_rBrhcheck_for_unused json_encodersrr0r1rrsri validatorsrM staticmethodsuper__new__rCrG__init__rgetattrclear__try_update_forward_refs__callable)(mcsrbases namespacerrarrpre_root_validatorspost_root_validatorsprivate_attributesbase_private_attributesslots class_vars hash_funcbaseresolve_forward_refsallowed_config_kwargs config_kwargsconfig_from_namespacevgfextra_validatorsr annotationsann_nameann_typer allowed_typesvar_namecan_be_changedinferred_custom_root_type json_encoder pre_rv_new post_rv_new new_namespaceclsobjset_namerm)rrrrgrzs8                                        zModelMetaclass.__new__instancerbcst|do t|S)z| Avoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 r)hasattrr__instancecheck__)selfrrrfrgr0sz ModelMetaclass.__instancecheck__) rrrrrr rr __classcell__rfrfrrgrxxs 6rxc@s6eZdZUeriZeeeefe d<dZ ee e ee fe d<dZee e ee fe d<iZeeeefe d<eeee d<eeeeefe d<eZeeee d<d d Zeee ge fe d <iZed e d <dZeee d<ede d<eeeefe d<eee d<eZeee d<eZdZ dZ!de ddfddZ"e#ddZ$dddZ%dd d!Z&dd"d#Z'dddddddd$d%e e(d&d'e e(d&d(ed)e ed*ed+ed,edd-fd.d/Z)ddddddddd0d1 d%e e(d&d'e e(d&d(ed)e ed*ed+ed,ed2e ee ge fd3ed4e defd5d6Z*e+d7e de fd8d9Z,e+d:ed;d7e dd;fdddd?d:ed;d@e.dAedBedCe/dDedd;fdEdFZ0e+dd>ddd?d:ed;dGe(ee1fdAedBedCe/dDedd;fdHdIZ2e+d:ed;d7e dd;fdJdKZ3e+dd:ed;dLe dMdNe dd;fdOdPZ4dQd;dNd-dRdMdSedd;f dTdUZ5dddddVdQd;d%e e(d&d'e e(d&dWe d-dSedd;f dXdYZ6e+d0e7fd(edZedd-fd[d\Z8e+d0e7d]d(edZed4e defd^d_Z9e+ddadbZ:e+d:ed;dce dd;fdddeZ;e+d:ed;d7e dee+dle ddfdmdnZ?e+dle ddfdodpZ@ddrdsZA       ddied(ed%e e(d&d'e e(d&d*ed+ed,eddqfdtduZB dd%e dvd'e dvd*edWe d-de eCef dwdxZDdye defdzd{ZEdd}d~ZFdS)r\rNrrrrrrcCs|Srkrf)xrfrfrgrFszBaseModel.rrUrFrrOrrr__fields_set__)rordatarbc Ksft|j|\}}}|r |zt|d|Wnty&}ztd|d}~wwt|d||dS)z Create a new model by parsing and validating input data from keyword arguments. Raises ValidationError if the input data cannot be parsed to form a valid model. rozYModel values must be a dict; you may not have returned a dictionary from a root validatorNr)r_rmobject_setattrr_init_private_attributes)__pydantic_self__rrp fields_setvalidation_errorerfrfrgrRs  zBaseModel.__init__c s*|jvs tvrt||S|jjtjur(|jvr(td|j j dd|jj r0|jj r:t d|j j d|jvrR|jjrRt d|j j dd|jjri|j|i}|jD]$}z||j |}Wqctt tfy}z tt|tdg|j d}~ww|jd}|r|jj st d|jdfdd |jD}|j|||j d \}}|rt|g|j ||<g} |jD]/\} }| r| rqz||j |}Wqtt tfy}z| t|tdWYd}~qd}~ww| rt| |j t|d |n||j<|jdS) N"z" object has no field "z3" is immutable and does not support item assignmentz " object "z2" field is final and does not support reassignmentlocz8" has allow_mutation set to False and cannot be assignedcsi|] \}}|kr||qSrfrfrkrrrfrgrrz)BaseModel.__setattr__..r rro)rrArrextrar allowrrermrallow_mutationrirfinalvalidate_assignmentrorAssertionErrorr$r#rBrrrrvalidaterappendrr) rrr new_values validatorexc known_fielddict_without_original_valueerror_errorsskip_on_failurerfr rg __setattr__esV     zBaseModel.__setattr__cs.fddjD}jjdd|DdS)Nc3s |] }|t|tfVqdSrk)rr.)rr rrfrgrsz)BaseModel.__getstate__..cSsi|] \}}|tur||qSrf)r.r rfrfrgrrz*BaseModel.__getstate__..)ror__private_attribute_values__)rror)r private_attrsrfr rg __getstate__s  zBaseModel.__getstate__statecCsJt|d|dt|d|d|diD] \}}t|||qdS)Nrorr!)rrr)rr$rrrfrfrg __setstate__s zBaseModel.__setstate__cCs4|jD]\}}|}|turt|||qdSrk)rr get_defaultr.r)rr private_attrrrfrfrgrs  z"BaseModel._init_private_attributes)rrby_alias skip_defaults exclude_unsetexclude_defaults exclude_noner)rRrWrr(r)r*r+r,rVc Cs>|durt|jjdt|}t|jd||||||dS)z Generate a dictionary representation of the model, optionally specifying which fields to include or exclude. NzF.dict(): "skip_defaults" is deprecated and replaced by "exclude_unset"Tto_dictr(rrr*r+r,)warningswarnrmrDeprecationWarningdict_iter)rrrr(r)r*r+r,rfrfrgr2s" zBaseModel.dictT) rrr(r)r*r+r,encodermodels_as_dictr4r5 dumps_kwargsc Ks~|durt|jjdt|}tttgtf|p|j}t |j | ||||||d} |j r3| t } |j j| fd|i| S)z Generate a JSON representation of the model, `include` and `exclude` arguments as per `dict()`. `encoder` is an optional function to supply as `default` to json.dumps(), other arguments as per `json.dumps()`. NzF.json(): "skip_defaults" is deprecated and replaced by "exclude_unset"r-r)r/r0rmrr1rr r rr2r3rrBr json_dumps) rrrr(r)r*r+r,r4r5r6rrfrfrgjsons*  zBaseModel.jsonrcCsT|jr(t|tr|thkst|tr$|jthkr$|jtjtvr(t|iS|Srk) rrr2rrBr\rshaper)rrrfrfrg_enforce_dict_if_rootszBaseModel._enforce_dict_if_rootrr[c Csz||}t|ts6zt|}Wn%ttfy5}zt|jd|jj}tt|t dg||d}~ww|di|S)Nz expected dict not r rf) r;rr2rrerrmr$r#rB)rrrrrfrfrg parse_obj s   zBaseModel.parse_objutf8) content_typeencodingproto allow_picklebr>r?r@rAc CsZzt||||||jjd}Wntttfy'}z tt|tdg|d}~ww| |S)Nr@r>r?rA json_loadsr ) r4rrDrerUnicodeDecodeErrorr$r#rBr<)rrBr>r?r@rArrrfrfrg parse_raws   zBaseModel.parse_rawpathcCs"t||||||jjd}||S)NrC)r3rrDr<)rrGr>r?r@rArrfrfrg parse_file-s  zBaseModel.parse_filecCsn|jjstd|jrt|in||}||}t||\}}}|r%|t|d|t|d|| |S)Nz@You must have the config attribute orm_mode=True to use from_ormror) rorm_moder%rrB_decompose_classrr_rr)rrmrprrrfrfrgfrom_ormAs   zBaseModel.from_orm _fields_setrYrpcKs||}i}|jD](\}}|jr |j|vr ||j||<q ||vr+||||<q |js4|||<q ||t|d||durJt | }t|d|| |S)a Creates a new model setting __dict__ and __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 roNr) rrr alt_aliasaliasrequiredr&rrrrr)rrMrprK fields_valuesrrrfrfrg constructOs"      zBaseModel.constructrrdeepcCsp|rt|}|j}||}t|d|t|d||jD]}t||t}|tur5|r/t|}t|||q|S)Nror)rrmrrrrr.)rrprrSrrKrrrfrfrg_copy_and_set_valuesgs      zBaseModel._copy_and_set_values)rrrrSrcCsRt|jdd||ddfi|pi}|r|j|B}nt|j}|j|||dS)a Duplicate a model, optionally choose which fields to include, exclude and change. :param include: fields to include in new model :param exclude: fields to exclude from new model, as with values this takes precedence over include :param 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 :param deep: set to `True` to make a deep copy of the model :return: new model instance F)r.r(rrr*rS)r2r3rrrrT)rrrrrSrprrfrfrgcopyys zBaseModel.copy ref_templatecCs<|j||f}|dur|St|||d}||j||f<|S)Nr(rW)rrr6)rr(rWcachedsrfrfrgschemas zBaseModel.schemarXcKs.ddlm}|jj|j||dfd|i|S)Nr)r1rXr)pydantic.v1.jsonr1rr7r[)rr(rWr6r1rfrfrg schema_jsons  zBaseModel.schema_jsonrTccs|jVdSrk)r)rrfrfrg__get_validators__s zBaseModel.__get_validators__rc Cst||r6|jj}d}|dvrtdt|rd}|dkr d}n|dkr&d}|dur,|S|j|j|j|dS| |}t|t rG|di|S|jj rP| |Szt |}Wnt tfyh}zt|d}~ww|di|S) N>rSnoneshallowzJ`copy_on_model_validation` should be a string: 'deep', 'shallow' or 'none'Fr`rSTrUrf)rrcopy_on_model_validationr/r0r1rTrorr;r2rIrLrrer&)rrra deep_copy value_as_dictrrfrfrgrs8     zBaseModel.validatecCst|tr|S|j|Srk)rrDr getter_dictr:rfrfrgrJs  zBaseModel._decompose_classrr.c st|tr#r|j||d} t| vr| tS| S|j||dS|r*t||nd|r3t||ndt|trLfdd|DSt|rqfddt|D} t |j rl|j | S| | St|t rt j ddr|jS|S) N)r(r*r+rrr,)rrc s\i|]*\}}r |sr|r|j|o"|o(|dqS)r.r(r*r+rrr, is_excluded is_included _get_value for_element)rk_v_r(rr+r,r*r. value_exclude value_includerfrgrs*      z(BaseModel._get_value..c 3s^|]*\}}r |sr|rj|o!|o'|dVqdS)reNrf)rirlrmrfrgrs,       z'BaseModel._get_value..use_enum_valuesF)rr\r2rBrVrFrrK enumerater=rmrrrr) rrr.r(rrr*r+r,v_dictseq_argsrfrmrgris8    zBaseModel._get_valuelocalnscKs t||j|jj|tfdS)z{ Same as update_forward_refs but will not raise exception when forward references are not defined. N)r@rrprrrrrurfrfrgr's z%BaseModel.__try_update_forward_refs__cKst||j|jj|dS)z` Try to update ForwardRefs on fields based on this Model, globalns and localns. N)r@rrprrrvrfrfrgupdate_forward_refs/szBaseModel.update_forward_refsrZccs|jEdHdS)z( so `dict(model)` works Nrorr rfrfrg__iter__6szBaseModel.__iter__c csz|dus |jdurt|j|}|dus|jdur#tj|j|dd}|j|||d}|durC|sC|sC|sC|sC|sC|jEdHdS|durLt||nd} |durWt||nd} |jD]\\} } |durj| |vsp|rq| durqq^|r|j| } t | ddst | dt | krq^|r| |jvr|j| j }n| }|s| s| r|j | ||| o| | | o| | |||d} || fVq^dS)NT) intersect)rrr*rPrr-)rrFmerger_calculate_keysrorrrr_missingrOrirj)rr.r(rrr*r+r, allowed_keysrnro field_keyr model_fielddict_keyrfrfrgr3<sH      zBaseModel._iterrWcCsx|dur|dur|durdS|r|j}n|j}|dur%||M}|r-||8}|r:|dd|D8}|S)NFcSsh|] \}}t|r|qSrf)rFis_truer rfrfrgrrz,BaseModel._calculate_keys..)rrVrorr)rrrr*rrrfrfrgr|ts    zBaseModel._calculate_keysothercCs&t|tr ||kS||kSrk)rr\r2)rrrfrfrg__eq__s  zBaseModel.__eq__rXcsfddjDS)Ncs8g|]\}}|tvr|jvsj|jjr||fqSrf)rArrreprr r rfrg s  z+BaseModel.__repr_args__..rxr rfr rg __repr_args__s zBaseModel.__repr_args__)rbrU)r$rUrbN)rbNrk)rbrT)rbrZ)FFNNFFF)rbrX)Grrrr rrrrr+rrrrr rrr9rrrrrrrr rrr,rYrrrry__doc__rrrr#r%rrr2r8 classmethodr;r<r8r2rFrrHrLrRrTrVr5r[r]r^rrDrJrirrwryr3r r|rrrfrfrfrgr\<s     7       %       -      &      &    H    =  ) metaclass)r__base__rr__cls_kwargs__ __model_namerrrrrSrfield_definitionscKdSrkrfrrrrrrrrfrfrgr^ r^)rrrrcKrrkrfrrfrfrgr^r)rrrrrryryc Ksb|dur tdt|dur|durtdt|ts|f}nttdtf}|p*i}i}i} | D]>\} } t | sEtd| dtt| trbz| \} } Wnt ya}ztd|d}~wwd| } } | rm| | | <| || <q3| |d}|r~| || ||rt |t|d <t|}t|||d \}}}||ur||d <| |||||fi|S) a Dynamically create a model. :param __model_name: name of the created model :param __config__: config class to use for the new model :param __base__: base class for the new model to inherit from :param __module__: module of the created model :param __validators__: a dict of method names and @validator class methods :param __cls_kwargs__: a dict for class creation :param __slots__: Deprecated, `__slots__` should not be passed to `create_model` :param field_definitions: fields of the model (or extra fields if a base is supplied) in the format `=(, )` or `=, e.g. `foobar=(str, ...)` or `foobar=123`, or, for complex use-cases, in the format `=` or `=(, )`, e.g. `foo=Field(datetime, default_factory=datetime.utcnow, alias='bar')` or `foo=(str, FieldInfo(title='Foo'))` Nz.__slots__ should not be passed to create_modelzBto avoid confusion __config__ and __base__ cannot be used togetherr[z3fields may not start with an underscore, ignoring "rzfield definitions should either be a tuple of (, ) or just a default value, unfortunately this means tuples as default values are not allowed)rrr)kwds__orig_bases__)r/r0RuntimeWarningr%rrnrrr\rrHrerr!rr r)rrrrrrryrrarf_namef_def f_annotationf_valuerrresolved_basesmetansrrfrfrgr^sT          model input_datarVrrQrYc Csi}g}t}t}|j}|jtju}|p|} |jD].} z| | |}WqtttfyH} zitt t | t dg| fWYd} ~ Sd} ~ ww|j D]{\} } || jt}d}|turn|jrn| jrn|| jt}d}|tur| jr|t t| jdqN| }|js| js||| <qNn|| |r||r| jn| j| j||| j| d\}}t|t r||qNt|tr||qN||| <qN|r t|tr| |}n|!|}|r ||O}|jtj"ur|D]}||||<qnt#|D] }|t t$|dq|j%D]4\}} |r|rq z| | |}Wq tttfy@} z|t | t dWYd} ~ q d} ~ ww|rL||t || fS||dfS)z( validate data against a model. r NFTr)&rrrr ignorerrerrr$r#rBrrrrOr}allow_population_by_field_namerNrrPrr(r& validate_allvalidate_alwaysrrrlistextendrD extra_keysrrsortedr'r)rrrrpr names_usedrr check_extracls_rrrrr using_namerlerrors_rrrrfrfrgr_ s|  ,              r_rk)r/abcrrVrenumr functoolsrpathlibrtypesrrr typingr r r r rrrrrrrrrrrrtyping_extensionsrpydantic.v1.class_validatorsrrrrpydantic.v1.configrr r!r"pydantic.v1.error_wrappersr#r$pydantic.v1.errorsr%r&r'r(pydantic.v1.fieldsr)r*r+r,r-r.r/r\r0r1pydantic.v1.parser2r3r4pydantic.v1.schemar5r6pydantic.v1.typesr7r8pydantic.v1.typingr9r:r;r<r=r>r?r@pydantic.v1.utilsrArBrCrDrErFrGrHrIrJrKrLrMrNinspectrOrPrQrRrSrTrUrVrWrXrYrZr[__all__r`rrhrrrrspropertytyperrrtrrurrxobjectrrr\rr^r}r_rfrfrfrgs     H $ (@    ,   Ae              M