Url Type (#317)

* working on Url type

* Url type

* tweak Cargo

* allow Url as input to Url

* international_domain -> punycode_domain

* add unicode_host and unicode_string

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "0.6.0"
+version = "0.6.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -38,6 +38,9 @@ mimalloc = { version = "0.1.30", default-features = false, optional = true }
 speedate = "0.7.0"
 ahash = "0.8.0"
 nohash-hasher = "0.2.0"
+url = "2.3.1"
+# idna is already required by url, added here to be explicit
+idna = "0.3.0"
 
 [lib]
 name = "_pydantic_core"

pydantic_core/__init__.py

@@ -4,6 +4,7 @@
     PydanticOmit,
     SchemaError,
     SchemaValidator,
+    Url,
     ValidationError,
     __version__,
 )
@@ -14,6 +15,7 @@
     'CoreConfig',
     'CoreSchema',
     'SchemaValidator',
+    'Url',
     'SchemaError',
     'ValidationError',
     'PydanticCustomError',

pydantic_core/_pydantic_core.pyi

@@ -1,6 +1,6 @@
 import decimal
 import sys
-from typing import Any, TypedDict
+from typing import Any, Literal, TypedDict
 
 from pydantic_core.core_schema import CoreConfig, CoreSchema, ErrorType
 
@@ -13,6 +13,7 @@ __all__ = (
     '__version__',
     'build_profile',
     'SchemaValidator',
+    'Url',
     'SchemaError',
     'ValidationError',
     'PydanticCustomError',
@@ -38,6 +39,24 @@ class SchemaValidator:
         self, field: str, input: Any, data: 'dict[str, Any]', strict: 'bool | None' = None, context: Any = None
     ) -> 'dict[str, Any]': ...
 
+class Url:
+    scheme: str
+    username: 'str | None'
+    password: 'str | None'
+    host: 'str | None'
+    host_type: Literal['domain', 'punycode_domain', 'ipv4', 'ipv6', None]
+    port: 'int | None'
+    path: 'str | None'
+    query: 'str | None'
+    fragment: 'str | None'
+
+    def __init__(self, raw_url: str) -> None: ...
+    def unicode_host(self) -> 'str | None': ...
+    def query_params(self) -> 'list[tuple[str, str]]': ...
+    def unicode_string(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+
 class SchemaError(Exception):
     pass
 

pydantic_core/core_schema.py

@@ -1021,6 +1021,33 @@ def json_schema(schema: CoreSchema | None = None, *, ref: str | None = None, ext
     return dict_not_none(type='json', schema=schema, ref=ref, extra=extra)
 
 
+class UrlSchema(TypedDict, total=False):
+    type: Required[Literal['url']]
+    host_required: bool  # default False
+    max_length: int
+    allowed_schemes: List[str]
+    ref: str
+    extra: Any
+
+
+def url_schema(
+    *,
+    host_required: bool | None = None,
+    max_length: int | None = None,
+    allowed_schemes: list[str] | None = None,
+    ref: str | None = None,
+    extra: Any = None,
+) -> UrlSchema:
+    return dict_not_none(
+        type='url',
+        host_required=host_required,
+        max_length=max_length,
+        allowed_schemes=allowed_schemes,
+        ref=ref,
+        extra=extra,
+    )
+
+
 CoreSchema = Union[
     AnySchema,
     NoneSchema,
@@ -1059,6 +1086,7 @@ def json_schema(schema: CoreSchema | None = None, *, ref: str | None = None, ext
     RecursiveReferenceSchema,
     CustomErrorSchema,
     JsonSchema,
+    UrlSchema,
 ]
 
 # used in _pydantic_core.pyi::PydanticKnownError
@@ -1139,4 +1167,8 @@ def json_schema(schema: CoreSchema | None = None, *, ref: str | None = None, ext
     'unexpected_positional_argument',
     'missing_positional_argument',
     'multiple_argument_values',
+    'url_error',
+    'url_too_long',
+    'url_schema',
+    'url_host_required',
 ]

src/errors/types.rs

@@ -317,6 +317,22 @@ pub enum ErrorType {
     MissingPositionalArgument,
     #[strum(message = "Got multiple values for argument")]
     MultipleArgumentValues,
+    // ---------------------
+    // URL errors
+    #[strum(message = "Invalid URL, {error}")]
+    UrlError {
+        error: String,
+    },
+    #[strum(message = "URL should have at most {max_length} characters")]
+    UrlTooLong {
+        max_length: usize,
+    },
+    #[strum(message = "URL schema should be {expected_schemas}")]
+    UrlSchema {
+        expected_schemas: String,
+    },
+    #[strum(message = "URL host required")]
+    UrlHostRequired,
 }
 
 macro_rules! render {
@@ -449,6 +465,9 @@ impl ErrorType {
                 expected_tags: String
             ),
             Self::UnionTagNotFound { .. } => extract_context!(UnionTagNotFound, ctx, discriminator: String),
+            Self::UrlError { .. } => extract_context!(UrlError, ctx, error: String),
+            Self::UrlTooLong { .. } => extract_context!(UrlTooLong, ctx, max_length: usize),
+            Self::UrlSchema { .. } => extract_context!(UrlSchema, ctx, expected_schemas: String),
             _ => {
                 if ctx.is_some() {
                     py_err!(PyTypeError; "'{}' errors do not require context", value)
@@ -536,6 +555,9 @@ impl ErrorType {
                 expected_tags,
             } => render!(self, discriminator, tag, expected_tags),
             Self::UnionTagNotFound { discriminator } => render!(self, discriminator),
+            Self::UrlError { error } => render!(self, error),
+            Self::UrlTooLong { max_length } => to_string_render!(self, max_length),
+            Self::UrlSchema { expected_schemas } => render!(self, expected_schemas),
             _ => Ok(self.message_template().to_string()),
         }
     }
@@ -585,6 +607,9 @@ impl ErrorType {
                 expected_tags,
             } => py_dict!(py, discriminator, tag, expected_tags),
             Self::UnionTagNotFound { discriminator } => py_dict!(py, discriminator),
+            Self::UrlError { error } => py_dict!(py, error),
+            Self::UrlTooLong { max_length } => py_dict!(py, max_length),
+            Self::UrlSchema { expected_schemas } => py_dict!(py, expected_schemas),
             _ => Ok(None),
         }
     }

src/errors/validation_exception.rs

@@ -81,6 +81,7 @@ impl ValidationError {
     }
 
     fn errors(&self, py: Python, include_context: Option<bool>) -> PyResult<PyObject> {
+        // TODO remove `collect` when we have https://github.com/PyO3/pyo3/pull/2676
         Ok(self
             .line_errors
             .iter()

src/input/input_abstract.rs

@@ -4,6 +4,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyString, PyType};
 
 use crate::errors::{InputValue, LocItem, ValResult};
+use crate::PyUrl;
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherString};
@@ -54,6 +55,10 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         Ok(false)
     }
 
+    fn input_as_url(&self) -> Option<PyUrl> {
+        None
+    }
+
     fn callable(&self) -> bool {
         false
     }

src/input/input_python.rs

@@ -13,6 +13,7 @@ use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
 use pyo3::{ffi, intern, AsPyPointer, PyTypeInfo};
 
 use crate::errors::{py_err_string, ErrorType, InputValue, LocItem, ValError, ValLineError, ValResult};
+use crate::PyUrl;
 
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, date_as_datetime, float_as_datetime,
@@ -102,13 +103,16 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn input_is_subclass(&self, class: &PyType) -> PyResult<bool> {
-        if let Ok(py_type) = self.cast_as::<PyType>() {
-            py_type.is_subclass(class)
-        } else {
-            Ok(false)
+        match self.cast_as::<PyType>() {
+            Ok(py_type) => py_type.is_subclass(class),
+            Err(_) => Ok(false),
         }
     }
 
+    fn input_as_url(&self) -> Option<PyUrl> {
+        self.extract::<PyUrl>().ok()
+    }
+
     fn callable(&self) -> bool {
         self.is_callable()
     }
@@ -124,7 +128,7 @@ impl<'a> Input<'a> for PyAny {
                         } else if args.is_none() {
                             Ok(None)
                         } else if let Ok(list) = args.cast_as::<PyList>() {
-                            // remove `collect` when we have https://github.com/PyO3/pyo3/pull/2676
+                            // TODO remove `collect` when we have https://github.com/PyO3/pyo3/pull/2676
                             Ok(Some(PyTuple::new(self.py(), list.iter().collect::<Vec<_>>())))
                         } else {
                             Err(ValLineError::new_with_loc(
@@ -161,7 +165,7 @@ impl<'a> Input<'a> for PyAny {
         } else if let Ok(tuple) = self.cast_as::<PyTuple>() {
             Ok(PyArgs::new(Some(tuple), None).into())
         } else if let Ok(list) = self.cast_as::<PyList>() {
-            // remove `collect` when we have https://github.com/PyO3/pyo3/pull/2676
+            // TODO remove `collect` when we have https://github.com/PyO3/pyo3/pull/2676
             let tuple = PyTuple::new(self.py(), list.iter().collect::<Vec<_>>());
             Ok(PyArgs::new(Some(tuple), None).into())
         } else {

src/lib.rs

@@ -14,9 +14,11 @@ mod input;
 mod lookup_key;
 mod questions;
 mod recursion_guard;
+mod url;
 mod validators;
 
 // required for benchmarks
+pub use self::url::PyUrl;
 pub use build_tools::SchemaError;
 pub use errors::{list_all_errors, PydanticCustomError, PydanticKnownError, PydanticOmit, ValidationError};
 pub use validators::SchemaValidator;
@@ -41,6 +43,7 @@ fn _pydantic_core(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<PydanticCustomError>()?;
     m.add_class::<PydanticKnownError>()?;
     m.add_class::<PydanticOmit>()?;
+    m.add_class::<self::url::PyUrl>()?;
     m.add_function(wrap_pyfunction!(list_all_errors, m)?)?;
     Ok(())
 }