Introspection: add typing.final on final classes

Author: Tpt

pyo3-introspection/src/introspection.rs

@@ -124,9 +124,13 @@ fn convert_members<'a>(
                     chunks_by_parent,
                 )?);
             }
-            Chunk::Class { name, id } => {
-                classes.push(convert_class(id, name, chunks_by_id, chunks_by_parent)?)
-            }
+            Chunk::Class { name, id, is_final } => classes.push(convert_class(
+                id,
+                name,
+                *is_final,
+                chunks_by_id,
+                chunks_by_parent,
+            )?),
             Chunk::Function {
                 name,
                 id: _,
@@ -168,6 +172,7 @@ fn convert_members<'a>(
 fn convert_class(
     id: &str,
     name: &str,
+    is_final: bool,
     chunks_by_id: &HashMap<&str, &Chunk>,
     chunks_by_parent: &HashMap<&str, Vec<&Chunk>>,
 ) -> Result<Class> {
@@ -188,6 +193,7 @@ fn convert_class(
         name: name.into(),
         methods,
         attributes,
+        is_final,
     })
 }
 
@@ -409,6 +415,8 @@ enum Chunk {
     Class {
         id: String,
         name: String,
+        #[serde(default, rename = "final")]
+        is_final: bool,
     },
     Function {
         #[serde(default)]

pyo3-introspection/src/model.rs

@@ -13,6 +13,7 @@ pub struct Class {
     pub name: String,
     pub methods: Vec<Function>,
     pub attributes: Vec<Attribute>,
+    pub is_final: bool,
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]

pyo3-introspection/src/stubs.rs

@@ -110,7 +110,21 @@ fn module_stubs(module: &Module, parents: &[&str]) -> String {
 }
 
 fn class_stubs(class: &Class, imports: &Imports) -> String {
-    let mut buffer = format!("class {}:", class.name);
+    let mut buffer = String::new();
+    if class.is_final {
+        buffer.push('@');
+        imports.serialize_type_hint(
+            &TypeHintExpr::Attribute {
+                module: "typing".into(),
+                attr: "final".into(),
+            },
+            &mut buffer,
+        );
+        buffer.push('\n');
+    }
+    buffer.push_str("class ");
+    buffer.push_str(&class.name);
+    buffer.push(':');
     if class.methods.is_empty() && class.attributes.is_empty() {
         buffer.push_str(" ...");
         return buffer;
@@ -410,6 +424,12 @@ impl ElementsUsedInAnnotations {
     }
 
     fn walk_class(&mut self, class: &Class) {
+        if class.is_final {
+            self.module_members
+                .entry("typing".into())
+                .or_default()
+                .insert("final".into());
+        }
         for method in &class.methods {
             self.walk_function(method);
         }
@@ -605,6 +625,7 @@ mod tests {
                     name: "A".into(),
                     methods: Vec::new(),
                     attributes: Vec::new(),
+                    is_final: true,
                 }],
                 functions: vec![Function {
                     name: String::new(),
@@ -628,7 +649,8 @@ mod tests {
             &[
                 "from _typeshed import Incomplete",
                 "from bat import A as A2",
-                "from foo import A as A3, B"
+                "from foo import A as A3, B",
+                "from typing import final"
             ]
         );
         let mut output = String::new();

pyo3-macros-backend/src/introspection.rs

@@ -61,6 +61,7 @@ pub fn class_introspection_code(
     pyo3_crate_path: &PyO3CratePath,
     ident: &Ident,
     name: &str,
+    is_final: bool,
 ) -> TokenStream {
     IntrospectionNode::Map(
         [
@@ -70,6 +71,7 @@ pub fn class_introspection_code(
                 IntrospectionNode::IntrospectionId(Some(ident_to_type(ident))),
             ),
             ("name", IntrospectionNode::String(name.into())),
+            ("final", IntrospectionNode::Bool(is_final)),
         ]
         .into(),
     )

pyo3-macros-backend/src/pyclass.rs

@@ -2664,7 +2664,12 @@ impl<'a> PyClassImplsBuilder<'a> {
         let Ctx { pyo3_path, .. } = ctx;
         let name = get_class_python_name(self.cls, self.attr).to_string();
         let ident = self.cls;
-        let static_introspection = class_introspection_code(pyo3_path, ident, &name);
+        let static_introspection = class_introspection_code(
+            pyo3_path,
+            ident,
+            &name,
+            self.attr.options.subclass.is_none(),
+        );
         let introspection_id = introspection_id_const();
         quote! {
             #static_introspection

pytests/src/lib.rs

@@ -25,7 +25,7 @@ mod pyo3_pytests {
     #[pymodule_export]
     use {
         comparisons::comparisons, consts::consts, enums::enums, pyclasses::pyclasses,
-        pyfunctions::pyfunctions,
+        pyfunctions::pyfunctions, subclassing::subclassing,
     };
 
     // Inserting to sys.modules allows importing submodules nicely from Python
@@ -43,7 +43,6 @@ mod pyo3_pytests {
         m.add_wrapped(wrap_pymodule!(othermod::othermod))?;
         m.add_wrapped(wrap_pymodule!(path::path))?;
         m.add_wrapped(wrap_pymodule!(sequence::sequence))?;
-        m.add_wrapped(wrap_pymodule!(subclassing::subclassing))?;
 
         // Inserting to sys.modules allows importing submodules nicely from Python
         // e.g. import pyo3_pytests.buf_and_str as bas

pytests/src/subclassing.rs

@@ -2,23 +2,22 @@
 
 use pyo3::prelude::*;
 
-#[pyclass(subclass)]
-pub struct Subclassable {}
+#[pymodule(gil_used = false)]
+pub mod subclassing {
+    use pyo3::prelude::*;
 
-#[pymethods]
-impl Subclassable {
-    #[new]
-    fn new() -> Self {
-        Subclassable {}
-    }
+    #[pyclass(subclass)]
+    pub struct Subclassable {}
 
-    fn __str__(&self) -> &'static str {
-        "Subclassable"
-    }
-}
+    #[pymethods]
+    impl Subclassable {
+        #[new]
+        fn new() -> Self {
+            Subclassable {}
+        }
 
-#[pymodule(gil_used = false)]
-pub fn subclassing(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<Subclassable>()?;
-    Ok(())
+        fn __str__(&self) -> &'static str {
+            "Subclassable"
+        }
+    }
 }

pytests/stubs/comparisons.pyi

@@ -1,17 +1,23 @@
+from typing import final
+
+@final
 class Eq:
     def __eq__(self, /, other: Eq) -> bool: ...
     def __ne__(self, /, other: Eq) -> bool: ...
     def __new__(cls, /, value: int) -> None: ...
 
+@final
 class EqDefaultNe:
     def __eq__(self, /, other: EqDefaultNe) -> bool: ...
     def __new__(cls, /, value: int) -> None: ...
 
+@final
 class EqDerived:
     def __eq__(self, /, other: EqDerived) -> bool: ...
     def __ne__(self, /, other: EqDerived) -> bool: ...
     def __new__(cls, /, value: int) -> None: ...
 
+@final
 class Ordered:
     def __eq__(self, /, other: Ordered) -> bool: ...
     def __ge__(self, /, other: Ordered) -> bool: ...
@@ -21,6 +27,7 @@ class Ordered:
     def __ne__(self, /, other: Ordered) -> bool: ...
     def __new__(cls, /, value: int) -> None: ...
 
+@final
 class OrderedDefaultNe:
     def __eq__(self, /, other: OrderedDefaultNe) -> bool: ...
     def __ge__(self, /, other: OrderedDefaultNe) -> bool: ...
@@ -29,6 +36,7 @@ class OrderedDefaultNe:
     def __lt__(self, /, other: OrderedDefaultNe) -> bool: ...
     def __new__(cls, /, value: int) -> None: ...
 
+@final
 class OrderedDerived:
     def __eq__(self, /, other: OrderedDerived) -> bool: ...
     def __ge__(self, /, other: OrderedDerived) -> bool: ...
@@ -40,6 +48,7 @@ class OrderedDerived:
     def __new__(cls, /, value: int) -> None: ...
     def __str__(self, /) -> str: ...
 
+@final
 class OrderedRichCmp:
     def __eq__(self, /, other: OrderedRichCmp) -> bool: ...
     def __ge__(self, /, other: OrderedRichCmp) -> bool: ...

pytests/stubs/consts.pyi

@@ -1,7 +1,8 @@
-from typing import Final
+from typing import Final, final
 
 PI: Final[float]
 SIMPLE: Final = "SIMPLE"
 
+@final
 class ClassWithConst:
     INSTANCE: Final[ClassWithConst]

pytests/stubs/enums.pyi

@@ -1,6 +1,9 @@
+from typing import final
+
 class ComplexEnum: ...
 class MixedComplexEnum: ...
 
+@final
 class SimpleEnum:
     def __eq__(self, /, other: SimpleEnum | int) -> bool: ...
     def __ne__(self, /, other: SimpleEnum | int) -> bool: ...