a

�,�hL$�@s�
dd
lZdd
l
Z
ddlmZmZ
ddlmZmZmZmZm	Z	m
Z
mZ
ddlm
Z

ddlmZmZmZ
ddlmZ
e
eeeefZeeefZGdd�de�Zd*eeeed
�dd�Zd+eeeed
�dd�Zee��
Zeed�dd�Zeed�dd�Zeed�dd�Zeed�dd�Z eed�dd�Z!e
�"d�
Z#eed�dd�Z$d,e	ee	eee	ed�dd �Z%d-eeefeeefeeeefd!�d"d#�Z&d.e
e	ee
eeefeed$�d%d&�Z'eed'�d(d)�Z(d
S)/�N)�datetime�	timedelta)�Any�Callable�Dict�Iterable�List�Optional�Union)
�UUID)�Schema�Url�MultipleInvalid)
�CANONICAL_TIMESTRING_FORMATc
@seZ
dZd
ZdS)�BadParameterExceptionz/To be raised when a validation operation fails.N)�__name__�
__module__�__qualname__�__doc__�rr�E/opt/nydus/tmp/pip-target-wkfpz8uv/lib/python/primordial/validator.pyrs
rF)�	validator�param_value�coerce_�returnc
Csrt|�
rbz||
�
}Wn6t
yJ
}
ztd
|
|f�
|�WYd}~n
d}~00|durZ|}n|
}|Std|�
�
dS)a�
Run a validation operation.

    Validate a particular parameter with a particular validator and possibly coerce the value into the validator's
    return type.

    :param validator: The validator to be run
    :param param_value: The value to be validated
    :param coerce_: Whether to return a type coerced value
    :raises ValueError: If the parameter could not be validated.
    z#Parameter %s failed validation (%s)NTz6Cannot use a non-callable as a parameter validator: %s)�callable�	Exceptionr�
ValueError)rrr�myval�
e�retrrr�validates


(

r!)�param_validatorrrrcCs�|d
u
r�t|t
�r�|D]Z}|d
ur2|
d
ur2|

Szt||
|d�}|W
Styn
}
zWYd
}~qd
}~00qtd|
|f�
�
t||
|d�S|
S)a
Validate a parameter.

    :param param_validator: The validator (or list of validators) to be run
    :param param_value: The value to be validated
    :param coerce_: Whether to return a type coerced value
    :raises ValueError: If the parameter could not be validated.
    N�
rz&No validator in list validated %s (%s))�
isinstancerr!rr)r"rrr�retval�
_rrr�validate_param1s










r')�valrc

CsHzt|�

Wn6t
yB
}

ztd
||
f�
|
�WYd}
~
n
d}
~
00|S)a
Validate that a string looks like a URL.

    url is intended to be used like str or int to be a basic callable that will except on type mismatch or non-
    coercible value.

    :param val: The value to be checked
    :raises ValueError: If the value does not look like a URL.
    zNot a url: %s (%s)N)�
URL_SCHEMArr)r(rrrr�urlUs



(r*c
Cs,zt�
|t�}
Wd
Sty&


YdS0dS)z�Validate that we can parse a datetime from a string.

    Catch exception and return false if strptime doesn't work.

    :param val: The value to be checked
    TFN)r�strptimerr)r(r&rrr�parseable_datetimehs




r,c

Cs&t|t
�st|�
r|Std
|�
�
dS)z�Validate that a value represents a datetime.

    :param val: The value to be checked
    :raises ValueError: If the value does not represent a datetime.
    zNot a datetime: %sN)r$rr,r�
r(rrr�is_datetimevs

r.c

Cst|t
�r|Std
|�
�
dS)z�Validate that a value is a timedelta.

    :param val: The value to be checked
    :raises ValueError: If the value is not a timedelta.
    zNot a timedelta: %sN)r$rrr-rrr�is_timedelta�s


r/c

Cs&t|t
�r|ikr|Std
|�
�
dS)z�Validate that a value is a non-empty dictionary.

    :param val: The value to be checked
    :raises ValueError: If the value is not a dictionary, or is empty.
    zNot a non-empty dict: %sN)r$�dictrr-rrr�is_non_empty_dict�s

r1z^[a-z_][a-z0-9_]*$c

Cs$t�
|�
r|Std
tj|f�
�
dS)z�Validate that argument is a valid Postgres identifier.

    :param val: The value to be checked
    :raises ValueError: If the value is not a valid Postgres identifier.
    z"Not a valid Postgres name (%s): %sN)�POSTGRES_NAME_REGEX�matchr�patternr-rrr�is_postgres_name�s




�r5)�positional_args�positional_arg_valuesrrc	Csvg}t|
�
D]d\}}z||}Wn(t
yH
}
zd
}WYd
}~n
d
}~00|d
u
rbt|||d�}n|}|�|�

q|S)az
Validate a list of positional arguments.

    If we run out of stated positionals, we simply dump the originals unvalidated (we're saying the validators are
    optional)

    :param positional_args: The validators to be run, in order, against the values
    :param positional_arg_values: The values to be validated
    :param coerce_: Whether to return type coerced values
    Nr#)�	enumerate�
IndexErrorr'�append)	r6r7r�outargs�indexZmyvaluerr&rrrr�internal_validate_positionals�s








r=)�keyword_args�keyword_arg_valuesrrc	Csti}|
��D]b\}}z||}Wn(t
yH
}
zd
}WYd
}~n
d
}~00|d
u
rbt|||d�}n|}|||<q|S)ar
Validate a dictionary of keyword arguments.

    If there is no matching validator for a particular keyword, then the original value is passed along in the output
    unvalidated.

    :param keyword_args: The validators to be run against the values
    :param keyword_arg_values: The values to be validated
    :param coerce_: Whether to return type coerced values
    Nr#)�items�KeyErrorr')	r>r?rZoutdict�key�valuerr&rrrr�internal_validate_keywords�s









rD)�positionals�keywordsrrcs��
�fd
d�}|S)a>
Either coerce the arguments in the suggested way or die with error back to the client.

    :param positionals: A list of validators to be run against positional arguments
    :param keywords: A dictionary of validators to be run against keyword arguments
    :param coerce_: Whether to return type coerced values
    c
s t�
��
�
���fd
d��
}
|
S)ZInnerc
s�z<�d
u
rt�|�d�}n|}�d
u
r6t
�|
�d�}n|
}Wn>tyz
}
z&tdt|�
t|�
f�
|�WYd
}~n
d
}~00�
|i|�
�
S)zActual wrapperNr#zFailed to validate: %s, %s)r=rDrr�str)�args�kwargsr;Z	outkwargsr)r�functionrFrErr�wrapper�s





0
z3coerce_or_error.<locals>.decorator.<locals>.wrapper)�	functools�wraps)rJrK�rrFrE)
rJr�	decorator�s
z"coerce_or_error.<locals>.decoratorr)rErFrrOrrNr�coerce_or_error�s
rP)�
uuid_mayberc

Cs(zt|�

Wd
St
y"


YdS0dS)z]Validate that a value represents a UUID.

    :param uuid_maybe: The value to be checked
    TFN)rr)
rQrrr�is_uuid�s




rR)
F)
F)
F)
F)NNF))rL�rerr�typingrrrrrr	r
�uuidrZ
voluptuousrr
rZprimordial.constantsrZ
ValidatorTyperGZDateTimeTyperr�boolr!r'r)r*r,r.r/r1�compiler2r5r=rDrPrRrrrr�<module>sL


$

!

�

��


�

�



�