simplify, use without caching

Author: samuelcolvin

src/input/return_enums.rs

@@ -19,7 +19,7 @@ use serde::{ser::Error, Serialize, Serializer};
 use crate::errors::{
     py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ToErrorValue, ValError, ValLineError, ValResult,
 };
-use crate::tools::{extract_i64, py_err};
+use crate::tools::{extract_i64, new_py_string, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
 use super::{py_error_on_minusone, BorrowInput, Input};
@@ -437,14 +437,7 @@ impl<'a> EitherString<'a> {
 
     pub fn as_py_string(&'a self, py: Python<'a>, cache_str: StringCacheMode) -> Bound<'a, PyString> {
         match self {
-            Self::Cow(cow) => {
-                if matches!(cache_str, StringCacheMode::All) {
-                    let s = cow.as_ref();
-                    jiter::cached_py_string(py, s, bytecount::num_chars(s.as_bytes()) == s.len())
-                } else {
-                    PyString::new_bound(py, cow.as_ref())
-                }
-            }
+            Self::Cow(cow) => new_py_string(py, cow.as_ref(), cache_str),
             Self::Py(py_string) => py_string.clone(),
         }
     }

src/tools.rs

@@ -5,6 +5,8 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 use pyo3::{ffi, intern, FromPyObject};
 
+use jiter::{cached_py_string, pystring_fast_new, StringCacheMode};
+
 pub trait SchemaDict<'py> {
     fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
     where
@@ -143,3 +145,12 @@ pub fn extract_i64(v: &Bound<'_, PyAny>) -> Option<i64> {
         None
     }
 }
+
+pub(crate) fn new_py_string<'py>(py: Python<'py>, s: &str, cache_str: StringCacheMode) -> Bound<'py, PyString> {
+    let ascii_only = bytecount::num_chars(s.as_bytes()) == s.len();
+    if matches!(cache_str, StringCacheMode::All) {
+        cached_py_string(py, s, ascii_only)
+    } else {
+        pystring_fast_new(py, s, ascii_only)
+    }
+}

src/validators/validation_state.rs

@@ -4,6 +4,7 @@ use pyo3::types::PyString;
 use jiter::StringCacheMode;
 
 use crate::recursion_guard::{ContainsRecursionState, RecursionState};
+use crate::tools::new_py_string;
 
 use super::Extra;
 
@@ -72,11 +73,7 @@ impl<'a, 'py> ValidationState<'a, 'py> {
     }
 
     pub fn maybe_cached_str(&self, py: Python<'py>, s: &str) -> Bound<'py, PyString> {
-        if matches!(self.extra.cache_str, StringCacheMode::All) {
-            jiter::cached_py_string(py, s, bytecount::num_chars(s.as_bytes()) == s.len())
-        } else {
-            PyString::new_bound(py, s)
-        }
+        new_py_string(py, s, self.extra.cache_str)
     }
 }