PyStrRef

Author: ijl

Cargo.toml

@@ -38,6 +38,7 @@ avx512 = []
 cold_path = []
 generic_simd = []
 inline_int = []
+inline_str = []
 optimize = []
 
 [dependencies]

build.rs

@@ -17,6 +17,8 @@ fn main() {
             #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
             if is_64_bit_python {
                 println!("cargo:rustc-cfg=feature=\"inline_int\"");
+                #[cfg(target_endian = "little")]
+                println!("cargo:rustc-cfg=feature=\"inline_str\"");
             }
         }
         pyo3_build_config::PythonImplementation::GraalPy => not_supported("GraalPy"),

src/deserialize/backend/yyjson.rs

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
-// Copyright ijl (2022-2025), Anders Kaseorg (2023)
+// Copyright ijl (2022-2026), Anders Kaseorg (2023)
 
 use super::ffi::{
     YYJSON_READ_SUCCESS, yyjson_alc, yyjson_alc_pool_init, yyjson_doc, yyjson_read_err,
@@ -9,7 +9,7 @@ use crate::deserialize::DeserializeError;
 use crate::deserialize::pyobject::{
     get_unicode_key, parse_f64, parse_false, parse_i64, parse_none, parse_true, parse_u64,
 };
-use crate::str::PyStr;
+use crate::ffi::PyStrRef;
 use crate::util::usize_to_isize;
 use core::ffi::c_char;
 use core::ptr::{NonNull, null, null_mut};
@@ -175,7 +175,7 @@ impl ElementType {
 
 #[inline(always)]
 fn parse_yy_string(elem: *mut yyjson_val) -> NonNull<crate::ffi::PyObject> {
-    PyStr::from_str(str_from_slice!(
+    PyStrRef::from_str(str_from_slice!(
         (*elem).uni.str_.cast::<u8>(),
         unsafe_yyjson_get_len(elem)
     ))

src/deserialize/cache.rs

@@ -1,27 +1,27 @@
 // SPDX-License-Identifier: MPL-2.0
-// Copyright ijl (2019-2025)
+// Copyright ijl (2019-2026)
 
-use crate::str::PyStr;
+use crate::ffi::PyStrRef;
 use associative_cache::{AssociativeCache, Capacity2048, HashDirectMapped, RoundRobinReplacement};
 use core::cell::OnceCell;
 
 #[repr(transparent)]
 pub(crate) struct CachedKey {
-    ptr: PyStr,
+    ptr: PyStrRef,
 }
 
 unsafe impl Send for CachedKey {}
 unsafe impl Sync for CachedKey {}
 
 impl CachedKey {
-    pub fn new(ptr: PyStr) -> CachedKey {
+    pub fn new(ptr: PyStrRef) -> CachedKey {
         CachedKey { ptr: ptr }
     }
-    pub fn get(&mut self) -> PyStr {
+    pub fn get(&mut self) -> PyStrRef {
         let ptr = self.ptr.as_ptr();
         debug_assert!(ffi!(Py_REFCNT(ptr)) >= 1);
         ffi!(Py_INCREF(ptr));
-        self.ptr
+        self.ptr.clone()
     }
 }
 

src/deserialize/pyobject.rs

@@ -1,39 +1,47 @@
 // SPDX-License-Identifier: MPL-2.0
-// Copyright ijl (2022-2025)
+// Copyright ijl (2022-2026)
 
-#[cfg(not(Py_GIL_DISABLED))]
-use crate::deserialize::cache::{CachedKey, KEY_MAP};
-use crate::str::PyStr;
+use crate::ffi::PyStrRef;
 use crate::typeref::{FALSE, NONE, TRUE};
 use core::ptr::NonNull;
 
-#[cfg(not(Py_GIL_DISABLED))]
+#[cfg(all(CPython, not(Py_GIL_DISABLED)))]
 #[inline(always)]
-pub(crate) fn get_unicode_key(key_str: &str) -> PyStr {
+pub(crate) fn get_unicode_key(key_str: &str) -> PyStrRef {
     if key_str.len() > 64 {
         cold_path!();
-        PyStr::from_str_with_hash(key_str)
+        PyStrRef::from_str_with_hash(key_str)
     } else {
         assume!(key_str.len() <= 64);
         let hash = xxhash_rust::xxh3::xxh3_64(key_str.as_bytes());
         unsafe {
-            let entry = KEY_MAP
+            let entry = crate::deserialize::cache::KEY_MAP
                 .get_mut()
                 .unwrap_or_else(|| unreachable_unchecked!())
                 .entry(&hash)
                 .or_insert_with(
                     || hash,
-                    || CachedKey::new(PyStr::from_str_with_hash(key_str)),
+                    || {
+                        crate::deserialize::cache::CachedKey::new(PyStrRef::from_str_with_hash(
+                            key_str,
+                        ))
+                    },
                 );
             entry.get()
         }
     }
 }
 
-#[cfg(Py_GIL_DISABLED)]
+#[cfg(all(CPython, Py_GIL_DISABLED))]
 #[inline(always)]
-pub(crate) fn get_unicode_key(key_str: &str) -> PyStr {
-    PyStr::from_str_with_hash(key_str)
+pub(crate) fn get_unicode_key(key_str: &str) -> PyStrRef {
+    PyStrRef::from_str_with_hash(key_str)
+}
+
+#[cfg(not(CPython))]
+#[inline(always)]
+pub(crate) fn get_unicode_key(key_str: &str) -> PyStrRef {
+    PyStrRef::from_str(key_str)
 }
 
 #[allow(dead_code)]

src/deserialize/utf8.rs

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
-// Copyright ijl (2021-2025), Aarni Koskela (2021)
+// Copyright ijl (2021-2026), Aarni Koskela (2021)
 
 use crate::deserialize::DeserializeError;
+use crate::ffi::PyStrRef;
 use crate::ffi::{PyBytes_AS_STRING, PyBytes_GET_SIZE, PyMemoryView_GET_BUFFER};
-use crate::str::PyStr;
 use crate::typeref::{BYTEARRAY_TYPE, BYTES_TYPE, MEMORYVIEW_TYPE, STR_TYPE};
 use crate::util::INVALID_STR;
 use crate::util::isize_to_usize;
@@ -50,8 +50,8 @@ pub(crate) fn read_input_to_buf(
             return Err(DeserializeError::invalid(Cow::Borrowed(INVALID_STR)));
         }
     } else if is_type!(obj_type_ptr, STR_TYPE) {
-        let pystr = unsafe { PyStr::from_ptr_unchecked(ptr) };
-        let uni = pystr.to_str();
+        let pystr = unsafe { PyStrRef::from_ptr_unchecked(ptr) };
+        let uni = pystr.as_str();
         if uni.is_none() {
             return Err(DeserializeError::invalid(Cow::Borrowed(INVALID_STR)));
         }

src/ffi/mod.rs

@@ -8,16 +8,21 @@ mod bytes;
 pub(crate) mod compat;
 mod fragment;
 mod long;
+mod pystrref;
 
-pub(crate) use buffer::*;
-pub(crate) use bytes::{PyBytes_AS_STRING, PyBytes_GET_SIZE, PyBytesObject};
 pub(crate) use compat::*;
 
-pub(crate) use fragment::{Fragment, orjson_fragmenttype_new};
 pub(crate) use long::pylong_is_unsigned;
 #[cfg(feature = "inline_int")]
 pub(crate) use long::{pylong_fits_in_i32, pylong_get_inline_value, pylong_is_zero};
 
+pub(crate) use {
+    buffer::PyMemoryView_GET_BUFFER,
+    bytes::{PyBytes_AS_STRING, PyBytes_GET_SIZE, PyBytesObject},
+    fragment::{Fragment, orjson_fragmenttype_new},
+    pystrref::{PyStrRef, PyStrSubclassRef, set_str_create_fn},
+};
+
 #[allow(unused_imports)]
 pub(crate) use pyo3_ffi::{
     _PyBytes_Resize, METH_FASTCALL, METH_KEYWORDS, METH_O, Py_DECREF, Py_False, Py_INCREF, Py_None,
@@ -53,7 +58,7 @@ pub(crate) use pyo3_ffi::PyErr_Restore;
 #[cfg(CPython)]
 pub(crate) use pyo3_ffi::{PyObject_CallMethodNoArgs, PyObject_CallMethodOneArg};
 
-#[cfg(all(CPython, not(target_endian = "little")))]
+#[cfg(not(feature = "inline_str"))]
 pub(crate) use pyo3_ffi::{PyUnicode_DATA, PyUnicode_KIND};
 
 #[cfg(Py_3_12)]

src/str/avx512.rs src/ffi/pystrref/avx512.rssrc/str/avx512.rs renamed to src/ffi/pystrref/avx512.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MPL-2.0
-// Copyright ijl (2024-2025)
+// Copyright ijl (2024-2026)
 
-use crate::str::pyunicode_new::*;
+use super::pyunicode_new::*;
 
 use core::arch::x86_64::{
     _mm512_and_si512, _mm512_cmpgt_epu8_mask, _mm512_cmpneq_epi8_mask, _mm512_loadu_epi8,

src/ffi/pystrref/mod.rs

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MPL-2.0
+// Copyright ijl (2026)
+
+#[cfg(feature = "avx512")]
+#[cfg(CPython)]
+mod avx512;
+mod object;
+#[cfg(CPython)]
+mod pyunicode_new;
+#[cfg(CPython)]
+mod scalar;
+
+pub(crate) use object::{PyStrRef, PyStrSubclassRef, set_str_create_fn};