remove FromPyObject blanket implementation

Author: Icxolu

guide/pyclass-parameters.md

@@ -23,7 +23,6 @@
 | `sequence` |  Inform PyO3 that this class is a [`Sequence`][params-sequence], and so leave its C-API mapping length slot empty. |
 | `set_all` | Generates setters for all fields of the pyclass. |
 | `new = "from_fields"` | Generates a default `__new__` constructor with all fields as parameters in the `new()` method. |
-| `skip_from_py_object` | Prevents this PyClass from participating in the `FromPyObject: PyClass + Clone` blanket implementation. This allows a custom `FromPyObject` impl, even if `self` is `Clone`. |
 | `str` | Implements `__str__` using the `Display` implementation of the underlying Rust datatype or by passing an optional format string `str="<format string>"`. *Note: The optional format string is only allowed for structs.  `name` and `rename_all` are incompatible with the optional format string.  Additional details can be found in the discussion on this [PR](https://github.com/PyO3/pyo3/pull/4233).* |
 | `subclass` | Allows other Python classes and `#[pyclass]` to inherit from this class. Enums cannot be subclassed. |
 | `unsendable` | Required if your struct is not [`Send`][params-3]. Rather than using `unsendable`, consider implementing your struct in a thread-safe way by e.g. substituting [`Rc`][params-4] with [`Arc`][params-5]. By using `unsendable`, your class will panic when accessed by another thread. Also note the Python's GC is multi-threaded and while unsendable classes will not be traversed on foreign threads to avoid UB, this can lead to memory leaks. |

guide/src/conversions/traits.md

@@ -525,7 +525,7 @@ Over the next few releases the blanket implementation is gradually phased out, a
 As a first step of this migration a new `skip_from_py_object` option for `#[pyclass]` was introduced, to opt-out of the blanket implementation and allow downstream users to provide their own implementation:
 
 ```rust
-# #![allow(dead_code)]
+# #![allow(dead_code, deprecated)]
 # use pyo3::prelude::*;
 
 #[pyclass(skip_from_py_object)] // opt-out of the PyO3 FromPyObject blanket
@@ -548,6 +548,10 @@ impl<'py> FromPyObject<'_, 'py> for Number {
 As a second step the `from_py_object` option was introduced.
 This option also opts-out of the blanket implementation and instead generates a custom `FromPyObject` implementation for the pyclass which is functionally equivalent to the blanket.
 
+As of PyO3 0.30.0 `skip_from_py_object` is the new default behavior.
+Setting the option is now deprecated and can be safely removed without changes in behavior.
+PyO3 will remove this option entirely in a future release.
+
 ## `IntoPyObject`
 
 The [`IntoPyObject`] trait defines the to-python conversion for a Rust type.

guide/src/migration.md

@@ -173,7 +173,7 @@ struct PyClass {}
 
 After:
 
-```rust
+```rust,ignore
 # use pyo3::prelude::*;
 // If the automatic implementation of `FromPyObject` is desired, opt in:
 #[pyclass(from_py_object)]

pyo3-macros-backend/src/pyclass.rs

@@ -2944,15 +2944,9 @@ impl<'a> PyClassImplsBuilder<'a> {
             });
         }
 
-        let deprecation = if self.attr.options.skip_from_py_object.is_none()
-            && self.attr.options.from_py_object.is_none()
-        {
-            quote! {
-                const _: () = {
-                    #[allow(unused_import)]
-                    use #pyo3_path::impl_::pyclass::Probe as _;
-                    #pyo3_path::impl_::deprecated::HasAutomaticFromPyObject::<{ #pyo3_path::impl_::pyclass::IsClone::<#cls>::VALUE }>::MSG
-                };
+        let deprecation = if self.attr.options.skip_from_py_object.is_some() {
+            quote_spanned! { self.attr.options.skip_from_py_object.span() =>
+                const _: () = #pyo3_path::impl_::deprecated::SKIP_FROM_PY_OBJECT_DEPRECATED;
             }
         } else {
             TokenStream::new()
@@ -2976,8 +2970,6 @@ impl<'a> PyClassImplsBuilder<'a> {
                     }
                 }
             }
-        } else if self.attr.options.skip_from_py_object.is_none() {
-            quote!( impl #pyo3_path::impl_::pyclass::ExtractPyClassWithClone for #cls {} )
         } else {
             TokenStream::new()
         };

pytests/src/pyclasses.rs

@@ -74,7 +74,7 @@ impl PyClassThreadIter {
 }
 
 /// Demonstrates a base class which can operate on the relevant subclass in its constructor.
-#[pyclass(subclass, skip_from_py_object)]
+#[pyclass(subclass)]
 #[derive(Clone, Debug)]
 struct AssertingBaseClass;
 
@@ -136,7 +136,7 @@ impl SubClassWithInit {
     }
 }
 
-#[pyclass(skip_from_py_object)]
+#[pyclass]
 #[derive(Clone)]
 struct ClassWithDecorators {
     attr: Option<usize>,

src/conversion.rs

@@ -1,6 +1,5 @@
 //! Defines conversions between Rust and Python types.
 use crate::err::PyResult;
-use crate::impl_::pyclass::ExtractPyClassWithClone;
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::{type_hint_identifier, type_hint_subscript, PyStaticExpr};
 use crate::platform::prelude::*;
@@ -9,8 +8,7 @@ use crate::pyclass::{PyClassGuardError, PyClassGuardMutError};
 use crate::types::PyList;
 use crate::types::PyTuple;
 use crate::{
-    Borrowed, Bound, BoundObject, Py, PyAny, PyClass, PyClassGuard, PyErr, PyRef, PyRefMut,
-    PyTypeCheck, Python,
+    Borrowed, Bound, BoundObject, Py, PyAny, PyClass, PyErr, PyRef, PyRefMut, PyTypeCheck, Python,
 };
 use core::convert::Infallible;
 use core::marker::PhantomData;
@@ -512,20 +510,6 @@ pub(crate) use from_py_object_sequence::FromPyObjectSequence;
 pub trait FromPyObjectOwned<'py>: for<'a> FromPyObject<'a, 'py> {}
 impl<'py, T> FromPyObjectOwned<'py> for T where T: for<'a> FromPyObject<'a, 'py> {}
 
-impl<'a, 'py, T> FromPyObject<'a, 'py> for T
-where
-    T: PyClass + Clone + ExtractPyClassWithClone,
-{
-    type Error = PyClassGuardError<'a, 'py>;
-
-    #[cfg(feature = "experimental-inspect")]
-    const INPUT_TYPE: PyStaticExpr = <T as crate::PyTypeInfo>::TYPE_HINT;
-
-    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
-        Ok(obj.extract::<PyClassGuard<'_, T>>()?.clone())
-    }
-}
-
 impl<'a, 'py, T> FromPyObject<'a, 'py> for PyRef<'py, T>
 where
     T: PyClass,
@@ -595,6 +579,7 @@ mod test_no_clone {}
 mod tests {
     #[test]
     #[cfg(feature = "macros")]
+    #[expect(deprecated)]
     fn test_pyclass_skip_from_py_object() {
         use crate::{types::PyAnyMethods, FromPyObject, IntoPyObject, PyErr, Python};
 

src/impl_/deprecated.rs

@@ -1,13 +1,5 @@
-pub struct HasAutomaticFromPyObject<const IS_CLONE: bool> {}
-
-impl HasAutomaticFromPyObject<true> {
-    #[deprecated(
-        since = "0.28.0",
-        note = "The `FromPyObject` implementation for `#[pyclass]` types which implement `Clone` is changing to an opt-in option. Use `#[pyclass(from_py_object)]` to opt-in to the `FromPyObject` derive now, or `#[pyclass(skip_from_py_object)]` to skip the `FromPyObject` implementation."
-    )]
-    pub const MSG: () = ();
-}
-
-impl HasAutomaticFromPyObject<false> {
-    pub const MSG: () = ();
-}
+#[deprecated(
+    since = "0.30.0",
+    note = "`skip_from_py_object` enabled by default. The option will be removed in the future"
+)]
+pub const SKIP_FROM_PY_OBJECT_DEPRECATED: () = ();

src/impl_/pyclass.rs

@@ -1472,8 +1472,6 @@ impl<const IMPLEMENTS_INTOPYOBJECT: bool> ConvertField<false, IMPLEMENTS_INTOPYO
     }
 }
 
-pub trait ExtractPyClassWithClone: generic_pyclass::Sealed {}
-
 #[cfg(test)]
 #[cfg(feature = "macros")]
 mod tests {

src/marker.rs

@@ -970,7 +970,7 @@ mod tests {
     fn test_py_run_inserts_globals_2() {
         use alloc::ffi::CString;
 
-        #[crate::pyclass(crate = "crate", skip_from_py_object)]
+        #[crate::pyclass(crate = "crate")]
         #[derive(Clone)]
         struct CodeRunner {
             code: CString,

src/pycell.rs

@@ -775,7 +775,7 @@ mod tests {
 
     use super::*;
 
-    #[crate::pyclass(skip_from_py_object)]
+    #[crate::pyclass]
     #[pyo3(crate = "crate")]
     #[derive(Copy, Clone, PartialEq, Eq, Debug)]
     struct SomeClass(i32);