Merge branch 'main' into fix-complex-infer

Author: changhc

.github/workflows/ci.yml

@@ -341,7 +341,7 @@ jobs:
           # NOTE!: as per https://github.com/pydantic/pydantic-core/pull/149 this version needs to match the version
           # in node_modules/pyodide/repodata.json, to get the version, run:
           # `cat node_modules/pyodide/repodata.json | python -m json.tool | rg platform`
-          version: '3.1.46'
+          version: '3.1.58'
           actions-cache-folder: emsdk-cache
 
       - run: pip install 'maturin>=1,<2' 'ruff==0.5.0' typing_extensions

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.25.0"
+version = "2.25.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -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"

Cargo.toml

@@ -84,8 +84,8 @@ endif
 
 .PHONY: build-wasm
 build-wasm:
-	@echo 'This requires python 3.11, maturin and emsdk to be installed'
-	maturin build --release --target wasm32-unknown-emscripten --out dist -i 3.11
+	@echo 'This requires python 3.12, maturin and emsdk to be installed'
+	maturin build --release --target wasm32-unknown-emscripten --out dist -i 3.12
 	ls -lh dist
 
 .PHONY: format

Makefile

@@ -8,7 +8,7 @@
   "main": "tests/emscripten_runner.js",
   "dependencies": {
     "prettier": "^2.7.1",
-    "pyodide": "^0.25.0"
+    "pyodide": "^0.26.3"
   },
   "scripts": {
     "test": "node tests/emscripten_runner.js",

package.json

@@ -357,7 +357,7 @@ def to_json(
     by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
-    timedelta_mode: Literal['iso8601', 'seconds_float', 'milliseconds_float'] = 'iso8601',
+    timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64', 'hex'] = 'utf8',
     inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
@@ -378,7 +378,7 @@ def to_json(
         by_alias: Whether to use the alias names of fields.
         exclude_none: Whether to exclude fields that have a value of `None`.
         round_trip: Whether to enable serialization and validation round-trip support.
-        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'`, `'seconds_float'` or `'milliseconds_float'`.
+        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.
         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
@@ -432,7 +432,7 @@ def to_jsonable_python(
     by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
-    timedelta_mode: Literal['iso8601', 'seconds_float', 'milliseconds_float'] = 'iso8601',
+    timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64', 'hex'] = 'utf8',
     inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
@@ -453,7 +453,7 @@ def to_jsonable_python(
         by_alias: Whether to use the alias names of fields.
         exclude_none: Whether to exclude fields that have a value of `None`.
         round_trip: Whether to enable serialization and validation round-trip support.
-        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'`, `'seconds_float'`, or`'milliseconds_float'`.
+        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.
         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails

python/pydantic_core/_pydantic_core.pyi

@@ -105,7 +105,7 @@ class CoreConfig(TypedDict, total=False):
     # fields related to float fields only
     allow_inf_nan: bool  # default: True
     # the config options are used to customise serialization to JSON
-    ser_json_timedelta: Literal['iso8601', 'seconds_float', 'milliseconds_float']  # default: 'iso8601'
+    ser_json_timedelta: Literal['iso8601', 'float']  # default: 'iso8601'
     ser_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
     ser_json_inf_nan: Literal['null', 'constants', 'strings']  # default: 'null'
     val_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'

python/pydantic_core/core_schema.py

@@ -109,93 +109,6 @@ impl<'a> EitherTimedelta<'a> {
             Self::Raw(duration) => duration_as_pytimedelta(py, duration),
         }
     }
-
-    pub fn total_seconds(&self) -> PyResult<f64> {
-        match self {
-            Self::Raw(timedelta) => {
-                let mut days: i64 = i64::from(timedelta.day);
-                let mut seconds: i64 = i64::from(timedelta.second);
-                let mut microseconds = i64::from(timedelta.microsecond);
-                if !timedelta.positive {
-                    days = -days;
-                    seconds = -seconds;
-                    microseconds = -microseconds;
-                }
-
-                let days_seconds = (86_400 * days) + seconds;
-                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
-                    let total_microseconds = days_seconds_as_micros + microseconds;
-                    Ok(total_microseconds as f64 / 1_000_000.0)
-                } else {
-                    // Fall back to floating-point operations if the multiplication overflows
-                    let total_seconds = days_seconds as f64 + microseconds as f64 / 1_000_000.0;
-                    Ok(total_seconds)
-                }
-            }
-            Self::PyExact(py_timedelta) => {
-                let days: i64 = py_timedelta.get_days().into(); // -999999999 to 999999999
-                let seconds: i64 = py_timedelta.get_seconds().into(); // 0 through 86399
-                let microseconds = py_timedelta.get_microseconds(); // 0 through 999999
-                let days_seconds = (86_400 * days) + seconds;
-                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
-                    let total_microseconds = days_seconds_as_micros + i64::from(microseconds);
-                    Ok(total_microseconds as f64 / 1_000_000.0)
-                } else {
-                    // Fall back to floating-point operations if the multiplication overflows
-                    let total_seconds = days_seconds as f64 + f64::from(microseconds) / 1_000_000.0;
-                    Ok(total_seconds)
-                }
-            }
-            Self::PySubclass(py_timedelta) => py_timedelta
-                .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
-                .extract(),
-        }
-    }
-
-    pub fn total_milliseconds(&self) -> PyResult<f64> {
-        match self {
-            Self::Raw(timedelta) => {
-                let mut days: i64 = i64::from(timedelta.day);
-                let mut seconds: i64 = i64::from(timedelta.second);
-                let mut microseconds = i64::from(timedelta.microsecond);
-                if !timedelta.positive {
-                    days = -days;
-                    seconds = -seconds;
-                    microseconds = -microseconds;
-                }
-
-                let days_seconds = (86_400 * days) + seconds;
-                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
-                    let total_microseconds = days_seconds_as_micros + microseconds;
-                    Ok(total_microseconds as f64 / 1_000.0)
-                } else {
-                    // Fall back to floating-point operations if the multiplication overflows
-                    let total_seconds = days_seconds as f64 + microseconds as f64 / 1_000.0;
-                    Ok(total_seconds)
-                }
-            }
-            Self::PyExact(py_timedelta) => {
-                let days: i64 = py_timedelta.get_days().into(); // -999999999 to 999999999
-                let seconds: i64 = py_timedelta.get_seconds().into(); // 0 through 86399
-                let microseconds = py_timedelta.get_microseconds(); // 0 through 999999
-                let days_seconds = (86_400 * days) + seconds;
-                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
-                    let total_microseconds = days_seconds_as_micros + i64::from(microseconds);
-                    Ok(total_microseconds as f64 / 1_000.0)
-                } else {
-                    // Fall back to floating-point operations if the multiplication overflows
-                    let total_milliseconds = days_seconds as f64 * 1_000.0 + f64::from(microseconds) / 1_000.0;
-                    Ok(total_milliseconds)
-                }
-            }
-            Self::PySubclass(py_timedelta) => {
-                let total_seconds: f64 = py_timedelta
-                    .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
-                    .extract()?;
-                Ok(total_seconds / 1000.0)
-            }
-        }
-    }
 }
 
 impl<'a> TryFrom<&'_ Bound<'a, PyAny>> for EitherTimedelta<'a> {

src/input/datetime.rs

@@ -4,7 +4,7 @@ use std::str::{from_utf8, FromStr, Utf8Error};
 use base64::Engine;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyString};
+use pyo3::types::{PyDelta, PyDict, PyString};
 
 use serde::ser::Error;
 
@@ -88,8 +88,7 @@ serialization_mode! {
     TimedeltaMode,
     "ser_json_timedelta",
     Iso8601 => "iso8601",
-    SecondsFloat => "seconds_float",
-    MillisecondsFloat => "milliseconds_float"
+    Float => "float",
 }
 
 serialization_mode! {
@@ -109,42 +108,43 @@ serialization_mode! {
 }
 
 impl TimedeltaMode {
+    fn total_seconds<'py>(py_timedelta: &Bound<'py, PyDelta>) -> PyResult<Bound<'py, PyAny>> {
+        py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
+    }
+
     pub fn either_delta_to_json(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<PyObject> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
                 Ok(d.to_string().into_py(py))
             }
-            Self::SecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds()?;
+            Self::Float => {
+                // convert to int via a py timedelta not duration since we know this this case the input would have
+                // been a py timedelta
+                let py_timedelta = either_delta.try_into_py(py)?;
+                let seconds = Self::total_seconds(&py_timedelta)?;
                 Ok(seconds.into_py(py))
             }
-            Self::MillisecondsFloat => {
-                let milliseconds: f64 = either_delta.total_milliseconds()?;
-                Ok(milliseconds.into_py(py))
-            }
         }
     }
 
-    pub fn json_key<'py>(self, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
+    pub fn json_key<'py>(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
                 Ok(d.to_string().into())
             }
-            Self::SecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds()?;
+            Self::Float => {
+                let py_timedelta = either_delta.try_into_py(py)?;
+                let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
                 Ok(seconds.to_string().into())
             }
-            Self::MillisecondsFloat => {
-                let milliseconds: f64 = either_delta.total_milliseconds()?;
-                Ok(milliseconds.to_string().into())
-            }
         }
     }
 
     pub fn timedelta_serialize<S: serde::ser::Serializer>(
         self,
+        py: Python,
         either_delta: &EitherTimedelta,
         serializer: S,
     ) -> Result<S::Ok, S::Error> {
@@ -153,14 +153,12 @@ impl TimedeltaMode {
                 let d = either_delta.to_duration().map_err(py_err_se_err)?;
                 serializer.serialize_str(&d.to_string())
             }
-            Self::SecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds().map_err(py_err_se_err)?;
+            Self::Float => {
+                let py_timedelta = either_delta.try_into_py(py).map_err(py_err_se_err)?;
+                let seconds = Self::total_seconds(&py_timedelta).map_err(py_err_se_err)?;
+                let seconds: f64 = seconds.extract().map_err(py_err_se_err)?;
                 serializer.serialize_f64(seconds)
             }
-            Self::MillisecondsFloat => {
-                let milliseconds: f64 = either_delta.total_milliseconds().map_err(py_err_se_err)?;
-                serializer.serialize_f64(milliseconds)
-            }
         }
     }
 }

src/serializers/config.rs

@@ -471,7 +471,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             extra
                 .config
                 .timedelta_mode
-                .timedelta_serialize(&either_delta, serializer)
+                .timedelta_serialize(value.py(), &either_delta, serializer)
         }
         ObType::Url => {
             let py_url: PyUrl = value.extract().map_err(py_err_se_err)?;
@@ -649,7 +649,7 @@ pub(crate) fn infer_json_key_known<'a>(
         }
         ObType::Timedelta => {
             let either_delta = EitherTimedelta::try_from(key)?;
-            extra.config.timedelta_mode.json_key(&either_delta)
+            extra.config.timedelta_mode.json_key(key.py(), &either_delta)
         }
         ObType::Url => {
             let py_url: PyUrl = key.extract()?;

src/serializers/infer.rs

@@ -54,7 +54,7 @@ impl TypeSerializer for TimeDeltaSerializer {
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match EitherTimedelta::try_from(key) {
-            Ok(either_timedelta) => self.timedelta_mode.json_key(&either_timedelta),
+            Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), &either_timedelta),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
                 infer_json_key(key, extra)
@@ -71,7 +71,9 @@ impl TypeSerializer for TimeDeltaSerializer {
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match EitherTimedelta::try_from(value) {
-            Ok(either_timedelta) => self.timedelta_mode.timedelta_serialize(&either_timedelta, serializer),
+            Ok(either_timedelta) => self
+                .timedelta_mode
+                .timedelta_serialize(value.py(), &either_timedelta, serializer),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)

src/serializers/type_serializers/timedelta.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
     }
 }