762 lines
22 KiB
Python
762 lines
22 KiB
Python
"""The networks module contains types for common network-related fields."""
|
||
|
||
from __future__ import annotations as _annotations
|
||
|
||
import dataclasses as _dataclasses
|
||
import re
|
||
from importlib.metadata import version
|
||
from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network
|
||
from typing import TYPE_CHECKING, Any
|
||
|
||
from pydantic_core import MultiHostUrl, PydanticCustomError, Url, core_schema
|
||
from typing_extensions import Annotated, Self, TypeAlias
|
||
|
||
from ._internal import _fields, _repr, _schema_generation_shared
|
||
from ._migration import getattr_migration
|
||
from .annotated_handlers import GetCoreSchemaHandler
|
||
from .json_schema import JsonSchemaValue
|
||
|
||
if TYPE_CHECKING:
|
||
import email_validator
|
||
|
||
NetworkType: TypeAlias = 'str | bytes | int | tuple[str | bytes | int, str | int]'
|
||
|
||
else:
|
||
email_validator = None
|
||
|
||
|
||
__all__ = [
|
||
'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',
|
||
]
|
||
|
||
|
||
@_dataclasses.dataclass
|
||
class UrlConstraints(_fields.PydanticMetadata):
|
||
"""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`.
|
||
"""
|
||
|
||
max_length: int | None = None
|
||
allowed_schemes: list[str] | None = None
|
||
host_required: bool | None = None
|
||
default_host: str | None = None
|
||
default_port: int | None = None
|
||
default_path: str | None = None
|
||
|
||
def __hash__(self) -> int:
|
||
return hash(
|
||
(
|
||
self.max_length,
|
||
tuple(self.allowed_schemes) if self.allowed_schemes is not None else None,
|
||
self.host_required,
|
||
self.default_host,
|
||
self.default_port,
|
||
self.default_path,
|
||
)
|
||
)
|
||
|
||
|
||
AnyUrl = Url
|
||
"""Base type for all URLs.
|
||
|
||
* Any scheme allowed
|
||
* Top-level domain (TLD) not required
|
||
* Host 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`), always set.
|
||
- `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`).
|
||
"""
|
||
AnyHttpUrl = Annotated[Url, UrlConstraints(allowed_schemes=['http', 'https'])]
|
||
"""A type that will accept any http or https URL.
|
||
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
HttpUrl = Annotated[Url, UrlConstraints(max_length=2083, allowed_schemes=['http', 'https'])]
|
||
"""A type that will accept any http or https URL.
|
||
|
||
* TLD not required
|
||
* Host required
|
||
* Max length 2083
|
||
|
||
```py
|
||
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):
|
||
|
||
```py
|
||
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.
|
||
"""
|
||
AnyWebsocketUrl = Annotated[Url, UrlConstraints(allowed_schemes=['ws', 'wss'])]
|
||
"""A type that will accept any ws or wss URL.
|
||
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
WebsocketUrl = Annotated[Url, UrlConstraints(max_length=2083, allowed_schemes=['ws', 'wss'])]
|
||
"""A type that will accept any ws or wss URL.
|
||
|
||
* TLD not required
|
||
* Host required
|
||
* Max length 2083
|
||
"""
|
||
FileUrl = Annotated[Url, UrlConstraints(allowed_schemes=['file'])]
|
||
"""A type that will accept any file URL.
|
||
|
||
* Host not required
|
||
"""
|
||
FtpUrl = Annotated[Url, UrlConstraints(allowed_schemes=['ftp'])]
|
||
"""A type that will accept ftp URL.
|
||
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
PostgresDsn = Annotated[
|
||
MultiHostUrl,
|
||
UrlConstraints(
|
||
host_required=True,
|
||
allowed_schemes=[
|
||
'postgres',
|
||
'postgresql',
|
||
'postgresql+asyncpg',
|
||
'postgresql+pg8000',
|
||
'postgresql+psycopg',
|
||
'postgresql+psycopg2',
|
||
'postgresql+psycopg2cffi',
|
||
'postgresql+py-postgresql',
|
||
'postgresql+pygresql',
|
||
],
|
||
),
|
||
]
|
||
"""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:
|
||
|
||
```py
|
||
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))
|
||
#> Url('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 = MultiHostUrl('postgres://user:pass@localhost:5432').path [type=assertion_error, input_value='postgres://user:pass@localhost:5432', input_type=str]
|
||
'''
|
||
```
|
||
"""
|
||
|
||
CockroachDsn = Annotated[
|
||
Url,
|
||
UrlConstraints(
|
||
host_required=True,
|
||
allowed_schemes=[
|
||
'cockroachdb',
|
||
'cockroachdb+psycopg2',
|
||
'cockroachdb+asyncpg',
|
||
],
|
||
),
|
||
]
|
||
"""A type that will accept any Cockroach DSN.
|
||
|
||
* User info required
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
AmqpDsn = Annotated[Url, UrlConstraints(allowed_schemes=['amqp', 'amqps'])]
|
||
"""A type that will accept any AMQP DSN.
|
||
|
||
* User info required
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
RedisDsn = Annotated[
|
||
Url,
|
||
UrlConstraints(allowed_schemes=['redis', 'rediss'], default_host='localhost', default_port=6379, default_path='/0'),
|
||
]
|
||
"""A type that will accept any Redis DSN.
|
||
|
||
* User info required
|
||
* TLD not required
|
||
* Host required (e.g., `rediss://:pass@localhost`)
|
||
"""
|
||
MongoDsn = Annotated[MultiHostUrl, UrlConstraints(allowed_schemes=['mongodb', 'mongodb+srv'], default_port=27017)]
|
||
"""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`).
|
||
"""
|
||
KafkaDsn = Annotated[Url, UrlConstraints(allowed_schemes=['kafka'], default_host='localhost', default_port=9092)]
|
||
"""A type that will accept any Kafka DSN.
|
||
|
||
* User info required
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
NatsDsn = Annotated[
|
||
MultiHostUrl, UrlConstraints(allowed_schemes=['nats', 'tls', 'ws'], default_host='localhost', default_port=4222)
|
||
]
|
||
"""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
|
||
"""
|
||
MySQLDsn = Annotated[
|
||
Url,
|
||
UrlConstraints(
|
||
allowed_schemes=[
|
||
'mysql',
|
||
'mysql+mysqlconnector',
|
||
'mysql+aiomysql',
|
||
'mysql+asyncmy',
|
||
'mysql+mysqldb',
|
||
'mysql+pymysql',
|
||
'mysql+cymysql',
|
||
'mysql+pyodbc',
|
||
],
|
||
default_port=3306,
|
||
),
|
||
]
|
||
"""A type that will accept any MySQL DSN.
|
||
|
||
* User info required
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
MariaDBDsn = Annotated[
|
||
Url,
|
||
UrlConstraints(
|
||
allowed_schemes=['mariadb', 'mariadb+mariadbconnector', 'mariadb+pymysql'],
|
||
default_port=3306,
|
||
),
|
||
]
|
||
"""A type that will accept any MariaDB DSN.
|
||
|
||
* User info required
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
ClickHouseDsn = Annotated[
|
||
Url,
|
||
UrlConstraints(
|
||
allowed_schemes=['clickhouse+native', 'clickhouse+asynch'],
|
||
default_host='localhost',
|
||
default_port=9000,
|
||
),
|
||
]
|
||
"""A type that will accept any ClickHouse DSN.
|
||
|
||
* User info required
|
||
* TLD not required
|
||
* Host required
|
||
"""
|
||
|
||
|
||
def import_email_validator() -> None:
|
||
global email_validator
|
||
try:
|
||
import email_validator
|
||
except ImportError as e:
|
||
raise ImportError('email-validator is not installed, run `pip install pydantic[email]`') from e
|
||
if not version('email-validator').partition('.')[0] == '2':
|
||
raise ImportError('email-validator version >= 2.0 required, run pip install -U email-validator')
|
||
|
||
|
||
if TYPE_CHECKING:
|
||
EmailStr = Annotated[str, ...]
|
||
else:
|
||
|
||
class EmailStr:
|
||
"""
|
||
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.
|
||
|
||
```py
|
||
from pydantic import BaseModel, EmailStr
|
||
|
||
class Model(BaseModel):
|
||
email: EmailStr
|
||
|
||
print(Model(email='contact@mail.com'))
|
||
#> email='contact@mail.com'
|
||
```
|
||
""" # noqa: D212
|
||
|
||
@classmethod
|
||
def __get_pydantic_core_schema__(
|
||
cls,
|
||
_source: type[Any],
|
||
_handler: GetCoreSchemaHandler,
|
||
) -> core_schema.CoreSchema:
|
||
import_email_validator()
|
||
return core_schema.no_info_after_validator_function(cls._validate, core_schema.str_schema())
|
||
|
||
@classmethod
|
||
def __get_pydantic_json_schema__(
|
||
cls, core_schema: core_schema.CoreSchema, handler: _schema_generation_shared.GetJsonSchemaHandler
|
||
) -> JsonSchemaValue:
|
||
field_schema = handler(core_schema)
|
||
field_schema.update(type='string', format='email')
|
||
return field_schema
|
||
|
||
@classmethod
|
||
def _validate(cls, input_value: str, /) -> str:
|
||
return validate_email(input_value)[1]
|
||
|
||
|
||
class NameEmail(_repr.Representation):
|
||
"""
|
||
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.
|
||
|
||
```py
|
||
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
|
||
```
|
||
""" # noqa: D212
|
||
|
||
__slots__ = 'name', 'email'
|
||
|
||
def __init__(self, name: str, email: str):
|
||
self.name = name
|
||
self.email = email
|
||
|
||
def __eq__(self, other: Any) -> bool:
|
||
return isinstance(other, NameEmail) and (self.name, self.email) == (other.name, other.email)
|
||
|
||
@classmethod
|
||
def __get_pydantic_json_schema__(
|
||
cls, core_schema: core_schema.CoreSchema, handler: _schema_generation_shared.GetJsonSchemaHandler
|
||
) -> JsonSchemaValue:
|
||
field_schema = handler(core_schema)
|
||
field_schema.update(type='string', format='name-email')
|
||
return field_schema
|
||
|
||
@classmethod
|
||
def __get_pydantic_core_schema__(
|
||
cls,
|
||
_source: type[Any],
|
||
_handler: GetCoreSchemaHandler,
|
||
) -> core_schema.CoreSchema:
|
||
import_email_validator()
|
||
|
||
return core_schema.no_info_after_validator_function(
|
||
cls._validate,
|
||
core_schema.json_or_python_schema(
|
||
json_schema=core_schema.str_schema(),
|
||
python_schema=core_schema.union_schema(
|
||
[core_schema.is_instance_schema(cls), core_schema.str_schema()],
|
||
custom_error_type='name_email_type',
|
||
custom_error_message='Input is not a valid NameEmail',
|
||
),
|
||
serialization=core_schema.to_string_ser_schema(),
|
||
),
|
||
)
|
||
|
||
@classmethod
|
||
def _validate(cls, input_value: Self | str, /) -> Self:
|
||
if isinstance(input_value, str):
|
||
name, email = validate_email(input_value)
|
||
return cls(name, email)
|
||
else:
|
||
return input_value
|
||
|
||
def __str__(self) -> str:
|
||
if '@' in self.name:
|
||
return f'"{self.name}" <{self.email}>'
|
||
|
||
return f'{self.name} <{self.email}>'
|
||
|
||
|
||
class IPvAnyAddress:
|
||
"""Validate an IPv4 or IPv6 address.
|
||
|
||
```py
|
||
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',
|
||
}
|
||
]
|
||
'''
|
||
```
|
||
"""
|
||
|
||
__slots__ = ()
|
||
|
||
def __new__(cls, value: Any) -> IPv4Address | IPv6Address:
|
||
"""Validate an IPv4 or IPv6 address."""
|
||
try:
|
||
return IPv4Address(value)
|
||
except ValueError:
|
||
pass
|
||
|
||
try:
|
||
return IPv6Address(value)
|
||
except ValueError:
|
||
raise PydanticCustomError('ip_any_address', 'value is not a valid IPv4 or IPv6 address')
|
||
|
||
@classmethod
|
||
def __get_pydantic_json_schema__(
|
||
cls, core_schema: core_schema.CoreSchema, handler: _schema_generation_shared.GetJsonSchemaHandler
|
||
) -> JsonSchemaValue:
|
||
field_schema = {}
|
||
field_schema.update(type='string', format='ipvanyaddress')
|
||
return field_schema
|
||
|
||
@classmethod
|
||
def __get_pydantic_core_schema__(
|
||
cls,
|
||
_source: type[Any],
|
||
_handler: GetCoreSchemaHandler,
|
||
) -> core_schema.CoreSchema:
|
||
return core_schema.no_info_plain_validator_function(
|
||
cls._validate, serialization=core_schema.to_string_ser_schema()
|
||
)
|
||
|
||
@classmethod
|
||
def _validate(cls, input_value: Any, /) -> IPv4Address | IPv6Address:
|
||
return cls(input_value) # type: ignore[return-value]
|
||
|
||
|
||
class IPvAnyInterface:
|
||
"""Validate an IPv4 or IPv6 interface."""
|
||
|
||
__slots__ = ()
|
||
|
||
def __new__(cls, value: NetworkType) -> IPv4Interface | IPv6Interface:
|
||
"""Validate an IPv4 or IPv6 interface."""
|
||
try:
|
||
return IPv4Interface(value)
|
||
except ValueError:
|
||
pass
|
||
|
||
try:
|
||
return IPv6Interface(value)
|
||
except ValueError:
|
||
raise PydanticCustomError('ip_any_interface', 'value is not a valid IPv4 or IPv6 interface')
|
||
|
||
@classmethod
|
||
def __get_pydantic_json_schema__(
|
||
cls, core_schema: core_schema.CoreSchema, handler: _schema_generation_shared.GetJsonSchemaHandler
|
||
) -> JsonSchemaValue:
|
||
field_schema = {}
|
||
field_schema.update(type='string', format='ipvanyinterface')
|
||
return field_schema
|
||
|
||
@classmethod
|
||
def __get_pydantic_core_schema__(
|
||
cls,
|
||
_source: type[Any],
|
||
_handler: GetCoreSchemaHandler,
|
||
) -> core_schema.CoreSchema:
|
||
return core_schema.no_info_plain_validator_function(
|
||
cls._validate, serialization=core_schema.to_string_ser_schema()
|
||
)
|
||
|
||
@classmethod
|
||
def _validate(cls, input_value: NetworkType, /) -> IPv4Interface | IPv6Interface:
|
||
return cls(input_value) # type: ignore[return-value]
|
||
|
||
|
||
IPvAnyNetworkType: TypeAlias = 'IPv4Network | IPv6Network'
|
||
|
||
if TYPE_CHECKING:
|
||
IPvAnyNetwork = IPvAnyNetworkType
|
||
else:
|
||
|
||
class IPvAnyNetwork:
|
||
"""Validate an IPv4 or IPv6 network."""
|
||
|
||
__slots__ = ()
|
||
|
||
def __new__(cls, value: NetworkType) -> IPvAnyNetworkType:
|
||
"""Validate an IPv4 or IPv6 network."""
|
||
# Assume IP Network is defined with a default value for `strict` argument.
|
||
# Define your own class if you want to specify network address check strictness.
|
||
try:
|
||
return IPv4Network(value)
|
||
except ValueError:
|
||
pass
|
||
|
||
try:
|
||
return IPv6Network(value)
|
||
except ValueError:
|
||
raise PydanticCustomError('ip_any_network', 'value is not a valid IPv4 or IPv6 network')
|
||
|
||
@classmethod
|
||
def __get_pydantic_json_schema__(
|
||
cls, core_schema: core_schema.CoreSchema, handler: _schema_generation_shared.GetJsonSchemaHandler
|
||
) -> JsonSchemaValue:
|
||
field_schema = {}
|
||
field_schema.update(type='string', format='ipvanynetwork')
|
||
return field_schema
|
||
|
||
@classmethod
|
||
def __get_pydantic_core_schema__(
|
||
cls,
|
||
_source: type[Any],
|
||
_handler: GetCoreSchemaHandler,
|
||
) -> core_schema.CoreSchema:
|
||
return core_schema.no_info_plain_validator_function(
|
||
cls._validate, serialization=core_schema.to_string_ser_schema()
|
||
)
|
||
|
||
@classmethod
|
||
def _validate(cls, input_value: NetworkType, /) -> IPvAnyNetworkType:
|
||
return cls(input_value) # type: ignore[return-value]
|
||
|
||
|
||
def _build_pretty_email_regex() -> re.Pattern[str]:
|
||
name_chars = r'[\w!#$%&\'*+\-/=?^_`{|}~]'
|
||
unquoted_name_group = rf'((?:{name_chars}+\s+)*{name_chars}+)'
|
||
quoted_name_group = r'"((?:[^"]|\")+)"'
|
||
email_group = r'<\s*(.+)\s*>'
|
||
return re.compile(rf'\s*(?:{unquoted_name_group}|{quoted_name_group})?\s*{email_group}\s*')
|
||
|
||
|
||
pretty_email_regex = _build_pretty_email_regex()
|
||
|
||
MAX_EMAIL_LENGTH = 2048
|
||
"""Maximum length for an email.
|
||
A somewhat arbitrary but very generous number compared to what is allowed by most implementations.
|
||
"""
|
||
|
||
|
||
def validate_email(value: str) -> tuple[str, str]:
|
||
"""Email address validation using [email-validator](https://pypi.org/project/email-validator/).
|
||
|
||
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.
|
||
"""
|
||
if email_validator is None:
|
||
import_email_validator()
|
||
|
||
if len(value) > MAX_EMAIL_LENGTH:
|
||
raise PydanticCustomError(
|
||
'value_error',
|
||
'value is not a valid email address: {reason}',
|
||
{'reason': f'Length must not exceed {MAX_EMAIL_LENGTH} characters'},
|
||
)
|
||
|
||
m = pretty_email_regex.fullmatch(value)
|
||
name: str | None = None
|
||
if m:
|
||
unquoted_name, quoted_name, value = m.groups()
|
||
name = unquoted_name or quoted_name
|
||
|
||
email = value.strip()
|
||
|
||
try:
|
||
parts = email_validator.validate_email(email, check_deliverability=False)
|
||
except email_validator.EmailNotValidError as e:
|
||
raise PydanticCustomError(
|
||
'value_error', 'value is not a valid email address: {reason}', {'reason': str(e.args[0])}
|
||
) from e
|
||
|
||
email = parts.normalized
|
||
assert email is not None
|
||
name = name or parts.local_part
|
||
return name, email
|
||
|
||
|
||
__getattr__ = getattr_migration(__name__)
|