,h8UdZddlmZddlZddlZddlmZddlm Z ddl m Z ddl m Z mZmZmZmZmZddlmZmZmZmZdd lmZmZmZmZmZdd lmZdd lm Z!dd l"m#Z#m$Z$dd l%m&Z&ddl'm(Z(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1er ddl2a2dZ3de4d<nda2gdZ5ejlGddZ7GddZ8GddZ9e dXdZ:Gdd e8Z;Gd!d"e;Z<Gd#d$e;Z=Gd%d&e;Z>Gd'd(e;Z?Gd)d*e;Z@Gd+d,e;ZAGd-d.e9ZBGd/d0e;ZCGd1d2e;ZDGd3d4e;ZEGd5d6e9ZFGd7d8e;ZGGd9d:e9ZHGd;de;ZJGd?d@e;ZKGdAdBe;ZLdYdCZMereeNdDfZOn GdEdFZOGdGdHe(jZQdIZRde4dJ<dKZSde4dL<dMZTde4dN<ereRZUeSZVeTZWnGdOdPZUGdQdRZVGdSdTZWdZdUZXeXZYdVZZ d[dWZ[e+e\Z]y)\zEThe networks module contains types for common network-related fields.) annotationsN)fields) lru_cache)version) IPv4Address IPv4Interface IPv4Network IPv6Address IPv6Interface IPv6Network) TYPE_CHECKING AnnotatedAnyClassVar) MultiHostHostPydanticCustomError$PydanticSerializationUnexpectedValueSchemaSerializer core_schema) MultiHostUrl)Url)Self TypeAlias)PydanticUserError)_repr_schema_generation_shared)getattr_migration)GetCoreSchemaHandler)JsonSchemaValue TypeAdapterz7str | bytes | int | tuple[str | bytes | int, str | int]r NetworkType)AnyUrl AnyHttpUrlFileUrlFtpUrlHttpUrl WebsocketUrlAnyWebsocketUrlUrlConstraintsEmailStr NameEmail IPvAnyAddressIPvAnyInterface IPvAnyNetwork PostgresDsn CockroachDsnAmqpDsnRedisDsnMongoDsnKafkaDsnNatsDsnvalidate_emailMySQLDsn MariaDBDsn ClickHouseDsn SnowflakeDsnceZdZUdZdZded<dZded<dZded<dZd ed <dZ ded <dZ d ed <dd Z e ddZ ddZy)r+aUrl 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] | Noneallowed_schemesz bool | None host_required str | None default_host default_port default_pathct|j|jt|jnd|j|j |j |jfSN)hashr?r@tuplerArCrDrEselfs S/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/pydantic/networks.py__hash__zUrlConstraints.__hash__Zs[/3/C/C/Od**+UY""!!!!!!    ct|Dcic](}t||jx}|j|*c}Scc}w)zeFetch a key / value mapping of constraints to values that are not None. Used for core schema updates.)rgetattrname)rKfieldvalues rLdefined_constraintsz"UrlConstraints.defined_constraintsfs>06d|peQUW\WaWaIb@b?o E!ppps>>c||}|ddk(r|dn|}|ddvx}rtd|dd|jjD] \}}|||< |S) Ntype function-wrapschema)urlzmulti-host-urlz"'UrlConstraints' cannot annotate 'z'.zinvalid-annotated-type)code)rrTitems)rKsourcehandlerrXschema_to_mutateannotated_typeconstraint_keyconstraint_values rL__get_pydantic_core_schema__z+UrlConstraints.__get_pydantic_core_schema__ks 06f~/P6(+V\-f5=VV V> V#4^4DBGNf 150H0H0N0N0P @ ,N,/? ^ , @ rNreturnint)rdzdict[str, Any])r\rr]rrdcore_schema.CoreSchema)__name__ __module__ __qualname____doc__r?__annotations__r@rArCrDrErMpropertyrTrbrNrLr+r+Fsf "J !(,O%,!%M;%#L*##L*##L*#  qq rNr+ceZdZUeZded<ded<d#dZed$dZed%dZ ed%dZ ed%d Z d%d Z ed&d Z ed%d Zed%d Zd'dZed%dZd$dZd$dZd$dZd$dZd(dZd)dZd)dZd)dZd)dZd)dZd*dZd*dZeddddddd d+dZed,dZ e d-d Z!e d.d!Z"e#e$jJe$jL"Z'y)/_BaseUrlClassVar[UrlConstraints] _constraints_CoreUrl_urlcjt|jj|j|_yrG_build_type_adapter __class__validate_pythonrsrKrYs rL__init__z_BaseUrl.__init__#'7GGLQQ rNc.|jjS)zoThe scheme part of the URL. e.g. `https` in `https://user:pass@host:port/path?query#fragment` rsschemerJs rLr~z_BaseUrl.scheme yyrNc.|jjS)z{The username part of the URL, or `None`. e.g. `user` in `https://user:pass@host:port/path?query#fragment` )rsusernamerJs rLrz_BaseUrl.username yy!!!rNc.|jjS)z{The password part of the URL, or `None`. e.g. `pass` in `https://user:pass@host:port/path?query#fragment` )rspasswordrJs rLrz_BaseUrl.passwordrrNc.|jjS)uThe 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` rshostrJs rLrz _BaseUrl.hostsyy~~rNc6|jjS)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` )rs unicode_hostrJs rLrz_BaseUrl.unicode_hostsyy%%''rNc.|jjS)zwThe port part of the URL, or `None`. e.g. `port` in `https://user:pass@host:port/path?query#fragment` )rsportrJs rLrz _BaseUrl.port yy~~rNc.|jjS)zxThe path part of the URL, or `None`. e.g. `/path` in `https://user:pass@host:port/path?query#fragment` rspathrJs rLrz _BaseUrl.pathrrNc.|jjS)zyThe query part of the URL, or `None`. e.g. `query` in `https://user:pass@host:port/path?query#fragment` rsqueryrJs rLrz_BaseUrl.query yyrNc6|jjS)zThe 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` rs query_paramsrJs rLrz_BaseUrl.query_params yy%%''rNc.|jjS)zThe fragment part of the URL, or `None`. e.g. `fragment` in `https://user:pass@host:port/path?query#fragment` rsfragmentrJs rLrz_BaseUrl.fragmentrrNc6|jjS)uThe 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` rsunicode_stringrJs rLrz_BaseUrl.unicode_strings yy''))rNct|SzThe URL's encoded string representation via __str__(). This returns the punycode-encoded host version of the URL as a string. strrJs rLencoded_stringz_BaseUrl.encoded_string 4yrNc,t|jSzDThe URL as a string, this will punycode encode the host if required.rrsrJs rL__str__z_BaseUrl.__str__499~rNc`|jjdt|jdSN()rwrgrrsrJs rL__repr__z_BaseUrl.__repr__)..))*!C N+=Q??rNc8|j|jSrGrwrsrKmemos rL __deepcopy__z_BaseUrl.__deepcopy__~~dii((rNch|j|juxr|j|jk(SrGrrKothers rL__eq__z_BaseUrl.__eq__'~~0LTYY%**5LLrNch|j|juxr|j|jkSrGrrs rL__lt__z_BaseUrl.__lt__'~~0KTYY5KKrNch|j|juxr|j|jkDSrGrrs rL__gt__z_BaseUrl.__gt__rrNch|j|juxr|j|jkSrGrrs rL__le__z_BaseUrl.__le__rrNch|j|juxr|j|jk\SrGrrs rL__ge__z_BaseUrl.__ge__rrNc,t|jSrGrHrsrJs rLrMz_BaseUrl.__hash__DIIrNc>tt|jSrGlenrrsrJs rL__len__z_BaseUrl.__len__3tyy>""rNN)rrrrrrc H|tj||||||||S)aBuild 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 )r~rrrrrrr)rrbuild) clsr~rrrrrrrs rLrz_BaseUrl.builds58 NN!!!   rNc t||std|dt|d|d|jdk(r t |S|SNz Expected `z ` but got `z` with value `'z-'` - serialized value may not be as expected.json isinstancerrVmoderrrYinfos rL serialize_urlz_BaseUrl.serialize_url+R#s#6SET#YKseKxy  99 s8O rNc fd}tj|tjdi|jjtj |j ddS)Nct|r|St|tr t|}||}j}||_|SrG)rror__new__rsvhcore_urlinstancer\s rLwrap_valz7_BaseUrl.__get_pydantic_core_schema__..wrap_val9sH!V$!X&FtH~~f-H$HMOrNTalwaysinfo_arg when_usedrX serializationrm)rno_info_wrap_validator_function url_schemarqrT$plain_serializer_function_ser_schemarrr\r]rs ` rLrbz%_BaseUrl.__get_pydantic_core_schema__5sX :: ))QC,<,<,P,PQ%JJ!!DH  rNc0|ddk(r|dn|}||SNrVrWrXrmrrr] inner_schemas rL__get_pydantic_json_schema__z%_BaseUrl.__get_pydantic_json_schema__K( 1rdzlist[tuple[str, str]]rdictrdrrrrdboolrc)r~rrrBrrBrrrr>rrBrrBrrBrdrrYrrzcore_schema.SerializationInfordz str | Self)r\ztype[_BaseUrl]r]rrdrfrrfr]z._schema_generation_shared.GetJsonSchemaHandlerrdr )(rgrhrir+rqrkrzrlr~rrrrrrrrrrrrrrrrrrrrMr classmethodrrrbrrr any_schemato_string_ser_schema__pydantic_serializer__rmrNrLroro{s-;-=L*= NR  """"((""*@)MLLMM# $# #& &  &  &  & & & & &  & & P # .B   *%0%;i% %%//E{/E/ETtT_TtTtTv/wxrNroc eZdZUeZded<ded<ddZeddZeddZ eddZ dd Z edd Z dd Z dd Zdd ZddZddZd dZd!dZd"dZd"dZeddddddddd d#dZed$dZe d%dZe d&dZeej:ej<Zy)'_BaseMultiHostUrlrprq_CoreMultiHostUrlrscjt|jj|j|_yrGrurys rLrzz_BaseMultiHostUrl.__init__[r{rNc.|jjS)zkThe scheme part of the URL. e.g. `https` in `https://foo.com,bar.com/path?query#fragment` r}rJs rLr~z_BaseMultiHostUrl.scheme^rrNc.|jjS)ztThe path part of the URL, or `None`. e.g. `/path` in `https://foo.com,bar.com/path?query#fragment` rrJs rLrz_BaseMultiHostUrl.pathfrrNc.|jjS)zuThe query part of the URL, or `None`. e.g. `query` in `https://foo.com,bar.com/path?query#fragment` rrJs rLrz_BaseMultiHostUrl.querynrrNc6|jjS)zThe query part of the URL as a list of key-value pairs. e.g. `[('foo', 'bar')]` in `https://foo.com,bar.com/path?foo=bar#fragment` rrJs rLrz_BaseMultiHostUrl.query_paramsvrrNc.|jjS)z{The fragment part of the URL, or `None`. e.g. `fragment` in `https://foo.com,bar.com/path?query#fragment` rrJs rLrz_BaseMultiHostUrl.fragment}rrNc6|jjS)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. )rshostsrJs rLr z_BaseMultiHostUrl.hostss"yy  rNct|SrrrJs rLrz _BaseMultiHostUrl.encoded_stringrrNc6|jjS)zXThe URL as a unicode string, unlike `__str__()` this will not punycode encode the hosts.rrJs rLrz _BaseMultiHostUrl.unicode_stringsyy''))rNc,t|jSrrrJs rLrz_BaseMultiHostUrl.__str__rrNc`|jjdt|jdSrrrJs rLrz_BaseMultiHostUrl.__repr__rrNc8|j|jSrGrrs rLrz_BaseMultiHostUrl.__deepcopy__rrNch|j|juxr|j|jk(SrGrrs rLrz_BaseMultiHostUrl.__eq__rrNc,t|jSrGrrJs rLrMz_BaseMultiHostUrl.__hash__rrNc>tt|jSrGrrJs rLrz_BaseMultiHostUrl.__len__rrNN)r rrrrrrrc J|tj|||||||||  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` ) r~r rrrrrrr)rr) rr~r rrrrrrrs rLrz_BaseMultiHostUrl.builds;B  # #!!!   rNc t||std|dt|d|d|jdk(r t |S|Srrrs rLrz_BaseMultiHostUrl.serialize_urlrrNc fd}tj|tjdi|jjtj |j ddS)Nct|r|St|tr t|}||}j}||_|SrG)rrrrrsrs rLrz@_BaseMultiHostUrl.__get_pydantic_core_schema__..wrap_valsI!V$!./FtH~~f-H$HMOrNTrrrrm)rrmulti_host_url_schemarqrTrrrs ` rLrbz._BaseMultiHostUrl.__get_pydantic_core_schema__sX :: 44\s7G7G7[7[\%JJ!!DH  rNc0|ddk(r|dn|}||Srrmrs rLrz._BaseMultiHostUrl.__get_pydantic_json_schema__rrNr)rYz+str | _CoreMultiHostUrl | _BaseMultiHostUrlrdrrrr)rdzlist[MultiHostHost]rrrc)r~rr zlist[MultiHostHost] | NonerrBrrBrrBrr>rrBrrBrrBrdrr)r\ztype[_BaseMultiHostUrl]r]rrdrfr) rgrhrir+rqrkrzrlr~rrrrr rrrrrrrMrrrrrbrrrrrrrmrNrLrrWs-;-=L*= R  (""!&*@)M# -1## #, , * ,  ,  , , , , , ,  , , \ , 7K   *%0%;i% %%//E{/E/ETtT_TtTtTv/wxrNrct|SrGr!)rs rLrvrvs s rNceZdZdZy)r$aBase 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)rgrhrirjrmrNrLr$r$srNr$c&eZdZdZeddgZy)r%zcA type that will accept any http or https URL. * TLD not required * Host not required httphttpsr@Nrgrhrirjr+rqrmrNrLr%r%/s "672CDLrNr%c(eZdZdZedddgZy)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. #rrr?r@Nr rmrNrLr(r(9sKZ"TFGCTULrNr(c&eZdZdZeddgZy)r*z_A type that will accept any ws or wss URL. * TLD not required * Host not required wswssrNr rmrNrLr*r*s "4-@LrNr*c(eZdZdZedddgZy)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 rmrNrLr)r)s"TD%=QLrNr)c$eZdZdZedgZy)r&zCA type that will accept any file URL. * Host not required filerNr rmrNrLr&r&s "6(;LrNr&c$eZdZdZedgZy)r'zUA type that will accept ftp URL. * TLD not required * Host not required ftprNr rmrNrLr'r's "5':LrNr'c:eZdZdZedgdZeddZy)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+pygresqlrAr@c.|jjSzThe required URL host.rrJs rLrzPostgresDsn.hostyy~~rNNrrgrhrirjr+rqrlrrmrNrLr1r1s09v"   LrNr1c:eZdZdZedgdZeddZy)r2ztA type that will accept any Cockroach DSN. * User info required * TLD not required * Host required T) cockroachdbzcockroachdb+psycopg2zcockroachdb+asyncpgr/c.|jjSr1rrJs rLrzCockroachDsn.hostr2rNNrr3rmrNrLr2r2s/" LrNr2c&eZdZdZeddgZy)r3zsA type that will accept any AMQP DSN. * User info required * TLD not required * Host not required amqpamqpsrNr rmrNrLr3r3s"672CDLrNr3c@eZdZdZeddgddddZed d Zy ) r4zA type that will accept any Redis DSN. * User info required * TLD not required * Host required (e.g., `rediss://:pass@localhost`) redisrediss localhostiz/0T)r@rCrDrErAc.|jjSr1rrJs rLrz RedisDsn.host5r2rNNrr3rmrNrLr4r4%s;" (+  LrNr4c(eZdZdZeddgdZy)r5zA 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`). mongodbz mongodb+srviir@rDNr rmrNrLr5r5;s"9m2L[`aLrNr5c(eZdZdZedgddZy)r6ztA type that will accept any Kafka DSN. * User info required * TLD not required * Host not required kafkar=i#r@rCrDNr rmrNrLr6r6Gs"7)+dhiLrNr6c*eZdZdZegdddZy)r7aLA 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 )natstlsr%r&r=i~rDNr rmrNrLr7r7Rs"4;]aLrNr7c*eZdZdZegdddZy)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@rDrANr rmrNrLr9r9`s "   LrNr9c(eZdZdZegddZy)r:zvA type that will accept any MariaDB DSN. * User info required * TLD not required * Host not required )mariadbzmariadb+mariadbconnectorzmariadb+pymysqlrJrANr rmrNrLr:r:xs"RLrNr:c*eZdZdZegdddZy)r;zyA type that will accept any ClickHouse DSN. * User info required * TLD not required * Host not required )zclickhouse+nativezclickhouse+asynchzclickhouse+http clickhouse clickhouses clickhousedbr=i(#rDNr rmrNrLr;r;s " ! LrNr;c8eZdZdZedgdZeddZy)r<ztA type that will accept any Snowflake DSN. * User info required * TLD not required * Host required snowflakeT)r@rAc.|jjSr1rrJs rLrzSnowflakeDsn.hostr2rNNrr3rmrNrLr<r<s/"$ L rNr<c ddlatdjdddk(s tdy#t$r}td|d}~wwxYw)NrzCemail-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)es rLimport_email_validatorr[s_h $ % / / 4Q 73 >ghh ? h_`fgghs2 A  AA .c^eZdZdZe ddZe ddZeddZy) 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' ``` czttj|jtjSrG)r[r no_info_after_validator_function _validate str_schemar_source_handlers rLrbz%EmailStr.__get_pydantic_core_schema__s* # $?? {OeOeOgh hrNc<||}|jdd|S)NstringemailrVformatupdaterrr] field_schemas rLrz%EmailStr.__get_pydantic_json_schema__s'#;/L   Xg  > rNct|dS)Nr)r8r input_values rLr_zEmailStr._validates!+.q1 1rNNrbz type[Any]rcrrdrfr)rorrdr)rgrhrirjrrbrr_rmrNrLr,r,s| ,  i i+ i$  i  i  4 ?m      2  2rNr,czeZdZdZdZd dZd dZe d dZe d dZ eddZ ddZ y )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 ') print(user.email) #> Fred Bloggs print(user.email.name) #> Fred Bloggs user = User(email='fred.bloggs@example.com') print(user.email) #> fred.bloggs print(user.email.name) #> fred.bloggs ``` rQrfc ||_||_yrGrr)rKrQrfs rLrzzNameEmail.__init__s  rNct|txr1|j|jf|j|jfk(SrG)rr-rQrfrs rLrzNameEmail.__eq__s6%+dDJJ0GEJJX]XcXcKd0ddrNc<||}|jdd|S)Nrez name-emailrgrirks rLrz&NameEmail.__get_pydantic_json_schema__s'{+ ,?rNc Dttj|jtjtj tj tj|tj gddtjS)Nname_email_typezInput is not a valid NameEmail)custom_error_typecustom_error_message) json_schema python_schemar) r[rr^r_json_or_python_schemar` union_schemais_instance_schemarras rLrbz&NameEmail.__get_pydantic_core_schema__s|  ;; MM  - -'224)66 33C8+:P:P:RS&7)I *>>@   rNcTt|trt|\}}|||S|SrG)rrr8)rrorQrfs rLr_zNameEmail._validate4s- k3 '(5KD%tU# # rNcd|jvrd|jd|jdS|jd|jdS)N@"z" <>z 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', } ] ''' ``` rmc t|S#t$rYnwxYw t|S#t$r tddwxYw)z!Validate an IPv4 or IPv6 address.ip_any_addressz)value is not a valid IPv4 or IPv6 address)r ValueErrorr rrrSs rLrzIPvAnyAddress.__new__msU "5))   i"5)) i)*:c0i}|jdd|S)Nre ipvanyaddressrgrirks rLrz*IPvAnyAddress.__get_pydantic_json_schema__y"L   Xo  F rNchtj|jtjSNrr no_info_plain_validator_functionr_rras rLrbz*IPvAnyAddress.__get_pydantic_core_schema__) ?? [-M-M-O rNc||SrGrmrns rLr_zIPvAnyAddress._validate {# #rNN)rSrrdrrrp)rorrdr rgrhrirjrrrrrbr_rmrNrLr.r.Ms :  i  4 ?m       + $      $  $rNr.cjeZdZdZdZddZe d dZe d dZed dZ y) r/#Validate an IPv4 or IPv6 interface.rmc t|S#t$rYnwxYw t|S#t$r tddwxYw)rip_any_interfacez+value is not a valid IPv4 or IPv6 interface)rrr rrs rLrzIPvAnyInterface.__new__sU $U++   m$U++ m)*<>kll mrc0i}|jdd|S)Nreipvanyinterfacergrirks rLrz,IPvAnyInterface.__get_pydantic_json_schema__s#L   X6G  H rNchtj|jtjSrrras rLrbz,IPvAnyInterface.__get_pydantic_core_schema__rrNc||SrGrmrns rLr_zIPvAnyInterface._validaterrNN)rSr#rdrrrp)ror#rdrrrmrNrLr/r/s1  m  4 ?m       + $      $  $rNr/cjeZdZdZdZddZe d dZe d dZed dZ y) r0!Validate an IPv4 or IPv6 network.rmc t|S#t$rYnwxYw t|S#t$r tddwxYw)rip_any_networkz)value is not a valid IPv4 or IPv6 network)r rr rrs rLrzIPvAnyNetwork.__new__sU "5))   i"5)) i)*:z\s*(?:|z)?\s*z\s*)recompile) name_charsunquoted_name_groupquoted_name_group email_groups rL_build_pretty_email_regexrsP-J!*VJ"` 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)rWr[rMAX_EMAIL_LENGTHrpretty_email_regex fullmatchgroupsstripr8EmailNotValidErrorrargs normalized local_part)rSmrQ unquoted_name quoted_namerfpartsrZs rLr8r8s"  5z$$!  : 01A0B+N O  $$U+AD,-HHJ) {E+  KKME..u5Q   E    #5##D ;  - -! IHVYZ[Z`Z`abZcVdKe  s>B99C7 &C22C7)rz"type[_BaseUrl | _BaseMultiHostUrl]rdr")rdr)rdzre.Pattern[str])rSrrdztuple[str, str])^rj __future__r _annotations dataclasses _dataclassesrr functoolsrimportlib.metadatar ipaddressrrr r r r typingr rrr pydantic_corerrrrrrrrrrtyping_extensionsrrpydantic.errorsr _internalrr _migrationrannotated_handlersrrzr type_adapterr"rWr#rk__all__ dataclassr+rorrvr$r%r(r*r)r&r'r1r2r3r4r5r6r7r9r:r;r<r[rr,Representationr-rrrr.r/r0rrrr8rg __getattr__rmrNrLrskK2" &ff::<)--7)4(%VKVO :111hYyYyxwywyt  X2EENVfNVbAfAR6R