Preserve order for collections.OrderedDict

src/input/input_python.rs

@@ -48,6 +48,35 @@ use super::{
     Input,
 };
 
+static ORDERED_DICT_TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+
+fn get_ordered_dict_type(py: Python<'_>) -> &Bound<'_, PyType> {
+    ORDERED_DICT_TYPE
+        .get_or_init(py, || {
+            py.import("collections")
+                .and_then(|collections_module| collections_module.getattr("OrderedDict"))
+                .unwrap()
+                .extract()
+                .unwrap()
+        })
+        .bind(py)
+}
+
+fn check_if_ordered_dict(obj: &Bound<'_, PyAny>) -> bool {
+    if obj.is_exact_instance_of::<PyDict>() {
+        return false;
+    }
+
+    if let Ok(type_name) = obj.get_type().name() {
+        if type_name != "OrderedDict" {
+            return false;
+        }
+    }
+
+    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> {
@@ -395,15 +424,19 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Self: 'a;
 
     fn strict_dict<'a>(&'a self) -> ValResult<GenericPyMapping<'a, 'py>> {
-        if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(GenericPyMapping::Dict(dict))
+        if self.is_exact_instance_of::<PyDict>() {
+            Ok(GenericPyMapping::Dict(self.downcast::<PyDict>()?))
+        } else if check_if_ordered_dict(self) {
+            Ok(GenericPyMapping::Mapping(self.downcast::<PyMapping>()?))
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
     }
 
     fn lax_dict<'a>(&'a self) -> ValResult<GenericPyMapping<'a, 'py>> {
-        if let Ok(dict) = self.downcast::<PyDict>() {
+        if check_if_ordered_dict(self) {
+            Ok(GenericPyMapping::Mapping(self.downcast::<PyMapping>()?))
+        } else if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(GenericPyMapping::Dict(dict))
         } else if let Ok(mapping) = self.downcast::<PyMapping>() {
             Ok(GenericPyMapping::Mapping(mapping))

tests/validators/test_dict.py

@@ -313,3 +313,25 @@ def test_dict_fail_fast(fail_fast, expected):
         v.validate_python({'a': 'b', 'c': 'd'})
 
     assert exc_info.value.errors(include_url=False) == expected
+
+
+@pytest.mark.parametrize('strict', [True, False])
+def test_ordered_dict_key_order_preservation(strict):
+    # GH 12273
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.str_schema(), values_schema=cs.int_schema()))
+
+    # Original issue
+    foo = OrderedDict({'a': 1, 'b': 2})
+    foo.move_to_end('a')
+
+    result = v.validate_python(foo, strict=strict)
+    assert list(result.keys()) == list(foo.keys()) == ['b', 'a']
+    assert result == {'b': 2, 'a': 1}
+
+    # More complex case
+    foo2 = OrderedDict({'x': 1, 'y': 2, 'z': 3})
+    foo2.move_to_end('x')
+
+    result2 = v.validate_python(foo2, strict=strict)
+    assert list(result2.keys()) == list(foo2.keys()) == ['y', 'z', 'x']
+    assert result2 == {'y': 2, 'z': 3, 'x': 1}