o

|��g���@
s^UdZd
dl
mZ
d
dlZd
dlZd
dlmZ
d
dlm	Z	
d
dl
mZ
d
dlm
Z
mZmZmZmZmZ
d
dlmZmZmZ
d
d	lmZmZmZmZmZ
d
d
lmZ
d
dlmZ 
d
dl!m"Z"m#Z#m$Z$
d
d
l%m&Z&
ddl'm(Z(m)Z)
ddl*m+Z+
ddl,m-Z-
ddl.m/Z/
ddl0m1Z1
er�d
dl2a2dZ3de4d<nda2gd�
Z5ej6Gdd�d��
Z7Gdd�d�Z8Gdd�d�Z9e	ded"d#��
Z:Gd$d%�d%e8�Z;Gd&d'�d'e;�Z<Gd(d)�d)e;�Z=Gd*d+�d+e;�Z>Gd,d-�d-e;�Z?Gd.d/�d/e;�Z@Gd0d1�d1e;�ZAGd2d3�d3e9�ZBGd4d5�d5e;�ZCGd6d7�d7e;�ZDGd8d9�d9e;�ZEGd:d;�d;e9�ZFGd<d=�d=e;�ZGGd>d?�d?e9�ZHGd@dA�dAe;�ZIGdBdC�dCe;�ZJGdDdE�dEe;�ZKGdFdG�dGe;�ZLdfdIdJ�ZMe�
rXe"eNdKfZOnGdLdM�dM�ZOGdNdO�dOe(jP�ZQdPZRde4dQ<dRZSde4dS<dTZTde4dU<e�
r�eRZUeSZVeTZWnGdVdW�dW�ZUGdXdY�dY�ZVGdZd[�d[�ZWdgd]d^�ZXeX�ZYd_ZZ	dhdcdd�Z[e+e\�
Z]dS)izEThe networks module contains types for common network-related fields.�)
�annotationsN�
�fields)
�	lru_cache)
�version)�IPv4Address�
IPv4Interface�IPv4Network�IPv6Address�
IPv6Interface�IPv6Network)�
TYPE_CHECKING�Any�ClassVar)�
MultiHostHost�PydanticCustomError�$PydanticSerializationUnexpectedValue�SchemaSerializer�core_schema)
�MultiHostUrl)
�Url)�	Annotated�Self�	TypeAlias)
�PydanticUserError�
)�_repr�_schema_generation_shared)
�getattr_migration)
�GetCoreSchemaHandler)
�JsonSchemaValue�
�TypeAdapterz7str | bytes | int | tuple[str | bytes | int, str | int]r�NetworkType)�AnyUrl�
AnyHttpUrl�FileUrl�FtpUrl�HttpUrl�WebsocketUrl�AnyWebsocketUrl�UrlConstraints�EmailStr�	NameEmail�
IPvAnyAddress�IPvAnyInterface�
IPvAnyNetwork�PostgresDsn�CockroachDsn�AmqpDsn�RedisDsn�MongoDsn�KafkaDsn�NatsDsn�validate_email�MySQLDsn�
MariaDBDsn�
ClickHouseDsn�SnowflakeDsnc@
s|eZ
dZUd
ZdZded<dZded<dZded<dZd	ed
<dZ	ded<dZ
d	ed<ddd�Zeddd��
Z
ddd�ZdS)r+a�
Url constraints.

    Attributes:
        max_length: The maximum length of the url. Defaults to `None`.
        allowed_schemes: The allowed schemes. Defaults to `None`.
        host_required: Whether the host is required. Defaults to `None`.
        default_host: The default host. Defaults to `None`.
        default_port: The default port. Defaults to `None`.
        default_path: The default path. Defaults to `None`.
    N�
int | None�
max_lengthzlist[str] | None�allowed_schemeszbool | None�
host_required�
str | None�default_host�default_port�default_path�return�intc

C
s2t|j
|jdu
r
t|j�
n
d|j|j|j|jf�
S�
N)�hashr>r?�tupler@rBrCrD�
�self�rL�</usr/local/lib/python3.10/dist-packages/pydantic/networks.py�__hash__Zs





��zUrlConstraints.__hash__�dict[str, Any]c


s��
fd
d�t��
D�
S)zeFetch a key / value mapping of constraints to values that are not None. Used for core schema updates.c

s(i|]}
t�|
j
��
du
r|
j
�
�qSrG)�getattr�name)�.0�field�rK�valuerLrM�
<dictcomp>is(z6UrlConstraints.defined_constraints.<locals>.<dictcomp>rrJrLrTrM�defined_constraintsfsz"UrlConstraints.defined_constraints�sourcer�handlerr�core_schema.CoreSchemacC
sd||
�
}|d
dkr|dn
|}|d
dv
}r"td|�d�dd��
|j
��D]\}}|||<q'|S)	N�type�
function-wrap�schema)�urlzmulti-host-urlz"'UrlConstraints' cannot annotate 'z'.zinvalid-annotated-type)
�code)rrW�items)rKrXrYr]�schema_to_mutate�annotated_type�constraint_key�constraint_valuerLrLrM�__get_pydantic_core_schema__ks



�


z+UrlConstraints.__get_pydantic_core_schema__�rErF)rErO)rXrrYrrErZ)�__name__�
__module__�__qualname__�__doc__r>�__annotations__r?r@rBrCrDrN�propertyrWrerLrLrLrMr+Fs







r+c@
s|
eZ
dZUe�Zd
ed<ded<d^d	d
�Zed_dd
��
Zed`dd��
Z	ed`dd��
Z
ed`dd��
Zd`dd�Zedadd��
Z
ed`dd��
Zed`dd��
Zdbdd �Zed`d!d"��
Zd_d#d$�Zd_d%d&�Zd_d'd(�Zdcd,d-�Zddd1d2�Zddd3d4�Zddd5d6�Zddd7d8�Zddd9d:�Zded<d=�Zded>d?�Zed@d@d@d@d@d@dA�dfdJdK��
ZedgdOdP��
ZedhdVdW��
Z edid[d\��
Z!e"e#j$e#�%�d]�
�
Z&d@S)j�_BaseUrl�ClassVar[UrlConstraints]�_constraints�_CoreUrl�_urlr^�str | _CoreUrl | _BaseUrlrE�NonecC
�t|j
�
�|
�
j|_dSrG��_build_type_adapter�	__class__�validate_pythonrq�rKr^rLrLrM�__init__�
z_BaseUrl.__init__�strc


C
�|jj
S)
zoThe scheme part of the URL.

        e.g. `https` in `https://user:pass@host:port/path?query#fragment`
        �rq�schemerJrLrLrMr��z_BaseUrl.schemerAc


C
r})
z{The username part of the URL, or `None`.

        e.g. `user` in `https://user:pass@host:port/path?query#fragment`
        )rq�usernamerJrLrLrMr��r�z_BaseUrl.usernamec


C
r})
z{The password part of the URL, or `None`.

        e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
        )rq�passwordrJrLrLrMr��r�z_BaseUrl.passwordc


C
r})
u�The host part of the URL, or `None`.

        If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
        `host` will be `xn--9aaa.com`
        �rq�hostrJrLrLrMr��sz
_BaseUrl.hostc

C
�
|j�
�S)
u/
The host part of the URL as a unicode string, or `None`.

        e.g. `host` in `https://user:pass@host:port/path?query#fragment`

        If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
        `unicode_host()` will be `£££.com`
        )rq�unicode_hostrJrLrLrMr��s
z_BaseUrl.unicode_hostr=c


C
r})
zwThe port part of the URL, or `None`.

        e.g. `port` in `https://user:pass@host:port/path?query#fragment`
        )rq�portrJrLrLrMr��r�z
_BaseUrl.portc


C
r})
zxThe path part of the URL, or `None`.

        e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
        �rq�pathrJrLrLrMr��r�z
_BaseUrl.pathc


C
r})
zyThe query part of the URL, or `None`.

        e.g. `query` in `https://user:pass@host:port/path?query#fragment`
        �rq�queryrJrLrLrMr��r�z_BaseUrl.query�list[tuple[str, str]]c

C
r�)
z�The query part of the URL as a list of key-value pairs.

        e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
        �rq�query_paramsrJrLrLrMr���
z_BaseUrl.query_paramsc


C
r})
zThe fragment part of the URL, or `None`.

        e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
        �rq�fragmentrJrLrLrMr��r�z_BaseUrl.fragmentc

C
r�)
u
The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.

        If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
        `unicode_string()` will be `https://£££.com`
        �rq�unicode_stringrJrLrLrMr��s
z_BaseUrl.unicode_stringc

C
�
t|j
�
S�
zDThe URL as a string, this will punycode encode the host if required.�r|rqrJrLrLrM�__str__��
z_BaseUrl.__str__c

C
�|jj
�d
t|j�
�d�S�N�
(�
)�rwrgr|rqrJrLrLrM�__repr__��
z_BaseUrl.__repr__�memo�dictrcC
�|�|j
�
SrG�rwrq�rKr�rLrLrM�__deepcopy__��
z_BaseUrl.__deepcopy__�otherr�boolcC
�|j|
juo|j
|
j
kSrGr��rKr�rLrLrM�__eq__�r{z_BaseUrl.__eq__cC
s|j|
juo|j
|
j
kSrGr�r�rLrLrM�__lt__�r{z_BaseUrl.__lt__cC
s|j|
juo|j
|
j
kSrGr�r�rLrLrM�__gt__�r{z_BaseUrl.__gt__cC
s|j|
juo|j
|
j
k
SrGr�r�rLrLrM�__le__�r{z_BaseUrl.__le__cC
s|j|
juo|j
|
j
kSrGr�r�rLrLrM�__ge__�r{z_BaseUrl.__ge__rFc

C
r�rG�rHrqrJrLrLrMrN��

z_BaseUrl.__hash__c

C
�tt
|j�
�
SrG��lenr|rqrJrLrLrM�__len__��
z_BaseUrl.__len__N)r�r�r�r�r�r�rr�r�r�r�r�r�r�c
	C
s|tj
|
|||||||d
��
S)a�Build a new `Url` instance from its component parts.

        Args:
            scheme: The scheme part of the URL.
            username: The username part of the URL, or omit for no username.
            password: The password part of the URL, or omit for no password.
            host: The host part of the URL.
            port: The port part of the URL, or omit for no port.
            path: The path part of the URL, or omit for no path.
            query: The query part of the URL, or omit for no query.
            fragment: The fragment part of the URL, or omit for no fragment.

        Returns:
            An instance of URL
        )rr�r�r�r�r�r�r�)rp�build)	�clsrr�r�r�r�r�r�r�rLrLrMr��s








��z_BaseUrl.build�info�core_schema.SerializationInfo�
str | SelfcC
�@t|
|�st
d
|�dt|
�
�d|
�d��
�
|jdkrt|
�
S|
S�Nz
Expected `z` but got `z` with value `'z-'` - serialized value may not be as expected.�json��
isinstancerr[�moder|�r�r^r�rLrLrM�
serialize_url$
�


�


z_BaseUrl.serialize_urlrX�type[_BaseUrl]rYrrZc
�:�f
d
d�}tj
|tjdi|jj�
�
tj|jddd�d�S)Nc
�<t|��r|St|t
�rt|�
}|
|�
}����
}||_|SrG)r�rmr|�__new__rq��
v�
h�core_url�instance�
rXrLrM�wrap_val2
�










z7_BaseUrl.__get_pydantic_core_schema__.<locals>.wrap_valT�always��info_arg�	when_used�r]�
serializationrL)r�no_info_wrap_validator_function�
url_schemarorW�$plain_serializer_function_ser_schemar��r�rXrYr�rLr�rMre.
�




��z%_BaseUrl.__get_pydantic_core_schema__r�._schema_generation_shared.GetJsonSchemaHandlerr cC
� |
d
dkr
|
dn
|
}||�
S�Nr[r\r]rL�r�rrY�inner_schemarLrLrM�__get_pydantic_json_schema__D
�
z%_BaseUrl.__get_pydantic_json_schema__�
r�)r^rrrErs�rEr|�rErA)rEr=�rEr��r�r�rEr�r�rrEr�rf)rr|r�rAr�rAr�r|r�r=r�rAr�rAr�rArEr�r^rr�r�rEr�)rXr�rYrrErZ�rrZrYr�rEr )'rgrhrir+rorkrzrlrr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rNr��classmethodr�r�rer�rr�
any_schema�to_string_ser_schema�__pydantic_serializer__rLrLrLrMrm{s`





























�(
	

rmc
@
s 
eZ
dZUe�Zd
ed<ded<dQd	d
�ZedRdd
��
ZedSdd��
Z	edSdd��
Z
dTdd�ZedSdd��
ZdUdd�Z
dRdd�ZdRdd�ZdRdd �ZdVd$d%�ZdWd)d*�ZdXd,d-�ZdXd.d/�Zed0d0d0d0d0d0d0d0d1�dYd=d>��
ZedZdBdC��
Zed[dIdJ��
Zed\dNdO��
Zeeje��dP�
�
Zd0S)]�_BaseMultiHostUrlrnro�_CoreMultiHostUrlrqr^�+str | _CoreMultiHostUrl | _BaseMultiHostUrlrErscC
rtrGruryrLrLrMrzT
r{z_BaseMultiHostUrl.__init__r|c


C
r})
zkThe scheme part of the URL.

        e.g. `https` in `https://foo.com,bar.com/path?query#fragment`
        r~rJrLrLrMrW
r�z_BaseMultiHostUrl.schemerAc


C
r})
ztThe path part of the URL, or `None`.

        e.g. `/path` in `https://foo.com,bar.com/path?query#fragment`
        r�rJrLrLrMr�_
r�z_BaseMultiHostUrl.pathc


C
r})
zuThe query part of the URL, or `None`.

        e.g. `query` in `https://foo.com,bar.com/path?query#fragment`
        r�rJrLrLrMr�g
r�z_BaseMultiHostUrl.queryr�c

C
r�)
z�The query part of the URL as a list of key-value pairs.

        e.g. `[('foo', 'bar')]` in `https://foo.com,bar.com/path?query#fragment`
        r�rJrLrLrMr�o
r�z_BaseMultiHostUrl.query_paramsc


C
r})
z{The fragment part of the URL, or `None`.

        e.g. `fragment` in `https://foo.com,bar.com/path?query#fragment`
        r�rJrLrLrMr�v
r�z_BaseMultiHostUrl.fragment�list[MultiHostHost]c

C
r�)
a%The hosts of the `MultiHostUrl` as [`MultiHostHost`][pydantic_core.MultiHostHost] typed dicts.

        ```python
        from pydantic_core import MultiHostUrl

        mhu = MultiHostUrl('https://foo.com:123,foo:bar@bar.com/path')
        print(mhu.hosts())
        """
        [
            {'username': None, 'password': None, 'host': 'foo.com', 'port': 123},
            {'username': 'foo', 'password': 'bar', 'host': 'bar.com', 'port': 443}
        ]
        ```
        Returns:
            A list of dicts, each representing a host.
        )rq�hostsrJrLrLrMr�~
s
z_BaseMultiHostUrl.hostsc

C
r�)
zXThe URL as a unicode string, unlike `__str__()` this will not punycode encode the hosts.r�rJrLrLrMr��
r�z _BaseMultiHostUrl.unicode_stringc

C
r�r�r�rJrLrLrMr��
r�z_BaseMultiHostUrl.__str__c

C
r�r�r�rJrLrLrMr��
r�z_BaseMultiHostUrl.__repr__r�r�rcC
r�rGr�r�rLrLrMr��
r�z_BaseMultiHostUrl.__deepcopy__r�rr�cC
r�rGr�r�rLrLrMr��
r{z_BaseMultiHostUrl.__eq__rFc

C
r�rGr�rJrLrLrMrN�
r�z_BaseMultiHostUrl.__hash__c

C
r�rGr�rJrLrLrMr��
r�z_BaseMultiHostUrl.__len__N)r�r�r�r�r�r�r�r�rr��list[MultiHostHost] | Noner�r�r�r�r=r�r�r�c
	
C
s |tj
|
||||||||	d
�	�
S)aBuild a new `MultiHostUrl` instance from its component parts.

        This method takes either `hosts` - a list of `MultiHostHost` typed dicts, or the individual components
        `username`, `password`, `host` and `port`.

        Args:
            scheme: The scheme part of the URL.
            hosts: Multiple hosts to build the URL from.
            username: The username part of the URL.
            password: The password part of the URL.
            host: The host part of the URL.
            port: The port part of the URL.
            path: The path part of the URL.
            query: The query part of the URL, or omit for no query.
            fragment: The fragment part of the URL, or omit for no fragment.

        Returns:
            An instance of `MultiHostUrl`
        )	rr�r�r�r�r�r�r�r�)r�r�)
r�rr�r�r�r�r�r�r�r�rLrLrMr��
s!









��z_BaseMultiHostUrl.buildr�r�r�cC
r�r�r�r�rLrLrMr��
r�z_BaseMultiHostUrl.serialize_urlrX�type[_BaseMultiHostUrl]rYrrZc
r�)Nc
r�rG)r�r�r|r�rqr�r�rLrMr��
r�z@_BaseMultiHostUrl.__get_pydantic_core_schema__.<locals>.wrap_valTr�r�r�rL)rr��multi_host_url_schemarorWr�r�r�rLr�rMre�
r�z._BaseMultiHostUrl.__get_pydantic_core_schema__rr�r cC
r�r�rLr�rLrLrMr��
r�z._BaseMultiHostUrl.__get_pydantic_json_schema__r�)r^r�rErsr�r�r�)rEr�r�r�rf)rr|r�r�r�rAr�rAr�rAr�r=r�rAr�rAr�rArErr�)rXr�rYrrErZr�)rgrhrir+rorkrzrlrr�r�r�r�r�r�r�r�r�r�rNr�r�r�r�rer�rrr�r�r�rLrLrLrMr�P
sL























�.
	

r�r��"type[_BaseUrl | _BaseMultiHostUrl]rEr"c

C
st|�
SrGr!)
r�rLrLrMrv�rvc
@
seZ
dZd
ZdS)r$a�Base type for all URLs.

    * Any scheme allowed
    * Top-level domain (TLD) not required
    * Host not required

    Assuming an input URL of `http://samuel:pass@example.com:8000/the/path/?query=here#fragment=is;this=bit`,
    the types export the following properties:

    - `scheme`: the URL scheme (`http`), always set.
    - `host`: the URL host (`example.com`).
    - `username`: optional username if included (`samuel`).
    - `password`: optional password if included (`pass`).
    - `port`: optional port (`8000`).
    - `path`: optional path (`/the/path/`).
    - `query`: optional URL query (for example, `GET` arguments or "search string", such as `query=here`).
    - `fragment`: optional fragment (`fragment=is;this=bit`).
    N)rgrhrirjrLrLrLrMr$s
r$c@
�eZ
dZd
Zeddgd�
ZdS)r%zcA type that will accept any http or https URL.

    * TLD not required
    * Host not required
    �http�https�
r?N�rgrhrirjr+rorLrLrLrMr%!�
r%c@
� eZ
dZd
Zedddgd�ZdS)r(u�
A type that will accept any http or https URL.

    * TLD not required
    * Host not required
    * Max length 2083

    ```python
    from pydantic import BaseModel, HttpUrl, ValidationError

    class MyModel(BaseModel):
        url: HttpUrl

    m = MyModel(url='http://www.example.com')  # (1)!
    print(m.url)
    #> http://www.example.com/

    try:
        MyModel(url='ftp://invalid.url')
    except ValidationError as e:
        print(e)
        '''
        1 validation error for MyModel
        url
          URL scheme should be 'http' or 'https' [type=url_scheme, input_value='ftp://invalid.url', input_type=str]
        '''

    try:
        MyModel(url='not a url')
    except ValidationError as e:
        print(e)
        '''
        1 validation error for MyModel
        url
          Input should be a valid URL, relative URL without a base [type=url_parsing, input_value='not a url', input_type=str]
        '''
    ```

    1. Note: mypy would prefer `m = MyModel(url=HttpUrl('http://www.example.com'))`, but Pydantic will convert the string to an HttpUrl instance anyway.

    "International domains" (e.g. a URL where the host or TLD includes non-ascii characters) will be encoded via
    [punycode](https://en.wikipedia.org/wiki/Punycode) (see
    [this article](https://www.xudongz.com/blog/2017/idn-phishing/) for a good description of why this is important):

    ```python
    from pydantic import BaseModel, HttpUrl

    class MyModel(BaseModel):
        url: HttpUrl

    m1 = MyModel(url='http://puny£code.com')
    print(m1.url)
    #> http://xn--punycode-eja.com/
    m2 = MyModel(url='https://www.аррӏе.com/')
    print(m2.url)
    #> https://www.xn--80ak6aa92e.com/
    m3 = MyModel(url='https://www.example.珠宝/')
    print(m3.url)
    #> https://www.example.xn--pbt977c/
    ```


    !!! warning "Underscores in Hostnames"
        In Pydantic, underscores are allowed in all parts of a domain except the TLD.
        Technically this might be wrong - in theory the hostname cannot have underscores, but subdomains can.

        To explain this; consider the following two cases:

        - `exam_ple.co.uk`: the hostname is `exam_ple`, which should not be allowed since it contains an underscore.
        - `foo_bar.example.com` the hostname is `example`, which should be allowed since the underscore is in the subdomain.

        Without having an exhaustive list of TLDs, it would be impossible to differentiate between these two. Therefore
        underscores are allowed, but you can always do further validation in a validator if desired.

        Also, Chrome, Firefox, and Safari all currently accept `http://exam_ple.com` as a URL, so we're in good
        (or at least big) company.
    �#r�r��r>r?Nr�rLrLrLrMr(+s
Mr(c@
r�)r*z_A type that will accept any ws or wss URL.

    * TLD not required
    * Host not required
    �ws�wssr�Nr�rLrLrLrMr*|r�r*c@
r�)r)zuA type that will accept any ws or wss URL.

    * TLD not required
    * Host not required
    * Max length 2083
    r
r
r
r

Nr�rLrLrLrMr)��
r)c@
�eZ
dZd
Zedg
d�
ZdS)r&zCA type that will accept any file URL.

    * Host not required
    �filer�Nr�rLrLrLrMr&�s
r&c@
r
)r'zUA type that will accept ftp URL.

    * TLD not required
    * Host not required
    �ftpr�Nr�rLrLrLrMr'�s
r'c@
�.eZ
dZd
Zedgd�
d�Zed
dd��
Zd	S)r1a:A type that will accept any Postgres DSN.

    * User info required
    * TLD not required
    * Host required
    * Supports multiple hosts

    If further validation is required, these properties can be used by validators to enforce specific behaviour:

    ```python
    from pydantic import (
        BaseModel,
        HttpUrl,
        PostgresDsn,
        ValidationError,
        field_validator,
    )

    class MyModel(BaseModel):
        url: HttpUrl

    m = MyModel(url='http://www.example.com')

    # the repr() method for a url will display all properties of the url
    print(repr(m.url))
    #> HttpUrl('http://www.example.com/')
    print(m.url.scheme)
    #> http
    print(m.url.host)
    #> www.example.com
    print(m.url.port)
    #> 80

    class MyDatabaseModel(BaseModel):
        db: PostgresDsn

        @field_validator('db')
        def check_db_name(cls, v):
            assert v.path and len(v.path) > 1, 'database must be provided'
            return v

    m = MyDatabaseModel(db='postgres://user:pass@localhost:5432/foobar')
    print(m.db)
    #> postgres://user:pass@localhost:5432/foobar

    try:
        MyDatabaseModel(db='postgres://user:pass@localhost:5432')
    except ValidationError as e:
        print(e)
        '''
        1 validation error for MyDatabaseModel
        db
          Assertion failed, database must be provided
        assert (None)
         +  where None = PostgresDsn('postgres://user:pass@localhost:5432').path [type=assertion_error, input_value='postgres://user:pass@localhost:5432', input_type=str]
        '''
    ```
    T)	�postgres�
postgresqlzpostgresql+asyncpgzpostgresql+pg8000zpostgresql+psycopgzpostgresql+psycopg2zpostgresql+psycopg2cffizpostgresql+py-postgresqlzpostgresql+pygresql�r@r?rEr|c


C
r}�
zThe required URL host.r�rJrLrLrMr���zPostgresDsn.hostNr��rgrhrirjr+rorlr�rLrLrLrMr1�s
;

�
r1c@
r
)r2ztA type that will accept any Cockroach DSN.

    * User info required
    * TLD not required
    * Host required
    T)�cockroachdbzcockroachdb+psycopg2zcockroachdb+asyncpgr
rEr|c


C
r}r
r�rJrLrLrMr�r

zCockroachDsn.hostNr�r
rLrLrLrMr2�s


�	
r2c@
r�)r3zsA type that will accept any AMQP DSN.

    * User info required
    * TLD not required
    * Host not required
    �amqp�amqpsr�Nr�rLrLrLrMr3s
r3c@
s4eZ
dZd
Zeddgddddd�Zeddd��
Zd
S)r4z�A type that will accept any Redis DSN.

    * User info required
    * TLD not required
    * Host required (e.g., `rediss://:pass@localhost`)
    �redis�rediss�	localhosti�z/0T)r?rBrCrDr@rEr|c


C
r}r
r�rJrLrLrMr�'r

z
RedisDsn.hostNr�r
rLrLrLrMr4s





�
r4c@
s eZ
dZd
Zeddgdd�ZdS)r5z�A type that will accept any MongoDB DSN.

    * User info not required
    * Database name not required
    * Port not required
    * User info may be passed without user part (e.g., `mongodb://mongodb0.example.com:27017`).
    �mongodbzmongodb+srvi�i�r?rCNr�rLrLrLrMr5-s
r5c@
s eZ
dZd
Zedg
ddd�ZdS)r6ztA type that will accept any Kafka DSN.

    * User info required
    * TLD not required
    * Host not required
    �kafkar
i�#�r?rBrCNr�rLrLrLrMr69r
r6c@
�"eZ
dZd
Zegd�
ddd�ZdS)r7aL
A type that will accept any NATS DSN.

    NATS is a connective technology built for the ever increasingly hyper-connected world.
    It is a single technology that enables applications to securely communicate across
    any combination of cloud vendors, on-premise, edge, web and mobile, and devices.
    More: https://nats.io
    )�nats�tlsr
r
r
i~r
Nr�rLrLrLrMr7Ds




�r7c@
r
)r9ztA type that will accept any MySQL DSN.

    * User info required
    * TLD not required
    * Host not required
    )�mysqlzmysql+mysqlconnectorzmysql+aiomysqlz
mysql+asyncmyz
mysql+mysqldbz
mysql+pymysqlz
mysql+cymysqlzmysql+pyodbc��T)r?rCr@Nr�rLrLrLrMr9Rs




�r9c@
s eZ
dZd
Zegd�
dd�ZdS)r:zvA type that will accept any MariaDB DSN.

    * User info required
    * TLD not required
    * Host not required
    )�mariadbzmariadb+mariadbconnectorzmariadb+pymysqlr
r
Nr�rLrLrLrMr:js



�r:c@
s"eZ
dZd
Zeddgddd�ZdS)r;zyA type that will accept any ClickHouse DSN.

    * User info required
    * TLD not required
    * Host not required
    zclickhouse+nativezclickhouse+asynchr
i(#r
Nr�rLrLrLrMr;xs




�r;c@
s,eZ
dZd
Zedg
dd�Zed
dd��
Zd	S)r<ztA type that will accept any Snowflake DSN.

    * User info required
    * TLD not required
    * Host required
    �	snowflakeT)r?r@rEr|c


C
r}r
r�rJrLrLrMr��r

zSnowflakeDsn.hostNr�r
rLrLrLrMr<�s


�
r<rsc

C
sRzd
dlaWnt
y
}
zt
d�
|�d}~w
wtd�
�d�
d
dks't
d�
�
dS)Nr
zCemail-validator is not installed, run `pip install pydantic[email]`zemail-validator�
.�
2zKemail-validator version >= 2.0 required, run pip install -U email-validator)�email_validator�ImportErrorr�	partition)
�
erLrLrM�import_email_validator�s



��
�r&
.c@
s:eZ
dZd
Zeddd	��
Zeddd��
Zeddd��
ZdS)r,a
        Info:
            To use this type, you need to install the optional
            [`email-validator`](https://github.com/JoshData/python-email-validator) package:

            ```bash
            pip install email-validator
            ```

        Validate email addresses.

        ```python
        from pydantic import BaseModel, EmailStr

        class Model(BaseModel):
            email: EmailStr

        print(Model(email='contact@mail.com'))
        #> email='contact@mail.com'
        ```
        �_source�	type[Any]�_handlerrrErZcC
st�
t
�|jt
���SrG)r&
r� no_info_after_validator_function�	_validate�
str_schema�r�r'
r)
rLrLrMre�s
z%EmailStr.__get_pydantic_core_schema__rrYr�r cC
�||
�
}|jd
dd�
|S)N�string�email�r[�format�
�update�r�rrY�field_schemarLrLrMr���

z%EmailStr.__get_pydantic_json_schema__�input_valuer|cC
st|
�
d
S)Nr)
r8�r�r8
rLrLrMr+
�szEmailStr._validateN�r'
r(
r)
rrErZr�)r8
r|rEr|)rgrhrirjr�rer�r+
rLrLrLrMr,�s



r,c@
s\eZ
dZd
ZdZd#dd�Zd$dd
�Zed%dd��
Zed&dd��
Z	ed'dd��
Z
d(d d!�Zd"S))r-a�
    Info:
        To use this type, you need to install the optional
        [`email-validator`](https://github.com/JoshData/python-email-validator) package:

        ```bash
        pip install email-validator
        ```

    Validate a name and email address combination, as specified by
    [RFC 5322](https://datatracker.ietf.org/doc/html/rfc5322#section-3.4).

    The `NameEmail` has two properties: `name` and `email`.
    In case the `name` is not provided, it's inferred from the email address.

    ```python
    from pydantic import BaseModel, NameEmail

    class User(BaseModel):
        email: NameEmail

    user = User(email='Fred Bloggs <fred.bloggs@example.com>')
    print(user.email)
    #> Fred Bloggs <fred.bloggs@example.com>
    print(user.email.name)
    #> Fred Bloggs

    user = User(email='fred.bloggs@example.com')
    print(user.email)
    #> fred.bloggs <fred.bloggs@example.com>
    print(user.email.name)
    #> fred.bloggs
    ```
    �rQr0
rQr|r0
cC
s|
|_||_
dSrGr;
)rKrQr0
rLrLrMrz�s


zNameEmail.__init__r�rrEr�cC
s"t|
t
�o|j|jf|
j|
jfkSrG)r�r-rQr0
r�rLrLrMr��s"
zNameEmail.__eq__rrZrYr�r cC
r.
)Nr/
z
name-emailr1
r3
r5
rLrLrMr�r7
z&NameEmail.__get_pydantic_json_schema__r'
r(
r)
rc
C
sBt�
t
�|jt
jt
��t
jt
�|�
t
��gd
dd�t
��d��S)N�name_email_typezInput is not a valid NameEmail)�custom_error_type�custom_error_message)�json_schema�
python_schemar�)	r&
rr*
r+
�json_or_python_schemar,
�union_schema�is_instance_schemar�r-
rLrLrMre
s






���z&NameEmail.__get_pydantic_core_schema__r8
�
Self | strrcC
s$t|
t
�rt|
�
\}}|||�S|
SrG)r�r|r8)r�r8
rQr0
rLrLrMr+
s



zNameEmail._validatec

C
s4d
|jvrd|j�d|j
�d�S|j�d|j
�d�S)N�
@�
"z" <�
>z <r;
rJrLrLrMr�'s


zNameEmail.__str__N)rQr|r0
r|r�r�r:
)r8
rD
rErr�)rgrhrirj�	__slots__rzr�r�r�rer+
r�rLrLrLrMr-�s
#




r-zIPv4Address | IPv6Address�IPvAnyAddressTypezIPv4Interface | IPv6Interface�IPvAnyInterfaceTypezIPv4Network | IPv6Network�IPvAnyNetworkTypec@
�HeZ
dZd
ZdZddd�Zeddd��
Zeddd��
Zeddd��
Z	dS)r.a�Validate an IPv4 or IPv6 address.

        ```python
        from pydantic import BaseModel
        from pydantic.networks import IPvAnyAddress

        class IpModel(BaseModel):
            ip: IPvAnyAddress

        print(IpModel(ip='127.0.0.1'))
        #> ip=IPv4Address('127.0.0.1')

        try:
            IpModel(ip='http://www.example.com')
        except ValueError as e:
            print(e.errors())
            '''
            [
                {
                    'type': 'ip_any_address',
                    'loc': ('ip',),
                    'msg': 'value is not a valid IPv4 or IPv6 address',
                    'input': 'http://www.example.com',
                }
            ]
            '''
        ```
        rLrUrrErI
cC
�Bzt|
�
WSt
y


Yn
wzt|
�
WSt
y 


td
d��
w)z!Validate an IPv4 or IPv6 address.�ip_any_addressz)value is not a valid IPv4 or IPv6 address)r�
ValueErrorr
r�r�rUrLrLrMr�X�



�




�zIPvAnyAddress.__new__rrZrYr�r cC
�i}|jd
dd�
|S)Nr/
�
ipvanyaddressr1
r3
r5
rLrLrMr�d�

z*IPvAnyAddress.__get_pydantic_json_schema__r'
r(
r)
rcC
�tj
|jt��d
�S�Nr��r� no_info_plain_validator_functionr+
r�r-
rLrLrMrel�

�z*IPvAnyAddress.__get_pydantic_core_schema__r8
cC
�||
�
SrGrLr9
rLrLrMr+
vr�zIPvAnyAddress._validateN)rUrrErI
r�r:
)r8
rrErI
�
rgrhrirjrH
r�r�r�rer+
rLrLrLrMr.8s



	
r.c@
rL
)r/�#Validate an IPv4 or IPv6 interface.rLrUr#rErJ
cC
rM
)r\
�ip_any_interfacez+value is not a valid IPv4 or IPv6 interface)rrO
rrrP
rLrLrMr�rQ
zIPvAnyInterface.__new__rrZrYr�r cC
rR
)Nr/
�ipvanyinterfacer1
r3
r5
rLrLrMr��rT
z,IPvAnyInterface.__get_pydantic_json_schema__r'
r(
r)
rcC
rU
rV
rW
r-
rLrLrMre�rY
z,IPvAnyInterface.__get_pydantic_core_schema__r8
cC
rZ
rGrLr9
rLrLrMr+
�r�zIPvAnyInterface._validateN)rUr#rErJ
r�r:
)r8
r#rErJ
r[
rLrLrLrMr/zs



	
r/c@
rL
)r0�!Validate an IPv4 or IPv6 network.rLrUr#rErK
cC
rM
)r_
�ip_any_networkz)value is not a valid IPv4 or IPv6 network)r	rO
rrrP
rLrLrMr��s



�




�zIPvAnyNetwork.__new__rrZrYr�r cC
rR
)Nr/
�
ipvanynetworkr1
r3
r5
rLrLrMr��rT
z*IPvAnyNetwork.__get_pydantic_json_schema__r'
r(
r)
rcC
rU
rV
rW
r-
rLrLrMre�rY
z*IPvAnyNetwork.__get_pydantic_core_schema__r8
cC
rZ
rGrLr9
rLrLrMr+
�r�zIPvAnyNetwork._validateN)rUr#rErK
r�r:
)r8
r#rErK
r[
rLrLrLrMr0�s



	
r0�re.Pattern[str]c	C
s<d
}d|�d|�d�}
d}d}t�
d|
�d|�d	|�d
��
S)Nz[\w!#$%&\'*+\-/=?^_`{|}~]z((?:z+\s+)*z+)z"((?:[^"]|\")+)"z<(.+)>z\s*(?:�
|z)?\s*z\s*)�re�compile)�
name_chars�unquoted_name_group�quoted_name_group�email_grouprLrLrM�_build_pretty_email_regex�s





rj
irUr|�tuple[str, str]c

C
s�td
urt
�
t|�
tkrtddddt�d�i
��
t�|�
}
d
}|
r-|
��\}}}|p,|}|��}z	tj	|dd�}Wntj
yU
}
ztdddt|jd	�
i
�|�d
}~w
w|j
}|d
u
s_J�
|pc|j}||fS)
aUEmail address validation using [email-validator](https://pypi.org/project/email-validator/).

    Returns:
        A tuple containing the local part of the email (or the name for "pretty" email addresses)
            and the normalized email.

    Raises:
        PydanticCustomError: If the email is invalid.

    Note:
        Note that:

        * Raw IP address (literal) domain parts are not allowed.
        * `"John Doe <local_part@domain.com>"` style "pretty" email addresses are processed.
        * Spaces are striped from the beginning and end of addresses, but no error is raised.
    N�value_errorz,value is not a valid email address: {reason}�reasonzLength must not exceed z charactersF)
�check_deliverabilityr
)r"
r&
r��MAX_EMAIL_LENGTHr�pretty_email_regex�	fullmatch�groups�stripr8�EmailNotValidErrorr|�args�
normalized�
local_part)rU�
mrQ�
unquoted_name�quoted_namer0
�partsr%
rLrLrMr8�s8




�








����



r8)r�r�rEr")rErs)rErb
)rUr|rErk
)^rj�
__future__r�_annotations�dataclasses�_dataclassesrd
r�	functoolsr�importlib.metadatar�	ipaddressrrr	r
rr�typingr
rr�
pydantic_corerrrrrrr�rrp�typing_extensionsrrr�pydantic.errorsr�	_internalrr�
_migrationr�annotated_handlersrr?
r �type_adapterr"r"
r#rk�__all__�	dataclassr+rmr�rvr$r%r(r*r)r&r'r1r2r3r4r5r6r7r9r:r;r<r&
r|r,�Representationr-rI
rJ
rK
r.r/r0rj
rp
ro
r8rg�__getattr__rLrLrLrM�<module>
s�



 









4V4

Q
	
Q


-Y




B'
*

0