OwlCyberSecurity - MANAGER
Edit File: functional_validators.cpython-312.pyc
� I��g�^ � � � U d Z ddlmZ ddlZddlZddlmZ ddlm Z ddl m Z m Z m Z mZmZmZmZ ddlmZ ddlmZ ddlmZmZmZ d d lmZ d d l m Z m Z m Z m Z d d l!mZ d d l"m#Z# ejH d k rddlm%Z% nddl m%Z% e jL Z' ejP dFddie jR �� G d� d� � Z* ejP dFddie jR �� G d� d� � Z+ ejP dFddie jR �� G d� d� � Z, ejP dFddie jR �� G d� d� � Z-e r~ G d� de%� Z. G d� d e%� Z/ G d � d e%� Z0ee/ejb e.ejd f Z3ee0ejh f Z5ee6e e e f e7e e f ee f Z8d e9d < ed!e3e8� Z: ed"e5e8� Z;ed#d#d$� dGd%�� Z<ed#d&� dHd'�� Z<ed( Z=d e9d)< d*dd$� dId+�Z< ed,� Z> ed-d�.� Z? G d/� d0ej� e%e? � ZA G d1� d2e%e> � ZB G d3� d4e%e> � ZC G d5� d6e%� ZD G d7� d8e%� ZE G d9� d:e%� ZF G d;� d<e%� ZGe e>ge>f ZH e e>ej� ge>f ZJ eeCe> eBe> f ZKeeFeGeDeEf ZLeeJe> eHe> f ZMe dJd=�� ZNe dKd>�� ZNe dLd?�� ZN dMd@�ZN edA� ZOe reeOd#f ZPn) ejP dFi e jR �� G dB� dC� � ZPe reeOd#f ZQy ejP dFi e jR �� G dD� dE� � ZQy)NzBThis module contains related classes and functions for validation.� )� annotationsN)� partialmethod)� FunctionType)� TYPE_CHECKING�Any�Callable�TypeVar�Union�cast�overload)� core_schema)� Annotated�Literal� TypeAlias� )�GetCoreSchemaHandler)�_core_metadata� _decorators� _generics�_internal_dataclass)�PydanticUserError)� � )�Protocol�frozenTc �$ � e Zd ZU dZded< dd�Zy)�AfterValidatora8 Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators A metadata class that indicates that a validation should be applied **after** the inner validation logic. Attributes: func: The validator function. Example: ```py from typing_extensions import Annotated from pydantic import AfterValidator, BaseModel, ValidationError MyInt = Annotated[int, AfterValidator(lambda v: v + 1)] class Model(BaseModel): a: MyInt print(Model(a=1).a) #> 2 try: Model(a='a') except ValidationError as e: print(e.json(indent=2)) ''' [ { "type": "int_parsing", "loc": [ "a" ], "msg": "Input should be a valid integer, unable to parse string as an integer", "input": "a", "url": "https://errors.pydantic.dev/2/v/int_parsing" } ] ''' ``` �Kcore_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction�funcc �D � ||� }t | j d� }|rFt t j | j � }t j |||j �� S t t j | j � }t j ||�� S )N�after��schema� field_name�r# ) �_inspect_validatorr r r �WithInfoValidatorFunction�"with_info_after_validator_functionr$ �NoInfoValidatorFunction� no_info_after_validator_function��self� source_type�handlerr# �info_argr s �M/opt/hc_python/lib/python3.12/site-packages/pydantic/functional_validators.py� __get_pydantic_core_schema__z+AfterValidator.__get_pydantic_core_schema__I sz � ���%��%�d�i�i��9�� �� �=�=�t�y�y�I�D� �A�A�$�v�bi�bt�bt�u� u�� �;�;�T�Y�Y�G�D� �?�?��V�T� T� N�r- r r. �_GetCoreSchemaHandler�return�core_schema.CoreSchema��__name__� __module__� __qualname__�__doc__�__annotations__r1 � r2 r0 r r s � �'�R V�U�Ur2 r c �$ � e Zd ZU dZded< dd�Zy)�BeforeValidatora� Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators A metadata class that indicates that a validation should be applied **before** the inner validation logic. Attributes: func: The validator function. Example: ```py from typing_extensions import Annotated from pydantic import BaseModel, BeforeValidator MyInt = Annotated[int, BeforeValidator(lambda v: v + 1)] class Model(BaseModel): a: MyInt print(Model(a=1).a) #> 2 try: Model(a='a') except TypeError as e: print(e) #> can only concatenate str (not "int") to str ``` r r c �D � ||� }t | j d� }|rFt t j | j � }t j |||j �� S t t j | j � }t j ||�� S )N�beforer" r% ) r& r r r r' �#with_info_before_validator_functionr$ r) �!no_info_before_validator_functionr+ s r0 r1 z,BeforeValidator.__get_pydantic_core_schema__u s{ � ���%��%�d�i�i��:�� �� �=�=�t�y�y�I�D� �B�B�4�PV�cj�cu�cu�v� v�� �;�;�T�Y�Y�G�D� �@�@��f�U� Ur2 Nr3 r7 r= r2 r0 r? r? T s � ��: V�U�Vr2 r? c �$ � e Zd ZU dZded< dd�Zy)�PlainValidatora; Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators A metadata class that indicates that a validation should be applied **instead** of the inner validation logic. Attributes: func: The validator function. Example: ```py from typing_extensions import Annotated from pydantic import BaseModel, PlainValidator MyInt = Annotated[int, PlainValidator(lambda v: int(v) + 1)] class Model(BaseModel): a: MyInt print(Model(a='1').a) #> 2 ``` r r c � � ddl m} ||� }t j d� |�� }t | j d� }|rFt t j | j � }t j ||j |�� S t t j | j � }t j ||�� S # |$ r d }Y ��w xY w)Nr �� PydanticSchemaGenerationErrorc � � || � S �Nr= ��v�hs r0 �<lambda>z=PlainValidator.__get_pydantic_core_schema__.<locals>.<lambda>� s � �bc�de�bfr2 ��functionr# �plain)r$ � serialization)rR ) �pydanticrH r �#wrap_serializer_function_ser_schemar& r r r' �"with_info_plain_validator_functionr$ r) � no_info_plain_validator_function)r, r- r. rH r# rR r/ r s r0 r1 z+PlainValidator.__get_pydantic_core_schema__� s� � � ;� !� �[�)�F� '� K� K�Uf�ou� v�M� &�d�i�i��9�� �� �=�=�t�y�y�I�D� �A�A���!3�!3�=�� � � �;�;�T�Y�Y�G�D� �?�?��Ta�b� b�� -� !� �M� !�s � C �C � C Nr3 r7 r= r2 r0 rE rE � s � ��. V�U�cr2 rE c �$ � e Zd ZU dZded< dd�Zy)� WrapValidatora Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators A metadata class that indicates that a validation should be applied **around** the inner validation logic. Attributes: func: The validator function. ```py from datetime import datetime from typing_extensions import Annotated from pydantic import BaseModel, ValidationError, WrapValidator def validate_timestamp(v, handler): if v == 'now': # we don't want to bother with further validation, just return the new value return datetime.now() try: return handler(v) except ValidationError: # validation failed, in this case we want to return a default value return datetime(2000, 1, 1) MyTimestamp = Annotated[datetime, WrapValidator(validate_timestamp)] class Model(BaseModel): a: MyTimestamp print(Model(a='now').a) #> 2032-01-02 03:04:05.000006 print(Model(a='invalid').a) #> 2000-01-01 00:00:00 ``` zScore_schema.NoInfoWrapValidatorFunction | core_schema.WithInfoWrapValidatorFunctionr c �D � ||� }t | j d� }|rFt t j | j � }t j |||j �� S t t j | j � }t j ||�� S )N�wrapr" r% ) r& r r r � WithInfoWrapValidatorFunction�!with_info_wrap_validator_functionr$ �NoInfoWrapValidatorFunction� no_info_wrap_validator_functionr+ s r0 r1 z*WrapValidator.__get_pydantic_core_schema__� sz � ���%��%�d�i�i��8�� �� �A�A�4�9�9�M�D� �@�@��f�ah�as�as�t� t�� �?�?����K�D� �>�>�t�F�S� Sr2 Nr3 r7 r= r2 r0 rX rX � s � �"�H ^�]�Tr2 rX c � � e Zd Zdd�Zy)� _OnlyValueValidatorClsMethodc � � y rJ r= �r, �cls�values r0 �__call__z%_OnlyValueValidatorClsMethod.__call__� s � �Cr2 N�rc r rd r r5 r �r8 r9 r: re r= r2 r0 r` r` � s � �?r2 r` c � � e Zd Zdd�Zy)�_V2ValidatorClsMethodc � � y rJ r= �r, rc rd �infos r0 re z _V2ValidatorClsMethod.__call__� s � �_br2 N�rc r rd r rl �_core_schema.ValidationInfor5 r rg r= r2 r0 ri ri � s � �br2 ri c �( � e Zd Z dd�Zy)�_V2WrapValidatorClsMethodc � � y rJ r= �r, rc rd r. rl s r0 re z"_V2WrapValidatorClsMethod.__call__� s � � r2 N) rc r rd r r. z)_core_schema.ValidatorFunctionWrapHandlerrl rn r5 r rg r= r2 r0 rp rp � s7 � � �� � � � ?� � .� � � r2 rp r �_PartialClsOrStaticMethod�"_V2BeforeAfterOrPlainValidatorType�_V2WrapValidatorType.)�mode� check_fieldsc � � y rJ r= ��fieldrv rw �fieldss r0 �field_validatorr| s � � Z]r2 )rw c � � y rJ r= ry s r0 r| r| s � � >Ar2 )rA r! rZ rQ �FieldValidatorModesr! c � ���� t | t � r t dd�� �| g����t d� �D � � s t dd�� � d���fd� }|S ) a: Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#field-validators Decorate methods on the class indicating that they should be used to validate fields. Example usage: ```py from typing import Any from pydantic import ( BaseModel, ValidationError, field_validator, ) class Model(BaseModel): a: str @field_validator('a') @classmethod def ensure_foobar(cls, v: Any): if 'foobar' not in v: raise ValueError('"foobar" not found in a') return v print(repr(Model(a='this is foobar good'))) #> Model(a='this is foobar good') try: Model(a='snap') except ValidationError as exc_info: print(exc_info) ''' 1 validation error for Model a Value error, "foobar" not found in a [type=value_error, input_value='snap', input_type=str] ''' ``` For more in depth examples, see [Field Validators](../concepts/validators.md#field-validators). Args: field: The first field the `field_validator` should be called on; this is separate from `fields` to ensure an error is raised if you don't pass at least one. *fields: Additional field(s) the `field_validator` should be called on. mode: Specifies whether to validate the fields before or after validation. check_fields: Whether to check that the fields actually exist on the model. Returns: A decorator that can be used to decorate a function to be used as a field_validator. Raises: PydanticUserError: - If `@field_validator` is used bare (with no fields). - If the args passed to `@field_validator` as fields are not strings. - If `@field_validator` applied to instance methods. z�`@field_validator` should be used with fields and keyword arguments, not bare. E.g. usage should be `@validator('<field_name>', ...)`zvalidator-no-fields��codec 3 �< K � | ] }t |t � �� � y �wrJ )� isinstance�str)�.0rz s r0 � <genexpr>z"field_validator.<locals>.<genexpr>l s � �� �:�6�%�z�%��%�6�s � z�`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('<field_name_1>', '<field_name_2>', ...)`zvalidator-invalid-fieldsc �� �� t j | � r t dd�� �t j | � } t j ����� }t j | |� S )Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodr� )r{ rv rw )r �is_instance_method_from_sigr �%ensure_classmethod_based_on_signature�FieldValidatorDecoratorInfo�PydanticDescriptorProxy)�f�dec_inforw r{ rv s ���r0 �decz field_validator.<locals>.decs s` �� � � 2� 2�1� 5�#�J�Ql�� � � =� =�a� @�� �:�:�&�t�bn�o���2�2�1�h�?�?r2 )r� zHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r5 �(_decorators.PydanticDescriptorProxy[Any])r� r r �all)rz rv rw r{ r� s ``` r0 r| r| & sv �� �~ �%� �&� � E�&� � � �^�V�^�F� �:�6�:� :� � Y�+� � � @� S� @� 1� @� �Jr2 � _ModelType� _ModelTypeCo)� covariantc �& � e Zd ZdZ d dd�Zy)�ModelWrapValidatorHandlerz[@model_validator decorated function handler argument type. This is used when `mode='wrap'`.Nc � � y rJ r= )r, rd �outer_locations r0 re z"ModelWrapValidatorHandler.__call__� s � � r2 rJ )rd r r� zstr | int | Noner5 r� �r8 r9 r: r; re r= r2 r0 r� r� � s+ � �e� ,0� �� � )� � � r2 r� c �( � e Zd ZdZ dd�Zy)� ModelWrapValidatorWithoutInfoz�A @model_validator decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. c � � y rJ r= )r, rc rd r. s r0 re z&ModelWrapValidatorWithoutInfo.__call__� s � � r2 N)rc �type[_ModelType]rd r r. �%ModelWrapValidatorHandler[_ModelType]r5 r� r� r= r2 r0 r� r� � s2 � �� � � � � � 7� � � r2 r� c �, � e Zd ZdZ dd�Zy)�ModelWrapValidatorzQA @model_validator decorated function signature. This is used when `mode='wrap'`.c � � y rJ r= rr s r0 re zModelWrapValidator.__call__� s � � r2 N) rc r� rd r r. r� rl rn r5 r� r� r= r2 r0 r� r� � s: � �[� � � � � � 7� � *� � � r2 r� c � � e Zd ZdZ dd�Zy)�#FreeModelBeforeValidatorWithoutInfo��A @model_validator decorated function signature. This is used when `mode='before'` and the function does not have info argument. c � � y rJ r= )r, rd s r0 re z,FreeModelBeforeValidatorWithoutInfo.__call__� s � � r2 N)rd r r5 r r� r= r2 r0 r� r� � s � ��� � � �r2 r� c �$ � e Zd ZdZ dd�Zy)� ModelBeforeValidatorWithoutInfor� c � � y rJ r= rb s r0 re z(ModelBeforeValidatorWithoutInfo.__call__� � � � r2 Nrf r� r= r2 r0 r� r� � s( � ��� �� � � �r2 r� c �$ � e Zd ZdZ dd�Zy)�FreeModelBeforeValidator�UA `@model_validator` decorated function signature. This is used when `mode='before'`.c � � y rJ r= )r, rd rl s r0 re z!FreeModelBeforeValidator.__call__� r� r2 N)rd r rl rn r5 r r� r= r2 r0 r� r� � s( � �_�� � � *� � �r2 r� c �( � e Zd ZdZ dd�Zy)�ModelBeforeValidatorr� c � � y rJ r= rk s r0 re z ModelBeforeValidator.__call__� s � � r2 Nrm r� r= r2 r0 r� r� � s0 � �_� � � � � � *� � � r2 r� c � � y rJ r= �rv s r0 �model_validatorr� � � � r2 c � � y rJ r= r� s r0 r� r� r� r2 c � � y rJ r= r� s r0 r� r� r� r2 c � � � d� fd� }|S )a" Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#model-validators Decorate model methods for validation purposes. Example usage: ```py from typing_extensions import Self from pydantic import BaseModel, ValidationError, model_validator class Square(BaseModel): width: float height: float @model_validator(mode='after') def verify_square(self) -> Self: if self.width != self.height: raise ValueError('width and height do not match') return self s = Square(width=1, height=1) print(repr(s)) #> Square(width=1.0, height=1.0) try: Square(width=1, height=2) except ValidationError as e: print(e) ''' 1 validation error for Square Value error, width and height do not match [type=value_error, input_value={'width': 1, 'height': 2}, input_type=dict] ''' ``` For more in depth examples, see [Model Validators](../concepts/validators.md#model-validators). Args: mode: A required string literal that specifies the validation mode. It can be one of the following: 'wrap', 'before', or 'after'. Returns: A decorator that can be used to decorate a function to be used as a model validator. c � �� t j | � } t j ��� }t j | |� S )Nr� )r r� �ModelValidatorDecoratorInfor� )r� r� rv s �r0 r� z model_validator.<locals>.decK s6 �� � � =� =�a� @�� �:�:��E���2�2�1�h�?�?r2 )r� r r5 r� r= )rv r� s ` r0 r� r� s �� �`@� �Jr2 �AnyTypec �L � e Zd ZdZedd�� Zedd�� Zej Zy)� InstanceOfu� Generic type for annotating a type that is an instance of a given class. Example: ```py from pydantic import BaseModel, InstanceOf class Foo: ... class Bar(BaseModel): foo: InstanceOf[Foo] Bar(foo=Foo()) try: Bar(foo=42) except ValidationError as e: print(e) """ [ │ { │ │ 'type': 'is_instance_of', │ │ 'loc': ('foo',), │ │ 'msg': 'Input should be an instance of Foo', │ │ 'input': 42, │ │ 'ctx': {'class': 'Foo'}, │ │ 'url': 'https://errors.pydantic.dev/0.38.0/v/is_instance_of' │ } ] """ ``` c �" � t | | � f S rJ )r �rc �items r0 �__class_getitem__z InstanceOf.__class_getitem__ s � � �T�3�5�[�)� )r2 c � � ddl m} t j t j |� xs |� } ||� }t j d� |�� |d< t j ||�� S # |$ r |cY S w xY w)Nr rG c � � || � S rJ r= rK s r0 rN z9InstanceOf.__get_pydantic_core_schema__.<locals>.<lambda>� � � �!�A�$r2 rO rR )� python_schema� json_schema)rS rH r �is_instance_schemar � get_originrT �json_or_python_schema)rc �sourcer. rH �instance_of_schema�original_schemas r0 r1 z'InstanceOf.__get_pydantic_core_schema__� s� � � >� "-�!?�!?� �@T�@T�U[�@\�@f�`f�!g� � x�")�&�/�� 7B�6e�6e� .��7�"�?�3� #�8�8�GY�gv�w�w�� 1� *�)�)� *�s �A. �.A8�7A8N)r� r� r5 r� �r� r r. r r5 r6 ) r8 r9 r: r; � classmethodr� r1 �object�__hash__r= r2 r0 r� r� ] s= � � �@ � *� � *� � x� � x�& �?�?�r2 r� c �B � e Zd ZdZdd�Zedd�� Zej Zy)�SkipValidationa� If this is applied as an annotation (e.g., via `x: Annotated[int, SkipValidation]`), validation will be skipped. You can also use `SkipValidation[int]` as a shorthand for `Annotated[int, SkipValidation]`. This can be useful if you want to use a type annotation for documentation/IDE/type-checking purposes, and know that it is safe to skip validation for one or more of the fields. Because this converts the validation schema to `any_schema`, subsequent annotation-applied transformations may not have the expected effects. Therefore, when used, this annotation should generally be the final annotation applied to a type. c �( � t |t � f S rJ )r r� r� s r0 r� z SkipValidation.__class_getitem__� s � � �T�>�#3� 3�4� 4r2 c � �� ||� �t j �fd�g�� }t j |t j d� ��� �� S )Nc � �� |�� S rJ r= )�_crM r� s �r0 rN z=SkipValidation.__get_pydantic_core_schema__.<locals>.<lambda>� s �� �ab�cr�asr2 )�js_annotation_functionsc � � || � S rJ r= rK s r0 rN z=SkipValidation.__get_pydantic_core_schema__.<locals>.<lambda>� r� r2 rO )�metadatarR )r �build_metadata_dictr � any_schemarT )rc r� r. r� r� s @r0 r1 z+SkipValidation.__get_pydantic_core_schema__� sI �� � %�f�o�O�%�9�9�Ss�Rt�u�H� �)�)�!� )� M� M� .�� �� r2 N)r� r r5 r r� ) r8 r9 r: r; r� r� r1 r� r� r= r2 r0 r� r� � s+ � � � 5� � � � � �?�?�r2 r� r= ) rz r� r{ r� rv z#Literal['before', 'after', 'plain']rw � bool | Noner5 zRCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]) rz r� r{ r� rv �Literal['wrap']rw r� r5 z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]) rz r� r{ r� rv r~ rw r� r5 zCallable[[Any], Any])rv r� r5 z|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rv zLiteral['before']r5 zqCallable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rv zLiteral['after']r5 z}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rv z"Literal['wrap', 'before', 'after']r5 r )Rr; � __future__r � _annotations� dataclasses�sys� functoolsr �typesr �typingr r r r r r r � pydantic_corer � _core_schema�typing_extensionsr r r � r r4 � _internalr r r r �annotated_handlers�errorsr � version_infor �inspect_validatorr& � dataclass� slots_truer r? rE rX r` ri rp r' r) � _V2Validatorr[ �_V2WrapValidatorr� � staticmethodrs r< rt ru r| r~ r� r� � ValidatorFunctionWrapHandlerr� r� r� r� r� r� r� � ModelAfterValidatorWithoutInfo�ValidationInfo�ModelAfterValidator�_AnyModelWrapValidator�_AnyModeBeforeValidator�_AnyModelAfterValidatorr� r� r� r� r= r2 r0 �<module>r� sA �� H� 2� � � #� � O� O� O� %� 5� ;� ;� ;� R� R� 4� %����g� �*� � �2�2� � ����E�d�E�&9�&D�&D�E�4U� 4U� F�4U�n ����E�d�E�&9�&D�&D�E�(V� (V� F�(V�V ����E�d�E�&9�&D�&D�E�0c� 0c� F�0c�f ����E�d�E�&9�&D�&D�E�/T� /T� F�/T�d �@�x� @�c�� c��H� � � ��.�.�$��,�,� .��L� �!��2�2� 4��� ,1��S�#�s�]�1K�\�Z]�_b�Zb�Mc�er�sv�ew�1w�+x� �y�x�)0�,��!�*�&� #�#9�;K�Mf�g�� � 14� #� ]� �]� �]� .� ]� � ]� X� ]� �]� � !$� A� �A� �A� � A� � A� <� A� �A� ")�)K�!L� �Y� L� !(� $� [� �[� �[� � [� � [� � [�| �\� "� ��~��6� � � � I� I�8�T`�Ka� ��H�Z�$8� �" ��*�-� � �(� � �h� � �x� � �8� � "*�:�,� �*B�!C� �� � �L�,G�,G� H�*� T�U� � Z� � 1�*� =�?\�]g�?h� h�i� � � � 2�4W�Yx�x�� � � 3�J� ?�A_�`j�Ak� k�l� � �� ���� �� �� ���� �� �� ���� ��6� ,�6� �6�r �)� �� ��7�C�<�(�J� �[���<� 0� ;� ;�<�9#� 9#� =�9#�x � �w��|�,�N� �[���<� 0� ;� ;�<�#� #� =�#r2