
    df)                       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      X/home/api-vastappli/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)zCollect 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1L%c?VF$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&1IYZ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    ))(GW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./dfx	
 '??Do.,S1LJ\
  #//0	:H
&s
+CCLC,88Cc#A4HO$,J66TYZ%F  //QV/WF !,,S1K++F3Fv&$S#,,8NO!667QRX7YZF ++/
5C -A,HHC 6-D^;;. C #36;"GC))	s		F 
 	F ,33D#>E ' $S#,,!AFF81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&&( )mY/))J U" 
 ::D!''E,=='Juc,BGZ[`Ga,c27JK[7\' $++G++ 004EE%//55G *>>GMMZdGMTE#(UZZ ;)> \%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5c'$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 '	#FOO :-v :0 3
%" 	f	f)f 	f
 +f 
fR/Ud"r3   