update things

Author: CloseChoice

.github/workflows/ci.yml

@@ -26,7 +26,7 @@ jobs:
           python-version: ${{ env.UV_PYTHON}}
 
       - name: install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
 

.github/workflows/codspeed.yml

@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.40.1"
+version = "2.41.4"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -28,7 +28,7 @@ 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.26", features = ["generate-import-lib", "num-bigint", "py-clone"] }
-regex = "1.11.3"
+regex = "1.12.2"
 strum = { version = "0.27", features = ["derive"] }
 strum_macros = "0.27"
 serde_json = { version = "1.0.145", features = ["arbitrary_precision"] }
@@ -44,8 +44,9 @@ base64 = "0.22.1"
 num-bigint = "0.4.6"
 num-traits = "0.2.19"
 uuid = "1.18.1"
-jiter = { version = "0.11.0", features = ["python"] }
+jiter = { version = "0.11.1", features = ["python"] }
 hex = "0.4.3"
+percent-encoding = "2.3.2"
 
 [lib]
 name = "_pydantic_core"
@@ -90,9 +91,7 @@ doc_markdown = "allow"
 float_cmp = "allow"
 fn_params_excessive_bools = "allow"
 if_not_else = "allow"
-manual_let_else = "allow"
 match_bool = "allow"
-match_same_arms = "allow"
 missing_errors_doc = "allow"
 missing_panics_doc = "allow"
 module_name_repetitions = "allow"

Cargo.lock

@@ -80,6 +80,7 @@ class CoreConfig(TypedDict, total=False):
         validate_by_alias: Whether to use the field's alias when validating against the provided input data. Default is `True`.
         validate_by_name: Whether to use the field's name when validating against the provided input data. Default is `False`. Replacement for `populate_by_name`.
         serialize_by_alias: Whether to serialize by alias. Default is `False`, expected to change to `True` in V3.
+        url_preserve_empty_path: Whether to preserve empty URL paths when validating values for a URL type. Defaults to `False`.
     """
 
     title: str
@@ -120,6 +121,7 @@ class CoreConfig(TypedDict, total=False):
     validate_by_alias: bool  # default: True
     validate_by_name: bool  # default: False
     serialize_by_alias: bool  # default: False
+    url_preserve_empty_path: bool  # default: False
 
 
 IncExCall: TypeAlias = 'set[int | str] | dict[int | str, IncExCall] | None'
@@ -4294,6 +4296,7 @@ def definition_reference_schema(
     'model_attributes_type',
     'dataclass_type',
     'dataclass_exact_type',
+    'default_factory_not_called',
     'none_required',
     'greater_than',
     'greater_than_equal',

Cargo.toml

@@ -60,10 +60,9 @@ impl PydanticUndefinedType {
     }
 
     #[staticmethod]
-    pub fn new(py: Python) -> Py<Self> {
-        UNDEFINED_CELL
-            .get_or_init(py, || Py::new(py, PydanticUndefinedType {}).unwrap())
-            .clone_ref(py)
+    #[pyo3(name = "new")]
+    pub fn get(py: Python<'_>) -> &Py<Self> {
+        UNDEFINED_CELL.get_or_init(py, || Py::new(py, PydanticUndefinedType {}).unwrap())
     }
 
     fn __repr__(&self) -> &'static str {

python/pydantic_core/core_schema.py

@@ -41,7 +41,7 @@ impl From<String> for LocItem {
 
 impl From<&String> for LocItem {
     fn from(s: &String) -> Self {
-        s.to_string().into()
+        s.clone().into()
     }
 }
 
@@ -87,22 +87,17 @@ impl Serialize for LocItem {
 /// Note: location in List is stored in **REVERSE** so adding an "outer" item to location involves
 /// pushing to the vec which is faster than inserting and shifting everything along.
 /// Then when "using" location in `Display` and `ToPyObject` order has to be reversed
-#[derive(Clone)]
+#[derive(Clone, Default)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum Location {
     // no location, avoid creating an unnecessary vec
+    #[default]
     Empty,
     // store the in a vec of LocItems, Note: this is the REVERSE of location, see above
     // we could perhaps use a smallvec or similar here, probably only worth it if we store a Cow in LocItem
     List(Vec<LocItem>),
 }
 
-impl Default for Location {
-    fn default() -> Self {
-        Self::Empty
-    }
-}
-
 static EMPTY_TUPLE: PyOnceLock<Py<PyTuple>> = PyOnceLock::new();
 
 impl<'py> IntoPyObject<'py> for &'_ Location {

src/argument_markers.rs

@@ -196,6 +196,9 @@ error_types! {
         class_name: {ctx_type: String, ctx_fn: field_from_context},
     },
     // ---------------------
+    // Default factory not called (happens when there's already an error and the factory takes data)
+    DefaultFactoryNotCalled {},
+    // ---------------------
     // None errors
     NoneRequired {},
     // ---------------------
@@ -480,6 +483,7 @@ impl ErrorType {
     }
 
     pub fn message_template_python(&self) -> &'static str {
+        #[allow(clippy::match_same_arms)]  // much nicer to have the messages explicitly listed
         match self {
             Self::NoSuchAttribute {..} => "Object has no attribute '{attribute}'",
             Self::JsonInvalid {..} => "Invalid JSON: {error}",
@@ -496,6 +500,7 @@ impl ErrorType {
             Self::ModelAttributesType {..} => "Input should be a valid dictionary or object to extract fields from",
             Self::DataclassType {..} => "Input should be a dictionary or an instance of {class_name}",
             Self::DataclassExactType {..} => "Input should be an instance of {class_name}",
+            Self::DefaultFactoryNotCalled {..} => "The default factory uses validated data, but at least one validation error occurred",
             Self::NoneRequired {..} => "Input should be None",
             Self::GreaterThan {..} => "Input should be greater than {gt}",
             Self::GreaterThanEqual {..} => "Input should be greater than or equal to {ge}",
@@ -637,12 +642,24 @@ impl ErrorType {
         };
         match self {
             Self::NoSuchAttribute { attribute, .. } => render!(tmpl, attribute),
-            Self::JsonInvalid { error, .. } => render!(tmpl, error),
+            Self::JsonInvalid { error, .. }
+            | Self::GetAttributeError { error, .. }
+            | Self::IterationError { error, .. }
+            | Self::DatetimeObjectInvalid { error, .. }
+            | Self::UrlParsing { error, .. }
+            | Self::UuidParsing { error, .. } => render!(tmpl, error),
+            Self::MappingType { error, .. }
+            | Self::DateParsing { error, .. }
+            | Self::DateFromDatetimeParsing { error, .. }
+            | Self::TimeParsing { error, .. }
+            | Self::DatetimeParsing { error, .. }
+            | Self::DatetimeFromDateParsing { error, .. }
+            | Self::TimeDeltaParsing { error, .. }
+            | Self::UrlSyntaxViolation { error, .. } => render!(tmpl, error),
             Self::NeedsPythonObject { method_name, .. } => render!(tmpl, method_name),
-            Self::GetAttributeError { error, .. } => render!(tmpl, error),
-            Self::ModelType { class_name, .. } => render!(tmpl, class_name),
-            Self::DataclassType { class_name, .. } => render!(tmpl, class_name),
-            Self::DataclassExactType { class_name, .. } => render!(tmpl, class_name),
+            Self::ModelType { class_name, .. }
+            | Self::DataclassType { class_name, .. }
+            | Self::DataclassExactType { class_name, .. } => render!(tmpl, class_name),
             Self::GreaterThan { gt, .. } => to_string_render!(tmpl, gt),
             Self::GreaterThanEqual { ge, .. } => to_string_render!(tmpl, ge),
             Self::LessThan { lt, .. } => to_string_render!(tmpl, lt),
@@ -667,26 +684,18 @@ impl ErrorType {
                 let actual_length = actual_length.map_or(Cow::Borrowed("more"), |v| Cow::Owned(v.to_string()));
                 to_string_render!(tmpl, field_type, max_length, actual_length, expected_plural,)
             }
-            Self::IterationError { error, .. } => render!(tmpl, error),
-            Self::StringTooShort { min_length, .. } => {
+            Self::StringTooShort { min_length, .. } | Self::BytesTooShort { min_length, .. } => {
                 let expected_plural = plural_s(*min_length);
                 to_string_render!(tmpl, min_length, expected_plural)
             }
-            Self::StringTooLong { max_length, .. } => {
+            Self::StringTooLong { max_length, .. }
+            | Self::BytesTooLong { max_length, .. }
+            | Self::UrlTooLong { max_length, .. } => {
                 let expected_plural = plural_s(*max_length);
                 to_string_render!(tmpl, max_length, expected_plural)
             }
             Self::StringPatternMismatch { pattern, .. } => render!(tmpl, pattern),
             Self::Enum { expected, .. } => to_string_render!(tmpl, expected),
-            Self::MappingType { error, .. } => render!(tmpl, error),
-            Self::BytesTooShort { min_length, .. } => {
-                let expected_plural = plural_s(*min_length);
-                to_string_render!(tmpl, min_length, expected_plural)
-            }
-            Self::BytesTooLong { max_length, .. } => {
-                let expected_plural = plural_s(*max_length);
-                to_string_render!(tmpl, max_length, expected_plural)
-            }
             Self::BytesInvalidEncoding {
                 encoding,
                 encoding_error,
@@ -710,33 +719,18 @@ impl ErrorType {
                 ..
             } => PydanticCustomError::format_message(message_template, context.as_ref().map(|c| c.bind(py))),
             Self::LiteralError { expected, .. } => render!(tmpl, expected),
-            Self::DateParsing { error, .. } => render!(tmpl, error),
-            Self::DateFromDatetimeParsing { error, .. } => render!(tmpl, error),
-            Self::TimeParsing { error, .. } => render!(tmpl, error),
-            Self::DatetimeParsing { error, .. } => render!(tmpl, error),
-            Self::DatetimeFromDateParsing { error, .. } => render!(tmpl, error),
-            Self::DatetimeObjectInvalid { error, .. } => render!(tmpl, error),
             Self::TimezoneOffset {
                 tz_expected, tz_actual, ..
             } => to_string_render!(tmpl, tz_expected, tz_actual),
-            Self::TimeDeltaParsing { error, .. } => render!(tmpl, error),
-            Self::IsInstanceOf { class, .. } => render!(tmpl, class),
-            Self::IsSubclassOf { class, .. } => render!(tmpl, class),
+            Self::IsInstanceOf { class, .. } | Self::IsSubclassOf { class, .. } => render!(tmpl, class),
             Self::UnionTagInvalid {
                 discriminator,
                 tag,
                 expected_tags,
                 ..
             } => render!(tmpl, discriminator, tag, expected_tags),
             Self::UnionTagNotFound { discriminator, .. } => render!(tmpl, discriminator),
-            Self::UrlParsing { error, .. } => render!(tmpl, error),
-            Self::UrlSyntaxViolation { error, .. } => render!(tmpl, error),
-            Self::UrlTooLong { max_length, .. } => {
-                let expected_plural = plural_s(*max_length);
-                to_string_render!(tmpl, max_length, expected_plural)
-            }
             Self::UrlScheme { expected_schemes, .. } => render!(tmpl, expected_schemes),
-            Self::UuidParsing { error, .. } => render!(tmpl, error),
             Self::UuidVersion { expected_version, .. } => to_string_render!(tmpl, expected_version),
             Self::DecimalMaxDigits { max_digits, .. } => {
                 let expected_plural = plural_s(*max_digits);