Ë
    ©2ÚiÓ)  ã                  óò  — d Z ddlmZ ddlZddlZddlZddlZddlm	Z	m
Z
 ddlmZmZmZ ddlmZmZmZ ddlmZmZmZmZmZ ddlmZ d	d
lmZ d	dlmZ d	dlmZ d	dlmZ ddl m!Z!m"Z"m#Z#m$Z$ ddl%m&Z&m'Z'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 ejj                  r2d	dl6m7Z7  G d„ dejp                  «      Z9 G d„ de9ejp                  «      Z:neZ;d"d#d„Z<ddœ	 	 	 	 	 	 	 	 	 d$d„Z=d%d „Z>d&d!„Z?y)'z0Private logic for creating pydantic dataclasses.é    )ÚannotationsN)ÚpartialÚwraps)Ú	ParameterÚ	SignatureÚ	signature)ÚAnyÚCallableÚClassVar)Ú
ArgsKwargsÚPydanticUndefinedÚSchemaSerializerÚSchemaValidatorÚcore_schema)Ú	TypeGuardé   )ÚPydanticUndefinedAnnotation)Ú	FieldInfo)Úcreate_schema_validator)ÚPydanticDeprecatedSince20é   )Ú_configÚ_decoratorsÚ_discriminated_unionÚ_typing_extra)Úcollect_invalid_schemasÚsimplify_schema_referencesÚvalidate_core_schema)Úcollect_dataclass_fields)ÚGenerateSchema)Úget_standard_typevars_map)Úset_dataclass_mock_validator)ÚCallbackGetCoreSchemaHandler)Úis_valid_identifier)Ú
ConfigDictc                  ó4   — e Zd ZU ded<   ded<   ded<   d	d„Zy)
ÚStandardDataclasszClassVar[dict[str, Any]]Ú__dataclass_fields__zClassVar[Any]Ú__dataclass_params__zClassVar[Callable[..., None]]Ú__post_init__c                 ó   — y ©N© )ÚselfÚargsÚkwargss      úV/var/www/html/acx/venv/lib/python3.12/site-packages/pydantic/_internal/_dataclasses.pyÚ__init__zStandardDataclass.__init__*   s   € Øó    N)r/   Úobjectr0   r4   ÚreturnÚNone)Ú__name__Ú
__module__Ú__qualname__Ú__annotations__r2   r-   r3   r1   r'   r'   %   s   … Ø6Ó6Ø+Ó+Ø4Ó4ô	r3   r'   c                  óX   — e Zd ZU dZded<   ded<   ded<   ded	<   d
ed<   ded<   ded<   y)ÚPydanticDataclassai  A protocol containing attributes only available once a class has been decorated as a Pydantic dataclass.

        Attributes:
            __pydantic_config__: Pydantic-specific configuration settings for the dataclass.
            __pydantic_complete__: Whether dataclass 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_decorators__: Metadata containing the decorators defined on the dataclass.
            __pydantic_fields__: Metadata about the fields defined on the dataclass.
            __pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the dataclass.
            __pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the dataclass.
        zClassVar[ConfigDict]Ú__pydantic_config__zClassVar[bool]Ú__pydantic_complete__z ClassVar[core_schema.CoreSchema]Ú__pydantic_core_schema__z$ClassVar[_decorators.DecoratorInfos]Ú__pydantic_decorators__zClassVar[dict[str, FieldInfo]]Ú__pydantic_fields__zClassVar[SchemaSerializer]Ú__pydantic_serializer__zClassVar[SchemaValidator]Ú__pydantic_validator__N)r7   r8   r9   Ú__doc__r:   r-   r3   r1   r<   r<   -   s3   … ñ
	ð 2Ó1Ø-Ó-Ø"BÓBØ!EÓEØ;Ó;Ø!;Ó;Ø 9Ô9r3   r<   c                óD   — t        | «      }t        | ||¬«      }|| _        y)z”Collect and set `cls.__pydantic_fields__`.

    Args:
        cls: The class.
        types_namespace: The types namespace, defaults to `None`.
    )Útypevars_mapN)r!   r   rA   )ÚclsÚtypes_namespacerF   Úfieldss       r1   Úset_dataclass_fieldsrJ   H   s$   € ô -¨SÓ1€LÜ% c¨?ÈÔV€Fà$€CÕr3   T)Úraise_errorsc          	     óZ  ‡— t        | d«      rt        j                  dt        «       |€t	        j
                  | «      }t        | |«       t        | «      }t        |||«      }dd„}| j                  › d�|_	        t        | «      }|| _        || _        |j                  | _        t        | dd«      }	 |r+ || t!        t#        |j$                  d¬«      |d	¬
«      «      }	n|j%                  | d¬«      }	|j/                  | «      }|j1                  |	«      }	t3        |	«      rt)        | | j*                  d«       yt5        j6                  t9        |	«      «      }	t;        j<                  d| «      } t?        |	«      x| _         }	tC        |	||jD                  «      x| _#        ŠtI        |	|«      | _%        |jL                  r5tO        | jP                  «      dˆfd„«       }|jS                  d| «      | _(        y# t&        $ r2}
|r‚ t)        | | j*                  d|
j,                  › d�«       Y d}
~
yd}
~
ww xY w)a—  Finish building a pydantic dataclass.

    This logic is called on a class which has already been wrapped in `dataclasses.dataclass()`.

    This is somewhat analogous to `pydantic._internal._model_construction.complete_model_class`.

    Args:
        cls: The class.
        config_wrapper: The config wrapper instance.
        raise_errors: Whether to raise errors, defaults to `True`.
        types_namespace: The types namespace.

    Returns:
        `True` if building a pydantic dataclass is successfully completed, `False` otherwise.

    Raises:
        PydanticUndefinedAnnotation: If `raise_error` is `True` and there is an undefined annotations.
    Ú__post_init_post_parse__zVSupport for `__post_init_post_parse__` has been dropped, the method will not be calledNc                óZ   — d}| }|j                   j                  t        ||«      |¬«       y )NT)Úself_instance)rC   Úvalidate_pythonr   )Ú__dataclass_self__r/   r0   Ú__tracebackhide__Úss        r1   r2   z$complete_dataclass.<locals>.__init__�   s.   € Ø ÐØˆØ	× Ñ ×0Ñ0´¸DÀ&Ó1IÐYZÐ0Õ[r3   z	.__init__Ú__get_pydantic_core_schema__F)Úfrom_dunder_get_core_schemaÚunpack)Úref_modeú`zall referenced typesztype[PydanticDataclass]c                ó,   •— ‰j                  | ||«       y r,   )Úvalidate_assignment)ÚinstanceÚ__fieldÚ__valueÚ	validators      €r1   Úvalidated_setattrz-complete_dataclass.<locals>.validated_setattrµ   s   ø€ à×)Ñ)¨(°G¸WÕEr3   T)rQ   r<   r/   r	   r0   r	   r5   r6   )r[   r	   r\   Ústrr]   r`   r5   r6   )*ÚhasattrÚwarningsÚwarnÚDeprecationWarningr   Úget_cls_types_namespacerJ   r!   r    r9   Úgenerate_dataclass_signaturer2   Ú__signature__Úconfig_dictr=   Úgetattrr#   r   Úgenerate_schemar   r"   r7   ÚnameÚcore_configÚcollect_definitionsr   r   Úapply_discriminatorsr   ÚtypingÚcastr   r?   r   Úplugin_settingsrC   r   rB   rZ   r   Ú__setattr__Ú__get__)rG   Úconfig_wrapperrK   rH   rF   Ú
gen_schemar2   ÚsigÚget_core_schemaÚschemaÚerl   r_   r^   s                @r1   Úcomplete_dataclassrz   U   s'  ø€ ô2 ˆsÐ.Ô/Ü�‰ØdÔfxô	
ð ÐÜ'×?Ñ?ÀÓDˆä˜˜oÔ.ä,¨SÓ1€LÜØØØó€Jó\ð
  #×/Ñ/Ð0°	Ð:€HÔÜ
& sÓ
+€CØ€C„LØ€CÔØ,×8Ñ8€CÔä˜cÐ#AÀ4ÓH€OðÙÙ$ØÜ,Ü˜J×6Ñ6ÐTYÔZØØ%ôó‰Fð  ×/Ñ/°ÐQVÐ/ÓWˆFð !×,Ñ,¨SÓ1€Kà×+Ñ+¨FÓ3€FÜ˜vÔ&Ü$ S¨#¯,©,Ð8NÔOØä!×6Ñ6Ô7QÐRXÓ7YÓZ€Fô �+‰+Ð/°Ó
5€Cô -AÀÓ,HÐH€CÔ  6Ü-DØ�˜^×;Ñ;ó.ð €CÔ ô #3°6¸;Ó"G€CÔà×)Ò)ä	ˆs�‰Ó	ô	Fó 
 ð	Fð ,×3Ñ3°D¸#Ó>ˆŒàøôE 'ò ÙØÜ$ S¨#¯,©,¸!¸A¿F¹F¸8À1¸ÔFÜûð	ús   Â3A G/ Ç/	H*Ç8(H%È%H*c                ó¶  — t        | «      }i }|j                  j                  «       D �]  }|j                  }t	        |t
        «      rÝ|j                  }|dk(  rt        }|j                  }|j                  }|j                  }|€t	        |t        «      rt        |«      r|}nt	        |t        «      rt        |«      r|}|j                  }	|	t        u r=|j                  t        u rt        j                   j"                  }	nt$        j&                  }	|j)                  |||	¬«      }|||j                  <   �Œ t!        t+        |j                  «       «      d¬«      S )a¡  Generate signature for a pydantic dataclass.

    This implementation assumes we do not support custom `__init__`, which is currently true for pydantic dataclasses.
    If we change this eventually, we should make this function's logic more closely mirror that from
    `pydantic._internal._model_construction.generate_model_signature`.

    Args:
        cls: The dataclass.

    Returns:
        The signature.
    r	   N)Ú
annotationrk   Údefault)Ú
parametersÚreturn_annotation)r   r~   Úvaluesr}   Ú
isinstancer   r|   r	   rk   ÚaliasÚvalidation_aliasr`   r$   r   Údefault_factoryÚinspectr   ÚemptyÚdataclassesÚ_HAS_DEFAULT_FACTORYÚreplaceÚlist)
rG   rv   Úfinal_paramsÚparamÚparam_defaultr|   rk   r‚   rƒ   r}   s
             r1   rf   rf   ¾   s5  € ô �C‹.€CØ)+€Là—‘×&Ñ&Ó(ó )ˆØŸ™ˆÜ�m¤YÔ/Ø×)Ñ)ˆJð ˜UÒ"Ü �
ð —:‘:ˆDØ!×'Ñ'ˆEØ,×=Ñ=ÐØÐ'¬J°u¼cÔ,BÔGZÐ[`ÔGaØ‘ÜÐ,¬cÔ2Ô7JÐK[Ô7\Ø'�ð $×+Ñ+ˆGØÔ+Ñ+Ø ×0Ñ0Ô4EÑEÜ%×/Ñ/×5Ñ5‘Gô *×>Ñ>�Gà—M‘M¨Z¸dÈG�MÓTˆEØ#(ˆ�U—Z‘ZÓ ð;)ô> ¤ \×%8Ñ%8Ó%:Ó ;ÈtÔTÐTr3   c           	     ó¾   — t        j                  | «      xrG t        | d«       xr8 t        | j                  «      j                  t        t        | di «      «      «      S )a>  Returns True if a class is a stdlib dataclass and *not* a pydantic dataclass.

    We check that
    - `_cls` is a dataclass
    - `_cls` does not inherit from a processed pydantic dataclass (and thus have a `__pydantic_validator__`)
    - `_cls` does not have any annotations that are not dataclass fields
    e.g.
    ```py
    import dataclasses

    import pydantic.dataclasses

    @dataclasses.dataclass
    class A:
        x: int

    @pydantic.dataclasses.dataclass
    class B(A):
        y: int
    ```
    In this case, when we first check `B`, we make an extra check and look at the annotations ('y'),
    which won't be a superset of all the dataclass fields (only the stdlib fields i.e. 'x')

    Args:
        cls: The class.

    Returns:
        `True` if the class is a stdlib dataclass, `False` otherwise.
    rC   r:   )r‡   Úis_dataclassra   Úsetr(   Ú
issupersetri   )Ú_clss    r1   Úis_builtin_dataclassr“   ð   sZ   € ô> 	× Ñ  Ó&ò 	aÜ˜Ð6Ó7Ð7ò	aä�×)Ñ)Ó*×5Ñ5´c¼'À$ÐHYÐ[]Ó:^Ó6_Ó`ðr3   r,   )rG   útype[StandardDataclass]rH   údict[str, Any] | Noner5   r6   )
rG   ú	type[Any]rt   z_config.ConfigWrapperrK   ÚboolrH   r•   r5   r—   )rG   r”   r5   r   )r’   r–   r5   z"TypeGuard[type[StandardDataclass]])@rD   Ú
__future__r   Ú_annotationsr‡   r…   ro   rb   Ú	functoolsr   r   r   r   r   r	   r
   r   Úpydantic_corer   r   r   r   r   Útyping_extensionsr   Úerrorsr   rI   r   Úplugin._schema_validatorr   r   Ú r   r   r   r   Ú_core_utilsr   r   r   Ú_fieldsr   Ú_generate_schemar    Ú	_genericsr!   Ú_mock_val_serr"   Ú_schema_generation_sharedr#   Ú_utilsr$   ÚTYPE_CHECKINGÚconfigr%   ÚProtocolr'   r<   rd   rJ   rz   rf   r“   r-   r3   r1   ú<module>rª      sæ   ðÙ 6Ý 2ã Û Û Û ß $ß 3Ñ 3ß *Ñ *÷õ õ (å 0Ý Ý >Ý 0ß GÓ Gß bÑ bÝ -Ý ,Ý 0Ý 7Ý CÝ 'à	×ÒÝ#ô˜FŸO™Oô ô:Ð-¨v¯©õ :ð0 3Ðô
%ð" ñ	fØ	ðfà)ðfð ð	fð
 +ðfð 
ófóR/Uôd"r3   