WIP: try to fix linting

Author: CloseChoice

benches/main.rs

@@ -151,7 +151,6 @@ fn list_error_json(bench: &mut Bencher) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
-                // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "list[int]");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
                 assert_eq!(error_count, 100);
@@ -184,7 +183,6 @@ fn list_error_python_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
         Ok(_) => panic!("unexpectedly valid"),
         Err(e) => {
             let v = e.value(py);
-            // println!("error: {}", v.to_string());
             assert_eq!(v.getattr("title").unwrap().to_string(), "list[int]");
             let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
             assert_eq!(error_count, 100);
@@ -357,7 +355,6 @@ fn dict_value_error(bench: &mut Bencher) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
-                // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "dict[str,constrained-int]");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
                 assert_eq!(error_count, 100);
@@ -484,7 +481,6 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
-                // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "typed-dict");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
                 assert_eq!(error_count, 1);

src/input/input_python.rs

@@ -49,7 +49,7 @@ use super::{
     Input,
 };
 
-static FRACTION_TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+
 
 pub(crate) fn downcast_python_input<'py, T: PyTypeCheck>(input: &(impl Input<'py> + ?Sized)) -> Option<&Bound<'py, T>> {
     input.as_python().and_then(|any| any.downcast::<T>().ok())
@@ -59,7 +59,6 @@ pub(crate) fn input_as_python_instance<'a, 'py>(
     input: &'a (impl Input<'py> + ?Sized),
     class: &Bound<'py, PyType>,
 ) -> Option<&'a Bound<'py, PyAny>> {
-    println!("input_as_python_instance: class={:?}", class);
     input.as_python().filter(|any| any.is_instance(class).unwrap_or(false))
 }
 
@@ -158,7 +157,6 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         strict: bool,
         coerce_numbers_to_str: bool,
     ) -> ValResult<ValidationMatch<EitherString<'_, 'py>>> {
-        println!("[RUST]: Call validate_str with {:?}, and strict {:?}", self, strict);
         if let Ok(py_str) = self.downcast_exact::<PyString>() {
             return Ok(ValidationMatch::exact(py_str.clone().into()));
         } else if let Ok(py_str) = self.downcast::<PyString>() {
@@ -275,7 +273,6 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
 
         'lax: {
             if !strict {
-                println!("[RUST]: validate_int lax path for {:?}", self);
                 return if let Some(s) = maybe_as_string(self, ErrorTypeDefaults::IntParsing)? {
                     str_as_int(self, s)
                 } else if self.is_exact_instance_of::<PyFloat>() {
@@ -342,7 +339,6 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
     }
 
     fn validate_fraction(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
-        println!("[RUST]: Call validate_fraction with {:?}, and strict {:?}", self, strict);
         let fraction_type = get_fraction_type(py);
 
         // Fast path for existing decimal objects
@@ -383,7 +379,6 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
     }
 
     fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
-        println!("[RUST]: Call validate_decimal with {:?}, and strict {:?}", self, strict);
         let decimal_type = get_decimal_type(py);
 
         // Fast path for existing decimal objects

src/serializers/infer.rs

@@ -136,16 +136,8 @@ pub(crate) fn infer_to_python_known(
                 }
                 v.into_py_any(py)?
             }
-            ObType::Decimal => {
-                // todo: delete before PR ready
-                println!("[RUST] infer_to_python_known - SerMode::Json - serializing ObType::Decimal");
-                value.to_string().into_py_any(py)?
-            },
-            ObType::Fraction => {
-                // todo: delete before PR ready
-                println!("[RUST] infer_to_python_known - SerMode::Json - serializing ObType::Fraction");
-                value.to_string().into_py_any(py)?
-            },
+            ObType::Decimal => value.to_string().into_py_any(py)?,
+            ObType::Fraction => value.to_string().into_py_any(py)?,
             ObType::StrSubclass => PyString::new(py, value.downcast::<PyString>()?.to_str()?).into(),
             ObType::Bytes => extra
                 .config
@@ -439,16 +431,8 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             let v = value.extract::<f64>().map_err(py_err_se_err)?;
             type_serializers::float::serialize_f64(v, serializer, extra.config.inf_nan_mode)
         }
-        ObType::Decimal => {
-            // todo: delete before PR ready
-            println!("[RUST] infer_serialize_known - serializing ObType::Decimal");
-            value.to_string().serialize(serializer)
-        },
-        ObType::Fraction => {
-            // todo: delete before PR ready
-            println!("[RUST] infer_serialize_known - serializing ObType::Fraction");
-            value.to_string().serialize(serializer)
-        },
+        ObType::Decimal => value.to_string().serialize(serializer),
+        ObType::Fraction => value.to_string().serialize(serializer),
         ObType::Str | ObType::StrSubclass => {
             let py_str = value.downcast::<PyString>().map_err(py_err_se_err)?;
             super::type_serializers::string::serialize_py_str(py_str, serializer)
@@ -630,16 +614,8 @@ pub(crate) fn infer_json_key_known<'a>(
                 super::type_serializers::simple::to_str_json_key(key)
             }
         }
-        ObType::Decimal => {
-            // todo: delete before PR ready
-            println!("[RUST] infer_json_key_known - converting ObType::Decimal to json key");
-            Ok(Cow::Owned(key.to_string()))
-        },
-        ObType::Fraction => {
-            // todo: delete before PR ready
-            println!("[RUST] infer_json_key_known - converting ObType::Fraction to json key");
-            Ok(Cow::Owned(key.to_string()))
-        },
+        ObType::Decimal => Ok(Cow::Owned(key.to_string())),
+        ObType::Fraction => Ok(Cow::Owned(key.to_string())),
         ObType::Bool => super::type_serializers::simple::bool_json_key(key),
         ObType::Str | ObType::StrSubclass => key.downcast::<PyString>()?.to_cow(),
         ObType::Bytes => extra

src/serializers/ob_type.rs

@@ -64,24 +64,15 @@ pub enum IsType {
 impl ObTypeLookup {
     fn new(py: Python) -> Self {
         // todo: delete before PR ready
-        println!("[RUST] ObTypeLookup::new");
         Self {
             none: PyNone::type_object_raw(py) as usize,
             int: PyInt::type_object_raw(py) as usize,
             bool: PyBool::type_object_raw(py) as usize,
             float: PyFloat::type_object_raw(py) as usize,
             list: PyList::type_object_raw(py) as usize,
             dict: PyDict::type_object_raw(py) as usize,
-            decimal_object: {
-                // todo: delete before PR ready
-                println!("[RUST] ObTypeLookup::new - loading decimal_object");
-                py.import("decimal").unwrap().getattr("Decimal").unwrap().unbind()
-            },
-            fraction_object: {
-                // todo: delete before PR ready
-                println!("[RUST] ObTypeLookup::new - loading fraction_object");
-                py.import("fractions").unwrap().getattr("Fraction").unwrap().unbind()
-            },
+            decimal_object: py.import("decimal").unwrap().getattr("Decimal").unwrap().unbind(),
+            fraction_object: py.import("fractions").unwrap().getattr("Fraction").unwrap().unbind(),
             string: PyString::type_object_raw(py) as usize,
             bytes: PyBytes::type_object_raw(py) as usize,
             bytearray: PyByteArray::type_object_raw(py) as usize,
@@ -108,7 +99,6 @@ impl ObTypeLookup {
     }
 
     pub fn is_type(&self, value: &Bound<'_, PyAny>, expected_ob_type: ObType) -> IsType {
-        println!("[RUST] is_type - expected_ob_type: {expected_ob_type}");
         match self.ob_type_is_expected(Some(value), &value.get_type(), &expected_ob_type) {
             IsType::False => {
                 if expected_ob_type == self.fallback_isinstance(value) {
@@ -129,7 +119,6 @@ impl ObTypeLookup {
     ) -> IsType {
         let type_ptr = py_type.as_ptr();
         let ob_type = type_ptr as usize;
-        println!("[RUST] ob_type_is_expected - ob_type: {ob_type}, expected_ob_type: {expected_ob_type}");
         let ans = match expected_ob_type {
             ObType::None => self.none == ob_type,
             ObType::Int => self.int == ob_type,
@@ -151,16 +140,8 @@ impl ObTypeLookup {
             ObType::Str => self.string == ob_type,
             ObType::List => self.list == ob_type,
             ObType::Dict => self.dict == ob_type,
-            ObType::Decimal => {
-                // todo: delete before PR ready
-                println!("[RUST] ob_type_is_expected - checking ObType::Decimal");
-                self.decimal_object.as_ptr() as usize == ob_type
-            },
-            ObType::Fraction => {
-                // todo: delete before PR ready
-                println!("[RUST] ob_type_is_expected - checking ObType::Fraction");
-                self.fraction_object.as_ptr() as usize == ob_type
-            },
+            ObType::Decimal => self.decimal_object.as_ptr() as usize == ob_type,
+            ObType::Fraction => self.fraction_object.as_ptr() as usize == ob_type,
             ObType::StrSubclass => self.string == ob_type && op_value.is_none(),
             ObType::Tuple => self.tuple == ob_type,
             ObType::Set => self.set == ob_type,
@@ -237,12 +218,8 @@ impl ObTypeLookup {
         } else if ob_type == self.dict {
             ObType::Dict
         } else if ob_type == self.decimal_object.as_ptr() as usize {
-            // todo: delete before PR ready
-            println!("[RUST] lookup_by_ob_type - found ObType::Decimal");
             ObType::Decimal
         } else if ob_type == self.fraction_object.as_ptr() as usize {
-            // todo: delete before PR ready
-            println!("[RUST] lookup_by_ob_type - found ObType::Fraction");
             ObType::Fraction
         } else if ob_type == self.bytes {
             ObType::Bytes
@@ -351,12 +328,8 @@ impl ObTypeLookup {
         } else if value.is_instance_of::<PyMultiHostUrl>() {
             ObType::MultiHostUrl
         } else if value.is_instance(self.decimal_object.bind(py)).unwrap_or(false) {
-            // todo: delete before PR ready
-            println!("[RUST] fallback_isinstance - found ObType::Decimal");
             ObType::Decimal
         } else if value.is_instance(self.fraction_object.bind(py)).unwrap_or(false) {
-            // todo: delete before PR ready
-            println!("[RUST] fallback_isinstance - found ObType::Fraction");
             ObType::Fraction
         } else if value.is_instance(self.uuid_object.bind(py)).unwrap_or(false) {
             ObType::Uuid

src/serializers/type_serializers/fraction.rs

@@ -16,10 +16,11 @@ use super::{
 #[derive(Debug)]
 pub struct FractionSerializer {}
 
-static FRACTION_SERIALIZER: LazyLock<Arc<CombinedSerializer>> = LazyLock::new(|| Arc::new(FractionSerializer {}.into()));
+static FRACTION_SERIALIZER: LazyLock<Arc<CombinedSerializer>> =
+    LazyLock::new(|| Arc::new(FractionSerializer {}.into()));
 
 impl BuildSerializer for FractionSerializer {
-    const EXPECTED_TYPE: &'static str = "decimal";
+    const EXPECTED_TYPE: &'static str = "fraction";
 
     fn build(
         _schema: &Bound<'_, PyDict>,
@@ -41,7 +42,6 @@ impl TypeSerializer for FractionSerializer {
         extra: &Extra,
     ) -> PyResult<Py<PyAny>> {
         let _py = value.py();
-        println!("[RUST] FractionSerializer to_python called");
         match extra.ob_type_lookup.is_type(value, ObType::Fraction) {
             IsType::Exact | IsType::Subclass => infer_to_python_known(ObType::Fraction, value, include, exclude, extra),
             IsType::False => {

src/serializers/type_serializers/mod.rs

@@ -4,12 +4,12 @@ pub mod complex;
 pub mod dataclass;
 pub mod datetime_etc;
 pub mod decimal;
-pub mod fraction;
 pub mod definitions;
 pub mod dict;
 pub mod enum_;
 pub mod float;
 pub mod format;
+pub mod fraction;
 pub mod function;
 pub mod generator;
 pub mod json;

src/validators/fraction.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
 use pyo3::sync::PyOnceLock;
-use pyo3::types::{IntoPyDict, PyDict, PyString, PyTuple, PyType};
+use pyo3::types::{PyDict, PyString, PyType};
 use pyo3::{prelude::*, PyTypeInfo};
 
 use crate::build_tools::{is_strict, schema_or_config_same};
@@ -77,12 +77,7 @@ impl BuildValidator for FractionValidator {
     }
 }
 
-impl_py_gc_traverse!(FractionValidator {
-    le,
-    lt,
-    ge,
-    gt
-});
+impl_py_gc_traverse!(FractionValidator { le, lt, ge, gt });
 
 fn extract_fraction_as_ints(fraction: &Bound<'_, PyAny>) -> ValResult<(i64, i64)> {
     let py = fraction.py();