WIP: add test

Author: CloseChoice

src/input/input_python.rs

@@ -62,6 +62,20 @@ fn get_ordered_dict_type(py: Python<'_>) -> &Bound<'_, PyType> {
         .bind(py)
 }
 
+// Lazy helper that only initializes OrderedDict type when actually needed
+fn check_if_ordered_dict(obj: &Bound<'_, PyAny>) -> bool {
+    // Quick type name check first - avoid Python import if possible
+    if let Ok(type_name) = obj.get_type().name() {
+        if type_name.to_string() != "OrderedDict" {
+            return false; // Fast path for non-OrderedDict objects
+        }
+    }
+
+    // Only now do we need the expensive type lookup
+    let ordered_dict_type = get_ordered_dict_type(obj.py());
+    obj.is_instance(ordered_dict_type).unwrap_or(false)
+}
+
 static FRACTION_TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
 
 pub fn get_fraction_type(py: Python<'_>) -> &Bound<'_, PyType> {
@@ -413,13 +427,14 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
     }
 
     fn lax_dict<'a>(&'a self) -> ValResult<GenericPyMapping<'a, 'py>> {
-        let ordered_dict_type = get_ordered_dict_type(self.py());
-        if self.is_instance(ordered_dict_type).unwrap_or(false) {
+        // Optimized: Only check for OrderedDict when needed
+        if check_if_ordered_dict(self) {
             // OrderedDict is a subclass of dict, but we want to treat it as a mapping to preserve order
             if let Ok(mapping) = self.downcast::<PyMapping>() {
                 return Ok(GenericPyMapping::Mapping(mapping));
             }
         }
+
         if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(GenericPyMapping::Dict(dict))
         } else if let Ok(mapping) = self.downcast::<PyMapping>() {

tests/validators/test_dict.py

@@ -255,3 +255,34 @@ def test_json_dict_complex_key():
     assert v.validate_json('{"1+2j": 2, "infj": 4}') == {complex(1, 2): 2, complex(0, float('inf')): 4}
     with pytest.raises(ValidationError, match='Input should be a valid complex string'):
         v.validate_json('{"1+2j": 2, "": 4}') == {complex(1, 2): 2, complex(0, float('inf')): 4}
+
+
+...
+def test_ordered_dict_key_order_preservation():
+    # GH 12273
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.str_schema(), values_schema=cs.int_schema()))
+
+    # Test case from original issue
+    foo = OrderedDict({"a": 1, "b": 2})
+    foo.move_to_end("a")
+
+    result = v.validate_python(foo)
+    assert list(result.keys()) == list(foo.keys()) == ['b', 'a']
+    assert result == {'b': 2, 'a': 1}
+
+    # Test with more complex reordering
+    foo2 = OrderedDict({"x": 1, "y": 2, "z": 3})
+    foo2.move_to_end("x")
+
+    result2 = v.validate_python(foo2)
+    assert list(result2.keys()) == list(foo2.keys()) == ['y', 'z', 'x']
+    assert result2 == {'y': 2, 'z': 3, 'x': 1}
+
+    # Test popitem and re-insertion
+    foo3 = OrderedDict({"p": 1, "q": 2})
+    item = foo3.popitem(last=False)
+    foo3[item[0]] = item[1]
+
+    result3 = v.validate_python(foo3)
+    assert list(result3.keys()) == list(foo3.keys()) == ['q', 'p']
+    assert result3 == {'q': 2, 'p': 1}