Fix the main branch (#2046)

Author: mejrs

benches/bench_call.rs

@@ -4,19 +4,13 @@ use pyo3::prelude::*;
 
 macro_rules! test_module {
     ($py:ident, $code:literal) => {
-        PyModule::from_code($py, indoc::indoc!($code), file!(), "test_module")
-            .expect("module creation failed")
+        PyModule::from_code($py, $code, file!(), "test_module").expect("module creation failed")
     };
 }
 
 fn bench_call_0(b: &mut Bencher) {
     Python::with_gil(|py| {
-        let module = test_module!(
-            py,
-            r#"
-            def foo(): pass
-        "#
-        );
+        let module = test_module!(py, "def foo(): pass");
 
         let foo_module = module.getattr("foo").unwrap();
 
@@ -32,10 +26,11 @@ fn bench_call_method_0(b: &mut Bencher) {
     Python::with_gil(|py| {
         let module = test_module!(
             py,
-            r#"
-            class Foo:
-                def foo(self): pass
-        "#
+            "
+class Foo:
+    def foo(self):
+        pass
+"
         );
 
         let foo_module = module.getattr("Foo").unwrap().call0().unwrap();

benches/bench_pyclass.rs

@@ -1,49 +1,64 @@
-use criterion::{criterion_group, criterion_main, Bencher, Criterion};
+#[cfg(feature = "macros")]
+use criterion::{criterion_group, criterion_main, Criterion};
 
-use pyo3::{class::PyObjectProtocol, prelude::*, type_object::LazyStaticType};
+#[cfg(feature = "macros")]
+mod m {
+    use pyo3::{class::PyObjectProtocol, prelude::*, type_object::LazyStaticType};
 
-/// This is a feature-rich class instance used to benchmark various parts of the pyclass lifecycle.
-#[pyclass]
-struct MyClass {
-    #[pyo3(get, set)]
-    elements: Vec<i32>,
-}
-
-#[pymethods]
-impl MyClass {
-    #[new]
-    fn new(elements: Vec<i32>) -> Self {
-        Self { elements }
+    /// This is a feature-rich class instance used to benchmark various parts of the pyclass lifecycle.
+    #[pyclass]
+    struct MyClass {
+        #[pyo3(get, set)]
+        elements: Vec<i32>,
     }
 
-    fn __call__(&mut self, new_element: i32) -> usize {
-        self.elements.push(new_element);
-        self.elements.len()
+    #[pymethods]
+    impl MyClass {
+        #[new]
+        fn new(elements: Vec<i32>) -> Self {
+            Self { elements }
+        }
+
+        fn __call__(&mut self, new_element: i32) -> usize {
+            self.elements.push(new_element);
+            self.elements.len()
+        }
     }
-}
 
-#[pyproto]
-impl PyObjectProtocol for MyClass {
-    /// A basic __str__ implementation.
-    fn __str__(&self) -> &'static str {
-        "MyClass"
+    #[pyproto]
+    impl PyObjectProtocol for MyClass {
+        /// A basic __str__ implementation.
+        fn __str__(&self) -> &'static str {
+            "MyClass"
+        }
     }
-}
 
-fn first_time_init(b: &mut Bencher) {
-    let gil = Python::acquire_gil();
-    let py = gil.python();
-    b.iter(|| {
-        // This is using an undocumented internal PyO3 API to measure pyclass performance; please
-        // don't use this in your own code!
-        let ty = LazyStaticType::new();
-        ty.get_or_init::<MyClass>(py);
-    });
+    pub fn first_time_init(b: &mut criterion::Bencher) {
+        let gil = Python::acquire_gil();
+        let py = gil.python();
+        b.iter(|| {
+            // This is using an undocumented internal PyO3 API to measure pyclass performance; please
+            // don't use this in your own code!
+            let ty = LazyStaticType::new();
+            ty.get_or_init::<MyClass>(py);
+        });
+    }
 }
 
+#[cfg(feature = "macros")]
 fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("first_time_init", first_time_init);
+    c.bench_function("first_time_init", m::first_time_init);
 }
 
+#[cfg(feature = "macros")]
 criterion_group!(benches, criterion_benchmark);
+
+#[cfg(feature = "macros")]
 criterion_main!(benches);
+
+#[cfg(not(feature = "macros"))]
+fn main() {
+    unimplemented!(
+        "benchmarking `bench_pyclass` is only available with the `macros` feature enabled"
+    );
+}

src/gil.rs

@@ -186,6 +186,7 @@ impl GILGuard {
                 // all depend on the auto-initialize feature for conciseness but Cargo does not
                 // provide a mechanism to specify required features for tests.
                 if option_env!("CARGO_PRIMARY_PACKAGE").is_some() {
+                    #[cfg(not(PyPy))]
                     prepare_freethreaded_python();
                 }