OwlCyberSecurity - MANAGER
Edit File: _dataclasses.cpython-312.pyc
� ���g " � �� � d Z ddlmZ ddlZddlZddlZddlmZm Z ddlm Z m Z m Z ddl mZmZmZmZ ddlmZ dd lmZ dd lmZ dd lmZmZ dd lmZ d dl m Z m Z m Z d dl m!Z! d dl"m#Z# d dl$m%Z% d dl&m'Z' d dl(m)Z) d dl*m+Z+ ejX r2ddl-m.Z. G d� dej^ � Z0 G d� de0ej^ � Z1neZ2 d d d�Z3dd � d!d �Z4d"d �Z5y)#z0Private logic for creating pydantic dataclasses.� )� annotationsN)�partial�wraps)�Any�Callable�ClassVar)� ArgsKwargs�SchemaSerializer�SchemaValidator� core_schema)� TypeGuard� )�PydanticUndefinedAnnotation)� FieldInfo)�PluggableSchemaValidator�create_schema_validator)�PydanticDeprecatedSince20� )�_config� _decorators� _typing_extra)�collect_dataclass_fields)�GenerateSchema)�get_standard_typevars_map)�set_dataclass_mocks)� CallbackGetCoreSchemaHandler)�generate_pydantic_signature)� ConfigDictc �4 � e Zd ZU ded< ded< ded< d d�Zy) �StandardDataclasszClassVar[dict[str, Any]]�__dataclass_fields__z ClassVar[Any]�__dataclass_params__z ClassVar[Callable[..., None]]� __post_init__c � � y �N� )�self�args�kwargss �N/opt/hc_python/lib/python3.12/site-packages/pydantic/_internal/_dataclasses.py�__init__zStandardDataclass.__init__' s � � � N)r( �objectr) r- �return�None)�__name__� __module__� __qualname__�__annotations__r+ r& r, r* r r " s � � 6�6� +�+�4�4� r, r c �X � e Zd ZU dZded< ded< ded< ded < d ed < d ed < ded< 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. zClassVar[ConfigDict]�__pydantic_config__zClassVar[bool]�__pydantic_complete__z ClassVar[core_schema.CoreSchema]�__pydantic_core_schema__z$ClassVar[_decorators.DecoratorInfos]�__pydantic_decorators__z ClassVar[dict[str, FieldInfo]]�__pydantic_fields__zClassVar[SchemaSerializer]�__pydantic_serializer__z4ClassVar[SchemaValidator | PluggableSchemaValidator]�__pydantic_validator__N)r0 r1 r2 �__doc__r3 r& r, r* r5 r5 * s3 � � � 2�1� -�-�"B�B�!E�E� ;�;�!;�;� T�Tr, r5 c �F � t | � }t | |||�� }|| _ y)z�Collect and set `cls.__pydantic_fields__`. Args: cls: The class. types_namespace: The types namespace, defaults to `None`. config_wrapper: The config wrapper instance, defaults to `None`. )� typevars_map�config_wrapperN)r r r: )�cls�types_namespacer@ r? �fieldss r* �set_dataclass_fieldsrD E s' � � -�S�1�L� %�c�?� �ft� u�F� $�C�r, T)� raise_errorsc � � � t | d� rt j dt � |�t j | � }t | ||�� t | � }t |||� }t | j | j |d�� }dd�}| j � d�|_ || _ |j | _ || _ t! | d d� } |r+ || t# t% |j& d � � |d � � � } n|j' | d � � } |j1 | � } |j3 | � } t7 j8 d| � } | | _ t= | | | j> | j d| |j@ � x| _! � tE | | � | _# |jH r5tK | jL � d� fd� � } | jO d| � | _& y# t( $ r2} |r� t+ | | j, d| j. � d�� Y d} ~ y d} ~ ww xY w# |j4 $ r t+ | | j, d� Y y w xY 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 calledN)r@ T)�initrC r@ � is_dataclassc �Z � d}| }|j j t ||� |�� y )NT)� self_instance)r< �validate_pythonr )�__dataclass_self__r( r) �__tracebackhide__�ss r* r+ z$complete_dataclass.<locals>.__init__� s. � � �� �� � � �0�0��D�&�1I�YZ�0�[r, z .__init__� __get_pydantic_core_schema__F)�from_dunder_get_core_schema�unpack)�ref_mode�`zall referenced typesztype[PydanticDataclass]� dataclassc �, �� �j | ||� y r% )�validate_assignment)�instance�field�value� validators �r* �validated_setattrz-complete_dataclass.<locals>.validated_setattr� s �� � � )� )�(�E�5� Ar, )rM r5 r( r r) r r. r/ )rX r rY �strrZ r] r. r/ )(�hasattr�warnings�warn�DeprecationWarningr �get_cls_types_namespacerD r r r r+ r: r2 � config_dictr6 � __signature__�getattrr r �generate_schemar r r0 �name� core_config� clean_schema�CollectedInvalid�typing�castr8 r r1 �plugin_settingsr< r r; rW r � __setattr__�__get__)rA r@ rE rB r? � gen_schema�sigr+ �get_core_schema�schema�erh r\ r[ s @r* �complete_dataclassru W sE �� �2 �s�.�/�� � � d�fx� � � �'�?�?��D����o�n�M�,�S�1�L� �����J� &� �\�\��&�&�%�� �C�\� #� /� /� 0� � :�H���C�L� ,� 8� 8�C���C�� �c�#A�4�H�O�� �$��,��J� 6� 6�TY�Z� � %���F� �/�/��QV�/�W�F� !�,�,�S�1�K���(�(��0�� �+�+�/�� 5�C� $*�C� �-D���S�^�^�S�%5�%5�{�K�Q_�Qo�Qo�.� �C� �� #3�6�;�"G�C� ��)�)� �s��� � B� � B� ,�3�3�D�#�>��� ��C '� � � ��C�� � ��1�6�6�(�!�}�=��� �� � &� &� ��C�� � �/E�F���s+ � A G � H � H� (H � H�&H=�<H=c � � t j | � xrG t | d� xr8 t | j � j t t | di � � � 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. r< r3 )� dataclassesrI r^ �setr! � issupersetre )�_clss r* �is_builtin_dataclassr{ � sZ � �> � � ��&� a��� 6�7� 7� a� ��)�)� *� 5� 5�c�'�$�HY�[]�:^�6_� `�r, )NN)rA ztype[StandardDataclass]rB �dict[str, Any] | Noner@ z _config.ConfigWrapper | Noner. r/ ) rA � type[Any]r@ z_config.ConfigWrapperrE �boolrB r| r. r~ )rz r} r. z"TypeGuard[type[StandardDataclass]])6r= � __future__r � _annotationsrw rk r_ � functoolsr r r r r � pydantic_corer r r r �typing_extensionsr �errorsr rC r �plugin._schema_validatorr r r � r r r �_fieldsr �_generate_schemar � _genericsr � _mock_val_serr �_schema_generation_sharedr � _signaturer � TYPE_CHECKING�configr �Protocolr r5 ra rD ru r{ r& r, r* �<module>r� s� �� 6� 2� � � � $� *� *�� � (� 0� � X� 0� 1� 1� -� ,� 0� .� C� 3� ���#��F�O�O� �U� -�v��� U�0 3�� .2�37�%� �%�*�%� 1�%� � %�, � k� �k�)�k� � k� +� k� � k�\"r,