Merge branch 'main' into allow_partial

Author: samuelcolvin

Cargo.lock

@@ -30,12 +30,12 @@ rust-version = "1.75"
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
 pyo3 = { version = "0.22.5", features = ["generate-import-lib", "num-bigint", "py-clone"] }
-regex = "1.11.0"
+regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.132", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.213", features = ["derive"] }
+serde = { version = "1.0.214", features = ["derive"] }
 speedate = "0.14.4"
 smallvec = "1.13.2"
 ahash = "0.8.10"
@@ -46,7 +46,7 @@ base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
 uuid = "1.11.0"
-jiter = { version = "0.7.0", features = ["python"] }
+jiter = { version = "0.7", features = ["python"] }
 hex = "0.4.3"
 
 [lib]

Cargo.toml

@@ -124,7 +124,7 @@ class ErrorTypeInfo(_TypedDict):
     """Example of context values."""
 
 
-class MultiHostHost(_TypedDict, total=False):
+class MultiHostHost(_TypedDict):
     """
     A host part of a multi-host URL.
     """

python/pydantic_core/__init__.py

@@ -598,7 +598,7 @@ class Url(SupportsAllComparisons):
         scheme: str,
         username: str | None = None,
         password: str | None = None,
-        host: str | None = None,
+        host: str,
         port: int | None = None,
         path: str | None = None,
         query: str | None = None,
@@ -611,7 +611,7 @@ class Url(SupportsAllComparisons):
             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, or omit for no host.
+            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.

python/pydantic_core/_pydantic_core.pyi

@@ -3655,7 +3655,6 @@ class MyModel:
 
 class UrlSchema(TypedDict, total=False):
     type: Required[Literal['url']]
-    cls: Type[Any]
     max_length: int
     allowed_schemes: List[str]
     host_required: bool  # default False
@@ -3670,7 +3669,6 @@ class UrlSchema(TypedDict, total=False):
 
 def url_schema(
     *,
-    cls: Type[Any] | None = None,
     max_length: int | None = None,
     allowed_schemes: list[str] | None = None,
     host_required: bool | None = None,
@@ -3695,7 +3693,6 @@ def url_schema(
     ```
 
     Args:
-        cls: The class to use for the URL build (a subclass of `pydantic_core.Url`)
         max_length: The maximum length of the URL
         allowed_schemes: The allowed URL schemes
         host_required: Whether the URL must have a host
@@ -3709,7 +3706,6 @@ def url_schema(
     """
     return _dict_not_none(
         type='url',
-        cls=cls,
         max_length=max_length,
         allowed_schemes=allowed_schemes,
         host_required=host_required,
@@ -3725,7 +3721,6 @@ def url_schema(
 
 class MultiHostUrlSchema(TypedDict, total=False):
     type: Required[Literal['multi-host-url']]
-    cls: Type[Any]
     max_length: int
     allowed_schemes: List[str]
     host_required: bool  # default False
@@ -3740,7 +3735,6 @@ class MultiHostUrlSchema(TypedDict, total=False):
 
 def multi_host_url_schema(
     *,
-    cls: Type[Any] | None = None,
     max_length: int | None = None,
     allowed_schemes: list[str] | None = None,
     host_required: bool | None = None,
@@ -3765,7 +3759,6 @@ def multi_host_url_schema(
     ```
 
     Args:
-        cls: The class to use for the URL build (a subclass of `pydantic_core.MultiHostUrl`)
         max_length: The maximum length of the URL
         allowed_schemes: The allowed URL schemes
         host_required: Whether the URL must have a host
@@ -3779,7 +3772,6 @@ def multi_host_url_schema(
     """
     return _dict_not_none(
         type='multi-host-url',
-        cls=cls,
         max_length=max_length,
         allowed_schemes=allowed_schemes,
         host_required=host_required,

python/pydantic_core/core_schema.py

@@ -231,11 +231,9 @@ pub(crate) fn infer_to_python_known(
                 PyList::new_bound(py, items).into_py(py)
             }
             ObType::Complex => {
-                let dict = value.downcast::<PyDict>()?;
-                let new_dict = PyDict::new_bound(py);
-                let _ = new_dict.set_item("real", dict.get_item("real")?);
-                let _ = new_dict.set_item("imag", dict.get_item("imag")?);
-                new_dict.into_py(py)
+                let v = value.downcast::<PyComplex>()?;
+                let complex_str = type_serializers::complex::complex_to_str(v);
+                complex_str.into_py(py)
             }
             ObType::Path => value.str()?.into_py(py),
             ObType::Pattern => value.getattr(intern!(py, "pattern"))?.into_py(py),
@@ -286,11 +284,9 @@ pub(crate) fn infer_to_python_known(
                 iter.into_py(py)
             }
             ObType::Complex => {
-                let dict = value.downcast::<PyDict>()?;
-                let new_dict = PyDict::new_bound(py);
-                let _ = new_dict.set_item("real", dict.get_item("real")?);
-                let _ = new_dict.set_item("imag", dict.get_item("imag")?);
-                new_dict.into_py(py)
+                let v = value.downcast::<PyComplex>()?;
+                let complex_str = type_serializers::complex::complex_to_str(v);
+                complex_str.into_py(py)
             }
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
@@ -422,10 +418,8 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::Bool => serialize!(bool),
         ObType::Complex => {
             let v = value.downcast::<PyComplex>().map_err(py_err_se_err)?;
-            let mut map = serializer.serialize_map(Some(2))?;
-            map.serialize_entry(&"real", &v.real())?;
-            map.serialize_entry(&"imag", &v.imag())?;
-            map.end()
+            let complex_str = type_serializers::complex::complex_to_str(v);
+            Ok(serializer.collect_str::<String>(&complex_str)?)
         }
         ObType::Float | ObType::FloatSubclass => {
             let v = value.extract::<f64>().map_err(py_err_se_err)?;
@@ -672,7 +666,7 @@ pub(crate) fn infer_json_key_known<'a>(
             }
             Ok(Cow::Owned(key_build.finish()))
         }
-        ObType::List | ObType::Set | ObType::Frozenset | ObType::Dict | ObType::Generator | ObType::Complex => {
+        ObType::List | ObType::Set | ObType::Frozenset | ObType::Dict | ObType::Generator => {
             py_err!(PyTypeError; "`{}` not valid as object key", ob_type)
         }
         ObType::Dataclass | ObType::PydanticSerializable => {
@@ -689,6 +683,10 @@ pub(crate) fn infer_json_key_known<'a>(
             // FIXME it would be nice to have a "PyCow" which carries ownership of the Python type too
             Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
         }
+        ObType::Complex => {
+            let v = key.downcast::<PyComplex>()?;
+            Ok(type_serializers::complex::complex_to_str(v).into())
+        }
         ObType::Pattern => Ok(Cow::Owned(
             key.getattr(intern!(key.py(), "pattern"))?
                 .str()?

src/serializers/infer.rs

@@ -252,6 +252,8 @@ impl ObTypeLookup {
             ObType::Url
         } else if ob_type == self.multi_host_url {
             ObType::MultiHostUrl
+        } else if ob_type == self.complex {
+            ObType::Complex
         } else if ob_type == self.uuid_object.as_ptr() as usize {
             ObType::Uuid
         } else if is_pydantic_serializable(op_value) {

src/serializers/ob_type.rs

@@ -33,22 +33,10 @@ impl TypeSerializer for ComplexSerializer {
     ) -> PyResult<PyObject> {
         let py = value.py();
         match value.downcast::<PyComplex>() {
-            Ok(py_complex) => match extra.mode {
-                SerMode::Json => {
-                    let re = py_complex.real();
-                    let im = py_complex.imag();
-                    let mut s = format!("{im}j");
-                    if re != 0.0 {
-                        let mut sign = "";
-                        if im >= 0.0 {
-                            sign = "+";
-                        }
-                        s = format!("{re}{sign}{s}");
-                    }
-                    Ok(s.into_py(py))
-                }
-                _ => Ok(value.into_py(py)),
-            },
+            Ok(py_complex) => Ok(match extra.mode {
+                SerMode::Json => complex_to_str(py_complex).into_py(py),
+                _ => value.into_py(py),
+            }),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
                 infer_to_python(value, include, exclude, extra)
@@ -70,16 +58,7 @@ impl TypeSerializer for ComplexSerializer {
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyComplex>() {
             Ok(py_complex) => {
-                let re = py_complex.real();
-                let im = py_complex.imag();
-                let mut s = format!("{im}j");
-                if re != 0.0 {
-                    let mut sign = "";
-                    if im >= 0.0 {
-                        sign = "+";
-                    }
-                    s = format!("{re}{sign}{s}");
-                }
+                let s = complex_to_str(py_complex);
                 Ok(serializer.collect_str::<String>(&s)?)
             }
             Err(_) => {
@@ -93,3 +72,17 @@ impl TypeSerializer for ComplexSerializer {
         "complex"
     }
 }
+
+pub fn complex_to_str(py_complex: &Bound<'_, PyComplex>) -> String {
+    let re = py_complex.real();
+    let im = py_complex.imag();
+    let mut s = format!("{im}j");
+    if re != 0.0 {
+        let mut sign = "";
+        if im >= 0.0 {
+            sign = "+";
+        }
+        s = format!("{re}{sign}{s}");
+    }
+    s
+}

src/serializers/type_serializers/complex.rs

@@ -156,12 +156,12 @@ impl PyUrl {
     }
 
     #[classmethod]
-    #[pyo3(signature=(*, scheme, host=None, username=None, password=None, port=None, path=None, query=None, fragment=None))]
+    #[pyo3(signature=(*, scheme, host, username=None, password=None, port=None, path=None, query=None, fragment=None))]
     #[allow(clippy::too_many_arguments)]
     pub fn build<'py>(
         cls: &Bound<'py, PyType>,
         scheme: &str,
-        host: Option<&str>,
+        host: &str,
         username: Option<&str>,
         password: Option<&str>,
         port: Option<u16>,
@@ -172,7 +172,7 @@ impl PyUrl {
         let url_host = UrlHostParts {
             username: username.map(Into::into),
             password: password.map(Into::into),
-            host: host.map(Into::into),
+            host: Some(host.into()),
             port,
         };
         let mut url = format!("{scheme}://{url_host}");
@@ -423,7 +423,6 @@ impl PyMultiHostUrl {
     }
 }
 
-#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct UrlHostParts {
     username: Option<String>,
     password: Option<String>,
@@ -441,12 +440,11 @@ impl FromPyObject<'_> for UrlHostParts {
     fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
         let py = ob.py();
         let dict = ob.downcast::<PyDict>()?;
-
         Ok(UrlHostParts {
-            username: dict.get_as::<Option<_>>(intern!(py, "username"))?.flatten(),
-            password: dict.get_as::<Option<_>>(intern!(py, "password"))?.flatten(),
-            host: dict.get_as::<Option<_>>(intern!(py, "host"))?.flatten(),
-            port: dict.get_as::<Option<_>>(intern!(py, "port"))?.flatten(),
+            username: dict.get_as(intern!(py, "username"))?,
+            password: dict.get_as(intern!(py, "password"))?,
+            host: dict.get_as(intern!(py, "host"))?,
+            port: dict.get_as(intern!(py, "port"))?,
         })
     }
 }

src/url.rs

@@ -200,15 +200,14 @@ impl StrConstrainedValidator {
     }
 
     // whether any of the constraints/customisations are actually enabled
-    // except strict which can be set on StrValidator
+    // except strict and coerce_numbers_to_str which can be set on StrValidator
     fn has_constraints_set(&self) -> bool {
         self.pattern.is_some()
             || self.max_length.is_some()
             || self.min_length.is_some()
             || self.strip_whitespace
             || self.to_lower
             || self.to_upper
-            || self.coerce_numbers_to_str
     }
 }