Feedback

Author: Viicos

src/validators/decimal.rs

@@ -1,7 +1,7 @@
 use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
 use pyo3::sync::GILOnceCell;
-use pyo3::types::{IntoPyDict, PyDict, PyTuple, PyType};
+use pyo3::types::{IntoPyDict, PyDict, PyString, PyTuple, PyType};
 use pyo3::{prelude::*, PyTypeInfo};
 
 use crate::build_tools::{is_strict, schema_or_config_same};
@@ -28,7 +28,11 @@ pub fn get_decimal_type(py: Python) -> &Bound<'_, PyType> {
         .bind(py)
 }
 
-fn validate_as_decimal(py: Python, schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Py<PyAny>>> {
+fn validate_as_decimal(
+    py: Python,
+    schema: &Bound<'_, PyDict>,
+    key: &Bound<'_, PyString>,
+) -> PyResult<Option<Py<PyAny>>> {
     match schema.get_item(key)? {
         Some(value) => match value.validate_decimal(false, py) {
             Ok(v) => Ok(Some(v.into_inner().unbind())),
@@ -77,11 +81,11 @@ impl BuildValidator for DecimalValidator {
             allow_inf_nan,
             check_digits: decimal_places.is_some() || max_digits.is_some(),
             decimal_places,
-            multiple_of: validate_as_decimal(py, schema, "multiple_of")?,
-            le: validate_as_decimal(py, schema, "le")?,
-            lt: validate_as_decimal(py, schema, "lt")?,
-            ge: validate_as_decimal(py, schema, "ge")?,
-            gt: validate_as_decimal(py, schema, "gt")?,
+            multiple_of: validate_as_decimal(py, schema, intern!(py, "multiple_of"))?,
+            le: validate_as_decimal(py, schema, intern!(py, "le"))?,
+            lt: validate_as_decimal(py, schema, intern!(py, "lt"))?,
+            ge: validate_as_decimal(py, schema, intern!(py, "ge"))?,
+            gt: validate_as_decimal(py, schema, intern!(py, "gt"))?,
             max_digits,
         }
         .into())

src/validators/int.rs

@@ -2,7 +2,7 @@ use num_bigint::BigInt;
 use pyo3::exceptions::PyValueError;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::PyDict;
+use pyo3::types::{PyDict, PyString};
 use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::is_strict;
@@ -11,7 +11,7 @@ use crate::input::{Input, Int};
 
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-fn validate_as_int(schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Int>> {
+fn validate_as_int(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<Int>> {
     match schema.get_item(key)? {
         Some(value) => match value.validate_int(false) {
             Ok(v) => match v.into_inner().as_int() {
@@ -89,13 +89,14 @@ pub struct ConstrainedIntValidator {
 
 impl ConstrainedIntValidator {
     fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<CombinedValidator> {
+        let py = schema.py();
         Ok(Self {
             strict: is_strict(schema, config)?,
-            multiple_of: validate_as_int(schema, "multiple_of")?,
-            le: validate_as_int(schema, "le")?,
-            lt: validate_as_int(schema, "lt")?,
-            ge: validate_as_int(schema, "ge")?,
-            gt: validate_as_int(schema, "gt")?,
+            multiple_of: validate_as_int(schema, intern!(py, "multiple_of"))?,
+            le: validate_as_int(schema, intern!(py, "le"))?,
+            lt: validate_as_int(schema, intern!(py, "lt"))?,
+            ge: validate_as_int(schema, intern!(py, "ge"))?,
+            gt: validate_as_int(schema, intern!(py, "gt"))?,
         }
         .into())
     }

src/validators/timedelta.rs

@@ -1,6 +1,7 @@
 use pyo3::exceptions::PyValueError;
+use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDelta, PyDeltaAccess, PyDict};
+use pyo3::types::{PyDelta, PyDeltaAccess, PyDict, PyString};
 use speedate::{Duration, MicrosecondsPrecisionOverflowBehavior};
 
 use crate::build_tools::is_strict;
@@ -25,7 +26,7 @@ struct TimedeltaConstraints {
     gt: Option<Duration>,
 }
 
-fn get_constraint(schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Duration>> {
+fn get_constraint(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<Duration>> {
     match schema.get_item(key)? {
         Some(value) => match value.validate_timedelta(false, MicrosecondsPrecisionOverflowBehavior::default()) {
             Ok(v) => Ok(Some(v.into_inner().to_duration()?)),
@@ -45,11 +46,12 @@ impl BuildValidator for TimeDeltaValidator {
         config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
+        let py = schema.py();
         let constraints = TimedeltaConstraints {
-            le: get_constraint(schema, "le")?,
-            lt: get_constraint(schema, "lt")?,
-            ge: get_constraint(schema, "ge")?,
-            gt: get_constraint(schema, "gt")?,
+            le: get_constraint(schema, intern!(py, "le"))?,
+            lt: get_constraint(schema, intern!(py, "lt"))?,
+            ge: get_constraint(schema, intern!(py, "ge"))?,
+            gt: get_constraint(schema, intern!(py, "gt"))?,
         };
 
         Ok(Self {