� h\�g�F����dZddlZddlZddlZddlmZddlmZ ddlmZn #e $rYnwxYwddl m Z m Z m Z mZmZmZmZmZmZmZmZddlmZddlmZdd lmZmZmZmZdd lm Z dd l!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*ddl+m,Z,e r8ddl(m-Z-ddl.m/Z/m0Z0edd���Z1eeddfZ2Gd�d��Z3gd�Z4ed��Z5ej6dkr�eej7e$f���eddddddddddd� de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d'e8d(e ee5gd)ffd*�����Z:eej7e$f���eddddddddddd� d+ee5de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d'e8d(d)fd,�����Z:n�eej7e$f���edddddddddd-� de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d(e ee5gd)ffd.�����Z:eej7e$f���edddddddddd-� d+ee5de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d(d)fd/�����Z:eej7e$f��� dIddddddddddd� d+eee5de8de8d e8d!e8d"e8d#e8d$eeee9dfd%ee8d&ee8d'e8d(ee ee5gd)fd)ffd0���Z:ed1edd2e8d(eedddffd3���Z;Gd4�d��Z<d5edd$eed%e8d6e=d(df d7�Z>dJd9�Z?d1edd:e d(dfd;�Z@edfd5edd$ee d6ee=d(ed<fd=�ZAej6d>kr d?dd@e=d(e8fdA�ZBn d?dd@e=d(e8fdB�ZBdKdD�ZCdCddEe=d2e d(dfdF�ZDd+ee d(e8fdG�ZEd5edd$eed(d8fdH�ZFdS)LaX The main purpose is to enhance stdlib dataclasses by adding validation A pydantic dataclass can be generated from scratch or from a stdlib one. Behind the scene, a pydantic dataclass is just like a regular one on which we attach a `BaseModel` and magic methods to trigger the validation of the data. `__init__` and `__post_init__` are hence overridden and have extra logic to be able to validate input data. When a pydantic dataclass is generated from scratch, it's just a plain dataclass with validation triggered at initialization The tricky part if for stdlib dataclasses that are converted after into pydantic ones e.g. ```py @dataclasses.dataclass class M: x: int ValidatedM = pydantic.dataclasses.dataclass(M) ``` We indeed still want to support equality, hashing, repr, ... as if it was the stdlib one! ```py assert isinstance(ValidatedM(x=1), M) assert ValidatedM(x=1) == M(x=1) ``` This means we **don't want to create a new dataclass that inherits from it** The trick is to create a wrapper around `M` that will act as a proxy to trigger validation without altering default `M` behaviour. �N)�contextmanager)�wraps)�cached_property) � TYPE_CHECKING�Any�Callable�ClassVar�Dict� Generator�Optional�Type�TypeVar�Union�overload)�dataclass_transform)�gather_all_validators)� BaseConfig� ConfigDict�Extra� get_config)�ValidationError)�DataclassTypeError)�Field� FieldInfo�Required� Undefined)� create_model�validate_model)�ClassAttribute)� BaseModel)�CallableGenerator�NoArgAnyCallable� DataclassT� Dataclass)�bound�DataclassProxyc��eZdZUeeeefed<eeed<eeded<ee ed<eeded<ee ed<ee e ed<eedgd fed <ee ed <d e d e dd fd�Z ede dddfd���Zede ddeddfd���Zd S)r$�__dataclass_fields__�__dataclass_params__).N� __post_init__�__pydantic_run_validation__�__post_init_post_parse__�__pydantic_initialised__�__pydantic_model__N�__pydantic_validate_values__�#__pydantic_has_field_info_default__�args�kwargs�returnc��dS�N���selfr1r2s �g/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/pydantic/v1/dataclasses.py�__init__zDataclass.__init__Ps�� �D��clsr!c��dSr5r6�r<s r9�__get_validators__zDataclass.__get_validators__S��� �Dr;r#�vc��dSr5r6�r<rAs r9� __validate__zDataclass.__validate__Wr@r;)�__name__� __module__� __qualname__r r �strr�__annotations__r�boolr r �objectr:� classmethodr?rDr6r;r9r$r$Bsf�������&�t�C��H�~�6�6�6�6�&�s�m�+�+�+���� 3�4�4�4�4�&.�d�^�3�3�3�"*�8�I�+>�"?�?�?�?�"*�4�.�0�0�0�$�T�)�_�5�5�5�5�&.�x�� �t�8K�/L�&M�M�M�M�-5�d�^�;�;�;� �&� �F� �t� � � � � � �D��$5� �:M� � � � �� � � �d�<�0� �S� �\� � � � �� � � r;)� dataclass�set_validation�$create_pydantic_model_from_dataclass�is_builtin_dataclass�make_dataclass_validator�_T��� )�field_specifiersTF.� �init�repr�eq�order� unsafe_hash�frozen�config�validate_on_init� use_proxy�kw_onlyrXrYrZr[r\r]r^r_r`rar3�DataclassClassOrWrapperc ��dSr5r6rWs r9rMrMh� �� �r;�_clsc ��dSr5r6) rerXrYrZr[r\r]r^r_r`ras r9rMrMys �� �r;� rXrYrZr[r\r]r^r_r`c ��dSr5r6rgs r9rMrM�s �� �r;c ��dSr5r6) rerXrYrZr[r\r]r^r_r`s r9rMrM�rdr;c ��������� � � �t|��� dttddf���� ��� �� �f d� } |�| S| |��S)a Like the python standard lib dataclasses but with type validation. The result is either a pydantic dataclass that will validate input data or a wrapper that will trigger validation around a stdlib dataclass to avoid modifying it directly r<r3rbc �� ����ngt|��oX|jdtupDtt |����tt |jd����k}|rd}t |��}d}nS|jpd}tjdkrtj |�� �� � �� ���}ntj |�� �� � ����}d}��|n�}t|� ||��|j j di|j|i��|S) Nr�FrS)rXrYrZr[r\r]ra)rXrYrZr[r\r]Tr6)rP� __bases__rK�set�dirr&�__doc__�sys� version_info� dataclassesrM�#_add_pydantic_validation_attributesr.�__try_update_forward_refs__rE)r<�should_use_proxy� dc_cls_doc�dc_cls�default_validate_on_init�should_validate_on_initrZr]rXrar[rY� the_configr\r`r_s ����������r9�wrapzdataclass.<locals>.wrap�sX����$� �I�%�S�)�)�`��]�1�%��/�^�3�s�3�x�x�=�=�C��C�M�Z[�L\�H]�H]�D^�D^�3^� � � ,��J�#�C�(�(�F�',� $� $���*��J���7�*�*�$�.������ +�!�#� � � ���%�.��d��"�E�{�ci�����(,� $�>N�>V�":�":�\l��+�C��=T�V`�a�a�a�=��!�=�T�T���s�@S�T�T�T�� r;)rr r) rerXrYrZr[r\r]r^r_r`rar|r{s `````` ``` @r9rMrM�s�������������*�F�#�#�J�#�$�s�)�#� 9�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�J �|�� � �4��:�:�r;r<�valuec#�VK�|j} ||_|V�||_dS#||_wxYwr5)r+)r<r}�original_run_validations r9rNrN�sI����!�=��B�*/��'�� � � �*A��'�'�'��*A��'�A�A�A�As� � (c��eZdZdZdedddfd�Zdededefd �Zd edefd �Z d ed eddfd�Z dede fd�Z dd�Z deddfd�ZdS)r&� __dataclass__rxr$r3Nc�>�t�|d|��dS)Nr�)rK� __setattr__)r8rxs r9r:zDataclassProxy.__init__�s �����4��&�9�9�9�9�9r;r1r2c�z�t|jd��5|j|i|��cddd��S#1swxYwYdS)NT)rNr�r7s r9�__call__zDataclassProxy.__call__s��� �D�.�� 5� 5� 7� 7�%�4�%�t�6�v�6�6� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7� 7���� 7� 7� 7� 7� 7� 7s � 0�4�4�namec�,�t|j|��Sr5)�getattrr�)r8r�s r9� __getattr__zDataclassProxy.__getattr__s���t�)�4�0�0�0r;�_DataclassProxy__name�_DataclassProxy__valuec�.�t|j||��Sr5)�setattrr�)r8r�r�s r9r�zDataclassProxy.__setattr__s���t�)�6�7�;�;�;r;�instancec�,�t||j��Sr5)� isinstancer�)r8r�s r9�__instancecheck__z DataclassProxy.__instancecheck__ s���(�D�$6�7�7�7r;c�N�ttj|j����Sr5)r&�copyr�)r8s r9�__copy__zDataclassProxy.__copy__s���d�i��(:�;�;�<�<�<r;�memoc�P�ttj|j|����Sr5)r&r��deepcopyr�)r8r�s r9� __deepcopy__zDataclassProxy.__deepcopy__s���d�m�D�,>��E�E�F�F�Fr;)r3r&)rErFrG� __slots__r r:rr�rHr�r�rJr�r�r�r6r;r9r&r&�s�������I�:�t�K�0�:�T�:�:�:�:�7�c�7�S�7�S�7�7�7�7�1��1��1�1�1�1�<�#�<��<��<�<�<�<�8�#�8�$�8�8�8�8�=�=�=�=�G��G�)9�G�G�G�G�G�Gr;rxrwc �������|j�t���dddtdtddf��fd� ���t|d��rv |jj�n#t $r |j�YnwxYwt���dddtdtddf��fd � ��}t|d ���t|d|��n>t���dddtdtddf�fd � ��}t|d |��t|d td |����t|d d��t|dt|�|����t|dt��t|dtt����t|dtt����|jjjr$|jjst|dt&��dSdSdS)a We need to replace the right method. If no `__post_init__` has been set in the stdlib dataclass it won't even exist (code is generated on the fly by `dataclasses`) By default, we run validation after `__init__` or `__post_init__` if defined r8r$r1r2r3Nc�����jtjkr,��g|�Ri�fd�|���D����dS�jtjkra|���D] \}}�j�||���!��g|�Ri�fd�|���D����dS��g|�Ri|��dS)Nc�.��i|]\}}|�jv�||��Sr6�r(��.0�krAr8s �r9� <dictcomp>zR_add_pydantic_validation_attributes.<locals>.handle_extra_init.<locals>.<dictcomp>%�,��� c� c� c�$�!�Q�A��Ib�Db�Db��A�Db�Db�Dbr;c�.��i|]\}}|�jv�||��Sr6r�r�s �r9r�zR_add_pydantic_validation_attributes.<locals>.handle_extra_init.<locals>.<dictcomp>*r�r;)�extrar�ignore�items�allow�__dict__� setdefault)r8r1r2r�rAr^rXs` ��r9�handle_extra_initz>_add_pydantic_validation_attributes.<locals>.handle_extra_init"s���� �<�5�<� '� '� �D�� d�� d� d� d� c� c� c� c�&�,�,�.�.� c� c� c� d� d� d� d� d� �\�U�[� (� (�� � ��� /� /���1�� �(�(��A�.�.�.�.� �D�� d�� d� d� d� c� c� c� c�&�,�,�.�.� c� c� c� d� d� d� d� d� �D�� '�� '� '� '�� '� '� '� '� 'r;r*c�����jdkr �|g|�Ri|��|jjr1|���t |d��r |j|i|���jdkr�|g|�Ri|��dSdS)N�before_validationr,�after_validation)�post_init_call� __class__r+r/�hasattrr,)r8r1r2r^� post_inits ��r9� new_post_initz:_add_pydantic_validation_attributes.<locals>.new_post_init5s�����$�(;�;�;�� �$�0��0�0�0��0�0�0��~�9� C��1�1�3�3�3��4�!;�<�<�C�1�D�1�4�B�6�B�B�B��$�(:�:�:�� �$�0��0�0�0��0�0�0�0�0�;�:r;r:c����|g|�Ri|��|jjr|���t|d��r�i}t |jj�����D]b\}}|jtj urJ ||||j <�*#t$r+|� |j |j ��||j <Y�^wxYw�c|jdi|��dSdS)Nr,r6)r�r+r/r�� enumerater(�values� _field_typers�_FIELD_INITVARr�� IndexError�get�defaultr,)r8r1r2�initvars_and_values�i�fr�s �r9�new_initz5_add_pydantic_validation_attributes.<locals>.new_initGs/��� � �d� 4�T� 4� 4� 4�V� 4� 4� 4��~�9� 4��1�1�3�3�3��t�7�8�8� E� 79�#�%�d�n�&I�&P�&P�&R�&R�S�S�X�X�D�A�q��}� �(B�B�B�X�:>�q�'�/���7�7��)�X�X�X�:@�*�*�Q�V�Q�Y�:W�:W�/���7�7�7�X���� C�.��-�D�D�0C�D�D�D�D�D� E� Es�B�2C � C r+r-Fr.r/rDr?r�)r:rrr�r*� __wrapped__�AttributeErrorr�rrO�_dataclass_validate_valuesrL�_validate_dataclass�_get_validatorsr.� __config__�validate_assignmentr)r]�&_dataclass_validate_assignment_setattr) rxr^r_rwr�r�r�rXr�s ` @@@r9rtrts������� �?�D� �4�[�[� (� � (�C� (�3� (�4� (� (� (� (� (� (��[� (��v��'�'�/.� -��,�8�I�I��� -� -� -��,�I�I�I� -���� �y� � � 1� � 1�C� 1�3� 1�4� 1� 1� 1� 1� 1� 1� � � 1� �� �$5�6�6�6�����7�7�7�7� �t��� E�;� E�s� E�c� E�d� E� E� E� E� E� �� E�, �� �H�-�-�-� �F�1�>�B_�aq�3r�3r�s�s�s� �F�.��6�6�6� �F�(�*N�v�W]�_i�*j�*j�k�k�k� �F�2�4N�O�O�O� �F�N�K�0C�$D�$D�E�E�E� �F�(�+�o�*F�*F�G�G�G� � �+�?�O��Hc�Hj�O��� �'M�N�N�N�N�N�O�O�O�Os� A�A,�+A,r!c#�K�|jV�dSr5)rDr>s r9r�r�ks���� � �����r;rAc�x�t|d��5t||��r"|���|cddd��St|ttf��r||�cddd��St|t ��r|di|��cddd��St |j����#1swxYwYdS)NT)� class_namer6)rNr�r/�list�tuple�dictrrErCs r9r�r�osF�� ��T� "� "� >� >� �a�� � � >� � *� *� ,� ,� ,�� >� >� >� >� >� >� >� >���D�%�=� )� )� >��3��7� >� >� >� >� >� >� >� >� ��4� � � >��3�8�8��8�8� >� >� >� >� >� >� >� >�%�� �=�=�=� =� >� >� >� >���� >� >� >� >� >� >s#�&B/� B/�1B/�B/�/B3�6B3r c���i}tj|��D]�}t}d}|jtjur|j}n"|jtjur|j}nt }t|t��r |}d|_ ntd||d�|j ��}|j |f||j <��t|��}t|jf||j|ddid�|��} |�|n|jpd| _| S)NT)r��default_factory�__resolve_forward_refs__F)r�rF�__validators__�__cls_kwargs__rlr6)rs�fieldsrr��MISSINGr�rr�rr0r�metadata�typer�rrrErFrp) rxr^rw�field_definitions�fieldr�r�� field_info� validators�models r9rOrO|s+�� )+���#�F�+�+�A�A�� ��8<�� �=� � 3� 3� 3��m�G�G� � "�+�*=� =� =�#�3�O�O��G� �g�y� )� )� c� �J�9=�F� 6� 6��b�w��b�b�SX�Sa�b�b�J�).��Z�(@��%�*�%�%�&�v�.�.�J�+��� ���$�!�2�E�:�  � � �  � �E�#-�"8�J�J�f�n�>R�PR�E�M� �Lr;)rT��objr�c�d�ttt|��|d��t��Sr5)r�r�r�r�r�r�s r9�_is_field_cached_propertyr��s$���'�$�s�)�)�Q��5�5��G�G�Gr;c��dS)NFr6r�s r9r�r��s���ur;r8c���t�d��rdSt�dd��r&�fd��j���D��}n%�fd��j���D��}t�j|�j���\}}}|r|��j�|��t��dd��dS)Nr-r0Fc�f��i|]-\}}t|t���t�|���*||��.Sr6)r�rr�r�s �r9r�z._dataclass_validate_values.<locals>.<dictcomp>�sU��� � � ���1��q�)�,�,� �1J�$�PQ�0R�0R� � �q� � � r;c�<��i|]\}}t�|���||��Sr6)r�r�s �r9r�z._dataclass_validate_values.<locals>.<dictcomp>�s1���g�g�g�t�q�!�D]�^b�de�Df�Df�g�a��g�g�gr;r>T) r�r�r�rr.r��updaterKr�)r8� input_data�d�_�validation_errors` r9r�r��s�����t�/�0�0�����t�:�E�B�B� h� � � � �� �+�+�-�-� � � � � � h�g�g�g�t�}�':�':�'<�'<�g�g�g� �+�D�,C�Z�UY�Uc�d�d�d��A�q� ������M������� ���t�7��>�>�>�>�>r;r�c�V�|jr�t|j��}|�|d��|jj�|d��}|r9|�||||j���\}}|rt|g|j���t� |||��dS)N)�locr<) r-r�r��popr.� __fields__r��validater�rrKr�)r8r�r}r�� known_field�error_s r9r�r��s��� �$�@� ��� � �� ���d�D�����-�8�<�<�T�4�H�H� � � @�'�0�0���t���0�X�X�M�E�6�� @�%�v�h���?�?�?� ���t�T�5�)�)�)�)�)r;c ���tj|��oSt|d�� oBt|j���tt |di������S)a� Whether a class is a stdlib dataclass (useful to discriminated a pydantic dataclass that is actually a wrapper around a stdlib dataclass) we check that - `_cls` is a dataclass - `_cls` is not a processed pydantic dataclass (with a basemodel attached) - `_cls` is not a pydantic dataclass inheriting directly from a stdlib dataclass e.g. ``` @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') r.rI)rs� is_dataclassr�rnr(� issupersetr�)res r9rPrP�sf��. � ��&�&� a���2�3�3� 3� a� ��)� *� *� 5� 5�c�'�$�HY�[]�:^�:^�6_�6_� `� `�r;c#�TK�tt||d�����Ed{V��dS)z� Create a pydantic.dataclass from a builtin dataclass to add type validation and yield the validators It retrieves the parameters of the dataclass and forwards them to the newly created dataclass T)r^r`N)r�rM)rxr^s r9rQrQ�s=���� �y���$�O�O�O�P�P�P�P�P�P�P�P�P�P�Pr;r5)r<rbr3r!)r8r$r3N)Grpr�rsrq� contextlibr� functoolsrr� ImportError�typingrrrr r r r r rrr�typing_extensionsr�pydantic.v1.class_validatorsr�pydantic.v1.configrrrr�pydantic.v1.error_wrappersr�pydantic.v1.errorsr�pydantic.v1.fieldsrrrr�pydantic.v1.mainrr�pydantic.v1.utilsrr �pydantic.v1.typingr!r"r#rbr$�__all__rRrrr�rJrKrMrNr&rHrtr�r�rOr�r�r�rPrQr6r;r9�<module>rs� �� � �B � � � ����� � � � �%�%�%�%�%�%������� �)�)�)�)�)�)�)��� � � ��D� ����u�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�t�1�1�1�1�1�1�>�>�>�>�>�>�H�H�H�H�H�H�H�H�H�H�H�H�6�6�6�6�6�6�1�1�1�1�1�1�D�D�D�D�D�D�D�D�D�D�D�D�9�9�9�9�9�9�9�9�,�,�,�,�,�,���*�*�*�*�*�*�F�F�F�F�F�F�F�F����[�9�9�9�J�#�D��$5�7G�$G�H����������4 � � �� �W�T�]�]����w�����;�+<�e�*D�E�E�E� �����!��8<�+/�$(��  �  �  ��  ��  � �  � �  � �  ��  ��j�$�v�,��4�5�  �#�4�.�  ��D�>�  ��  � �4��8�*�7�7� 8�  �  �  ��X�F�E�  ���;�+<�e�*D�E�E�E� �����!��8<�+/�$(�� � � ��2�h� �� ��  � �  � �  �� �� ��j�$�v�,��4�5� �#�4�.� ��D�>� �� � #� � � ��X�F�E� � �$��;�+<�e�*D�E�E�E� �����!��8<�+/�$(�  �  �  ��  ��  � �  � �  � �  ��  ��j�$�v�,��4�5�  �#�4�.�  ��D�>�  � �4��8�*�7�7� 8�  �  �  ��X�F�E�  ���;�+<�e�*D�E�E�E� �����!��8<�+/�$(�  �  �  ��2�h�  ��  ��  � �  � �  ��  ��  ��j�$�v�,��4�5�  �#�4�.�  ��D�>�  � #�  �  �  ��X�F�E�  � ��{�'8�%�&@�A�A�A�#�>�������48�'+� $��>�>�>� �4��8� �>� �>� � >� � >� � >��>� �>� �*�d�6�l�D�0� 1�>��t�n�>���~�>��>� �8�T�"�X�J� 9�9� :�<U� U�V�>�>�>�B�A�>�B�B��\�*�B�4�B�I�d�<�FX�Z^�`d�Fd�<e�B�B�B���B�G�G�G�G�G�G�G�G�4SO� �� �SO� �� �SO��SO�� SO�  � SO�SO�SO�SO�l���� >�T�,�/� >�C� >�L� >� >� >� >�#� $�$�$� �� �$� ��I�$��� �$� �+�� $�$�$�$�N��v���H�{�H�s�H�t�H�H�H�H�H� �{��s��t�����?�?�?�?�, *�� *�C� *�PS� *�X\� *� *� *� *��t�C�y��T�����:Q�T�+�%6�Q��Z�@P�Q�Uh�Q�Q�Q�Q�Q�Qs �#�+�+
Memory