fix serialize_as_any with recursive ref

Author: nix010

src/serializers/type_serializers/definitions.rs

@@ -7,6 +7,7 @@ use pyo3::types::{PyDict, PyList};
 
 use crate::definitions::DefinitionsBuilder;
 use crate::definitions::{DefinitionRef, RecursionSafeCache};
+use crate::serializers::DuckTypingSerMode;
 
 use crate::tools::SchemaDict;
 
@@ -93,8 +94,12 @@ impl TypeSerializer for DefinitionRefSerializer {
     ) -> PyResult<PyObject> {
         self.definition.read(|comb_serializer| {
             let comb_serializer = comb_serializer.unwrap();
-            let mut guard = extra.recursion_guard(value, self.definition.id())?;
-            comb_serializer.to_python(value, include, exclude, guard.state())
+            if extra.duck_typing_ser_mode != DuckTypingSerMode::Inferred {
+                comb_serializer.to_python(value, include, exclude, extra)
+            } else {
+                let mut guard = extra.recursion_guard(value, self.definition.id())?;
+                comb_serializer.to_python(value, include, exclude, guard.state())
+            }
         })
     }
 
@@ -112,10 +117,14 @@ impl TypeSerializer for DefinitionRefSerializer {
     ) -> Result<S::Ok, S::Error> {
         self.definition.read(|comb_serializer| {
             let comb_serializer = comb_serializer.unwrap();
-            let mut guard = extra
-                .recursion_guard(value, self.definition.id())
-                .map_err(py_err_se_err)?;
-            comb_serializer.serde_serialize(value, serializer, include, exclude, guard.state())
+            if extra.duck_typing_ser_mode != DuckTypingSerMode::Inferred {
+                comb_serializer.serde_serialize(value, serializer, include, exclude, extra)
+            } else {
+                let mut guard = extra
+                    .recursion_guard(value, self.definition.id())
+                    .map_err(py_err_se_err)?;
+                comb_serializer.serde_serialize(value, serializer, include, exclude, guard.state())
+            }
         })
     }
 

tests/serializers/test_serialize_as_any.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from typing import Optional
 
 from typing_extensions import TypedDict
 
@@ -155,3 +156,38 @@ class Other:
         'x': 1,
         'y': 'hopefully not a secret',
     }
+
+
+def test_serialize_with_recursive_models() -> None:
+
+    class Node:
+        next: Optional['Node'] = None
+        value: int = 42
+
+    schema = core_schema.definitions_schema(
+        core_schema.definition_reference_schema('Node'),
+        [
+            core_schema.model_schema(
+                Node,
+                core_schema.model_fields_schema(
+                    {
+                        'value': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=42)),
+                        'next': core_schema.model_field(
+                            core_schema.with_default_schema(
+                                core_schema.nullable_schema(
+                                    core_schema.definition_reference_schema('Node')
+                                ),
+                                default=None,
+                            )
+                        ),
+                    }
+                ),
+                ref='Node',
+            )
+        ],
+    )
+
+    s = SchemaSerializer(schema)
+    v = SchemaValidator(schema)
+
+    obj = v.validate_python({'value': 2, 'asdas': 1})