o
    fU6                     @  sL  d Z ddlmZ ddlZddlZddlZddlmZm	Z	m
Z
mZmZ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 dd	lmZ dd
lmZ ddlmZ ddlm Z m!Z!m"Z" erdddl#m$Z$ dZ%edZ&ej'dkreej(e e"fdeddddddddddd
dJd&d'Z)eej(e e"fdeddddddddddd
dKd+d'Z)n4eej(e e"fdeddddddddd,dLd-d'Z)eej(e e"fdeddddddddd,dMd.d'Z)eej(e e"fd	dNddddddddddd
dOd1d'Z)ee*Z+d2ej'  kr	d3k rn n	dPd8d9Z,e,ej-_.ddd:dd;dQdCdDZ/dRdHdIZ0dS )Sz7Provide an enhanced dataclass that performs validation.    )annotationsN)TYPE_CHECKINGAnyCallableGenericNoReturnTypeVaroverload)Literal	TypeGuarddataclass_transform   )_config_decorators_typing_extra)_dataclasses)getattr_migration)
ConfigDict)PydanticUserError)Field	FieldInfoPrivateAttr)PydanticDataclass)	dataclassrebuild_dataclass_T   
   )field_specifiersFT.
initrepreqorderunsafe_hashfrozenconfigvalidate_on_initkw_onlyslotsr!   Literal[False]r"   boolr#   r$   r%   r&   r'    ConfigDict | type[object] | Noner(   bool | Noner)   r*   return-Callable[[type[_T]], type[PydanticDataclass]]c        
   
      C     d S N r    r3   r3   L/var/www/NoticeGen/venv/lib/python3.10/site-packages/pydantic/dataclasses.pyr         r   _clstype[_T]type[PydanticDataclass]c       
         C  r1   r2   r3   )r6   r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r3   r3   r4   r   -   r5   r!   r"   r#   r$   r%   r&   r'   r(   c                 C  r1   r2   r3   r9   r3   r3   r4   r   @      c          	      C  r1   r2   r3   )	r6   r!   r"   r#   r$   r%   r&   r'   r(   r3   r3   r4   r   O   r:   type[_T] | NoneGCallable[[type[_T]], type[PydanticDataclass]] | type[PydanticDataclass]c       
      	     sv   |du sJ d|dusJ dt jdkrt|	|
dni dd
dd fdd}| du r7|S || S )aS  Usage docs: https://docs.pydantic.dev/2.8/concepts/dataclasses/

    A decorator used to create a Pydantic-enhanced dataclass, similar to the standard Python `dataclass`,
    but with added validation.

    This function should be used similarly to `dataclasses.dataclass`.

    Args:
        _cls: The target `dataclass`.
        init: Included for signature compatibility with `dataclasses.dataclass`, and is passed through to
            `dataclasses.dataclass` when appropriate. If specified, must be set to `False`, as pydantic inserts its
            own  `__init__` function.
        repr: A boolean indicating whether to include the field in the `__repr__` output.
        eq: Determines if a `__eq__` method should be generated for the class.
        order: Determines if comparison magic methods should be generated, such as `__lt__`, but not `__eq__`.
        unsafe_hash: Determines if a `__hash__` method should be included in the class, as in `dataclasses.dataclass`.
        frozen: Determines if the generated class should be a 'frozen' `dataclass`, which does not allow its
            attributes to be modified after it has been initialized.
        config: The Pydantic config to use for the `dataclass`.
        validate_on_init: A deprecated parameter included for backwards compatibility; in V2, all Pydantic dataclasses
            are validated on init.
        kw_only: Determines if `__init__` method parameters must be specified by keyword only. Defaults to `False`.
        slots: Determines if the generated class should be a 'slots' `dataclass`, which does not allow the addition of
            new attributes after instantiation.

    Returns:
        A decorator that accepts a class as its argument and returns a Pydantic `dataclass`.

    Raises:
        AssertionError: Raised if `init` is not `False` or `validate_on_init` is `False`.
    Fz7pydantic.dataclasses.dataclass only supports init=Falsez-validate_on_init=False is no longer supportedr   )r)   r*   cls	type[Any]r/   Nonec              	   S  s   | j D ]Q}t|dg }|D ]F}t| |d}t|tsqd|i}tjdkr+|jr+d|d< |jdur5|j|d< t| |t	j
di | | jddu rLi | _|| | j|< qqdS )	a  Make sure that stdlib `dataclasses` understands `Field` kwargs like `kw_only`
        To do that, we simply change
          `x: int = pydantic.Field(..., kw_only=True)`
        into
          `x: int = dataclasses.field(default=pydantic.Field(..., kw_only=True), kw_only=True)`
        __annotations__Ndefaultr   Tr)   r"   r3   )__mro__getattr
isinstancer   sysversion_infor)   r"   setattrdataclassesfield__dict__getr@   )r=   annotation_clsr   
field_namefield_value
field_argsr3   r3   r4   make_pydantic_fields_compatible   s"   



z2dataclass.<locals>.make_pydantic_fields_compatibler8   c              	     s  ddl m} || rtd| j ddd| } }|du r)t| dd}|dur)|}t|}tj	| }| j
}t| rWd}| f}t| trPt| j }	||	f }t| j|} |  tj| fd	d
} || _|| _
|j| _|j| _tj| |ddd}
|
| _| S )zCreate a Pydantic dataclass from a regular dataclass.

        Args:
            cls: The class to create the Pydantic dataclass from.

        Returns:
            A Pydantic dataclass.
        r   )is_model_classz(Cannot create a Pydantic dataclass from z" as it is already a Pydantic modelzdataclass-on-model)codeN__pydantic_config__T)r!   r"   r#   r$   r%   r&   Fraise_errorstypes_namespace)_internal._utilsrQ   r   __name__rC   r   ConfigWrapperr   DecoratorInfosbuild__doc___pydantic_dataclassesis_builtin_dataclass
issubclassr   __parameters__types	new_classrH   r   __pydantic_decorators__
__module____qualname__complete_dataclass__pydantic_complete__)r=   rQ   original_clsconfig_dict
cls_configconfig_wrapper
decoratorsoriginal_docbasesgeneric_basepydantic_completer'   r#   r&   kwargsrP   r$   r"   r%   r3   r4   create_dataclass   sX   	




	z#dataclass.<locals>.create_dataclassN)r=   r>   r/   r?   )r=   r>   r/   r8   )rE   rF   dict)r6   r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   rs   r3   rq   r4   r   _   s   .

#G)r      )r      argsr   rr   r   c                  O  s   t d)a9  This function does nothing but raise an error that is as similar as possible to what you'd get
        if you were to try calling `InitVar[int]()` without this monkeypatch. The whole purpose is just
        to ensure typing._type_check does not error if the type hint evaluates to `InitVar[<parameter>]`.
        z 'InitVar' object is not callable)	TypeError)rw   rr   r3   r3   r4   _call_initvar  s   ry      )forcerU   _parent_namespace_depth_types_namespacer=   r{   rU   r|   intr}   dict[str, Any] | Nonec                C  sl   |s| j rdS |dur| }n|dkrtj|dpi }|}ni }t| |}tj| tj| j	dd||dS )ax  Try to rebuild the pydantic-core schema for the dataclass.

    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.

    This is analogous to `BaseModel.model_rebuild`.

    Args:
        cls: The class to rebuild the pydantic-core schema for.
        force: Whether to force the rebuilding of the 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`.
    Nr   )parent_depthF)checkrT   )
rg   copyr   parent_frame_namespaceget_cls_types_namespacer]   rf   r   rY   rS   )r=   r{   rU   r|   r}   rV   frame_parent_nsr3   r3   r4   r     s   

r   class_r>   "TypeGuard[type[PydanticDataclass]]c                C  s,   zd| j v o
t| W S  ty   Y dS w )zWhether a class is a pydantic dataclass.

    Args:
        class_: The class.

    Returns:
        `True` if the class is a pydantic dataclass, `False` otherwise.
    __pydantic_validator__F)rJ   rH   is_dataclassAttributeError)r   r3   r3   r4   is_pydantic_dataclassF  s
   	r   )r!   r+   r"   r,   r#   r,   r$   r,   r%   r,   r&   r,   r'   r-   r(   r.   r)   r,   r*   r,   r/   r0   )r6   r7   r!   r+   r"   r,   r#   r,   r$   r,   r%   r,   r&   r,   r'   r-   r(   r.   r)   r,   r*   r,   r/   r8   )r!   r+   r"   r,   r#   r,   r$   r,   r%   r,   r&   r,   r'   r-   r(   r.   r/   r0   )r6   r7   r!   r+   r"   r,   r#   r,   r$   r,   r%   r,   r&   r,   r'   r-   r(   r.   r/   r8   r2   )r6   r;   r!   r+   r"   r,   r#   r,   r$   r,   r%   r,   r&   r,   r'   r-   r(   r.   r)   r,   r*   r,   r/   r<   )rw   r   rr   r   r/   r   )r=   r8   r{   r,   rU   r,   r|   r~   r}   r   r/   r.   )r   r>   r/   r   )1r\   
__future__r   _annotationsrH   rE   ra   typingr   r   r   r   r   r   r	   typing_extensionsr
   r   r   	_internalr   r   r   r   r]   
_migrationr   r'   r   errorsr   fieldsr   r   r   _internal._dataclassesr   __all__r   rF   rI   r   rX   __getattr__ry   InitVar__call__r   r   r3   r3   r3   r4   <module>   s    $
 &
1