Merge main

Author: dmontagu

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.3.0"
+version = "2.4.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -35,7 +35,7 @@ enum_dispatch = "0.3.8"
 serde = { version = "1.0.147", features = ["derive"] }
 # disabled for benchmarks since it makes microbenchmark performance more flakey
 mimalloc = { version = "0.1.30", optional = true, default-features = false, features = ["local_dynamic_tls"] }
-speedate = "0.10.0"
+speedate = "0.11.0"
 ahash = "0.8.0"
 url = "2.3.1"
 # idna is already required by url, added here to be explicit

Cargo.toml

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 import decimal
 import sys
 from typing import Any, Callable, Generic, Optional, Type, TypeVar
@@ -43,6 +44,7 @@ __all__ = [
     'to_json',
     'to_jsonable_python',
     'list_all_errors',
+    'TzInfo',
 ]
 __version__: str
 build_profile: str
@@ -71,7 +73,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: Any = None,
+        context: 'dict[str, Any] | None' = None,
         self_instance: Any | None = None,
     ) -> Any: ...
     def isinstance_python(
@@ -80,15 +82,15 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: Any = None,
+        context: 'dict[str, Any] | None' = None,
         self_instance: Any | None = None,
     ) -> bool: ...
     def validate_json(
         self,
         input: str | bytes | bytearray,
         *,
         strict: bool | None = None,
-        context: Any = None,
+        context: 'dict[str, Any] | None' = None,
         self_instance: Any | None = None,
     ) -> Any: ...
     def validate_assignment(
@@ -99,7 +101,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: Any = None,
+        context: 'dict[str, Any] | None' = None,
     ) -> dict[str, Any] | tuple[dict[str, Any], dict[str, Any] | None, set[str]]:
         """
         ModelValidator and ModelFieldsValidator will return a tuple of (fields data, extra data, fields set)
@@ -326,3 +328,10 @@ def list_all_errors() -> list[ErrorTypeInfo]:
     """
     Get information about all built-in errors.
     """
+
+@final
+class TzInfo(datetime.tzinfo):
+    def tzname(self, _dt: datetime.datetime | None) -> str | None: ...
+    def utcoffset(self, _dt: datetime.datetime | None) -> datetime.timedelta: ...
+    def dst(self, _dt: datetime.datetime | None) -> datetime.timedelta: ...
+    def __deepcopy__(self, _memo: dict[Any, Any]) -> 'TzInfo': ...

python/pydantic_core/_pydantic_core.pyi

@@ -1,14 +1,15 @@
 use pyo3::intern;
 use pyo3::prelude::*;
+
 use pyo3::types::{PyDate, PyDateTime, PyDelta, PyDeltaAccess, PyDict, PyTime, PyTzInfo};
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 use speedate::{Date, DateTime, Duration, ParseError, Time, TimeConfig};
 use std::borrow::Cow;
-use strum::EnumMessage;
 
-use crate::errors::{ErrorType, ValError, ValResult};
+use strum::EnumMessage;
 
 use super::Input;
+use crate::errors::{ErrorType, ValError, ValResult};
 
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherDate<'a> {
@@ -272,8 +273,9 @@ pub fn bytes_as_time<'a>(
 ) -> ValResult<'a, EitherTime<'a>> {
     match Time::parse_bytes_with_config(
         bytes,
-        TimeConfig {
+        &TimeConfig {
             microseconds_precision_overflow_behavior: microseconds_overflow_behavior,
+            unix_timestamp_offset: Some(0),
         },
     ) {
         Ok(date) => Ok(date.into()),
@@ -293,8 +295,9 @@ pub fn bytes_as_datetime<'a, 'b>(
 ) -> ValResult<'a, EitherDateTime<'a>> {
     match DateTime::parse_bytes_with_config(
         bytes,
-        TimeConfig {
+        &TimeConfig {
             microseconds_precision_overflow_behavior: microseconds_overflow_behavior,
+            unix_timestamp_offset: Some(0),
         },
     ) {
         Ok(dt) => Ok(dt.into()),
@@ -312,7 +315,14 @@ pub fn int_as_datetime<'a>(
     timestamp: i64,
     timestamp_microseconds: u32,
 ) -> ValResult<EitherDateTime> {
-    match DateTime::from_timestamp(timestamp, timestamp_microseconds) {
+    match DateTime::from_timestamp_with_config(
+        timestamp,
+        timestamp_microseconds,
+        &TimeConfig {
+            unix_timestamp_offset: Some(0),
+            ..Default::default()
+        },
+    ) {
         Ok(dt) => Ok(dt.into()),
         Err(err) => Err(ValError::new(
             ErrorType::DatetimeParsing {
@@ -381,7 +391,14 @@ pub fn int_as_time<'a>(
         // ok
         t => t as u32,
     };
-    match Time::from_timestamp(time_timestamp, timestamp_microseconds) {
+    match Time::from_timestamp_with_config(
+        time_timestamp,
+        timestamp_microseconds,
+        &TimeConfig {
+            unix_timestamp_offset: Some(0),
+            ..Default::default()
+        },
+    ) {
         Ok(dt) => Ok(dt.into()),
         Err(err) => Err(ValError::new(
             ErrorType::TimeParsing {
@@ -415,8 +432,9 @@ pub fn bytes_as_timedelta<'a, 'b>(
 ) -> ValResult<'a, EitherTimedelta<'a>> {
     match Duration::parse_bytes_with_config(
         bytes,
-        TimeConfig {
+        &TimeConfig {
             microseconds_precision_overflow_behavior: microseconds_overflow_behavior,
+            unix_timestamp_offset: Some(0),
         },
     ) {
         Ok(dt) => Ok(dt.into()),
@@ -447,7 +465,7 @@ pub fn float_as_duration<'a>(input: &'a impl Input<'a>, total_seconds: f64) -> V
 #[pyclass(module = "pydantic_core._pydantic_core", extends = PyTzInfo)]
 #[derive(Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
-struct TzInfo {
+pub struct TzInfo {
     seconds: i32,
 }
 
@@ -486,4 +504,10 @@ impl TzInfo {
     fn __deepcopy__(&self, py: Python, _memo: &PyDict) -> PyResult<Py<Self>> {
         Py::new(py, self.clone())
     }
+
+    pub fn __reduce__(&self, py: Python) -> PyResult<PyObject> {
+        let args = (self.seconds,);
+        let cls = Py::new(py, self.clone())?.getattr(py, "__class__")?;
+        Ok((cls, args).into_py(py))
+    }
 }

src/input/datetime.rs

@@ -10,6 +10,7 @@ mod parse_json;
 mod return_enums;
 mod shared;
 
+pub use datetime::TzInfo;
 pub(crate) use datetime::{
     duration_as_pytimedelta, pydate_as_date, pydatetime_as_datetime, pytime_as_time, pytimedelta_as_duration,
     EitherDate, EitherDateTime, EitherTime, EitherTimedelta,

src/input/mod.rs

@@ -24,6 +24,7 @@ mod url;
 mod validators;
 
 // required for benchmarks
+pub use self::input::TzInfo;
 pub use self::url::{PyMultiHostUrl, PyUrl};
 pub use argument_markers::{ArgsKwargs, PydanticUndefinedType};
 pub use build_tools::SchemaError;
@@ -93,6 +94,7 @@ fn _pydantic_core(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<PyMultiHostUrl>()?;
     m.add_class::<ArgsKwargs>()?;
     m.add_class::<SchemaSerializer>()?;
+    m.add_class::<TzInfo>()?;
     m.add_function(wrap_pyfunction!(to_json, m)?)?;
     m.add_function(wrap_pyfunction!(to_jsonable_python, m)?)?;
     m.add_function(wrap_pyfunction!(list_all_errors, m)?)?;

src/lib.rs

@@ -135,6 +135,9 @@ impl ComputedField {
             let value = self
                 .serializer
                 .to_python(next_value, next_include, next_exclude, extra)?;
+            if extra.exclude_none && value.is_none(py) {
+                return Ok(());
+            }
             let key = match extra.by_alias {
                 true => self.alias_py.as_ref(py),
                 false => property_name_py,

src/serializers/computed_fields.rs

@@ -153,7 +153,7 @@ fn date_from_datetime<'data>(
         minute: 0,
         second: 0,
         microsecond: 0,
-        tz_offset: None,
+        tz_offset: dt.time.tz_offset,
     };
     if dt.time == zero_time {
         Ok(EitherDate::Raw(dt.date))

src/validators/date.rs

@@ -605,6 +605,46 @@ def volume(self) -> int:
     assert s.to_json(Model(3, 4)) == b'{"width":3,"height":4,"Area":12,"volume":48}'
 
 
+def test_computed_field_to_python_exclude_none():
+    @dataclasses.dataclass
+    class Model:
+        width: int
+        height: int
+
+        @property
+        def area(self) -> int:
+            return self.width * self.height
+
+        @property
+        def volume(self) -> None:
+            return None
+
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            Model,
+            core_schema.model_fields_schema(
+                {
+                    'width': core_schema.model_field(core_schema.int_schema()),
+                    'height': core_schema.model_field(core_schema.int_schema()),
+                },
+                computed_fields=[
+                    core_schema.computed_field('area', core_schema.int_schema(), alias='Area'),
+                    core_schema.computed_field('volume', core_schema.int_schema()),
+                ],
+            ),
+        )
+    )
+    assert s.to_python(Model(3, 4), exclude_none=False) == {'width': 3, 'height': 4, 'Area': 12, 'volume': None}
+    assert s.to_python(Model(3, 4), exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
+    assert s.to_python(Model(3, 4), mode='json', exclude_none=False) == {
+        'width': 3,
+        'height': 4,
+        'Area': 12,
+        'volume': None,
+    }
+    assert s.to_python(Model(3, 4), mode='json', exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
+
+
 @pytest.mark.skipif(cached_property is None, reason='cached_property is not available')
 def test_cached_property_alias():
     @dataclasses.dataclass

tests/serializers/test_model.py

@@ -36,7 +36,7 @@ def test_datetime_int(datetime_schema, data):
     except OverflowError:
         pytest.skip('OverflowError, see pyodide/pyodide#2841, this can happen on 32-bit systems')
     else:
-        assert datetime_schema.validate_python(data) == expected, data
+        assert datetime_schema.validate_python(data).replace(tzinfo=None) == expected, data
 
 
 @given(strategies.binary())