diff --git a/Cargo.toml b/Cargo.toml
index 8e43b189..df2b843b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,7 @@ include = ["LICENSE", "Cargo.toml", "src/**/*.rs"]
 resolver = "2"
 members = [
     "ast", "core", "format", "literal", "parser",
+    "ast-pyo3",
     "ruff_text_size", "ruff_source_location",
 ]
 
diff --git a/ast-pyo3/Cargo.toml b/ast-pyo3/Cargo.toml
new file mode 100644
index 00000000..c1394a4c
--- /dev/null
+++ b/ast-pyo3/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "rustpython-ast-pyo3"
+version = "0.1.0"
+edition = "2021"
+
+[features]
+# This feature is experimental
+# It reimplements AST types, but currently both slower than python AST types and limited to use in other API
+wrapper = []
+
+[dependencies]
+rustpython-ast = { workspace = true, features = ["location"] }
+num-complex = { workspace = true }
+once_cell = { workspace = true }
+
+pyo3 = { workspace = true, features = ["num-bigint", "num-complex"] }
diff --git a/ast-pyo3/src/gen/to_py_ast.rs b/ast-pyo3/src/gen/to_py_ast.rs
new file mode 100644
index 00000000..16ccadb9
--- /dev/null
+++ b/ast-pyo3/src/gen/to_py_ast.rs
@@ -0,0 +1,4841 @@
+// File automatically generated by ast/asdl_rs.py.
+
+impl<R> PyNode for ast::Mod<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ModModule<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ModInteractive<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ModExpression<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ModFunctionType<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Stmt<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtFunctionDef<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtAsyncFunctionDef<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtClassDef<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtReturn<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtDelete<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtAssign<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtAugAssign<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtAnnAssign<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtFor<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtAsyncFor<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtWhile<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtIf<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtWith<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtAsyncWith<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtMatch<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtRaise<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtTry<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtTryStar<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtAssert<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtImport<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtImportFrom<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtGlobal<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtNonlocal<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtExpr<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtPass<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtBreak<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::StmtContinue<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Expr<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprBoolOp<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprNamedExpr<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprBinOp<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprUnaryOp<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprLambda<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprIfExp<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprDict<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprSet<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprListComp<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprSetComp<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprDictComp<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprGeneratorExp<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprAwait<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprYield<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprYieldFrom<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprCompare<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprCall<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprFormattedValue<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprJoinedStr<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprConstant<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprAttribute<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprSubscript<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprStarred<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprName<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprList<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprTuple<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExprSlice<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::ExprContext {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::ExprContextLoad {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::ExprContextStore {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::ExprContextDel {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::Boolop {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::BoolopAnd {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::BoolopOr {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::Operator {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorAdd {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorSub {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorMult {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorMatMult {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorDiv {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorMod {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorPow {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorLShift {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorRShift {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorBitOr {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorBitXor {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorBitAnd {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::OperatorFloorDiv {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::Unaryop {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::UnaryopInvert {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::UnaryopNot {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::UnaryopUAdd {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::UnaryopUSub {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::Cmpop {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopEq {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopNotEq {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopLt {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopLtE {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopGt {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopGtE {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopIs {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopIsNot {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopIn {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl PyNode for ast::CmpopNotIn {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Comprehension<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Excepthandler<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::ExcepthandlerExceptHandler<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Arguments<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Arg<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Keyword<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Alias<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Withitem<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::MatchCase<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::Pattern<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::PatternMatchValue<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::PatternMatchSingleton<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::PatternMatchSequence<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::PatternMatchMapping<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::PatternMatchClass<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::PatternMatchStar<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::PatternMatchAs<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::PatternMatchOr<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::TypeIgnore<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::TypeIgnoreTypeIgnore<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl ToPyAst for ast::ExprContext {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cell = match &self {
+            ast::ExprContext::Load => ast::ExprContextLoad::py_type_cache(),
+            ast::ExprContext::Store => ast::ExprContextStore::py_type_cache(),
+            ast::ExprContext::Del => ast::ExprContextDel::py_type_cache(),
+        };
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
+    }
+}
+
+impl ToPyAst for ast::Boolop {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cell = match &self {
+            ast::Boolop::And => ast::BoolopAnd::py_type_cache(),
+            ast::Boolop::Or => ast::BoolopOr::py_type_cache(),
+        };
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
+    }
+}
+
+impl ToPyAst for ast::Operator {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cell = match &self {
+            ast::Operator::Add => ast::OperatorAdd::py_type_cache(),
+            ast::Operator::Sub => ast::OperatorSub::py_type_cache(),
+            ast::Operator::Mult => ast::OperatorMult::py_type_cache(),
+            ast::Operator::MatMult => ast::OperatorMatMult::py_type_cache(),
+            ast::Operator::Div => ast::OperatorDiv::py_type_cache(),
+            ast::Operator::Mod => ast::OperatorMod::py_type_cache(),
+            ast::Operator::Pow => ast::OperatorPow::py_type_cache(),
+            ast::Operator::LShift => ast::OperatorLShift::py_type_cache(),
+            ast::Operator::RShift => ast::OperatorRShift::py_type_cache(),
+            ast::Operator::BitOr => ast::OperatorBitOr::py_type_cache(),
+            ast::Operator::BitXor => ast::OperatorBitXor::py_type_cache(),
+            ast::Operator::BitAnd => ast::OperatorBitAnd::py_type_cache(),
+            ast::Operator::FloorDiv => ast::OperatorFloorDiv::py_type_cache(),
+        };
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
+    }
+}
+
+impl ToPyAst for ast::Unaryop {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cell = match &self {
+            ast::Unaryop::Invert => ast::UnaryopInvert::py_type_cache(),
+            ast::Unaryop::Not => ast::UnaryopNot::py_type_cache(),
+            ast::Unaryop::UAdd => ast::UnaryopUAdd::py_type_cache(),
+            ast::Unaryop::USub => ast::UnaryopUSub::py_type_cache(),
+        };
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
+    }
+}
+
+impl ToPyAst for ast::Cmpop {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cell = match &self {
+            ast::Cmpop::Eq => ast::CmpopEq::py_type_cache(),
+            ast::Cmpop::NotEq => ast::CmpopNotEq::py_type_cache(),
+            ast::Cmpop::Lt => ast::CmpopLt::py_type_cache(),
+            ast::Cmpop::LtE => ast::CmpopLtE::py_type_cache(),
+            ast::Cmpop::Gt => ast::CmpopGt::py_type_cache(),
+            ast::Cmpop::GtE => ast::CmpopGtE::py_type_cache(),
+            ast::Cmpop::Is => ast::CmpopIs::py_type_cache(),
+            ast::Cmpop::IsNot => ast::CmpopIsNot::py_type_cache(),
+            ast::Cmpop::In => ast::CmpopIn::py_type_cache(),
+            ast::Cmpop::NotIn => ast::CmpopNotIn::py_type_cache(),
+        };
+        Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
+    }
+}
+
+impl ToPyAst for ast::Mod<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Mod::Module(cons) => cons.to_py_ast(py)?,
+            ast::Mod::Interactive(cons) => cons.to_py_ast(py)?,
+            ast::Mod::Expression(cons) => cons.to_py_ast(py)?,
+            ast::Mod::FunctionType(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ModModule<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            type_ignores,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((body.to_py_ast(py)?, type_ignores.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ModInteractive<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ModExpression<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ModFunctionType<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            argtypes,
+            returns,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((argtypes.to_py_ast(py)?, returns.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Stmt<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Stmt::FunctionDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncFunctionDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::ClassDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Return(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Delete(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Assign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AugAssign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AnnAssign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::For(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncFor(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::While(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::If(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::With(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncWith(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Match(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Raise(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Try(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::TryStar(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Assert(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Import(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::ImportFrom(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Global(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Nonlocal(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Expr(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Pass(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Break(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Continue(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtFunctionDef<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            args,
+            body,
+            decorator_list,
+            returns,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+            returns.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAsyncFunctionDef<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            args,
+            body,
+            decorator_list,
+            returns,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+            returns.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtClassDef<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            bases,
+            keywords,
+            body,
+            decorator_list,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_py_ast(py)?,
+            bases.to_py_ast(py)?,
+            keywords.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtReturn<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtDelete<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            targets,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((targets.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAssign<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            targets,
+            value,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            targets.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAugAssign<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            op,
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            op.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAnnAssign<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            annotation,
+            value,
+            simple,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            annotation.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            simple.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtFor<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            iter,
+            body,
+            orelse,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAsyncFor<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            iter,
+            body,
+            orelse,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtWhile<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            test,
+            body,
+            orelse,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtIf<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            test,
+            body,
+            orelse,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtWith<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            items,
+            body,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            items.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAsyncWith<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            items,
+            body,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            items.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtMatch<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            subject,
+            cases,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((subject.to_py_ast(py)?, cases.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtRaise<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            exc,
+            cause,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((exc.to_py_ast(py)?, cause.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtTry<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            body.to_py_ast(py)?,
+            handlers.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            finalbody.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtTryStar<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            body.to_py_ast(py)?,
+            handlers.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            finalbody.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAssert<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            test,
+            msg,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((test.to_py_ast(py)?, msg.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtImport<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            names,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtImportFrom<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            module,
+            names,
+            level,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            module.to_py_ast(py)?,
+            names.to_py_ast(py)?,
+            level.map_or_else(|| py.None(), |level| level.to_u32().to_object(py)),
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtGlobal<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            names,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtNonlocal<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            names,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtExpr<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtPass<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
+        let Self { range: _range } = self;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtBreak<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
+        let Self { range: _range } = self;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtContinue<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
+        let Self { range: _range } = self;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Expr<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Expr::BoolOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::NamedExpr(cons) => cons.to_py_ast(py)?,
+            ast::Expr::BinOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::UnaryOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Lambda(cons) => cons.to_py_ast(py)?,
+            ast::Expr::IfExp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Dict(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Set(cons) => cons.to_py_ast(py)?,
+            ast::Expr::ListComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::SetComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::DictComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::GeneratorExp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Await(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Yield(cons) => cons.to_py_ast(py)?,
+            ast::Expr::YieldFrom(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Compare(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Call(cons) => cons.to_py_ast(py)?,
+            ast::Expr::FormattedValue(cons) => cons.to_py_ast(py)?,
+            ast::Expr::JoinedStr(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Constant(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Attribute(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Subscript(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Starred(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Name(cons) => cons.to_py_ast(py)?,
+            ast::Expr::List(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Tuple(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Slice(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprBoolOp<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            op,
+            values,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((op.to_py_ast(py)?, values.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprNamedExpr<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((target.to_py_ast(py)?, value.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprBinOp<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            left,
+            op,
+            right,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            left.to_py_ast(py)?,
+            op.to_py_ast(py)?,
+            right.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprUnaryOp<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            op,
+            operand,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((op.to_py_ast(py)?, operand.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprLambda<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            args,
+            body,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((args.to_py_ast(py)?, body.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprIfExp<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            test,
+            body,
+            orelse,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprDict<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            keys,
+            values,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((keys.to_py_ast(py)?, values.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprSet<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elts,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprListComp<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elt,
+            generators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprSetComp<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elt,
+            generators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprDictComp<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            key,
+            value,
+            generators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            key.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            generators.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprGeneratorExp<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elt,
+            generators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprAwait<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprYield<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprYieldFrom<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprCompare<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            left,
+            ops,
+            comparators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            left.to_py_ast(py)?,
+            ops.to_py_ast(py)?,
+            comparators.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprCall<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            func,
+            args,
+            keywords,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            func.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            keywords.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprFormattedValue<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            conversion,
+            format_spec,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_py_ast(py)?,
+            conversion.to_py_ast(py)?,
+            format_spec.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprJoinedStr<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            values,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((values.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprConstant<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            kind,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((constant_to_object(value, py), kind.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprAttribute<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            attr,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_py_ast(py)?,
+            attr.to_py_ast(py)?,
+            ctx.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprSubscript<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            slice,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_py_ast(py)?,
+            slice.to_py_ast(py)?,
+            ctx.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprStarred<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprName<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            id,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((id.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprList<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elts,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprTuple<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elts,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprSlice<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            lower,
+            upper,
+            step,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            lower.to_py_ast(py)?,
+            upper.to_py_ast(py)?,
+            step.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Comprehension<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            iter,
+            ifs,
+            is_async,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            ifs.to_py_ast(py)?,
+            is_async.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Excepthandler<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Excepthandler::ExceptHandler(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExcepthandlerExceptHandler<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            type_,
+            name,
+            body,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            type_.to_py_ast(py)?,
+            name.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Arguments<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            posonlyargs,
+            args,
+            vararg,
+            kwonlyargs,
+            kw_defaults,
+            kwarg,
+            defaults,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            posonlyargs.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            vararg.to_py_ast(py)?,
+            kwonlyargs.to_py_ast(py)?,
+            kw_defaults.to_py_ast(py)?,
+            kwarg.to_py_ast(py)?,
+            defaults.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Arg<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            arg,
+            annotation,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            arg.to_py_ast(py)?,
+            annotation.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Keyword<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            arg,
+            value,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((arg.to_py_ast(py)?, value.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Alias<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            asname,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((name.to_py_ast(py)?, asname.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Withitem<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            context_expr,
+            optional_vars,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((context_expr.to_py_ast(py)?, optional_vars.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::MatchCase<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            pattern,
+            guard,
+            body,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            pattern.to_py_ast(py)?,
+            guard.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Pattern<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Pattern::MatchValue(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchSingleton(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchSequence(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchMapping(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchClass(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchStar(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchAs(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchOr(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchValue<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchSingleton<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((constant_to_object(value, py),))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchSequence<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            patterns,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchMapping<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            keys,
+            patterns,
+            rest,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            keys.to_py_ast(py)?,
+            patterns.to_py_ast(py)?,
+            rest.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchClass<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            cls,
+            patterns,
+            kwd_attrs,
+            kwd_patterns,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            cls.to_py_ast(py)?,
+            patterns.to_py_ast(py)?,
+            kwd_attrs.to_py_ast(py)?,
+            kwd_patterns.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchStar<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchAs<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            pattern,
+            name,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((pattern.to_py_ast(py)?, name.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchOr<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            patterns,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeIgnore<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::TypeIgnore::TypeIgnore(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeIgnoreTypeIgnore<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            lineno,
+            tag,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((lineno.to_u32().to_object(py), tag.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Mod<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Mod::Module(cons) => cons.to_py_ast(py)?,
+            ast::Mod::Interactive(cons) => cons.to_py_ast(py)?,
+            ast::Mod::Expression(cons) => cons.to_py_ast(py)?,
+            ast::Mod::FunctionType(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ModModule<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            type_ignores,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((body.to_py_ast(py)?, type_ignores.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ModInteractive<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ModExpression<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((body.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ModFunctionType<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            argtypes,
+            returns,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((argtypes.to_py_ast(py)?, returns.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Stmt<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Stmt::FunctionDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncFunctionDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::ClassDef(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Return(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Delete(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Assign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AugAssign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AnnAssign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::For(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncFor(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::While(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::If(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::With(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::AsyncWith(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Match(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Raise(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Try(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::TryStar(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Assert(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Import(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::ImportFrom(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Global(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Nonlocal(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Expr(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Pass(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Break(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::Continue(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtFunctionDef<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            args,
+            body,
+            decorator_list,
+            returns,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+            returns.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAsyncFunctionDef<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            args,
+            body,
+            decorator_list,
+            returns,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+            returns.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtClassDef<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            bases,
+            keywords,
+            body,
+            decorator_list,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_py_ast(py)?,
+            bases.to_py_ast(py)?,
+            keywords.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            decorator_list.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtReturn<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtDelete<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            targets,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((targets.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAssign<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            targets,
+            value,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            targets.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAugAssign<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            op,
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            op.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAnnAssign<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            annotation,
+            value,
+            simple,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            annotation.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            simple.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtFor<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            iter,
+            body,
+            orelse,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAsyncFor<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            iter,
+            body,
+            orelse,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtWhile<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            test,
+            body,
+            orelse,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtIf<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            test,
+            body,
+            orelse,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtWith<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            items,
+            body,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            items.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAsyncWith<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            items,
+            body,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            items.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtMatch<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            subject,
+            cases,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((subject.to_py_ast(py)?, cases.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtRaise<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            exc,
+            cause,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((exc.to_py_ast(py)?, cause.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtTry<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            body.to_py_ast(py)?,
+            handlers.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            finalbody.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtTryStar<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            body.to_py_ast(py)?,
+            handlers.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+            finalbody.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtAssert<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            test,
+            msg,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((test.to_py_ast(py)?, msg.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtImport<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            names,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtImportFrom<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            module,
+            names,
+            level,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            module.to_py_ast(py)?,
+            names.to_py_ast(py)?,
+            level.map_or_else(|| py.None(), |level| level.to_u32().to_object(py)),
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtGlobal<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            names,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtNonlocal<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            names,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((names.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtExpr<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtPass<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
+        let Self { range: _range } = self;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtBreak<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
+        let Self { range: _range } = self;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::StmtContinue<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;
+        let Self { range: _range } = self;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Expr<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Expr::BoolOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::NamedExpr(cons) => cons.to_py_ast(py)?,
+            ast::Expr::BinOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::UnaryOp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Lambda(cons) => cons.to_py_ast(py)?,
+            ast::Expr::IfExp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Dict(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Set(cons) => cons.to_py_ast(py)?,
+            ast::Expr::ListComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::SetComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::DictComp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::GeneratorExp(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Await(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Yield(cons) => cons.to_py_ast(py)?,
+            ast::Expr::YieldFrom(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Compare(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Call(cons) => cons.to_py_ast(py)?,
+            ast::Expr::FormattedValue(cons) => cons.to_py_ast(py)?,
+            ast::Expr::JoinedStr(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Constant(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Attribute(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Subscript(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Starred(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Name(cons) => cons.to_py_ast(py)?,
+            ast::Expr::List(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Tuple(cons) => cons.to_py_ast(py)?,
+            ast::Expr::Slice(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprBoolOp<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            op,
+            values,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((op.to_py_ast(py)?, values.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprNamedExpr<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((target.to_py_ast(py)?, value.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprBinOp<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            left,
+            op,
+            right,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            left.to_py_ast(py)?,
+            op.to_py_ast(py)?,
+            right.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprUnaryOp<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            op,
+            operand,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((op.to_py_ast(py)?, operand.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprLambda<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            args,
+            body,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((args.to_py_ast(py)?, body.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprIfExp<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            test,
+            body,
+            orelse,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            test.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+            orelse.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprDict<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            keys,
+            values,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((keys.to_py_ast(py)?, values.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprSet<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elts,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprListComp<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elt,
+            generators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprSetComp<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elt,
+            generators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprDictComp<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            key,
+            value,
+            generators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            key.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+            generators.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprGeneratorExp<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elt,
+            generators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((elt.to_py_ast(py)?, generators.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprAwait<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprYield<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprYieldFrom<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprCompare<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            left,
+            ops,
+            comparators,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            left.to_py_ast(py)?,
+            ops.to_py_ast(py)?,
+            comparators.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprCall<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            func,
+            args,
+            keywords,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            func.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            keywords.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprFormattedValue<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            conversion,
+            format_spec,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_py_ast(py)?,
+            conversion.to_py_ast(py)?,
+            format_spec.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprJoinedStr<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            values,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((values.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprConstant<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            kind,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((constant_to_object(value, py), kind.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprAttribute<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            attr,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_py_ast(py)?,
+            attr.to_py_ast(py)?,
+            ctx.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprSubscript<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            slice,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            value.to_py_ast(py)?,
+            slice.to_py_ast(py)?,
+            ctx.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprStarred<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprName<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            id,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((id.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprList<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elts,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprTuple<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            elts,
+            ctx,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((elts.to_py_ast(py)?, ctx.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExprSlice<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            lower,
+            upper,
+            step,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            lower.to_py_ast(py)?,
+            upper.to_py_ast(py)?,
+            step.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Comprehension<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            target,
+            iter,
+            ifs,
+            is_async,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            target.to_py_ast(py)?,
+            iter.to_py_ast(py)?,
+            ifs.to_py_ast(py)?,
+            is_async.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Excepthandler<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Excepthandler::ExceptHandler(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::ExcepthandlerExceptHandler<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            type_,
+            name,
+            body,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            type_.to_py_ast(py)?,
+            name.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Arguments<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            posonlyargs,
+            args,
+            vararg,
+            kwonlyargs,
+            kw_defaults,
+            kwarg,
+            defaults,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            posonlyargs.to_py_ast(py)?,
+            args.to_py_ast(py)?,
+            vararg.to_py_ast(py)?,
+            kwonlyargs.to_py_ast(py)?,
+            kw_defaults.to_py_ast(py)?,
+            kwarg.to_py_ast(py)?,
+            defaults.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Arg<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            arg,
+            annotation,
+            type_comment,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            arg.to_py_ast(py)?,
+            annotation.to_py_ast(py)?,
+            type_comment.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Keyword<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            arg,
+            value,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((arg.to_py_ast(py)?, value.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Alias<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            asname,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((name.to_py_ast(py)?, asname.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Withitem<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            context_expr,
+            optional_vars,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((context_expr.to_py_ast(py)?, optional_vars.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::MatchCase<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            pattern,
+            guard,
+            body,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            pattern.to_py_ast(py)?,
+            guard.to_py_ast(py)?,
+            body.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::Pattern<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::Pattern::MatchValue(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchSingleton(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchSequence(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchMapping(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchClass(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchStar(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchAs(cons) => cons.to_py_ast(py)?,
+            ast::Pattern::MatchOr(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchValue<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((value.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchSingleton<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((constant_to_object(value, py),))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchSequence<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            patterns,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchMapping<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            keys,
+            patterns,
+            rest,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            keys.to_py_ast(py)?,
+            patterns.to_py_ast(py)?,
+            rest.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchClass<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            cls,
+            patterns,
+            kwd_attrs,
+            kwd_patterns,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            cls.to_py_ast(py)?,
+            patterns.to_py_ast(py)?,
+            kwd_attrs.to_py_ast(py)?,
+            kwd_patterns.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchStar<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchAs<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            pattern,
+            name,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((pattern.to_py_ast(py)?, name.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::PatternMatchOr<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            patterns,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((patterns.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeIgnore<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::TypeIgnore::TypeIgnore(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeIgnoreTypeIgnore<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            lineno,
+            tag,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py)
+            .call1((lineno.to_u32().to_object(py), tag.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+fn init_types(py: Python) -> PyResult<()> {
+    let ast_module = PyModule::import(py, "_ast")?;
+    cache_py_type::<ast::Mod>(ast_module)?;
+    cache_py_type::<ast::ModModule>(ast_module)?;
+    cache_py_type::<ast::ModInteractive>(ast_module)?;
+    cache_py_type::<ast::ModExpression>(ast_module)?;
+    cache_py_type::<ast::ModFunctionType>(ast_module)?;
+    cache_py_type::<ast::Stmt>(ast_module)?;
+    cache_py_type::<ast::StmtFunctionDef>(ast_module)?;
+    cache_py_type::<ast::StmtAsyncFunctionDef>(ast_module)?;
+    cache_py_type::<ast::StmtClassDef>(ast_module)?;
+    cache_py_type::<ast::StmtReturn>(ast_module)?;
+    cache_py_type::<ast::StmtDelete>(ast_module)?;
+    cache_py_type::<ast::StmtAssign>(ast_module)?;
+    cache_py_type::<ast::StmtAugAssign>(ast_module)?;
+    cache_py_type::<ast::StmtAnnAssign>(ast_module)?;
+    cache_py_type::<ast::StmtFor>(ast_module)?;
+    cache_py_type::<ast::StmtAsyncFor>(ast_module)?;
+    cache_py_type::<ast::StmtWhile>(ast_module)?;
+    cache_py_type::<ast::StmtIf>(ast_module)?;
+    cache_py_type::<ast::StmtWith>(ast_module)?;
+    cache_py_type::<ast::StmtAsyncWith>(ast_module)?;
+    cache_py_type::<ast::StmtMatch>(ast_module)?;
+    cache_py_type::<ast::StmtRaise>(ast_module)?;
+    cache_py_type::<ast::StmtTry>(ast_module)?;
+    cache_py_type::<ast::StmtTryStar>(ast_module)?;
+    cache_py_type::<ast::StmtAssert>(ast_module)?;
+    cache_py_type::<ast::StmtImport>(ast_module)?;
+    cache_py_type::<ast::StmtImportFrom>(ast_module)?;
+    cache_py_type::<ast::StmtGlobal>(ast_module)?;
+    cache_py_type::<ast::StmtNonlocal>(ast_module)?;
+    cache_py_type::<ast::StmtExpr>(ast_module)?;
+    cache_py_type::<ast::StmtPass>(ast_module)?;
+    cache_py_type::<ast::StmtBreak>(ast_module)?;
+    cache_py_type::<ast::StmtContinue>(ast_module)?;
+    cache_py_type::<ast::Expr>(ast_module)?;
+    cache_py_type::<ast::ExprBoolOp>(ast_module)?;
+    cache_py_type::<ast::ExprNamedExpr>(ast_module)?;
+    cache_py_type::<ast::ExprBinOp>(ast_module)?;
+    cache_py_type::<ast::ExprUnaryOp>(ast_module)?;
+    cache_py_type::<ast::ExprLambda>(ast_module)?;
+    cache_py_type::<ast::ExprIfExp>(ast_module)?;
+    cache_py_type::<ast::ExprDict>(ast_module)?;
+    cache_py_type::<ast::ExprSet>(ast_module)?;
+    cache_py_type::<ast::ExprListComp>(ast_module)?;
+    cache_py_type::<ast::ExprSetComp>(ast_module)?;
+    cache_py_type::<ast::ExprDictComp>(ast_module)?;
+    cache_py_type::<ast::ExprGeneratorExp>(ast_module)?;
+    cache_py_type::<ast::ExprAwait>(ast_module)?;
+    cache_py_type::<ast::ExprYield>(ast_module)?;
+    cache_py_type::<ast::ExprYieldFrom>(ast_module)?;
+    cache_py_type::<ast::ExprCompare>(ast_module)?;
+    cache_py_type::<ast::ExprCall>(ast_module)?;
+    cache_py_type::<ast::ExprFormattedValue>(ast_module)?;
+    cache_py_type::<ast::ExprJoinedStr>(ast_module)?;
+    cache_py_type::<ast::ExprConstant>(ast_module)?;
+    cache_py_type::<ast::ExprAttribute>(ast_module)?;
+    cache_py_type::<ast::ExprSubscript>(ast_module)?;
+    cache_py_type::<ast::ExprStarred>(ast_module)?;
+    cache_py_type::<ast::ExprName>(ast_module)?;
+    cache_py_type::<ast::ExprList>(ast_module)?;
+    cache_py_type::<ast::ExprTuple>(ast_module)?;
+    cache_py_type::<ast::ExprSlice>(ast_module)?;
+    cache_py_type::<ast::ExprContext>(ast_module)?;
+    cache_py_type::<ast::ExprContextLoad>(ast_module)?;
+    cache_py_type::<ast::ExprContextStore>(ast_module)?;
+    cache_py_type::<ast::ExprContextDel>(ast_module)?;
+    cache_py_type::<ast::Boolop>(ast_module)?;
+    cache_py_type::<ast::BoolopAnd>(ast_module)?;
+    cache_py_type::<ast::BoolopOr>(ast_module)?;
+    cache_py_type::<ast::Operator>(ast_module)?;
+    cache_py_type::<ast::OperatorAdd>(ast_module)?;
+    cache_py_type::<ast::OperatorSub>(ast_module)?;
+    cache_py_type::<ast::OperatorMult>(ast_module)?;
+    cache_py_type::<ast::OperatorMatMult>(ast_module)?;
+    cache_py_type::<ast::OperatorDiv>(ast_module)?;
+    cache_py_type::<ast::OperatorMod>(ast_module)?;
+    cache_py_type::<ast::OperatorPow>(ast_module)?;
+    cache_py_type::<ast::OperatorLShift>(ast_module)?;
+    cache_py_type::<ast::OperatorRShift>(ast_module)?;
+    cache_py_type::<ast::OperatorBitOr>(ast_module)?;
+    cache_py_type::<ast::OperatorBitXor>(ast_module)?;
+    cache_py_type::<ast::OperatorBitAnd>(ast_module)?;
+    cache_py_type::<ast::OperatorFloorDiv>(ast_module)?;
+    cache_py_type::<ast::Unaryop>(ast_module)?;
+    cache_py_type::<ast::UnaryopInvert>(ast_module)?;
+    cache_py_type::<ast::UnaryopNot>(ast_module)?;
+    cache_py_type::<ast::UnaryopUAdd>(ast_module)?;
+    cache_py_type::<ast::UnaryopUSub>(ast_module)?;
+    cache_py_type::<ast::Cmpop>(ast_module)?;
+    cache_py_type::<ast::CmpopEq>(ast_module)?;
+    cache_py_type::<ast::CmpopNotEq>(ast_module)?;
+    cache_py_type::<ast::CmpopLt>(ast_module)?;
+    cache_py_type::<ast::CmpopLtE>(ast_module)?;
+    cache_py_type::<ast::CmpopGt>(ast_module)?;
+    cache_py_type::<ast::CmpopGtE>(ast_module)?;
+    cache_py_type::<ast::CmpopIs>(ast_module)?;
+    cache_py_type::<ast::CmpopIsNot>(ast_module)?;
+    cache_py_type::<ast::CmpopIn>(ast_module)?;
+    cache_py_type::<ast::CmpopNotIn>(ast_module)?;
+    cache_py_type::<ast::Comprehension>(ast_module)?;
+    cache_py_type::<ast::Excepthandler>(ast_module)?;
+    cache_py_type::<ast::ExcepthandlerExceptHandler>(ast_module)?;
+    cache_py_type::<ast::Arguments>(ast_module)?;
+    cache_py_type::<ast::Arg>(ast_module)?;
+    cache_py_type::<ast::Keyword>(ast_module)?;
+    cache_py_type::<ast::Alias>(ast_module)?;
+    cache_py_type::<ast::Withitem>(ast_module)?;
+    cache_py_type::<ast::MatchCase>(ast_module)?;
+    cache_py_type::<ast::Pattern>(ast_module)?;
+    cache_py_type::<ast::PatternMatchValue>(ast_module)?;
+    cache_py_type::<ast::PatternMatchSingleton>(ast_module)?;
+    cache_py_type::<ast::PatternMatchSequence>(ast_module)?;
+    cache_py_type::<ast::PatternMatchMapping>(ast_module)?;
+    cache_py_type::<ast::PatternMatchClass>(ast_module)?;
+    cache_py_type::<ast::PatternMatchStar>(ast_module)?;
+    cache_py_type::<ast::PatternMatchAs>(ast_module)?;
+    cache_py_type::<ast::PatternMatchOr>(ast_module)?;
+    cache_py_type::<ast::TypeIgnore>(ast_module)?;
+    cache_py_type::<ast::TypeIgnoreTypeIgnore>(ast_module)?;
+    Ok(())
+}
diff --git a/ast/src/gen/pyo3_wrapper_located.rs b/ast-pyo3/src/gen/wrapper_located.rs
similarity index 54%
rename from ast/src/gen/pyo3_wrapper_located.rs
rename to ast-pyo3/src/gen/wrapper_located.rs
index ba55ee24..1f4e0d6d 100644
--- a/ast/src/gen/pyo3_wrapper_located.rs
+++ b/ast-pyo3/src/gen/wrapper_located.rs
@@ -1,11 +1,11 @@
 // File automatically generated by ast/asdl_rs.py.
 
-#[pyclass(module="rustpython_ast.located", name="_mod", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_mod", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Mod;
 
-impl From<&'static crate::Mod<SourceRange>> for Mod {
-    fn from(_node: &'static crate::Mod<SourceRange>) -> Self {
+impl From<&'static ast::Mod<SourceRange>> for Mod {
+    fn from(_node: &'static ast::Mod<SourceRange>) -> Self {
         Mod
     }
 }
@@ -14,7 +14,7 @@ impl From<&'static crate::Mod<SourceRange>> for Mod {
 impl Mod {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Mod {
@@ -24,40 +24,40 @@ impl ToPyObject for Mod {
     }
 }
 
-impl ToPyo3Wrapper for crate::Mod<SourceRange> {
+impl ToPyWrapper for ast::Mod<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::Module(cons) => cons.to_pyo3_wrapper(py),
-            Self::Interactive(cons) => cons.to_pyo3_wrapper(py),
-            Self::Expression(cons) => cons.to_pyo3_wrapper(py),
-            Self::FunctionType(cons) => cons.to_pyo3_wrapper(py),
+            Self::Module(cons) => cons.to_py_wrapper(py),
+            Self::Interactive(cons) => cons.to_py_wrapper(py),
+            Self::Expression(cons) => cons.to_py_wrapper(py),
+            Self::FunctionType(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Module", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModModule(pub &'static crate::ModModule<SourceRange>);
+pub struct ModModule(pub &'static ast::ModModule<SourceRange>);
 
-impl From<&'static crate::ModModule<SourceRange>> for ModModule {
-    fn from(node: &'static crate::ModModule<SourceRange>) -> Self {
+impl From<&'static ast::ModModule<SourceRange>> for ModModule {
+    fn from(node: &'static ast::ModModule<SourceRange>) -> Self {
         ModModule(node)
     }
 }
 
 impl ToPyObject for ModModule {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModModule<SourceRange> {
+impl ToPyWrapper for ast::ModModule<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModModule(self).to_object(py))
     }
 }
@@ -67,38 +67,38 @@ impl ModModule {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_ignores(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_ignores.to_pyo3_wrapper(py)
+        self.0.type_ignores.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Interactive", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModInteractive(pub &'static crate::ModInteractive<SourceRange>);
+pub struct ModInteractive(pub &'static ast::ModInteractive<SourceRange>);
 
-impl From<&'static crate::ModInteractive<SourceRange>> for ModInteractive {
-    fn from(node: &'static crate::ModInteractive<SourceRange>) -> Self {
+impl From<&'static ast::ModInteractive<SourceRange>> for ModInteractive {
+    fn from(node: &'static ast::ModInteractive<SourceRange>) -> Self {
         ModInteractive(node)
     }
 }
 
 impl ToPyObject for ModInteractive {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModInteractive<SourceRange> {
+impl ToPyWrapper for ast::ModInteractive<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModInteractive(self).to_object(py))
     }
 }
@@ -108,32 +108,32 @@ impl ModInteractive {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Expression", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModExpression(pub &'static crate::ModExpression<SourceRange>);
+pub struct ModExpression(pub &'static ast::ModExpression<SourceRange>);
 
-impl From<&'static crate::ModExpression<SourceRange>> for ModExpression {
-    fn from(node: &'static crate::ModExpression<SourceRange>) -> Self {
+impl From<&'static ast::ModExpression<SourceRange>> for ModExpression {
+    fn from(node: &'static ast::ModExpression<SourceRange>) -> Self {
         ModExpression(node)
     }
 }
 
 impl ToPyObject for ModExpression {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModExpression<SourceRange> {
+impl ToPyWrapper for ast::ModExpression<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModExpression(self).to_object(py))
     }
 }
@@ -143,32 +143,32 @@ impl ModExpression {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_FunctionType", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModFunctionType(pub &'static crate::ModFunctionType<SourceRange>);
+pub struct ModFunctionType(pub &'static ast::ModFunctionType<SourceRange>);
 
-impl From<&'static crate::ModFunctionType<SourceRange>> for ModFunctionType {
-    fn from(node: &'static crate::ModFunctionType<SourceRange>) -> Self {
+impl From<&'static ast::ModFunctionType<SourceRange>> for ModFunctionType {
+    fn from(node: &'static ast::ModFunctionType<SourceRange>) -> Self {
         ModFunctionType(node)
     }
 }
 
 impl ToPyObject for ModFunctionType {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModFunctionType<SourceRange> {
+impl ToPyWrapper for ast::ModFunctionType<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModFunctionType(self).to_object(py))
     }
 }
@@ -178,22 +178,22 @@ impl ModFunctionType {
     #[getter]
     #[inline]
     fn get_argtypes(&self, py: Python) -> PyResult<PyObject> {
-        self.0.argtypes.to_pyo3_wrapper(py)
+        self.0.argtypes.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_stmt", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_stmt", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Stmt;
 
-impl From<&'static crate::Stmt<SourceRange>> for Stmt {
-    fn from(_node: &'static crate::Stmt<SourceRange>) -> Self {
+impl From<&'static ast::Stmt<SourceRange>> for Stmt {
+    fn from(_node: &'static ast::Stmt<SourceRange>) -> Self {
         Stmt
     }
 }
@@ -202,7 +202,7 @@ impl From<&'static crate::Stmt<SourceRange>> for Stmt {
 impl Stmt {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Stmt {
@@ -212,63 +212,63 @@ impl ToPyObject for Stmt {
     }
 }
 
-impl ToPyo3Wrapper for crate::Stmt<SourceRange> {
+impl ToPyWrapper for ast::Stmt<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::FunctionDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncFunctionDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::ClassDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::Return(cons) => cons.to_pyo3_wrapper(py),
-            Self::Delete(cons) => cons.to_pyo3_wrapper(py),
-            Self::Assign(cons) => cons.to_pyo3_wrapper(py),
-            Self::AugAssign(cons) => cons.to_pyo3_wrapper(py),
-            Self::AnnAssign(cons) => cons.to_pyo3_wrapper(py),
-            Self::For(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncFor(cons) => cons.to_pyo3_wrapper(py),
-            Self::While(cons) => cons.to_pyo3_wrapper(py),
-            Self::If(cons) => cons.to_pyo3_wrapper(py),
-            Self::With(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncWith(cons) => cons.to_pyo3_wrapper(py),
-            Self::Match(cons) => cons.to_pyo3_wrapper(py),
-            Self::Raise(cons) => cons.to_pyo3_wrapper(py),
-            Self::Try(cons) => cons.to_pyo3_wrapper(py),
-            Self::TryStar(cons) => cons.to_pyo3_wrapper(py),
-            Self::Assert(cons) => cons.to_pyo3_wrapper(py),
-            Self::Import(cons) => cons.to_pyo3_wrapper(py),
-            Self::ImportFrom(cons) => cons.to_pyo3_wrapper(py),
-            Self::Global(cons) => cons.to_pyo3_wrapper(py),
-            Self::Nonlocal(cons) => cons.to_pyo3_wrapper(py),
-            Self::Expr(cons) => cons.to_pyo3_wrapper(py),
-            Self::Pass(cons) => cons.to_pyo3_wrapper(py),
-            Self::Break(cons) => cons.to_pyo3_wrapper(py),
-            Self::Continue(cons) => cons.to_pyo3_wrapper(py),
+            Self::FunctionDef(cons) => cons.to_py_wrapper(py),
+            Self::AsyncFunctionDef(cons) => cons.to_py_wrapper(py),
+            Self::ClassDef(cons) => cons.to_py_wrapper(py),
+            Self::Return(cons) => cons.to_py_wrapper(py),
+            Self::Delete(cons) => cons.to_py_wrapper(py),
+            Self::Assign(cons) => cons.to_py_wrapper(py),
+            Self::AugAssign(cons) => cons.to_py_wrapper(py),
+            Self::AnnAssign(cons) => cons.to_py_wrapper(py),
+            Self::For(cons) => cons.to_py_wrapper(py),
+            Self::AsyncFor(cons) => cons.to_py_wrapper(py),
+            Self::While(cons) => cons.to_py_wrapper(py),
+            Self::If(cons) => cons.to_py_wrapper(py),
+            Self::With(cons) => cons.to_py_wrapper(py),
+            Self::AsyncWith(cons) => cons.to_py_wrapper(py),
+            Self::Match(cons) => cons.to_py_wrapper(py),
+            Self::Raise(cons) => cons.to_py_wrapper(py),
+            Self::Try(cons) => cons.to_py_wrapper(py),
+            Self::TryStar(cons) => cons.to_py_wrapper(py),
+            Self::Assert(cons) => cons.to_py_wrapper(py),
+            Self::Import(cons) => cons.to_py_wrapper(py),
+            Self::ImportFrom(cons) => cons.to_py_wrapper(py),
+            Self::Global(cons) => cons.to_py_wrapper(py),
+            Self::Nonlocal(cons) => cons.to_py_wrapper(py),
+            Self::Expr(cons) => cons.to_py_wrapper(py),
+            Self::Pass(cons) => cons.to_py_wrapper(py),
+            Self::Break(cons) => cons.to_py_wrapper(py),
+            Self::Continue(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_FunctionDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtFunctionDef(pub &'static crate::StmtFunctionDef<SourceRange>);
+pub struct StmtFunctionDef(pub &'static ast::StmtFunctionDef<SourceRange>);
 
-impl From<&'static crate::StmtFunctionDef<SourceRange>> for StmtFunctionDef {
-    fn from(node: &'static crate::StmtFunctionDef<SourceRange>) -> Self {
+impl From<&'static ast::StmtFunctionDef<SourceRange>> for StmtFunctionDef {
+    fn from(node: &'static ast::StmtFunctionDef<SourceRange>) -> Self {
         StmtFunctionDef(node)
     }
 }
 
 impl ToPyObject for StmtFunctionDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtFunctionDef<SourceRange> {
+impl ToPyWrapper for ast::StmtFunctionDef<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtFunctionDef(self).to_object(py))
     }
 }
@@ -278,62 +278,62 @@ impl StmtFunctionDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AsyncFunctionDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncFunctionDef(pub &'static crate::StmtAsyncFunctionDef<SourceRange>);
+pub struct StmtAsyncFunctionDef(pub &'static ast::StmtAsyncFunctionDef<SourceRange>);
 
-impl From<&'static crate::StmtAsyncFunctionDef<SourceRange>> for StmtAsyncFunctionDef {
-    fn from(node: &'static crate::StmtAsyncFunctionDef<SourceRange>) -> Self {
+impl From<&'static ast::StmtAsyncFunctionDef<SourceRange>> for StmtAsyncFunctionDef {
+    fn from(node: &'static ast::StmtAsyncFunctionDef<SourceRange>) -> Self {
         StmtAsyncFunctionDef(node)
     }
 }
 
 impl ToPyObject for StmtAsyncFunctionDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncFunctionDef<SourceRange> {
+impl ToPyWrapper for ast::StmtAsyncFunctionDef<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncFunctionDef(self).to_object(py))
     }
 }
@@ -343,62 +343,62 @@ impl StmtAsyncFunctionDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ClassDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtClassDef(pub &'static crate::StmtClassDef<SourceRange>);
+pub struct StmtClassDef(pub &'static ast::StmtClassDef<SourceRange>);
 
-impl From<&'static crate::StmtClassDef<SourceRange>> for StmtClassDef {
-    fn from(node: &'static crate::StmtClassDef<SourceRange>) -> Self {
+impl From<&'static ast::StmtClassDef<SourceRange>> for StmtClassDef {
+    fn from(node: &'static ast::StmtClassDef<SourceRange>) -> Self {
         StmtClassDef(node)
     }
 }
 
 impl ToPyObject for StmtClassDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtClassDef<SourceRange> {
+impl ToPyWrapper for ast::StmtClassDef<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtClassDef(self).to_object(py))
     }
 }
@@ -408,56 +408,56 @@ impl StmtClassDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_bases(&self, py: Python) -> PyResult<PyObject> {
-        self.0.bases.to_pyo3_wrapper(py)
+        self.0.bases.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_keywords(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keywords.to_pyo3_wrapper(py)
+        self.0.keywords.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Return", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtReturn(pub &'static crate::StmtReturn<SourceRange>);
+pub struct StmtReturn(pub &'static ast::StmtReturn<SourceRange>);
 
-impl From<&'static crate::StmtReturn<SourceRange>> for StmtReturn {
-    fn from(node: &'static crate::StmtReturn<SourceRange>) -> Self {
+impl From<&'static ast::StmtReturn<SourceRange>> for StmtReturn {
+    fn from(node: &'static ast::StmtReturn<SourceRange>) -> Self {
         StmtReturn(node)
     }
 }
 
 impl ToPyObject for StmtReturn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtReturn<SourceRange> {
+impl ToPyWrapper for ast::StmtReturn<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtReturn(self).to_object(py))
     }
 }
@@ -467,32 +467,32 @@ impl StmtReturn {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Delete", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtDelete(pub &'static crate::StmtDelete<SourceRange>);
+pub struct StmtDelete(pub &'static ast::StmtDelete<SourceRange>);
 
-impl From<&'static crate::StmtDelete<SourceRange>> for StmtDelete {
-    fn from(node: &'static crate::StmtDelete<SourceRange>) -> Self {
+impl From<&'static ast::StmtDelete<SourceRange>> for StmtDelete {
+    fn from(node: &'static ast::StmtDelete<SourceRange>) -> Self {
         StmtDelete(node)
     }
 }
 
 impl ToPyObject for StmtDelete {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtDelete<SourceRange> {
+impl ToPyWrapper for ast::StmtDelete<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtDelete(self).to_object(py))
     }
 }
@@ -502,32 +502,32 @@ impl StmtDelete {
     #[getter]
     #[inline]
     fn get_targets(&self, py: Python) -> PyResult<PyObject> {
-        self.0.targets.to_pyo3_wrapper(py)
+        self.0.targets.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Assign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAssign(pub &'static crate::StmtAssign<SourceRange>);
+pub struct StmtAssign(pub &'static ast::StmtAssign<SourceRange>);
 
-impl From<&'static crate::StmtAssign<SourceRange>> for StmtAssign {
-    fn from(node: &'static crate::StmtAssign<SourceRange>) -> Self {
+impl From<&'static ast::StmtAssign<SourceRange>> for StmtAssign {
+    fn from(node: &'static ast::StmtAssign<SourceRange>) -> Self {
         StmtAssign(node)
     }
 }
 
 impl ToPyObject for StmtAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAssign<SourceRange> {
+impl ToPyWrapper for ast::StmtAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAssign(self).to_object(py))
     }
 }
@@ -537,44 +537,44 @@ impl StmtAssign {
     #[getter]
     #[inline]
     fn get_targets(&self, py: Python) -> PyResult<PyObject> {
-        self.0.targets.to_pyo3_wrapper(py)
+        self.0.targets.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AugAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAugAssign(pub &'static crate::StmtAugAssign<SourceRange>);
+pub struct StmtAugAssign(pub &'static ast::StmtAugAssign<SourceRange>);
 
-impl From<&'static crate::StmtAugAssign<SourceRange>> for StmtAugAssign {
-    fn from(node: &'static crate::StmtAugAssign<SourceRange>) -> Self {
+impl From<&'static ast::StmtAugAssign<SourceRange>> for StmtAugAssign {
+    fn from(node: &'static ast::StmtAugAssign<SourceRange>) -> Self {
         StmtAugAssign(node)
     }
 }
 
 impl ToPyObject for StmtAugAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAugAssign<SourceRange> {
+impl ToPyWrapper for ast::StmtAugAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAugAssign(self).to_object(py))
     }
 }
@@ -584,44 +584,44 @@ impl StmtAugAssign {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AnnAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAnnAssign(pub &'static crate::StmtAnnAssign<SourceRange>);
+pub struct StmtAnnAssign(pub &'static ast::StmtAnnAssign<SourceRange>);
 
-impl From<&'static crate::StmtAnnAssign<SourceRange>> for StmtAnnAssign {
-    fn from(node: &'static crate::StmtAnnAssign<SourceRange>) -> Self {
+impl From<&'static ast::StmtAnnAssign<SourceRange>> for StmtAnnAssign {
+    fn from(node: &'static ast::StmtAnnAssign<SourceRange>) -> Self {
         StmtAnnAssign(node)
     }
 }
 
 impl ToPyObject for StmtAnnAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAnnAssign<SourceRange> {
+impl ToPyWrapper for ast::StmtAnnAssign<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAnnAssign(self).to_object(py))
     }
 }
@@ -631,50 +631,50 @@ impl StmtAnnAssign {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_annotation(&self, py: Python) -> PyResult<PyObject> {
-        self.0.annotation.to_pyo3_wrapper(py)
+        self.0.annotation.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_simple(&self, py: Python) -> PyResult<PyObject> {
-        self.0.simple.to_pyo3_wrapper(py)
+        self.0.simple.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_For", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtFor(pub &'static crate::StmtFor<SourceRange>);
+pub struct StmtFor(pub &'static ast::StmtFor<SourceRange>);
 
-impl From<&'static crate::StmtFor<SourceRange>> for StmtFor {
-    fn from(node: &'static crate::StmtFor<SourceRange>) -> Self {
+impl From<&'static ast::StmtFor<SourceRange>> for StmtFor {
+    fn from(node: &'static ast::StmtFor<SourceRange>) -> Self {
         StmtFor(node)
     }
 }
 
 impl ToPyObject for StmtFor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtFor<SourceRange> {
+impl ToPyWrapper for ast::StmtFor<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtFor(self).to_object(py))
     }
 }
@@ -684,56 +684,56 @@ impl StmtFor {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AsyncFor", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncFor(pub &'static crate::StmtAsyncFor<SourceRange>);
+pub struct StmtAsyncFor(pub &'static ast::StmtAsyncFor<SourceRange>);
 
-impl From<&'static crate::StmtAsyncFor<SourceRange>> for StmtAsyncFor {
-    fn from(node: &'static crate::StmtAsyncFor<SourceRange>) -> Self {
+impl From<&'static ast::StmtAsyncFor<SourceRange>> for StmtAsyncFor {
+    fn from(node: &'static ast::StmtAsyncFor<SourceRange>) -> Self {
         StmtAsyncFor(node)
     }
 }
 
 impl ToPyObject for StmtAsyncFor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncFor<SourceRange> {
+impl ToPyWrapper for ast::StmtAsyncFor<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncFor(self).to_object(py))
     }
 }
@@ -743,56 +743,56 @@ impl StmtAsyncFor {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_While", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtWhile(pub &'static crate::StmtWhile<SourceRange>);
+pub struct StmtWhile(pub &'static ast::StmtWhile<SourceRange>);
 
-impl From<&'static crate::StmtWhile<SourceRange>> for StmtWhile {
-    fn from(node: &'static crate::StmtWhile<SourceRange>) -> Self {
+impl From<&'static ast::StmtWhile<SourceRange>> for StmtWhile {
+    fn from(node: &'static ast::StmtWhile<SourceRange>) -> Self {
         StmtWhile(node)
     }
 }
 
 impl ToPyObject for StmtWhile {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtWhile<SourceRange> {
+impl ToPyWrapper for ast::StmtWhile<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtWhile(self).to_object(py))
     }
 }
@@ -802,44 +802,44 @@ impl StmtWhile {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_If", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtIf(pub &'static crate::StmtIf<SourceRange>);
+pub struct StmtIf(pub &'static ast::StmtIf<SourceRange>);
 
-impl From<&'static crate::StmtIf<SourceRange>> for StmtIf {
-    fn from(node: &'static crate::StmtIf<SourceRange>) -> Self {
+impl From<&'static ast::StmtIf<SourceRange>> for StmtIf {
+    fn from(node: &'static ast::StmtIf<SourceRange>) -> Self {
         StmtIf(node)
     }
 }
 
 impl ToPyObject for StmtIf {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtIf<SourceRange> {
+impl ToPyWrapper for ast::StmtIf<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtIf(self).to_object(py))
     }
 }
@@ -849,44 +849,44 @@ impl StmtIf {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_With", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtWith(pub &'static crate::StmtWith<SourceRange>);
+pub struct StmtWith(pub &'static ast::StmtWith<SourceRange>);
 
-impl From<&'static crate::StmtWith<SourceRange>> for StmtWith {
-    fn from(node: &'static crate::StmtWith<SourceRange>) -> Self {
+impl From<&'static ast::StmtWith<SourceRange>> for StmtWith {
+    fn from(node: &'static ast::StmtWith<SourceRange>) -> Self {
         StmtWith(node)
     }
 }
 
 impl ToPyObject for StmtWith {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtWith<SourceRange> {
+impl ToPyWrapper for ast::StmtWith<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtWith(self).to_object(py))
     }
 }
@@ -896,44 +896,44 @@ impl StmtWith {
     #[getter]
     #[inline]
     fn get_items(&self, py: Python) -> PyResult<PyObject> {
-        self.0.items.to_pyo3_wrapper(py)
+        self.0.items.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AsyncWith", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncWith(pub &'static crate::StmtAsyncWith<SourceRange>);
+pub struct StmtAsyncWith(pub &'static ast::StmtAsyncWith<SourceRange>);
 
-impl From<&'static crate::StmtAsyncWith<SourceRange>> for StmtAsyncWith {
-    fn from(node: &'static crate::StmtAsyncWith<SourceRange>) -> Self {
+impl From<&'static ast::StmtAsyncWith<SourceRange>> for StmtAsyncWith {
+    fn from(node: &'static ast::StmtAsyncWith<SourceRange>) -> Self {
         StmtAsyncWith(node)
     }
 }
 
 impl ToPyObject for StmtAsyncWith {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncWith<SourceRange> {
+impl ToPyWrapper for ast::StmtAsyncWith<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncWith(self).to_object(py))
     }
 }
@@ -943,44 +943,44 @@ impl StmtAsyncWith {
     #[getter]
     #[inline]
     fn get_items(&self, py: Python) -> PyResult<PyObject> {
-        self.0.items.to_pyo3_wrapper(py)
+        self.0.items.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Match", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtMatch(pub &'static crate::StmtMatch<SourceRange>);
+pub struct StmtMatch(pub &'static ast::StmtMatch<SourceRange>);
 
-impl From<&'static crate::StmtMatch<SourceRange>> for StmtMatch {
-    fn from(node: &'static crate::StmtMatch<SourceRange>) -> Self {
+impl From<&'static ast::StmtMatch<SourceRange>> for StmtMatch {
+    fn from(node: &'static ast::StmtMatch<SourceRange>) -> Self {
         StmtMatch(node)
     }
 }
 
 impl ToPyObject for StmtMatch {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtMatch<SourceRange> {
+impl ToPyWrapper for ast::StmtMatch<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtMatch(self).to_object(py))
     }
 }
@@ -990,38 +990,38 @@ impl StmtMatch {
     #[getter]
     #[inline]
     fn get_subject(&self, py: Python) -> PyResult<PyObject> {
-        self.0.subject.to_pyo3_wrapper(py)
+        self.0.subject.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_cases(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cases.to_pyo3_wrapper(py)
+        self.0.cases.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Raise", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtRaise(pub &'static crate::StmtRaise<SourceRange>);
+pub struct StmtRaise(pub &'static ast::StmtRaise<SourceRange>);
 
-impl From<&'static crate::StmtRaise<SourceRange>> for StmtRaise {
-    fn from(node: &'static crate::StmtRaise<SourceRange>) -> Self {
+impl From<&'static ast::StmtRaise<SourceRange>> for StmtRaise {
+    fn from(node: &'static ast::StmtRaise<SourceRange>) -> Self {
         StmtRaise(node)
     }
 }
 
 impl ToPyObject for StmtRaise {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtRaise<SourceRange> {
+impl ToPyWrapper for ast::StmtRaise<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtRaise(self).to_object(py))
     }
 }
@@ -1031,38 +1031,38 @@ impl StmtRaise {
     #[getter]
     #[inline]
     fn get_exc(&self, py: Python) -> PyResult<PyObject> {
-        self.0.exc.to_pyo3_wrapper(py)
+        self.0.exc.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_cause(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cause.to_pyo3_wrapper(py)
+        self.0.cause.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Try", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtTry(pub &'static crate::StmtTry<SourceRange>);
+pub struct StmtTry(pub &'static ast::StmtTry<SourceRange>);
 
-impl From<&'static crate::StmtTry<SourceRange>> for StmtTry {
-    fn from(node: &'static crate::StmtTry<SourceRange>) -> Self {
+impl From<&'static ast::StmtTry<SourceRange>> for StmtTry {
+    fn from(node: &'static ast::StmtTry<SourceRange>) -> Self {
         StmtTry(node)
     }
 }
 
 impl ToPyObject for StmtTry {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtTry<SourceRange> {
+impl ToPyWrapper for ast::StmtTry<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtTry(self).to_object(py))
     }
 }
@@ -1072,50 +1072,50 @@ impl StmtTry {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_handlers(&self, py: Python) -> PyResult<PyObject> {
-        self.0.handlers.to_pyo3_wrapper(py)
+        self.0.handlers.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_finalbody(&self, py: Python) -> PyResult<PyObject> {
-        self.0.finalbody.to_pyo3_wrapper(py)
+        self.0.finalbody.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_TryStar", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtTryStar(pub &'static crate::StmtTryStar<SourceRange>);
+pub struct StmtTryStar(pub &'static ast::StmtTryStar<SourceRange>);
 
-impl From<&'static crate::StmtTryStar<SourceRange>> for StmtTryStar {
-    fn from(node: &'static crate::StmtTryStar<SourceRange>) -> Self {
+impl From<&'static ast::StmtTryStar<SourceRange>> for StmtTryStar {
+    fn from(node: &'static ast::StmtTryStar<SourceRange>) -> Self {
         StmtTryStar(node)
     }
 }
 
 impl ToPyObject for StmtTryStar {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtTryStar<SourceRange> {
+impl ToPyWrapper for ast::StmtTryStar<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtTryStar(self).to_object(py))
     }
 }
@@ -1125,50 +1125,50 @@ impl StmtTryStar {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_handlers(&self, py: Python) -> PyResult<PyObject> {
-        self.0.handlers.to_pyo3_wrapper(py)
+        self.0.handlers.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_finalbody(&self, py: Python) -> PyResult<PyObject> {
-        self.0.finalbody.to_pyo3_wrapper(py)
+        self.0.finalbody.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Assert", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAssert(pub &'static crate::StmtAssert<SourceRange>);
+pub struct StmtAssert(pub &'static ast::StmtAssert<SourceRange>);
 
-impl From<&'static crate::StmtAssert<SourceRange>> for StmtAssert {
-    fn from(node: &'static crate::StmtAssert<SourceRange>) -> Self {
+impl From<&'static ast::StmtAssert<SourceRange>> for StmtAssert {
+    fn from(node: &'static ast::StmtAssert<SourceRange>) -> Self {
         StmtAssert(node)
     }
 }
 
 impl ToPyObject for StmtAssert {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAssert<SourceRange> {
+impl ToPyWrapper for ast::StmtAssert<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAssert(self).to_object(py))
     }
 }
@@ -1178,38 +1178,38 @@ impl StmtAssert {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_msg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.msg.to_pyo3_wrapper(py)
+        self.0.msg.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Import", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtImport(pub &'static crate::StmtImport<SourceRange>);
+pub struct StmtImport(pub &'static ast::StmtImport<SourceRange>);
 
-impl From<&'static crate::StmtImport<SourceRange>> for StmtImport {
-    fn from(node: &'static crate::StmtImport<SourceRange>) -> Self {
+impl From<&'static ast::StmtImport<SourceRange>> for StmtImport {
+    fn from(node: &'static ast::StmtImport<SourceRange>) -> Self {
         StmtImport(node)
     }
 }
 
 impl ToPyObject for StmtImport {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtImport<SourceRange> {
+impl ToPyWrapper for ast::StmtImport<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtImport(self).to_object(py))
     }
 }
@@ -1219,32 +1219,32 @@ impl StmtImport {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ImportFrom", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtImportFrom(pub &'static crate::StmtImportFrom<SourceRange>);
+pub struct StmtImportFrom(pub &'static ast::StmtImportFrom<SourceRange>);
 
-impl From<&'static crate::StmtImportFrom<SourceRange>> for StmtImportFrom {
-    fn from(node: &'static crate::StmtImportFrom<SourceRange>) -> Self {
+impl From<&'static ast::StmtImportFrom<SourceRange>> for StmtImportFrom {
+    fn from(node: &'static ast::StmtImportFrom<SourceRange>) -> Self {
         StmtImportFrom(node)
     }
 }
 
 impl ToPyObject for StmtImportFrom {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtImportFrom<SourceRange> {
+impl ToPyWrapper for ast::StmtImportFrom<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtImportFrom(self).to_object(py))
     }
 }
@@ -1254,44 +1254,44 @@ impl StmtImportFrom {
     #[getter]
     #[inline]
     fn get_module(&self, py: Python) -> PyResult<PyObject> {
-        self.0.module.to_pyo3_wrapper(py)
+        self.0.module.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_level(&self, py: Python) -> PyResult<PyObject> {
-        self.0.level.to_pyo3_wrapper(py)
+        self.0.level.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Global", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtGlobal(pub &'static crate::StmtGlobal<SourceRange>);
+pub struct StmtGlobal(pub &'static ast::StmtGlobal<SourceRange>);
 
-impl From<&'static crate::StmtGlobal<SourceRange>> for StmtGlobal {
-    fn from(node: &'static crate::StmtGlobal<SourceRange>) -> Self {
+impl From<&'static ast::StmtGlobal<SourceRange>> for StmtGlobal {
+    fn from(node: &'static ast::StmtGlobal<SourceRange>) -> Self {
         StmtGlobal(node)
     }
 }
 
 impl ToPyObject for StmtGlobal {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtGlobal<SourceRange> {
+impl ToPyWrapper for ast::StmtGlobal<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtGlobal(self).to_object(py))
     }
 }
@@ -1301,32 +1301,32 @@ impl StmtGlobal {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Nonlocal", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtNonlocal(pub &'static crate::StmtNonlocal<SourceRange>);
+pub struct StmtNonlocal(pub &'static ast::StmtNonlocal<SourceRange>);
 
-impl From<&'static crate::StmtNonlocal<SourceRange>> for StmtNonlocal {
-    fn from(node: &'static crate::StmtNonlocal<SourceRange>) -> Self {
+impl From<&'static ast::StmtNonlocal<SourceRange>> for StmtNonlocal {
+    fn from(node: &'static ast::StmtNonlocal<SourceRange>) -> Self {
         StmtNonlocal(node)
     }
 }
 
 impl ToPyObject for StmtNonlocal {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtNonlocal<SourceRange> {
+impl ToPyWrapper for ast::StmtNonlocal<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtNonlocal(self).to_object(py))
     }
 }
@@ -1336,32 +1336,32 @@ impl StmtNonlocal {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Expr", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtExpr(pub &'static crate::StmtExpr<SourceRange>);
+pub struct StmtExpr(pub &'static ast::StmtExpr<SourceRange>);
 
-impl From<&'static crate::StmtExpr<SourceRange>> for StmtExpr {
-    fn from(node: &'static crate::StmtExpr<SourceRange>) -> Self {
+impl From<&'static ast::StmtExpr<SourceRange>> for StmtExpr {
+    fn from(node: &'static ast::StmtExpr<SourceRange>) -> Self {
         StmtExpr(node)
     }
 }
 
 impl ToPyObject for StmtExpr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtExpr<SourceRange> {
+impl ToPyWrapper for ast::StmtExpr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtExpr(self).to_object(py))
     }
 }
@@ -1371,32 +1371,32 @@ impl StmtExpr {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Pass", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtPass(pub &'static crate::StmtPass<SourceRange>);
+pub struct StmtPass(pub &'static ast::StmtPass<SourceRange>);
 
-impl From<&'static crate::StmtPass<SourceRange>> for StmtPass {
-    fn from(node: &'static crate::StmtPass<SourceRange>) -> Self {
+impl From<&'static ast::StmtPass<SourceRange>> for StmtPass {
+    fn from(node: &'static ast::StmtPass<SourceRange>) -> Self {
         StmtPass(node)
     }
 }
 
 impl ToPyObject for StmtPass {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtPass<SourceRange> {
+impl ToPyWrapper for ast::StmtPass<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtPass(self).to_object(py))
     }
 }
@@ -1406,26 +1406,26 @@ impl StmtPass {}
 
 #[pyclass(module="rustpython_ast.located", name="_Break", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtBreak(pub &'static crate::StmtBreak<SourceRange>);
+pub struct StmtBreak(pub &'static ast::StmtBreak<SourceRange>);
 
-impl From<&'static crate::StmtBreak<SourceRange>> for StmtBreak {
-    fn from(node: &'static crate::StmtBreak<SourceRange>) -> Self {
+impl From<&'static ast::StmtBreak<SourceRange>> for StmtBreak {
+    fn from(node: &'static ast::StmtBreak<SourceRange>) -> Self {
         StmtBreak(node)
     }
 }
 
 impl ToPyObject for StmtBreak {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtBreak<SourceRange> {
+impl ToPyWrapper for ast::StmtBreak<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtBreak(self).to_object(py))
     }
 }
@@ -1435,26 +1435,26 @@ impl StmtBreak {}
 
 #[pyclass(module="rustpython_ast.located", name="_Continue", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtContinue(pub &'static crate::StmtContinue<SourceRange>);
+pub struct StmtContinue(pub &'static ast::StmtContinue<SourceRange>);
 
-impl From<&'static crate::StmtContinue<SourceRange>> for StmtContinue {
-    fn from(node: &'static crate::StmtContinue<SourceRange>) -> Self {
+impl From<&'static ast::StmtContinue<SourceRange>> for StmtContinue {
+    fn from(node: &'static ast::StmtContinue<SourceRange>) -> Self {
         StmtContinue(node)
     }
 }
 
 impl ToPyObject for StmtContinue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtContinue<SourceRange> {
+impl ToPyWrapper for ast::StmtContinue<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtContinue(self).to_object(py))
     }
 }
@@ -1462,12 +1462,12 @@ impl ToPyo3Wrapper for crate::StmtContinue<SourceRange> {
 #[pymethods]
 impl StmtContinue {}
 
-#[pyclass(module="rustpython_ast.located", name="_expr", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_expr", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Expr;
 
-impl From<&'static crate::Expr<SourceRange>> for Expr {
-    fn from(_node: &'static crate::Expr<SourceRange>) -> Self {
+impl From<&'static ast::Expr<SourceRange>> for Expr {
+    fn from(_node: &'static ast::Expr<SourceRange>) -> Self {
         Expr
     }
 }
@@ -1476,7 +1476,7 @@ impl From<&'static crate::Expr<SourceRange>> for Expr {
 impl Expr {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Expr {
@@ -1486,63 +1486,63 @@ impl ToPyObject for Expr {
     }
 }
 
-impl ToPyo3Wrapper for crate::Expr<SourceRange> {
+impl ToPyWrapper for ast::Expr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::BoolOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::NamedExpr(cons) => cons.to_pyo3_wrapper(py),
-            Self::BinOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::UnaryOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Lambda(cons) => cons.to_pyo3_wrapper(py),
-            Self::IfExp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Dict(cons) => cons.to_pyo3_wrapper(py),
-            Self::Set(cons) => cons.to_pyo3_wrapper(py),
-            Self::ListComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::SetComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::DictComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::GeneratorExp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Await(cons) => cons.to_pyo3_wrapper(py),
-            Self::Yield(cons) => cons.to_pyo3_wrapper(py),
-            Self::YieldFrom(cons) => cons.to_pyo3_wrapper(py),
-            Self::Compare(cons) => cons.to_pyo3_wrapper(py),
-            Self::Call(cons) => cons.to_pyo3_wrapper(py),
-            Self::FormattedValue(cons) => cons.to_pyo3_wrapper(py),
-            Self::JoinedStr(cons) => cons.to_pyo3_wrapper(py),
-            Self::Constant(cons) => cons.to_pyo3_wrapper(py),
-            Self::Attribute(cons) => cons.to_pyo3_wrapper(py),
-            Self::Subscript(cons) => cons.to_pyo3_wrapper(py),
-            Self::Starred(cons) => cons.to_pyo3_wrapper(py),
-            Self::Name(cons) => cons.to_pyo3_wrapper(py),
-            Self::List(cons) => cons.to_pyo3_wrapper(py),
-            Self::Tuple(cons) => cons.to_pyo3_wrapper(py),
-            Self::Slice(cons) => cons.to_pyo3_wrapper(py),
+            Self::BoolOp(cons) => cons.to_py_wrapper(py),
+            Self::NamedExpr(cons) => cons.to_py_wrapper(py),
+            Self::BinOp(cons) => cons.to_py_wrapper(py),
+            Self::UnaryOp(cons) => cons.to_py_wrapper(py),
+            Self::Lambda(cons) => cons.to_py_wrapper(py),
+            Self::IfExp(cons) => cons.to_py_wrapper(py),
+            Self::Dict(cons) => cons.to_py_wrapper(py),
+            Self::Set(cons) => cons.to_py_wrapper(py),
+            Self::ListComp(cons) => cons.to_py_wrapper(py),
+            Self::SetComp(cons) => cons.to_py_wrapper(py),
+            Self::DictComp(cons) => cons.to_py_wrapper(py),
+            Self::GeneratorExp(cons) => cons.to_py_wrapper(py),
+            Self::Await(cons) => cons.to_py_wrapper(py),
+            Self::Yield(cons) => cons.to_py_wrapper(py),
+            Self::YieldFrom(cons) => cons.to_py_wrapper(py),
+            Self::Compare(cons) => cons.to_py_wrapper(py),
+            Self::Call(cons) => cons.to_py_wrapper(py),
+            Self::FormattedValue(cons) => cons.to_py_wrapper(py),
+            Self::JoinedStr(cons) => cons.to_py_wrapper(py),
+            Self::Constant(cons) => cons.to_py_wrapper(py),
+            Self::Attribute(cons) => cons.to_py_wrapper(py),
+            Self::Subscript(cons) => cons.to_py_wrapper(py),
+            Self::Starred(cons) => cons.to_py_wrapper(py),
+            Self::Name(cons) => cons.to_py_wrapper(py),
+            Self::List(cons) => cons.to_py_wrapper(py),
+            Self::Tuple(cons) => cons.to_py_wrapper(py),
+            Self::Slice(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_BoolOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprBoolOp(pub &'static crate::ExprBoolOp<SourceRange>);
+pub struct ExprBoolOp(pub &'static ast::ExprBoolOp<SourceRange>);
 
-impl From<&'static crate::ExprBoolOp<SourceRange>> for ExprBoolOp {
-    fn from(node: &'static crate::ExprBoolOp<SourceRange>) -> Self {
+impl From<&'static ast::ExprBoolOp<SourceRange>> for ExprBoolOp {
+    fn from(node: &'static ast::ExprBoolOp<SourceRange>) -> Self {
         ExprBoolOp(node)
     }
 }
 
 impl ToPyObject for ExprBoolOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprBoolOp<SourceRange> {
+impl ToPyWrapper for ast::ExprBoolOp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprBoolOp(self).to_object(py))
     }
 }
@@ -1552,38 +1552,38 @@ impl ExprBoolOp {
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_NamedExpr", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprNamedExpr(pub &'static crate::ExprNamedExpr<SourceRange>);
+pub struct ExprNamedExpr(pub &'static ast::ExprNamedExpr<SourceRange>);
 
-impl From<&'static crate::ExprNamedExpr<SourceRange>> for ExprNamedExpr {
-    fn from(node: &'static crate::ExprNamedExpr<SourceRange>) -> Self {
+impl From<&'static ast::ExprNamedExpr<SourceRange>> for ExprNamedExpr {
+    fn from(node: &'static ast::ExprNamedExpr<SourceRange>) -> Self {
         ExprNamedExpr(node)
     }
 }
 
 impl ToPyObject for ExprNamedExpr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprNamedExpr<SourceRange> {
+impl ToPyWrapper for ast::ExprNamedExpr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprNamedExpr(self).to_object(py))
     }
 }
@@ -1593,38 +1593,38 @@ impl ExprNamedExpr {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_BinOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprBinOp(pub &'static crate::ExprBinOp<SourceRange>);
+pub struct ExprBinOp(pub &'static ast::ExprBinOp<SourceRange>);
 
-impl From<&'static crate::ExprBinOp<SourceRange>> for ExprBinOp {
-    fn from(node: &'static crate::ExprBinOp<SourceRange>) -> Self {
+impl From<&'static ast::ExprBinOp<SourceRange>> for ExprBinOp {
+    fn from(node: &'static ast::ExprBinOp<SourceRange>) -> Self {
         ExprBinOp(node)
     }
 }
 
 impl ToPyObject for ExprBinOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprBinOp<SourceRange> {
+impl ToPyWrapper for ast::ExprBinOp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprBinOp(self).to_object(py))
     }
 }
@@ -1634,44 +1634,44 @@ impl ExprBinOp {
     #[getter]
     #[inline]
     fn get_left(&self, py: Python) -> PyResult<PyObject> {
-        self.0.left.to_pyo3_wrapper(py)
+        self.0.left.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_right(&self, py: Python) -> PyResult<PyObject> {
-        self.0.right.to_pyo3_wrapper(py)
+        self.0.right.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_UnaryOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprUnaryOp(pub &'static crate::ExprUnaryOp<SourceRange>);
+pub struct ExprUnaryOp(pub &'static ast::ExprUnaryOp<SourceRange>);
 
-impl From<&'static crate::ExprUnaryOp<SourceRange>> for ExprUnaryOp {
-    fn from(node: &'static crate::ExprUnaryOp<SourceRange>) -> Self {
+impl From<&'static ast::ExprUnaryOp<SourceRange>> for ExprUnaryOp {
+    fn from(node: &'static ast::ExprUnaryOp<SourceRange>) -> Self {
         ExprUnaryOp(node)
     }
 }
 
 impl ToPyObject for ExprUnaryOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprUnaryOp<SourceRange> {
+impl ToPyWrapper for ast::ExprUnaryOp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprUnaryOp(self).to_object(py))
     }
 }
@@ -1681,38 +1681,38 @@ impl ExprUnaryOp {
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_operand(&self, py: Python) -> PyResult<PyObject> {
-        self.0.operand.to_pyo3_wrapper(py)
+        self.0.operand.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Lambda", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprLambda(pub &'static crate::ExprLambda<SourceRange>);
+pub struct ExprLambda(pub &'static ast::ExprLambda<SourceRange>);
 
-impl From<&'static crate::ExprLambda<SourceRange>> for ExprLambda {
-    fn from(node: &'static crate::ExprLambda<SourceRange>) -> Self {
+impl From<&'static ast::ExprLambda<SourceRange>> for ExprLambda {
+    fn from(node: &'static ast::ExprLambda<SourceRange>) -> Self {
         ExprLambda(node)
     }
 }
 
 impl ToPyObject for ExprLambda {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprLambda<SourceRange> {
+impl ToPyWrapper for ast::ExprLambda<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprLambda(self).to_object(py))
     }
 }
@@ -1722,38 +1722,38 @@ impl ExprLambda {
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_IfExp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprIfExp(pub &'static crate::ExprIfExp<SourceRange>);
+pub struct ExprIfExp(pub &'static ast::ExprIfExp<SourceRange>);
 
-impl From<&'static crate::ExprIfExp<SourceRange>> for ExprIfExp {
-    fn from(node: &'static crate::ExprIfExp<SourceRange>) -> Self {
+impl From<&'static ast::ExprIfExp<SourceRange>> for ExprIfExp {
+    fn from(node: &'static ast::ExprIfExp<SourceRange>) -> Self {
         ExprIfExp(node)
     }
 }
 
 impl ToPyObject for ExprIfExp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprIfExp<SourceRange> {
+impl ToPyWrapper for ast::ExprIfExp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprIfExp(self).to_object(py))
     }
 }
@@ -1763,44 +1763,44 @@ impl ExprIfExp {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Dict", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprDict(pub &'static crate::ExprDict<SourceRange>);
+pub struct ExprDict(pub &'static ast::ExprDict<SourceRange>);
 
-impl From<&'static crate::ExprDict<SourceRange>> for ExprDict {
-    fn from(node: &'static crate::ExprDict<SourceRange>) -> Self {
+impl From<&'static ast::ExprDict<SourceRange>> for ExprDict {
+    fn from(node: &'static ast::ExprDict<SourceRange>) -> Self {
         ExprDict(node)
     }
 }
 
 impl ToPyObject for ExprDict {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprDict<SourceRange> {
+impl ToPyWrapper for ast::ExprDict<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprDict(self).to_object(py))
     }
 }
@@ -1810,38 +1810,38 @@ impl ExprDict {
     #[getter]
     #[inline]
     fn get_keys(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keys.to_pyo3_wrapper(py)
+        self.0.keys.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Set", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSet(pub &'static crate::ExprSet<SourceRange>);
+pub struct ExprSet(pub &'static ast::ExprSet<SourceRange>);
 
-impl From<&'static crate::ExprSet<SourceRange>> for ExprSet {
-    fn from(node: &'static crate::ExprSet<SourceRange>) -> Self {
+impl From<&'static ast::ExprSet<SourceRange>> for ExprSet {
+    fn from(node: &'static ast::ExprSet<SourceRange>) -> Self {
         ExprSet(node)
     }
 }
 
 impl ToPyObject for ExprSet {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSet<SourceRange> {
+impl ToPyWrapper for ast::ExprSet<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSet(self).to_object(py))
     }
 }
@@ -1851,32 +1851,32 @@ impl ExprSet {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ListComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprListComp(pub &'static crate::ExprListComp<SourceRange>);
+pub struct ExprListComp(pub &'static ast::ExprListComp<SourceRange>);
 
-impl From<&'static crate::ExprListComp<SourceRange>> for ExprListComp {
-    fn from(node: &'static crate::ExprListComp<SourceRange>) -> Self {
+impl From<&'static ast::ExprListComp<SourceRange>> for ExprListComp {
+    fn from(node: &'static ast::ExprListComp<SourceRange>) -> Self {
         ExprListComp(node)
     }
 }
 
 impl ToPyObject for ExprListComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprListComp<SourceRange> {
+impl ToPyWrapper for ast::ExprListComp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprListComp(self).to_object(py))
     }
 }
@@ -1886,38 +1886,38 @@ impl ExprListComp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_SetComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSetComp(pub &'static crate::ExprSetComp<SourceRange>);
+pub struct ExprSetComp(pub &'static ast::ExprSetComp<SourceRange>);
 
-impl From<&'static crate::ExprSetComp<SourceRange>> for ExprSetComp {
-    fn from(node: &'static crate::ExprSetComp<SourceRange>) -> Self {
+impl From<&'static ast::ExprSetComp<SourceRange>> for ExprSetComp {
+    fn from(node: &'static ast::ExprSetComp<SourceRange>) -> Self {
         ExprSetComp(node)
     }
 }
 
 impl ToPyObject for ExprSetComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSetComp<SourceRange> {
+impl ToPyWrapper for ast::ExprSetComp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSetComp(self).to_object(py))
     }
 }
@@ -1927,38 +1927,38 @@ impl ExprSetComp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_DictComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprDictComp(pub &'static crate::ExprDictComp<SourceRange>);
+pub struct ExprDictComp(pub &'static ast::ExprDictComp<SourceRange>);
 
-impl From<&'static crate::ExprDictComp<SourceRange>> for ExprDictComp {
-    fn from(node: &'static crate::ExprDictComp<SourceRange>) -> Self {
+impl From<&'static ast::ExprDictComp<SourceRange>> for ExprDictComp {
+    fn from(node: &'static ast::ExprDictComp<SourceRange>) -> Self {
         ExprDictComp(node)
     }
 }
 
 impl ToPyObject for ExprDictComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprDictComp<SourceRange> {
+impl ToPyWrapper for ast::ExprDictComp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprDictComp(self).to_object(py))
     }
 }
@@ -1968,44 +1968,44 @@ impl ExprDictComp {
     #[getter]
     #[inline]
     fn get_key(&self, py: Python) -> PyResult<PyObject> {
-        self.0.key.to_pyo3_wrapper(py)
+        self.0.key.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_GeneratorExp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprGeneratorExp(pub &'static crate::ExprGeneratorExp<SourceRange>);
+pub struct ExprGeneratorExp(pub &'static ast::ExprGeneratorExp<SourceRange>);
 
-impl From<&'static crate::ExprGeneratorExp<SourceRange>> for ExprGeneratorExp {
-    fn from(node: &'static crate::ExprGeneratorExp<SourceRange>) -> Self {
+impl From<&'static ast::ExprGeneratorExp<SourceRange>> for ExprGeneratorExp {
+    fn from(node: &'static ast::ExprGeneratorExp<SourceRange>) -> Self {
         ExprGeneratorExp(node)
     }
 }
 
 impl ToPyObject for ExprGeneratorExp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprGeneratorExp<SourceRange> {
+impl ToPyWrapper for ast::ExprGeneratorExp<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprGeneratorExp(self).to_object(py))
     }
 }
@@ -2015,38 +2015,38 @@ impl ExprGeneratorExp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Await", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprAwait(pub &'static crate::ExprAwait<SourceRange>);
+pub struct ExprAwait(pub &'static ast::ExprAwait<SourceRange>);
 
-impl From<&'static crate::ExprAwait<SourceRange>> for ExprAwait {
-    fn from(node: &'static crate::ExprAwait<SourceRange>) -> Self {
+impl From<&'static ast::ExprAwait<SourceRange>> for ExprAwait {
+    fn from(node: &'static ast::ExprAwait<SourceRange>) -> Self {
         ExprAwait(node)
     }
 }
 
 impl ToPyObject for ExprAwait {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprAwait<SourceRange> {
+impl ToPyWrapper for ast::ExprAwait<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprAwait(self).to_object(py))
     }
 }
@@ -2056,32 +2056,32 @@ impl ExprAwait {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Yield", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprYield(pub &'static crate::ExprYield<SourceRange>);
+pub struct ExprYield(pub &'static ast::ExprYield<SourceRange>);
 
-impl From<&'static crate::ExprYield<SourceRange>> for ExprYield {
-    fn from(node: &'static crate::ExprYield<SourceRange>) -> Self {
+impl From<&'static ast::ExprYield<SourceRange>> for ExprYield {
+    fn from(node: &'static ast::ExprYield<SourceRange>) -> Self {
         ExprYield(node)
     }
 }
 
 impl ToPyObject for ExprYield {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprYield<SourceRange> {
+impl ToPyWrapper for ast::ExprYield<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprYield(self).to_object(py))
     }
 }
@@ -2091,32 +2091,32 @@ impl ExprYield {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_YieldFrom", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprYieldFrom(pub &'static crate::ExprYieldFrom<SourceRange>);
+pub struct ExprYieldFrom(pub &'static ast::ExprYieldFrom<SourceRange>);
 
-impl From<&'static crate::ExprYieldFrom<SourceRange>> for ExprYieldFrom {
-    fn from(node: &'static crate::ExprYieldFrom<SourceRange>) -> Self {
+impl From<&'static ast::ExprYieldFrom<SourceRange>> for ExprYieldFrom {
+    fn from(node: &'static ast::ExprYieldFrom<SourceRange>) -> Self {
         ExprYieldFrom(node)
     }
 }
 
 impl ToPyObject for ExprYieldFrom {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprYieldFrom<SourceRange> {
+impl ToPyWrapper for ast::ExprYieldFrom<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprYieldFrom(self).to_object(py))
     }
 }
@@ -2126,32 +2126,32 @@ impl ExprYieldFrom {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Compare", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprCompare(pub &'static crate::ExprCompare<SourceRange>);
+pub struct ExprCompare(pub &'static ast::ExprCompare<SourceRange>);
 
-impl From<&'static crate::ExprCompare<SourceRange>> for ExprCompare {
-    fn from(node: &'static crate::ExprCompare<SourceRange>) -> Self {
+impl From<&'static ast::ExprCompare<SourceRange>> for ExprCompare {
+    fn from(node: &'static ast::ExprCompare<SourceRange>) -> Self {
         ExprCompare(node)
     }
 }
 
 impl ToPyObject for ExprCompare {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprCompare<SourceRange> {
+impl ToPyWrapper for ast::ExprCompare<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprCompare(self).to_object(py))
     }
 }
@@ -2161,44 +2161,44 @@ impl ExprCompare {
     #[getter]
     #[inline]
     fn get_left(&self, py: Python) -> PyResult<PyObject> {
-        self.0.left.to_pyo3_wrapper(py)
+        self.0.left.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ops(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ops.to_pyo3_wrapper(py)
+        self.0.ops.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_comparators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.comparators.to_pyo3_wrapper(py)
+        self.0.comparators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Call", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprCall(pub &'static crate::ExprCall<SourceRange>);
+pub struct ExprCall(pub &'static ast::ExprCall<SourceRange>);
 
-impl From<&'static crate::ExprCall<SourceRange>> for ExprCall {
-    fn from(node: &'static crate::ExprCall<SourceRange>) -> Self {
+impl From<&'static ast::ExprCall<SourceRange>> for ExprCall {
+    fn from(node: &'static ast::ExprCall<SourceRange>) -> Self {
         ExprCall(node)
     }
 }
 
 impl ToPyObject for ExprCall {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprCall<SourceRange> {
+impl ToPyWrapper for ast::ExprCall<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprCall(self).to_object(py))
     }
 }
@@ -2208,44 +2208,44 @@ impl ExprCall {
     #[getter]
     #[inline]
     fn get_func(&self, py: Python) -> PyResult<PyObject> {
-        self.0.func.to_pyo3_wrapper(py)
+        self.0.func.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_keywords(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keywords.to_pyo3_wrapper(py)
+        self.0.keywords.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_FormattedValue", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprFormattedValue(pub &'static crate::ExprFormattedValue<SourceRange>);
+pub struct ExprFormattedValue(pub &'static ast::ExprFormattedValue<SourceRange>);
 
-impl From<&'static crate::ExprFormattedValue<SourceRange>> for ExprFormattedValue {
-    fn from(node: &'static crate::ExprFormattedValue<SourceRange>) -> Self {
+impl From<&'static ast::ExprFormattedValue<SourceRange>> for ExprFormattedValue {
+    fn from(node: &'static ast::ExprFormattedValue<SourceRange>) -> Self {
         ExprFormattedValue(node)
     }
 }
 
 impl ToPyObject for ExprFormattedValue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprFormattedValue<SourceRange> {
+impl ToPyWrapper for ast::ExprFormattedValue<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprFormattedValue(self).to_object(py))
     }
 }
@@ -2255,44 +2255,44 @@ impl ExprFormattedValue {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_conversion(&self, py: Python) -> PyResult<PyObject> {
-        self.0.conversion.to_pyo3_wrapper(py)
+        self.0.conversion.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_format_spec(&self, py: Python) -> PyResult<PyObject> {
-        self.0.format_spec.to_pyo3_wrapper(py)
+        self.0.format_spec.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_JoinedStr", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprJoinedStr(pub &'static crate::ExprJoinedStr<SourceRange>);
+pub struct ExprJoinedStr(pub &'static ast::ExprJoinedStr<SourceRange>);
 
-impl From<&'static crate::ExprJoinedStr<SourceRange>> for ExprJoinedStr {
-    fn from(node: &'static crate::ExprJoinedStr<SourceRange>) -> Self {
+impl From<&'static ast::ExprJoinedStr<SourceRange>> for ExprJoinedStr {
+    fn from(node: &'static ast::ExprJoinedStr<SourceRange>) -> Self {
         ExprJoinedStr(node)
     }
 }
 
 impl ToPyObject for ExprJoinedStr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprJoinedStr<SourceRange> {
+impl ToPyWrapper for ast::ExprJoinedStr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprJoinedStr(self).to_object(py))
     }
 }
@@ -2302,32 +2302,32 @@ impl ExprJoinedStr {
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Constant", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprConstant(pub &'static crate::ExprConstant<SourceRange>);
+pub struct ExprConstant(pub &'static ast::ExprConstant<SourceRange>);
 
-impl From<&'static crate::ExprConstant<SourceRange>> for ExprConstant {
-    fn from(node: &'static crate::ExprConstant<SourceRange>) -> Self {
+impl From<&'static ast::ExprConstant<SourceRange>> for ExprConstant {
+    fn from(node: &'static ast::ExprConstant<SourceRange>) -> Self {
         ExprConstant(node)
     }
 }
 
 impl ToPyObject for ExprConstant {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprConstant<SourceRange> {
+impl ToPyWrapper for ast::ExprConstant<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprConstant(self).to_object(py))
     }
 }
@@ -2337,38 +2337,38 @@ impl ExprConstant {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kind(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kind.to_pyo3_wrapper(py)
+        self.0.kind.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Attribute", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprAttribute(pub &'static crate::ExprAttribute<SourceRange>);
+pub struct ExprAttribute(pub &'static ast::ExprAttribute<SourceRange>);
 
-impl From<&'static crate::ExprAttribute<SourceRange>> for ExprAttribute {
-    fn from(node: &'static crate::ExprAttribute<SourceRange>) -> Self {
+impl From<&'static ast::ExprAttribute<SourceRange>> for ExprAttribute {
+    fn from(node: &'static ast::ExprAttribute<SourceRange>) -> Self {
         ExprAttribute(node)
     }
 }
 
 impl ToPyObject for ExprAttribute {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprAttribute<SourceRange> {
+impl ToPyWrapper for ast::ExprAttribute<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprAttribute(self).to_object(py))
     }
 }
@@ -2378,44 +2378,44 @@ impl ExprAttribute {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_attr(&self, py: Python) -> PyResult<PyObject> {
-        self.0.attr.to_pyo3_wrapper(py)
+        self.0.attr.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Subscript", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSubscript(pub &'static crate::ExprSubscript<SourceRange>);
+pub struct ExprSubscript(pub &'static ast::ExprSubscript<SourceRange>);
 
-impl From<&'static crate::ExprSubscript<SourceRange>> for ExprSubscript {
-    fn from(node: &'static crate::ExprSubscript<SourceRange>) -> Self {
+impl From<&'static ast::ExprSubscript<SourceRange>> for ExprSubscript {
+    fn from(node: &'static ast::ExprSubscript<SourceRange>) -> Self {
         ExprSubscript(node)
     }
 }
 
 impl ToPyObject for ExprSubscript {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSubscript<SourceRange> {
+impl ToPyWrapper for ast::ExprSubscript<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSubscript(self).to_object(py))
     }
 }
@@ -2425,44 +2425,44 @@ impl ExprSubscript {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_slice(&self, py: Python) -> PyResult<PyObject> {
-        self.0.slice.to_pyo3_wrapper(py)
+        self.0.slice.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Starred", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprStarred(pub &'static crate::ExprStarred<SourceRange>);
+pub struct ExprStarred(pub &'static ast::ExprStarred<SourceRange>);
 
-impl From<&'static crate::ExprStarred<SourceRange>> for ExprStarred {
-    fn from(node: &'static crate::ExprStarred<SourceRange>) -> Self {
+impl From<&'static ast::ExprStarred<SourceRange>> for ExprStarred {
+    fn from(node: &'static ast::ExprStarred<SourceRange>) -> Self {
         ExprStarred(node)
     }
 }
 
 impl ToPyObject for ExprStarred {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprStarred<SourceRange> {
+impl ToPyWrapper for ast::ExprStarred<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprStarred(self).to_object(py))
     }
 }
@@ -2472,38 +2472,38 @@ impl ExprStarred {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Name", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprName(pub &'static crate::ExprName<SourceRange>);
+pub struct ExprName(pub &'static ast::ExprName<SourceRange>);
 
-impl From<&'static crate::ExprName<SourceRange>> for ExprName {
-    fn from(node: &'static crate::ExprName<SourceRange>) -> Self {
+impl From<&'static ast::ExprName<SourceRange>> for ExprName {
+    fn from(node: &'static ast::ExprName<SourceRange>) -> Self {
         ExprName(node)
     }
 }
 
 impl ToPyObject for ExprName {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprName<SourceRange> {
+impl ToPyWrapper for ast::ExprName<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprName(self).to_object(py))
     }
 }
@@ -2513,38 +2513,38 @@ impl ExprName {
     #[getter]
     #[inline]
     fn get_id(&self, py: Python) -> PyResult<PyObject> {
-        self.0.id.to_pyo3_wrapper(py)
+        self.0.id.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_List", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprList(pub &'static crate::ExprList<SourceRange>);
+pub struct ExprList(pub &'static ast::ExprList<SourceRange>);
 
-impl From<&'static crate::ExprList<SourceRange>> for ExprList {
-    fn from(node: &'static crate::ExprList<SourceRange>) -> Self {
+impl From<&'static ast::ExprList<SourceRange>> for ExprList {
+    fn from(node: &'static ast::ExprList<SourceRange>) -> Self {
         ExprList(node)
     }
 }
 
 impl ToPyObject for ExprList {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprList<SourceRange> {
+impl ToPyWrapper for ast::ExprList<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprList(self).to_object(py))
     }
 }
@@ -2554,38 +2554,38 @@ impl ExprList {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Tuple", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprTuple(pub &'static crate::ExprTuple<SourceRange>);
+pub struct ExprTuple(pub &'static ast::ExprTuple<SourceRange>);
 
-impl From<&'static crate::ExprTuple<SourceRange>> for ExprTuple {
-    fn from(node: &'static crate::ExprTuple<SourceRange>) -> Self {
+impl From<&'static ast::ExprTuple<SourceRange>> for ExprTuple {
+    fn from(node: &'static ast::ExprTuple<SourceRange>) -> Self {
         ExprTuple(node)
     }
 }
 
 impl ToPyObject for ExprTuple {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprTuple<SourceRange> {
+impl ToPyWrapper for ast::ExprTuple<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprTuple(self).to_object(py))
     }
 }
@@ -2595,38 +2595,38 @@ impl ExprTuple {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Slice", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSlice(pub &'static crate::ExprSlice<SourceRange>);
+pub struct ExprSlice(pub &'static ast::ExprSlice<SourceRange>);
 
-impl From<&'static crate::ExprSlice<SourceRange>> for ExprSlice {
-    fn from(node: &'static crate::ExprSlice<SourceRange>) -> Self {
+impl From<&'static ast::ExprSlice<SourceRange>> for ExprSlice {
+    fn from(node: &'static ast::ExprSlice<SourceRange>) -> Self {
         ExprSlice(node)
     }
 }
 
 impl ToPyObject for ExprSlice {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSlice<SourceRange> {
+impl ToPyWrapper for ast::ExprSlice<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSlice(self).to_object(py))
     }
 }
@@ -2636,28 +2636,28 @@ impl ExprSlice {
     #[getter]
     #[inline]
     fn get_lower(&self, py: Python) -> PyResult<PyObject> {
-        self.0.lower.to_pyo3_wrapper(py)
+        self.0.lower.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_upper(&self, py: Python) -> PyResult<PyObject> {
-        self.0.upper.to_pyo3_wrapper(py)
+        self.0.upper.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_step(&self, py: Python) -> PyResult<PyObject> {
-        self.0.step.to_pyo3_wrapper(py)
+        self.0.step.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_expr_context", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_expr_context", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct ExprContext;
 
-impl From<&'static crate::ExprContext> for ExprContext {
-    fn from(_node: &'static crate::ExprContext) -> Self {
+impl From<&'static ast::ExprContext> for ExprContext {
+    fn from(_node: &'static ast::ExprContext) -> Self {
         ExprContext
     }
 }
@@ -2666,7 +2666,7 @@ impl From<&'static crate::ExprContext> for ExprContext {
 impl ExprContext {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for ExprContext {
@@ -2681,7 +2681,7 @@ pub struct ExprContextLoad;
 
 impl ToPyObject for ExprContextLoad {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2693,7 +2693,7 @@ pub struct ExprContextStore;
 
 impl ToPyObject for ExprContextStore {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2705,19 +2705,19 @@ pub struct ExprContextDel;
 
 impl ToPyObject for ExprContextDel {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_boolop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_boolop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Boolop;
 
-impl From<&'static crate::Boolop> for Boolop {
-    fn from(_node: &'static crate::Boolop) -> Self {
+impl From<&'static ast::Boolop> for Boolop {
+    fn from(_node: &'static ast::Boolop) -> Self {
         Boolop
     }
 }
@@ -2726,7 +2726,7 @@ impl From<&'static crate::Boolop> for Boolop {
 impl Boolop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Boolop {
@@ -2741,7 +2741,7 @@ pub struct BoolopAnd;
 
 impl ToPyObject for BoolopAnd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Boolop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2753,19 +2753,19 @@ pub struct BoolopOr;
 
 impl ToPyObject for BoolopOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Boolop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_operator", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_operator", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Operator;
 
-impl From<&'static crate::Operator> for Operator {
-    fn from(_node: &'static crate::Operator) -> Self {
+impl From<&'static ast::Operator> for Operator {
+    fn from(_node: &'static ast::Operator) -> Self {
         Operator
     }
 }
@@ -2774,7 +2774,7 @@ impl From<&'static crate::Operator> for Operator {
 impl Operator {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Operator {
@@ -2789,7 +2789,7 @@ pub struct OperatorAdd;
 
 impl ToPyObject for OperatorAdd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2801,7 +2801,7 @@ pub struct OperatorSub;
 
 impl ToPyObject for OperatorSub {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2813,7 +2813,7 @@ pub struct OperatorMult;
 
 impl ToPyObject for OperatorMult {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2825,7 +2825,7 @@ pub struct OperatorMatMult;
 
 impl ToPyObject for OperatorMatMult {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2837,7 +2837,7 @@ pub struct OperatorDiv;
 
 impl ToPyObject for OperatorDiv {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2849,7 +2849,7 @@ pub struct OperatorMod;
 
 impl ToPyObject for OperatorMod {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2861,7 +2861,7 @@ pub struct OperatorPow;
 
 impl ToPyObject for OperatorPow {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2873,7 +2873,7 @@ pub struct OperatorLShift;
 
 impl ToPyObject for OperatorLShift {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2885,7 +2885,7 @@ pub struct OperatorRShift;
 
 impl ToPyObject for OperatorRShift {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2897,7 +2897,7 @@ pub struct OperatorBitOr;
 
 impl ToPyObject for OperatorBitOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2909,7 +2909,7 @@ pub struct OperatorBitXor;
 
 impl ToPyObject for OperatorBitXor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2921,7 +2921,7 @@ pub struct OperatorBitAnd;
 
 impl ToPyObject for OperatorBitAnd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2933,19 +2933,19 @@ pub struct OperatorFloorDiv;
 
 impl ToPyObject for OperatorFloorDiv {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_unaryop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_unaryop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Unaryop;
 
-impl From<&'static crate::Unaryop> for Unaryop {
-    fn from(_node: &'static crate::Unaryop) -> Self {
+impl From<&'static ast::Unaryop> for Unaryop {
+    fn from(_node: &'static ast::Unaryop) -> Self {
         Unaryop
     }
 }
@@ -2954,7 +2954,7 @@ impl From<&'static crate::Unaryop> for Unaryop {
 impl Unaryop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Unaryop {
@@ -2969,7 +2969,7 @@ pub struct UnaryopInvert;
 
 impl ToPyObject for UnaryopInvert {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2981,7 +2981,7 @@ pub struct UnaryopNot;
 
 impl ToPyObject for UnaryopNot {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2993,7 +2993,7 @@ pub struct UnaryopUAdd;
 
 impl ToPyObject for UnaryopUAdd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3005,19 +3005,19 @@ pub struct UnaryopUSub;
 
 impl ToPyObject for UnaryopUSub {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_cmpop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_cmpop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Cmpop;
 
-impl From<&'static crate::Cmpop> for Cmpop {
-    fn from(_node: &'static crate::Cmpop) -> Self {
+impl From<&'static ast::Cmpop> for Cmpop {
+    fn from(_node: &'static ast::Cmpop) -> Self {
         Cmpop
     }
 }
@@ -3026,7 +3026,7 @@ impl From<&'static crate::Cmpop> for Cmpop {
 impl Cmpop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Cmpop {
@@ -3041,7 +3041,7 @@ pub struct CmpopEq;
 
 impl ToPyObject for CmpopEq {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3053,7 +3053,7 @@ pub struct CmpopNotEq;
 
 impl ToPyObject for CmpopNotEq {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3065,7 +3065,7 @@ pub struct CmpopLt;
 
 impl ToPyObject for CmpopLt {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3077,7 +3077,7 @@ pub struct CmpopLtE;
 
 impl ToPyObject for CmpopLtE {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3089,7 +3089,7 @@ pub struct CmpopGt;
 
 impl ToPyObject for CmpopGt {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3101,7 +3101,7 @@ pub struct CmpopGtE;
 
 impl ToPyObject for CmpopGtE {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3113,7 +3113,7 @@ pub struct CmpopIs;
 
 impl ToPyObject for CmpopIs {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3125,7 +3125,7 @@ pub struct CmpopIsNot;
 
 impl ToPyObject for CmpopIsNot {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3137,7 +3137,7 @@ pub struct CmpopIn;
 
 impl ToPyObject for CmpopIn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3149,33 +3149,33 @@ pub struct CmpopNotIn;
 
 impl ToPyObject for CmpopNotIn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_comprehension", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_comprehension", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Comprehension(pub &'static crate::Comprehension<SourceRange>);
+pub struct Comprehension(pub &'static ast::Comprehension<SourceRange>);
 
-impl From<&'static crate::Comprehension<SourceRange>> for Comprehension {
-    fn from(node: &'static crate::Comprehension<SourceRange>) -> Self {
+impl From<&'static ast::Comprehension<SourceRange>> for Comprehension {
+    fn from(node: &'static ast::Comprehension<SourceRange>) -> Self {
         Comprehension(node)
     }
 }
 
 impl ToPyObject for Comprehension {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Comprehension<SourceRange> {
+impl ToPyWrapper for ast::Comprehension<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Comprehension(self).to_object(py))
     }
 }
@@ -3185,34 +3185,34 @@ impl Comprehension {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ifs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ifs.to_pyo3_wrapper(py)
+        self.0.ifs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_is_async(&self, py: Python) -> PyResult<PyObject> {
-        self.0.is_async.to_pyo3_wrapper(py)
+        self.0.is_async.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_excepthandler", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_excepthandler", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Excepthandler;
 
-impl From<&'static crate::Excepthandler<SourceRange>> for Excepthandler {
-    fn from(_node: &'static crate::Excepthandler<SourceRange>) -> Self {
+impl From<&'static ast::Excepthandler<SourceRange>> for Excepthandler {
+    fn from(_node: &'static ast::Excepthandler<SourceRange>) -> Self {
         Excepthandler
     }
 }
@@ -3221,7 +3221,7 @@ impl From<&'static crate::Excepthandler<SourceRange>> for Excepthandler {
 impl Excepthandler {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Excepthandler {
@@ -3231,37 +3231,37 @@ impl ToPyObject for Excepthandler {
     }
 }
 
-impl ToPyo3Wrapper for crate::Excepthandler<SourceRange> {
+impl ToPyWrapper for ast::Excepthandler<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::ExceptHandler(cons) => cons.to_pyo3_wrapper(py),
+            Self::ExceptHandler(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ExceptHandler", extends=Excepthandler, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExcepthandlerExceptHandler(pub &'static crate::ExcepthandlerExceptHandler<SourceRange>);
+pub struct ExcepthandlerExceptHandler(pub &'static ast::ExcepthandlerExceptHandler<SourceRange>);
 
-impl From<&'static crate::ExcepthandlerExceptHandler<SourceRange>> for ExcepthandlerExceptHandler {
-    fn from(node: &'static crate::ExcepthandlerExceptHandler<SourceRange>) -> Self {
+impl From<&'static ast::ExcepthandlerExceptHandler<SourceRange>> for ExcepthandlerExceptHandler {
+    fn from(node: &'static ast::ExcepthandlerExceptHandler<SourceRange>) -> Self {
         ExcepthandlerExceptHandler(node)
     }
 }
 
 impl ToPyObject for ExcepthandlerExceptHandler {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Excepthandler)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExcepthandlerExceptHandler<SourceRange> {
+impl ToPyWrapper for ast::ExcepthandlerExceptHandler<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExcepthandlerExceptHandler(self).to_object(py))
     }
 }
@@ -3271,42 +3271,42 @@ impl ExcepthandlerExceptHandler {
     #[getter]
     #[inline]
     fn get_type(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_.to_pyo3_wrapper(py)
+        self.0.type_.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_arguments", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_arguments", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arguments(pub &'static crate::Arguments<SourceRange>);
+pub struct Arguments(pub &'static ast::Arguments<SourceRange>);
 
-impl From<&'static crate::Arguments<SourceRange>> for Arguments {
-    fn from(node: &'static crate::Arguments<SourceRange>) -> Self {
+impl From<&'static ast::Arguments<SourceRange>> for Arguments {
+    fn from(node: &'static ast::Arguments<SourceRange>) -> Self {
         Arguments(node)
     }
 }
 
 impl ToPyObject for Arguments {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Arguments<SourceRange> {
+impl ToPyWrapper for ast::Arguments<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arguments(self).to_object(py))
     }
 }
@@ -3316,66 +3316,66 @@ impl Arguments {
     #[getter]
     #[inline]
     fn get_posonlyargs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.posonlyargs.to_pyo3_wrapper(py)
+        self.0.posonlyargs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_vararg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.vararg.to_pyo3_wrapper(py)
+        self.0.vararg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwonlyargs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwonlyargs.to_pyo3_wrapper(py)
+        self.0.kwonlyargs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kw_defaults(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kw_defaults.to_pyo3_wrapper(py)
+        self.0.kw_defaults.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwarg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwarg.to_pyo3_wrapper(py)
+        self.0.kwarg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_defaults(&self, py: Python) -> PyResult<PyObject> {
-        self.0.defaults.to_pyo3_wrapper(py)
+        self.0.defaults.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_arg", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_arg", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arg(pub &'static crate::Arg<SourceRange>);
+pub struct Arg(pub &'static ast::Arg<SourceRange>);
 
-impl From<&'static crate::Arg<SourceRange>> for Arg {
-    fn from(node: &'static crate::Arg<SourceRange>) -> Self {
+impl From<&'static ast::Arg<SourceRange>> for Arg {
+    fn from(node: &'static ast::Arg<SourceRange>) -> Self {
         Arg(node)
     }
 }
 
 impl ToPyObject for Arg {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Arg<SourceRange> {
+impl ToPyWrapper for ast::Arg<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arg(self).to_object(py))
     }
 }
@@ -3385,42 +3385,42 @@ impl Arg {
     #[getter]
     #[inline]
     fn get_arg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.arg.to_pyo3_wrapper(py)
+        self.0.arg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_annotation(&self, py: Python) -> PyResult<PyObject> {
-        self.0.annotation.to_pyo3_wrapper(py)
+        self.0.annotation.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_keyword", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_keyword", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Keyword(pub &'static crate::Keyword<SourceRange>);
+pub struct Keyword(pub &'static ast::Keyword<SourceRange>);
 
-impl From<&'static crate::Keyword<SourceRange>> for Keyword {
-    fn from(node: &'static crate::Keyword<SourceRange>) -> Self {
+impl From<&'static ast::Keyword<SourceRange>> for Keyword {
+    fn from(node: &'static ast::Keyword<SourceRange>) -> Self {
         Keyword(node)
     }
 }
 
 impl ToPyObject for Keyword {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Keyword<SourceRange> {
+impl ToPyWrapper for ast::Keyword<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Keyword(self).to_object(py))
     }
 }
@@ -3430,36 +3430,36 @@ impl Keyword {
     #[getter]
     #[inline]
     fn get_arg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.arg.to_pyo3_wrapper(py)
+        self.0.arg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_alias", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_alias", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Alias(pub &'static crate::Alias<SourceRange>);
+pub struct Alias(pub &'static ast::Alias<SourceRange>);
 
-impl From<&'static crate::Alias<SourceRange>> for Alias {
-    fn from(node: &'static crate::Alias<SourceRange>) -> Self {
+impl From<&'static ast::Alias<SourceRange>> for Alias {
+    fn from(node: &'static ast::Alias<SourceRange>) -> Self {
         Alias(node)
     }
 }
 
 impl ToPyObject for Alias {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Alias<SourceRange> {
+impl ToPyWrapper for ast::Alias<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Alias(self).to_object(py))
     }
 }
@@ -3469,36 +3469,36 @@ impl Alias {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_asname(&self, py: Python) -> PyResult<PyObject> {
-        self.0.asname.to_pyo3_wrapper(py)
+        self.0.asname.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_withitem", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_withitem", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Withitem(pub &'static crate::Withitem<SourceRange>);
+pub struct Withitem(pub &'static ast::Withitem<SourceRange>);
 
-impl From<&'static crate::Withitem<SourceRange>> for Withitem {
-    fn from(node: &'static crate::Withitem<SourceRange>) -> Self {
+impl From<&'static ast::Withitem<SourceRange>> for Withitem {
+    fn from(node: &'static ast::Withitem<SourceRange>) -> Self {
         Withitem(node)
     }
 }
 
 impl ToPyObject for Withitem {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Withitem<SourceRange> {
+impl ToPyWrapper for ast::Withitem<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Withitem(self).to_object(py))
     }
 }
@@ -3508,36 +3508,36 @@ impl Withitem {
     #[getter]
     #[inline]
     fn get_context_expr(&self, py: Python) -> PyResult<PyObject> {
-        self.0.context_expr.to_pyo3_wrapper(py)
+        self.0.context_expr.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_optional_vars(&self, py: Python) -> PyResult<PyObject> {
-        self.0.optional_vars.to_pyo3_wrapper(py)
+        self.0.optional_vars.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_match_case", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.located", name="_match_case", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct MatchCase(pub &'static crate::MatchCase<SourceRange>);
+pub struct MatchCase(pub &'static ast::MatchCase<SourceRange>);
 
-impl From<&'static crate::MatchCase<SourceRange>> for MatchCase {
-    fn from(node: &'static crate::MatchCase<SourceRange>) -> Self {
+impl From<&'static ast::MatchCase<SourceRange>> for MatchCase {
+    fn from(node: &'static ast::MatchCase<SourceRange>) -> Self {
         MatchCase(node)
     }
 }
 
 impl ToPyObject for MatchCase {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::MatchCase<SourceRange> {
+impl ToPyWrapper for ast::MatchCase<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(MatchCase(self).to_object(py))
     }
 }
@@ -3547,28 +3547,28 @@ impl MatchCase {
     #[getter]
     #[inline]
     fn get_pattern(&self, py: Python) -> PyResult<PyObject> {
-        self.0.pattern.to_pyo3_wrapper(py)
+        self.0.pattern.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_guard(&self, py: Python) -> PyResult<PyObject> {
-        self.0.guard.to_pyo3_wrapper(py)
+        self.0.guard.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_pattern", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_pattern", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Pattern;
 
-impl From<&'static crate::Pattern<SourceRange>> for Pattern {
-    fn from(_node: &'static crate::Pattern<SourceRange>) -> Self {
+impl From<&'static ast::Pattern<SourceRange>> for Pattern {
+    fn from(_node: &'static ast::Pattern<SourceRange>) -> Self {
         Pattern
     }
 }
@@ -3577,7 +3577,7 @@ impl From<&'static crate::Pattern<SourceRange>> for Pattern {
 impl Pattern {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Pattern {
@@ -3587,44 +3587,44 @@ impl ToPyObject for Pattern {
     }
 }
 
-impl ToPyo3Wrapper for crate::Pattern<SourceRange> {
+impl ToPyWrapper for ast::Pattern<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::MatchValue(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchSingleton(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchSequence(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchMapping(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchClass(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchStar(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchAs(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchOr(cons) => cons.to_pyo3_wrapper(py),
+            Self::MatchValue(cons) => cons.to_py_wrapper(py),
+            Self::MatchSingleton(cons) => cons.to_py_wrapper(py),
+            Self::MatchSequence(cons) => cons.to_py_wrapper(py),
+            Self::MatchMapping(cons) => cons.to_py_wrapper(py),
+            Self::MatchClass(cons) => cons.to_py_wrapper(py),
+            Self::MatchStar(cons) => cons.to_py_wrapper(py),
+            Self::MatchAs(cons) => cons.to_py_wrapper(py),
+            Self::MatchOr(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchValue", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchValue(pub &'static crate::PatternMatchValue<SourceRange>);
+pub struct PatternMatchValue(pub &'static ast::PatternMatchValue<SourceRange>);
 
-impl From<&'static crate::PatternMatchValue<SourceRange>> for PatternMatchValue {
-    fn from(node: &'static crate::PatternMatchValue<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchValue<SourceRange>> for PatternMatchValue {
+    fn from(node: &'static ast::PatternMatchValue<SourceRange>) -> Self {
         PatternMatchValue(node)
     }
 }
 
 impl ToPyObject for PatternMatchValue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchValue<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchValue<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchValue(self).to_object(py))
     }
 }
@@ -3634,32 +3634,32 @@ impl PatternMatchValue {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchSingleton", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchSingleton(pub &'static crate::PatternMatchSingleton<SourceRange>);
+pub struct PatternMatchSingleton(pub &'static ast::PatternMatchSingleton<SourceRange>);
 
-impl From<&'static crate::PatternMatchSingleton<SourceRange>> for PatternMatchSingleton {
-    fn from(node: &'static crate::PatternMatchSingleton<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchSingleton<SourceRange>> for PatternMatchSingleton {
+    fn from(node: &'static ast::PatternMatchSingleton<SourceRange>) -> Self {
         PatternMatchSingleton(node)
     }
 }
 
 impl ToPyObject for PatternMatchSingleton {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchSingleton<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchSingleton<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchSingleton(self).to_object(py))
     }
 }
@@ -3669,32 +3669,32 @@ impl PatternMatchSingleton {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchSequence", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchSequence(pub &'static crate::PatternMatchSequence<SourceRange>);
+pub struct PatternMatchSequence(pub &'static ast::PatternMatchSequence<SourceRange>);
 
-impl From<&'static crate::PatternMatchSequence<SourceRange>> for PatternMatchSequence {
-    fn from(node: &'static crate::PatternMatchSequence<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchSequence<SourceRange>> for PatternMatchSequence {
+    fn from(node: &'static ast::PatternMatchSequence<SourceRange>) -> Self {
         PatternMatchSequence(node)
     }
 }
 
 impl ToPyObject for PatternMatchSequence {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchSequence<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchSequence<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchSequence(self).to_object(py))
     }
 }
@@ -3704,32 +3704,32 @@ impl PatternMatchSequence {
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchMapping", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchMapping(pub &'static crate::PatternMatchMapping<SourceRange>);
+pub struct PatternMatchMapping(pub &'static ast::PatternMatchMapping<SourceRange>);
 
-impl From<&'static crate::PatternMatchMapping<SourceRange>> for PatternMatchMapping {
-    fn from(node: &'static crate::PatternMatchMapping<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchMapping<SourceRange>> for PatternMatchMapping {
+    fn from(node: &'static ast::PatternMatchMapping<SourceRange>) -> Self {
         PatternMatchMapping(node)
     }
 }
 
 impl ToPyObject for PatternMatchMapping {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchMapping<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchMapping<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchMapping(self).to_object(py))
     }
 }
@@ -3739,44 +3739,44 @@ impl PatternMatchMapping {
     #[getter]
     #[inline]
     fn get_keys(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keys.to_pyo3_wrapper(py)
+        self.0.keys.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_rest(&self, py: Python) -> PyResult<PyObject> {
-        self.0.rest.to_pyo3_wrapper(py)
+        self.0.rest.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchClass", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchClass(pub &'static crate::PatternMatchClass<SourceRange>);
+pub struct PatternMatchClass(pub &'static ast::PatternMatchClass<SourceRange>);
 
-impl From<&'static crate::PatternMatchClass<SourceRange>> for PatternMatchClass {
-    fn from(node: &'static crate::PatternMatchClass<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchClass<SourceRange>> for PatternMatchClass {
+    fn from(node: &'static ast::PatternMatchClass<SourceRange>) -> Self {
         PatternMatchClass(node)
     }
 }
 
 impl ToPyObject for PatternMatchClass {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchClass<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchClass<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchClass(self).to_object(py))
     }
 }
@@ -3786,50 +3786,50 @@ impl PatternMatchClass {
     #[getter]
     #[inline]
     fn get_cls(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cls.to_pyo3_wrapper(py)
+        self.0.cls.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwd_attrs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwd_attrs.to_pyo3_wrapper(py)
+        self.0.kwd_attrs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwd_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwd_patterns.to_pyo3_wrapper(py)
+        self.0.kwd_patterns.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchStar", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchStar(pub &'static crate::PatternMatchStar<SourceRange>);
+pub struct PatternMatchStar(pub &'static ast::PatternMatchStar<SourceRange>);
 
-impl From<&'static crate::PatternMatchStar<SourceRange>> for PatternMatchStar {
-    fn from(node: &'static crate::PatternMatchStar<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchStar<SourceRange>> for PatternMatchStar {
+    fn from(node: &'static ast::PatternMatchStar<SourceRange>) -> Self {
         PatternMatchStar(node)
     }
 }
 
 impl ToPyObject for PatternMatchStar {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchStar<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchStar<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchStar(self).to_object(py))
     }
 }
@@ -3839,32 +3839,32 @@ impl PatternMatchStar {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchAs", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchAs(pub &'static crate::PatternMatchAs<SourceRange>);
+pub struct PatternMatchAs(pub &'static ast::PatternMatchAs<SourceRange>);
 
-impl From<&'static crate::PatternMatchAs<SourceRange>> for PatternMatchAs {
-    fn from(node: &'static crate::PatternMatchAs<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchAs<SourceRange>> for PatternMatchAs {
+    fn from(node: &'static ast::PatternMatchAs<SourceRange>) -> Self {
         PatternMatchAs(node)
     }
 }
 
 impl ToPyObject for PatternMatchAs {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchAs<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchAs<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchAs(self).to_object(py))
     }
 }
@@ -3874,38 +3874,38 @@ impl PatternMatchAs {
     #[getter]
     #[inline]
     fn get_pattern(&self, py: Python) -> PyResult<PyObject> {
-        self.0.pattern.to_pyo3_wrapper(py)
+        self.0.pattern.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_MatchOr", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchOr(pub &'static crate::PatternMatchOr<SourceRange>);
+pub struct PatternMatchOr(pub &'static ast::PatternMatchOr<SourceRange>);
 
-impl From<&'static crate::PatternMatchOr<SourceRange>> for PatternMatchOr {
-    fn from(node: &'static crate::PatternMatchOr<SourceRange>) -> Self {
+impl From<&'static ast::PatternMatchOr<SourceRange>> for PatternMatchOr {
+    fn from(node: &'static ast::PatternMatchOr<SourceRange>) -> Self {
         PatternMatchOr(node)
     }
 }
 
 impl ToPyObject for PatternMatchOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchOr<SourceRange> {
+impl ToPyWrapper for ast::PatternMatchOr<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchOr(self).to_object(py))
     }
 }
@@ -3915,16 +3915,16 @@ impl PatternMatchOr {
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.located", name="_type_ignore", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.located", name="_type_ignore", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct TypeIgnore;
 
-impl From<&'static crate::TypeIgnore<SourceRange>> for TypeIgnore {
-    fn from(_node: &'static crate::TypeIgnore<SourceRange>) -> Self {
+impl From<&'static ast::TypeIgnore<SourceRange>> for TypeIgnore {
+    fn from(_node: &'static ast::TypeIgnore<SourceRange>) -> Self {
         TypeIgnore
     }
 }
@@ -3933,7 +3933,7 @@ impl From<&'static crate::TypeIgnore<SourceRange>> for TypeIgnore {
 impl TypeIgnore {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for TypeIgnore {
@@ -3943,37 +3943,37 @@ impl ToPyObject for TypeIgnore {
     }
 }
 
-impl ToPyo3Wrapper for crate::TypeIgnore<SourceRange> {
+impl ToPyWrapper for ast::TypeIgnore<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::TypeIgnore(cons) => cons.to_pyo3_wrapper(py),
+            Self::TypeIgnore(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_TypeIgnore", extends=TypeIgnore, frozen)]
 #[derive(Clone, Debug)]
-pub struct TypeIgnoreTypeIgnore(pub &'static crate::TypeIgnoreTypeIgnore<SourceRange>);
+pub struct TypeIgnoreTypeIgnore(pub &'static ast::TypeIgnoreTypeIgnore<SourceRange>);
 
-impl From<&'static crate::TypeIgnoreTypeIgnore<SourceRange>> for TypeIgnoreTypeIgnore {
-    fn from(node: &'static crate::TypeIgnoreTypeIgnore<SourceRange>) -> Self {
+impl From<&'static ast::TypeIgnoreTypeIgnore<SourceRange>> for TypeIgnoreTypeIgnore {
+    fn from(node: &'static ast::TypeIgnoreTypeIgnore<SourceRange>) -> Self {
         TypeIgnoreTypeIgnore(node)
     }
 }
 
 impl ToPyObject for TypeIgnoreTypeIgnore {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(TypeIgnore)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::TypeIgnoreTypeIgnore<SourceRange> {
+impl ToPyWrapper for ast::TypeIgnoreTypeIgnore<SourceRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(TypeIgnoreTypeIgnore(self).to_object(py))
     }
 }
@@ -3983,19 +3983,19 @@ impl TypeIgnoreTypeIgnore {
     #[getter]
     #[inline]
     fn get_lineno(&self, py: Python) -> PyResult<PyObject> {
-        self.0.lineno.to_pyo3_wrapper(py)
+        self.0.lineno.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_tag(&self, py: Python) -> PyResult<PyObject> {
-        self.0.tag.to_pyo3_wrapper(py)
+        self.0.tag.to_py_wrapper(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::ExprContext {
+impl ToPyWrapper for ast::ExprContext {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::Load => Ok(ExprContextLoad.to_object(py)),
             Self::Store => Ok(ExprContextStore.to_object(py)),
@@ -4004,30 +4004,30 @@ impl ToPyo3Wrapper for crate::generic::ExprContext {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::ExprContextLoad {
+impl ToPyWrapper for ast::ExprContextLoad {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprContextLoad.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::ExprContextStore {
+impl ToPyWrapper for ast::ExprContextStore {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprContextStore.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::ExprContextDel {
+impl ToPyWrapper for ast::ExprContextDel {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprContextDel.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::Boolop {
+impl ToPyWrapper for ast::Boolop {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::And => Ok(BoolopAnd.to_object(py)),
             Self::Or => Ok(BoolopOr.to_object(py)),
@@ -4035,23 +4035,23 @@ impl ToPyo3Wrapper for crate::generic::Boolop {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::BoolopAnd {
+impl ToPyWrapper for ast::BoolopAnd {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(BoolopAnd.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::BoolopOr {
+impl ToPyWrapper for ast::BoolopOr {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(BoolopOr.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::Operator {
+impl ToPyWrapper for ast::Operator {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::Add => Ok(OperatorAdd.to_object(py)),
             Self::Sub => Ok(OperatorSub.to_object(py)),
@@ -4070,100 +4070,100 @@ impl ToPyo3Wrapper for crate::generic::Operator {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorAdd {
+impl ToPyWrapper for ast::OperatorAdd {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorAdd.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorSub {
+impl ToPyWrapper for ast::OperatorSub {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorSub.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorMult {
+impl ToPyWrapper for ast::OperatorMult {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorMult.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorMatMult {
+impl ToPyWrapper for ast::OperatorMatMult {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorMatMult.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorDiv {
+impl ToPyWrapper for ast::OperatorDiv {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorDiv.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorMod {
+impl ToPyWrapper for ast::OperatorMod {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorMod.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorPow {
+impl ToPyWrapper for ast::OperatorPow {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorPow.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorLShift {
+impl ToPyWrapper for ast::OperatorLShift {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorLShift.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorRShift {
+impl ToPyWrapper for ast::OperatorRShift {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorRShift.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorBitOr {
+impl ToPyWrapper for ast::OperatorBitOr {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorBitOr.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorBitXor {
+impl ToPyWrapper for ast::OperatorBitXor {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorBitXor.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorBitAnd {
+impl ToPyWrapper for ast::OperatorBitAnd {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorBitAnd.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::OperatorFloorDiv {
+impl ToPyWrapper for ast::OperatorFloorDiv {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(OperatorFloorDiv.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::Unaryop {
+impl ToPyWrapper for ast::Unaryop {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::Invert => Ok(UnaryopInvert.to_object(py)),
             Self::Not => Ok(UnaryopNot.to_object(py)),
@@ -4173,37 +4173,37 @@ impl ToPyo3Wrapper for crate::generic::Unaryop {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::UnaryopInvert {
+impl ToPyWrapper for ast::UnaryopInvert {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(UnaryopInvert.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::UnaryopNot {
+impl ToPyWrapper for ast::UnaryopNot {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(UnaryopNot.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::UnaryopUAdd {
+impl ToPyWrapper for ast::UnaryopUAdd {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(UnaryopUAdd.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::UnaryopUSub {
+impl ToPyWrapper for ast::UnaryopUSub {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(UnaryopUSub.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::Cmpop {
+impl ToPyWrapper for ast::Cmpop {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
             Self::Eq => Ok(CmpopEq.to_object(py)),
             Self::NotEq => Ok(CmpopNotEq.to_object(py)),
@@ -4219,197 +4219,195 @@ impl ToPyo3Wrapper for crate::generic::Cmpop {
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopEq {
+impl ToPyWrapper for ast::CmpopEq {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopEq.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopNotEq {
+impl ToPyWrapper for ast::CmpopNotEq {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopNotEq.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopLt {
+impl ToPyWrapper for ast::CmpopLt {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopLt.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopLtE {
+impl ToPyWrapper for ast::CmpopLtE {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopLtE.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopGt {
+impl ToPyWrapper for ast::CmpopGt {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopGt.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopGtE {
+impl ToPyWrapper for ast::CmpopGtE {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopGtE.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopIs {
+impl ToPyWrapper for ast::CmpopIs {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopIs.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopIsNot {
+impl ToPyWrapper for ast::CmpopIsNot {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopIsNot.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopIn {
+impl ToPyWrapper for ast::CmpopIn {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopIn.to_object(py))
     }
 }
 
-impl ToPyo3Wrapper for crate::generic::CmpopNotIn {
+impl ToPyWrapper for ast::CmpopNotIn {
     #[inline]
-    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(CmpopNotIn.to_object(py))
     }
 }
 
 pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_module(py, m)?;
-    super::init_type::<Mod, crate::generic::Mod>(py, m)?;
-    super::init_type::<ModModule, crate::generic::ModModule>(py, m)?;
-    super::init_type::<ModInteractive, crate::generic::ModInteractive>(py, m)?;
-    super::init_type::<ModExpression, crate::generic::ModExpression>(py, m)?;
-    super::init_type::<ModFunctionType, crate::generic::ModFunctionType>(py, m)?;
-    super::init_type::<Stmt, crate::generic::Stmt>(py, m)?;
-    super::init_type::<StmtFunctionDef, crate::generic::StmtFunctionDef>(py, m)?;
-    super::init_type::<StmtAsyncFunctionDef, crate::generic::StmtAsyncFunctionDef>(py, m)?;
-    super::init_type::<StmtClassDef, crate::generic::StmtClassDef>(py, m)?;
-    super::init_type::<StmtReturn, crate::generic::StmtReturn>(py, m)?;
-    super::init_type::<StmtDelete, crate::generic::StmtDelete>(py, m)?;
-    super::init_type::<StmtAssign, crate::generic::StmtAssign>(py, m)?;
-    super::init_type::<StmtAugAssign, crate::generic::StmtAugAssign>(py, m)?;
-    super::init_type::<StmtAnnAssign, crate::generic::StmtAnnAssign>(py, m)?;
-    super::init_type::<StmtFor, crate::generic::StmtFor>(py, m)?;
-    super::init_type::<StmtAsyncFor, crate::generic::StmtAsyncFor>(py, m)?;
-    super::init_type::<StmtWhile, crate::generic::StmtWhile>(py, m)?;
-    super::init_type::<StmtIf, crate::generic::StmtIf>(py, m)?;
-    super::init_type::<StmtWith, crate::generic::StmtWith>(py, m)?;
-    super::init_type::<StmtAsyncWith, crate::generic::StmtAsyncWith>(py, m)?;
-    super::init_type::<StmtMatch, crate::generic::StmtMatch>(py, m)?;
-    super::init_type::<StmtRaise, crate::generic::StmtRaise>(py, m)?;
-    super::init_type::<StmtTry, crate::generic::StmtTry>(py, m)?;
-    super::init_type::<StmtTryStar, crate::generic::StmtTryStar>(py, m)?;
-    super::init_type::<StmtAssert, crate::generic::StmtAssert>(py, m)?;
-    super::init_type::<StmtImport, crate::generic::StmtImport>(py, m)?;
-    super::init_type::<StmtImportFrom, crate::generic::StmtImportFrom>(py, m)?;
-    super::init_type::<StmtGlobal, crate::generic::StmtGlobal>(py, m)?;
-    super::init_type::<StmtNonlocal, crate::generic::StmtNonlocal>(py, m)?;
-    super::init_type::<StmtExpr, crate::generic::StmtExpr>(py, m)?;
-    super::init_type::<StmtPass, crate::generic::StmtPass>(py, m)?;
-    super::init_type::<StmtBreak, crate::generic::StmtBreak>(py, m)?;
-    super::init_type::<StmtContinue, crate::generic::StmtContinue>(py, m)?;
-    super::init_type::<Expr, crate::generic::Expr>(py, m)?;
-    super::init_type::<ExprBoolOp, crate::generic::ExprBoolOp>(py, m)?;
-    super::init_type::<ExprNamedExpr, crate::generic::ExprNamedExpr>(py, m)?;
-    super::init_type::<ExprBinOp, crate::generic::ExprBinOp>(py, m)?;
-    super::init_type::<ExprUnaryOp, crate::generic::ExprUnaryOp>(py, m)?;
-    super::init_type::<ExprLambda, crate::generic::ExprLambda>(py, m)?;
-    super::init_type::<ExprIfExp, crate::generic::ExprIfExp>(py, m)?;
-    super::init_type::<ExprDict, crate::generic::ExprDict>(py, m)?;
-    super::init_type::<ExprSet, crate::generic::ExprSet>(py, m)?;
-    super::init_type::<ExprListComp, crate::generic::ExprListComp>(py, m)?;
-    super::init_type::<ExprSetComp, crate::generic::ExprSetComp>(py, m)?;
-    super::init_type::<ExprDictComp, crate::generic::ExprDictComp>(py, m)?;
-    super::init_type::<ExprGeneratorExp, crate::generic::ExprGeneratorExp>(py, m)?;
-    super::init_type::<ExprAwait, crate::generic::ExprAwait>(py, m)?;
-    super::init_type::<ExprYield, crate::generic::ExprYield>(py, m)?;
-    super::init_type::<ExprYieldFrom, crate::generic::ExprYieldFrom>(py, m)?;
-    super::init_type::<ExprCompare, crate::generic::ExprCompare>(py, m)?;
-    super::init_type::<ExprCall, crate::generic::ExprCall>(py, m)?;
-    super::init_type::<ExprFormattedValue, crate::generic::ExprFormattedValue>(py, m)?;
-    super::init_type::<ExprJoinedStr, crate::generic::ExprJoinedStr>(py, m)?;
-    super::init_type::<ExprConstant, crate::generic::ExprConstant>(py, m)?;
-    super::init_type::<ExprAttribute, crate::generic::ExprAttribute>(py, m)?;
-    super::init_type::<ExprSubscript, crate::generic::ExprSubscript>(py, m)?;
-    super::init_type::<ExprStarred, crate::generic::ExprStarred>(py, m)?;
-    super::init_type::<ExprName, crate::generic::ExprName>(py, m)?;
-    super::init_type::<ExprList, crate::generic::ExprList>(py, m)?;
-    super::init_type::<ExprTuple, crate::generic::ExprTuple>(py, m)?;
-    super::init_type::<ExprSlice, crate::generic::ExprSlice>(py, m)?;
-    super::init_type::<ExprContext, crate::generic::ExprContext>(py, m)?;
-    super::init_type::<ExprContextLoad, crate::generic::ExprContextLoad>(py, m)?;
-    super::init_type::<ExprContextStore, crate::generic::ExprContextStore>(py, m)?;
-    super::init_type::<ExprContextDel, crate::generic::ExprContextDel>(py, m)?;
-    super::init_type::<Boolop, crate::generic::Boolop>(py, m)?;
-    super::init_type::<BoolopAnd, crate::generic::BoolopAnd>(py, m)?;
-    super::init_type::<BoolopOr, crate::generic::BoolopOr>(py, m)?;
-    super::init_type::<Operator, crate::generic::Operator>(py, m)?;
-    super::init_type::<OperatorAdd, crate::generic::OperatorAdd>(py, m)?;
-    super::init_type::<OperatorSub, crate::generic::OperatorSub>(py, m)?;
-    super::init_type::<OperatorMult, crate::generic::OperatorMult>(py, m)?;
-    super::init_type::<OperatorMatMult, crate::generic::OperatorMatMult>(py, m)?;
-    super::init_type::<OperatorDiv, crate::generic::OperatorDiv>(py, m)?;
-    super::init_type::<OperatorMod, crate::generic::OperatorMod>(py, m)?;
-    super::init_type::<OperatorPow, crate::generic::OperatorPow>(py, m)?;
-    super::init_type::<OperatorLShift, crate::generic::OperatorLShift>(py, m)?;
-    super::init_type::<OperatorRShift, crate::generic::OperatorRShift>(py, m)?;
-    super::init_type::<OperatorBitOr, crate::generic::OperatorBitOr>(py, m)?;
-    super::init_type::<OperatorBitXor, crate::generic::OperatorBitXor>(py, m)?;
-    super::init_type::<OperatorBitAnd, crate::generic::OperatorBitAnd>(py, m)?;
-    super::init_type::<OperatorFloorDiv, crate::generic::OperatorFloorDiv>(py, m)?;
-    super::init_type::<Unaryop, crate::generic::Unaryop>(py, m)?;
-    super::init_type::<UnaryopInvert, crate::generic::UnaryopInvert>(py, m)?;
-    super::init_type::<UnaryopNot, crate::generic::UnaryopNot>(py, m)?;
-    super::init_type::<UnaryopUAdd, crate::generic::UnaryopUAdd>(py, m)?;
-    super::init_type::<UnaryopUSub, crate::generic::UnaryopUSub>(py, m)?;
-    super::init_type::<Cmpop, crate::generic::Cmpop>(py, m)?;
-    super::init_type::<CmpopEq, crate::generic::CmpopEq>(py, m)?;
-    super::init_type::<CmpopNotEq, crate::generic::CmpopNotEq>(py, m)?;
-    super::init_type::<CmpopLt, crate::generic::CmpopLt>(py, m)?;
-    super::init_type::<CmpopLtE, crate::generic::CmpopLtE>(py, m)?;
-    super::init_type::<CmpopGt, crate::generic::CmpopGt>(py, m)?;
-    super::init_type::<CmpopGtE, crate::generic::CmpopGtE>(py, m)?;
-    super::init_type::<CmpopIs, crate::generic::CmpopIs>(py, m)?;
-    super::init_type::<CmpopIsNot, crate::generic::CmpopIsNot>(py, m)?;
-    super::init_type::<CmpopIn, crate::generic::CmpopIn>(py, m)?;
-    super::init_type::<CmpopNotIn, crate::generic::CmpopNotIn>(py, m)?;
-    super::init_type::<Comprehension, crate::generic::Comprehension>(py, m)?;
-    super::init_type::<Excepthandler, crate::generic::Excepthandler>(py, m)?;
-    super::init_type::<ExcepthandlerExceptHandler, crate::generic::ExcepthandlerExceptHandler>(
-        py, m,
-    )?;
-    super::init_type::<Arguments, crate::generic::Arguments>(py, m)?;
-    super::init_type::<Arg, crate::generic::Arg>(py, m)?;
-    super::init_type::<Keyword, crate::generic::Keyword>(py, m)?;
-    super::init_type::<Alias, crate::generic::Alias>(py, m)?;
-    super::init_type::<Withitem, crate::generic::Withitem>(py, m)?;
-    super::init_type::<MatchCase, crate::generic::MatchCase>(py, m)?;
-    super::init_type::<Pattern, crate::generic::Pattern>(py, m)?;
-    super::init_type::<PatternMatchValue, crate::generic::PatternMatchValue>(py, m)?;
-    super::init_type::<PatternMatchSingleton, crate::generic::PatternMatchSingleton>(py, m)?;
-    super::init_type::<PatternMatchSequence, crate::generic::PatternMatchSequence>(py, m)?;
-    super::init_type::<PatternMatchMapping, crate::generic::PatternMatchMapping>(py, m)?;
-    super::init_type::<PatternMatchClass, crate::generic::PatternMatchClass>(py, m)?;
-    super::init_type::<PatternMatchStar, crate::generic::PatternMatchStar>(py, m)?;
-    super::init_type::<PatternMatchAs, crate::generic::PatternMatchAs>(py, m)?;
-    super::init_type::<PatternMatchOr, crate::generic::PatternMatchOr>(py, m)?;
-    super::init_type::<TypeIgnore, crate::generic::TypeIgnore>(py, m)?;
-    super::init_type::<TypeIgnoreTypeIgnore, crate::generic::TypeIgnoreTypeIgnore>(py, m)?;
+    super::init_type::<Mod, ast::Mod>(py, m)?;
+    super::init_type::<ModModule, ast::ModModule>(py, m)?;
+    super::init_type::<ModInteractive, ast::ModInteractive>(py, m)?;
+    super::init_type::<ModExpression, ast::ModExpression>(py, m)?;
+    super::init_type::<ModFunctionType, ast::ModFunctionType>(py, m)?;
+    super::init_type::<Stmt, ast::Stmt>(py, m)?;
+    super::init_type::<StmtFunctionDef, ast::StmtFunctionDef>(py, m)?;
+    super::init_type::<StmtAsyncFunctionDef, ast::StmtAsyncFunctionDef>(py, m)?;
+    super::init_type::<StmtClassDef, ast::StmtClassDef>(py, m)?;
+    super::init_type::<StmtReturn, ast::StmtReturn>(py, m)?;
+    super::init_type::<StmtDelete, ast::StmtDelete>(py, m)?;
+    super::init_type::<StmtAssign, ast::StmtAssign>(py, m)?;
+    super::init_type::<StmtAugAssign, ast::StmtAugAssign>(py, m)?;
+    super::init_type::<StmtAnnAssign, ast::StmtAnnAssign>(py, m)?;
+    super::init_type::<StmtFor, ast::StmtFor>(py, m)?;
+    super::init_type::<StmtAsyncFor, ast::StmtAsyncFor>(py, m)?;
+    super::init_type::<StmtWhile, ast::StmtWhile>(py, m)?;
+    super::init_type::<StmtIf, ast::StmtIf>(py, m)?;
+    super::init_type::<StmtWith, ast::StmtWith>(py, m)?;
+    super::init_type::<StmtAsyncWith, ast::StmtAsyncWith>(py, m)?;
+    super::init_type::<StmtMatch, ast::StmtMatch>(py, m)?;
+    super::init_type::<StmtRaise, ast::StmtRaise>(py, m)?;
+    super::init_type::<StmtTry, ast::StmtTry>(py, m)?;
+    super::init_type::<StmtTryStar, ast::StmtTryStar>(py, m)?;
+    super::init_type::<StmtAssert, ast::StmtAssert>(py, m)?;
+    super::init_type::<StmtImport, ast::StmtImport>(py, m)?;
+    super::init_type::<StmtImportFrom, ast::StmtImportFrom>(py, m)?;
+    super::init_type::<StmtGlobal, ast::StmtGlobal>(py, m)?;
+    super::init_type::<StmtNonlocal, ast::StmtNonlocal>(py, m)?;
+    super::init_type::<StmtExpr, ast::StmtExpr>(py, m)?;
+    super::init_type::<StmtPass, ast::StmtPass>(py, m)?;
+    super::init_type::<StmtBreak, ast::StmtBreak>(py, m)?;
+    super::init_type::<StmtContinue, ast::StmtContinue>(py, m)?;
+    super::init_type::<Expr, ast::Expr>(py, m)?;
+    super::init_type::<ExprBoolOp, ast::ExprBoolOp>(py, m)?;
+    super::init_type::<ExprNamedExpr, ast::ExprNamedExpr>(py, m)?;
+    super::init_type::<ExprBinOp, ast::ExprBinOp>(py, m)?;
+    super::init_type::<ExprUnaryOp, ast::ExprUnaryOp>(py, m)?;
+    super::init_type::<ExprLambda, ast::ExprLambda>(py, m)?;
+    super::init_type::<ExprIfExp, ast::ExprIfExp>(py, m)?;
+    super::init_type::<ExprDict, ast::ExprDict>(py, m)?;
+    super::init_type::<ExprSet, ast::ExprSet>(py, m)?;
+    super::init_type::<ExprListComp, ast::ExprListComp>(py, m)?;
+    super::init_type::<ExprSetComp, ast::ExprSetComp>(py, m)?;
+    super::init_type::<ExprDictComp, ast::ExprDictComp>(py, m)?;
+    super::init_type::<ExprGeneratorExp, ast::ExprGeneratorExp>(py, m)?;
+    super::init_type::<ExprAwait, ast::ExprAwait>(py, m)?;
+    super::init_type::<ExprYield, ast::ExprYield>(py, m)?;
+    super::init_type::<ExprYieldFrom, ast::ExprYieldFrom>(py, m)?;
+    super::init_type::<ExprCompare, ast::ExprCompare>(py, m)?;
+    super::init_type::<ExprCall, ast::ExprCall>(py, m)?;
+    super::init_type::<ExprFormattedValue, ast::ExprFormattedValue>(py, m)?;
+    super::init_type::<ExprJoinedStr, ast::ExprJoinedStr>(py, m)?;
+    super::init_type::<ExprConstant, ast::ExprConstant>(py, m)?;
+    super::init_type::<ExprAttribute, ast::ExprAttribute>(py, m)?;
+    super::init_type::<ExprSubscript, ast::ExprSubscript>(py, m)?;
+    super::init_type::<ExprStarred, ast::ExprStarred>(py, m)?;
+    super::init_type::<ExprName, ast::ExprName>(py, m)?;
+    super::init_type::<ExprList, ast::ExprList>(py, m)?;
+    super::init_type::<ExprTuple, ast::ExprTuple>(py, m)?;
+    super::init_type::<ExprSlice, ast::ExprSlice>(py, m)?;
+    super::init_type::<ExprContext, ast::ExprContext>(py, m)?;
+    super::init_type::<ExprContextLoad, ast::ExprContextLoad>(py, m)?;
+    super::init_type::<ExprContextStore, ast::ExprContextStore>(py, m)?;
+    super::init_type::<ExprContextDel, ast::ExprContextDel>(py, m)?;
+    super::init_type::<Boolop, ast::Boolop>(py, m)?;
+    super::init_type::<BoolopAnd, ast::BoolopAnd>(py, m)?;
+    super::init_type::<BoolopOr, ast::BoolopOr>(py, m)?;
+    super::init_type::<Operator, ast::Operator>(py, m)?;
+    super::init_type::<OperatorAdd, ast::OperatorAdd>(py, m)?;
+    super::init_type::<OperatorSub, ast::OperatorSub>(py, m)?;
+    super::init_type::<OperatorMult, ast::OperatorMult>(py, m)?;
+    super::init_type::<OperatorMatMult, ast::OperatorMatMult>(py, m)?;
+    super::init_type::<OperatorDiv, ast::OperatorDiv>(py, m)?;
+    super::init_type::<OperatorMod, ast::OperatorMod>(py, m)?;
+    super::init_type::<OperatorPow, ast::OperatorPow>(py, m)?;
+    super::init_type::<OperatorLShift, ast::OperatorLShift>(py, m)?;
+    super::init_type::<OperatorRShift, ast::OperatorRShift>(py, m)?;
+    super::init_type::<OperatorBitOr, ast::OperatorBitOr>(py, m)?;
+    super::init_type::<OperatorBitXor, ast::OperatorBitXor>(py, m)?;
+    super::init_type::<OperatorBitAnd, ast::OperatorBitAnd>(py, m)?;
+    super::init_type::<OperatorFloorDiv, ast::OperatorFloorDiv>(py, m)?;
+    super::init_type::<Unaryop, ast::Unaryop>(py, m)?;
+    super::init_type::<UnaryopInvert, ast::UnaryopInvert>(py, m)?;
+    super::init_type::<UnaryopNot, ast::UnaryopNot>(py, m)?;
+    super::init_type::<UnaryopUAdd, ast::UnaryopUAdd>(py, m)?;
+    super::init_type::<UnaryopUSub, ast::UnaryopUSub>(py, m)?;
+    super::init_type::<Cmpop, ast::Cmpop>(py, m)?;
+    super::init_type::<CmpopEq, ast::CmpopEq>(py, m)?;
+    super::init_type::<CmpopNotEq, ast::CmpopNotEq>(py, m)?;
+    super::init_type::<CmpopLt, ast::CmpopLt>(py, m)?;
+    super::init_type::<CmpopLtE, ast::CmpopLtE>(py, m)?;
+    super::init_type::<CmpopGt, ast::CmpopGt>(py, m)?;
+    super::init_type::<CmpopGtE, ast::CmpopGtE>(py, m)?;
+    super::init_type::<CmpopIs, ast::CmpopIs>(py, m)?;
+    super::init_type::<CmpopIsNot, ast::CmpopIsNot>(py, m)?;
+    super::init_type::<CmpopIn, ast::CmpopIn>(py, m)?;
+    super::init_type::<CmpopNotIn, ast::CmpopNotIn>(py, m)?;
+    super::init_type::<Comprehension, ast::Comprehension>(py, m)?;
+    super::init_type::<Excepthandler, ast::Excepthandler>(py, m)?;
+    super::init_type::<ExcepthandlerExceptHandler, ast::ExcepthandlerExceptHandler>(py, m)?;
+    super::init_type::<Arguments, ast::Arguments>(py, m)?;
+    super::init_type::<Arg, ast::Arg>(py, m)?;
+    super::init_type::<Keyword, ast::Keyword>(py, m)?;
+    super::init_type::<Alias, ast::Alias>(py, m)?;
+    super::init_type::<Withitem, ast::Withitem>(py, m)?;
+    super::init_type::<MatchCase, ast::MatchCase>(py, m)?;
+    super::init_type::<Pattern, ast::Pattern>(py, m)?;
+    super::init_type::<PatternMatchValue, ast::PatternMatchValue>(py, m)?;
+    super::init_type::<PatternMatchSingleton, ast::PatternMatchSingleton>(py, m)?;
+    super::init_type::<PatternMatchSequence, ast::PatternMatchSequence>(py, m)?;
+    super::init_type::<PatternMatchMapping, ast::PatternMatchMapping>(py, m)?;
+    super::init_type::<PatternMatchClass, ast::PatternMatchClass>(py, m)?;
+    super::init_type::<PatternMatchStar, ast::PatternMatchStar>(py, m)?;
+    super::init_type::<PatternMatchAs, ast::PatternMatchAs>(py, m)?;
+    super::init_type::<PatternMatchOr, ast::PatternMatchOr>(py, m)?;
+    super::init_type::<TypeIgnore, ast::TypeIgnore>(py, m)?;
+    super::init_type::<TypeIgnoreTypeIgnore, ast::TypeIgnoreTypeIgnore>(py, m)?;
     Ok(())
 }
diff --git a/ast/src/gen/pyo3_wrapper_ranged.rs b/ast-pyo3/src/gen/wrapper_ranged.rs
similarity index 55%
rename from ast/src/gen/pyo3_wrapper_ranged.rs
rename to ast-pyo3/src/gen/wrapper_ranged.rs
index dfa0a30a..f22a5601 100644
--- a/ast/src/gen/pyo3_wrapper_ranged.rs
+++ b/ast-pyo3/src/gen/wrapper_ranged.rs
@@ -1,11 +1,11 @@
 // File automatically generated by ast/asdl_rs.py.
 
-#[pyclass(module="rustpython_ast.ranged", name="_mod", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_mod", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Mod;
 
-impl From<&'static crate::Mod<TextRange>> for Mod {
-    fn from(_node: &'static crate::Mod<TextRange>) -> Self {
+impl From<&'static ast::Mod<TextRange>> for Mod {
+    fn from(_node: &'static ast::Mod<TextRange>) -> Self {
         Mod
     }
 }
@@ -14,7 +14,7 @@ impl From<&'static crate::Mod<TextRange>> for Mod {
 impl Mod {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Mod {
@@ -24,40 +24,40 @@ impl ToPyObject for Mod {
     }
 }
 
-impl ToPyo3Wrapper for crate::Mod<TextRange> {
+impl ToPyWrapper for ast::Mod<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::Module(cons) => cons.to_pyo3_wrapper(py),
-            Self::Interactive(cons) => cons.to_pyo3_wrapper(py),
-            Self::Expression(cons) => cons.to_pyo3_wrapper(py),
-            Self::FunctionType(cons) => cons.to_pyo3_wrapper(py),
+            Self::Module(cons) => cons.to_py_wrapper(py),
+            Self::Interactive(cons) => cons.to_py_wrapper(py),
+            Self::Expression(cons) => cons.to_py_wrapper(py),
+            Self::FunctionType(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Module", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModModule(pub &'static crate::ModModule<TextRange>);
+pub struct ModModule(pub &'static ast::ModModule<TextRange>);
 
-impl From<&'static crate::ModModule<TextRange>> for ModModule {
-    fn from(node: &'static crate::ModModule<TextRange>) -> Self {
+impl From<&'static ast::ModModule<TextRange>> for ModModule {
+    fn from(node: &'static ast::ModModule<TextRange>) -> Self {
         ModModule(node)
     }
 }
 
 impl ToPyObject for ModModule {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModModule<TextRange> {
+impl ToPyWrapper for ast::ModModule<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModModule(self).to_object(py))
     }
 }
@@ -67,38 +67,38 @@ impl ModModule {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_ignores(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_ignores.to_pyo3_wrapper(py)
+        self.0.type_ignores.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Interactive", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModInteractive(pub &'static crate::ModInteractive<TextRange>);
+pub struct ModInteractive(pub &'static ast::ModInteractive<TextRange>);
 
-impl From<&'static crate::ModInteractive<TextRange>> for ModInteractive {
-    fn from(node: &'static crate::ModInteractive<TextRange>) -> Self {
+impl From<&'static ast::ModInteractive<TextRange>> for ModInteractive {
+    fn from(node: &'static ast::ModInteractive<TextRange>) -> Self {
         ModInteractive(node)
     }
 }
 
 impl ToPyObject for ModInteractive {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModInteractive<TextRange> {
+impl ToPyWrapper for ast::ModInteractive<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModInteractive(self).to_object(py))
     }
 }
@@ -108,32 +108,32 @@ impl ModInteractive {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Expression", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModExpression(pub &'static crate::ModExpression<TextRange>);
+pub struct ModExpression(pub &'static ast::ModExpression<TextRange>);
 
-impl From<&'static crate::ModExpression<TextRange>> for ModExpression {
-    fn from(node: &'static crate::ModExpression<TextRange>) -> Self {
+impl From<&'static ast::ModExpression<TextRange>> for ModExpression {
+    fn from(node: &'static ast::ModExpression<TextRange>) -> Self {
         ModExpression(node)
     }
 }
 
 impl ToPyObject for ModExpression {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModExpression<TextRange> {
+impl ToPyWrapper for ast::ModExpression<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModExpression(self).to_object(py))
     }
 }
@@ -143,32 +143,32 @@ impl ModExpression {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_FunctionType", extends=Mod, frozen)]
 #[derive(Clone, Debug)]
-pub struct ModFunctionType(pub &'static crate::ModFunctionType<TextRange>);
+pub struct ModFunctionType(pub &'static ast::ModFunctionType<TextRange>);
 
-impl From<&'static crate::ModFunctionType<TextRange>> for ModFunctionType {
-    fn from(node: &'static crate::ModFunctionType<TextRange>) -> Self {
+impl From<&'static ast::ModFunctionType<TextRange>> for ModFunctionType {
+    fn from(node: &'static ast::ModFunctionType<TextRange>) -> Self {
         ModFunctionType(node)
     }
 }
 
 impl ToPyObject for ModFunctionType {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Mod)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ModFunctionType<TextRange> {
+impl ToPyWrapper for ast::ModFunctionType<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ModFunctionType(self).to_object(py))
     }
 }
@@ -178,22 +178,22 @@ impl ModFunctionType {
     #[getter]
     #[inline]
     fn get_argtypes(&self, py: Python) -> PyResult<PyObject> {
-        self.0.argtypes.to_pyo3_wrapper(py)
+        self.0.argtypes.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_stmt", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_stmt", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Stmt;
 
-impl From<&'static crate::Stmt<TextRange>> for Stmt {
-    fn from(_node: &'static crate::Stmt<TextRange>) -> Self {
+impl From<&'static ast::Stmt<TextRange>> for Stmt {
+    fn from(_node: &'static ast::Stmt<TextRange>) -> Self {
         Stmt
     }
 }
@@ -202,7 +202,7 @@ impl From<&'static crate::Stmt<TextRange>> for Stmt {
 impl Stmt {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Stmt {
@@ -212,63 +212,63 @@ impl ToPyObject for Stmt {
     }
 }
 
-impl ToPyo3Wrapper for crate::Stmt<TextRange> {
+impl ToPyWrapper for ast::Stmt<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::FunctionDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncFunctionDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::ClassDef(cons) => cons.to_pyo3_wrapper(py),
-            Self::Return(cons) => cons.to_pyo3_wrapper(py),
-            Self::Delete(cons) => cons.to_pyo3_wrapper(py),
-            Self::Assign(cons) => cons.to_pyo3_wrapper(py),
-            Self::AugAssign(cons) => cons.to_pyo3_wrapper(py),
-            Self::AnnAssign(cons) => cons.to_pyo3_wrapper(py),
-            Self::For(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncFor(cons) => cons.to_pyo3_wrapper(py),
-            Self::While(cons) => cons.to_pyo3_wrapper(py),
-            Self::If(cons) => cons.to_pyo3_wrapper(py),
-            Self::With(cons) => cons.to_pyo3_wrapper(py),
-            Self::AsyncWith(cons) => cons.to_pyo3_wrapper(py),
-            Self::Match(cons) => cons.to_pyo3_wrapper(py),
-            Self::Raise(cons) => cons.to_pyo3_wrapper(py),
-            Self::Try(cons) => cons.to_pyo3_wrapper(py),
-            Self::TryStar(cons) => cons.to_pyo3_wrapper(py),
-            Self::Assert(cons) => cons.to_pyo3_wrapper(py),
-            Self::Import(cons) => cons.to_pyo3_wrapper(py),
-            Self::ImportFrom(cons) => cons.to_pyo3_wrapper(py),
-            Self::Global(cons) => cons.to_pyo3_wrapper(py),
-            Self::Nonlocal(cons) => cons.to_pyo3_wrapper(py),
-            Self::Expr(cons) => cons.to_pyo3_wrapper(py),
-            Self::Pass(cons) => cons.to_pyo3_wrapper(py),
-            Self::Break(cons) => cons.to_pyo3_wrapper(py),
-            Self::Continue(cons) => cons.to_pyo3_wrapper(py),
+            Self::FunctionDef(cons) => cons.to_py_wrapper(py),
+            Self::AsyncFunctionDef(cons) => cons.to_py_wrapper(py),
+            Self::ClassDef(cons) => cons.to_py_wrapper(py),
+            Self::Return(cons) => cons.to_py_wrapper(py),
+            Self::Delete(cons) => cons.to_py_wrapper(py),
+            Self::Assign(cons) => cons.to_py_wrapper(py),
+            Self::AugAssign(cons) => cons.to_py_wrapper(py),
+            Self::AnnAssign(cons) => cons.to_py_wrapper(py),
+            Self::For(cons) => cons.to_py_wrapper(py),
+            Self::AsyncFor(cons) => cons.to_py_wrapper(py),
+            Self::While(cons) => cons.to_py_wrapper(py),
+            Self::If(cons) => cons.to_py_wrapper(py),
+            Self::With(cons) => cons.to_py_wrapper(py),
+            Self::AsyncWith(cons) => cons.to_py_wrapper(py),
+            Self::Match(cons) => cons.to_py_wrapper(py),
+            Self::Raise(cons) => cons.to_py_wrapper(py),
+            Self::Try(cons) => cons.to_py_wrapper(py),
+            Self::TryStar(cons) => cons.to_py_wrapper(py),
+            Self::Assert(cons) => cons.to_py_wrapper(py),
+            Self::Import(cons) => cons.to_py_wrapper(py),
+            Self::ImportFrom(cons) => cons.to_py_wrapper(py),
+            Self::Global(cons) => cons.to_py_wrapper(py),
+            Self::Nonlocal(cons) => cons.to_py_wrapper(py),
+            Self::Expr(cons) => cons.to_py_wrapper(py),
+            Self::Pass(cons) => cons.to_py_wrapper(py),
+            Self::Break(cons) => cons.to_py_wrapper(py),
+            Self::Continue(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_FunctionDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtFunctionDef(pub &'static crate::StmtFunctionDef<TextRange>);
+pub struct StmtFunctionDef(pub &'static ast::StmtFunctionDef<TextRange>);
 
-impl From<&'static crate::StmtFunctionDef<TextRange>> for StmtFunctionDef {
-    fn from(node: &'static crate::StmtFunctionDef<TextRange>) -> Self {
+impl From<&'static ast::StmtFunctionDef<TextRange>> for StmtFunctionDef {
+    fn from(node: &'static ast::StmtFunctionDef<TextRange>) -> Self {
         StmtFunctionDef(node)
     }
 }
 
 impl ToPyObject for StmtFunctionDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtFunctionDef<TextRange> {
+impl ToPyWrapper for ast::StmtFunctionDef<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtFunctionDef(self).to_object(py))
     }
 }
@@ -278,62 +278,62 @@ impl StmtFunctionDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AsyncFunctionDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncFunctionDef(pub &'static crate::StmtAsyncFunctionDef<TextRange>);
+pub struct StmtAsyncFunctionDef(pub &'static ast::StmtAsyncFunctionDef<TextRange>);
 
-impl From<&'static crate::StmtAsyncFunctionDef<TextRange>> for StmtAsyncFunctionDef {
-    fn from(node: &'static crate::StmtAsyncFunctionDef<TextRange>) -> Self {
+impl From<&'static ast::StmtAsyncFunctionDef<TextRange>> for StmtAsyncFunctionDef {
+    fn from(node: &'static ast::StmtAsyncFunctionDef<TextRange>) -> Self {
         StmtAsyncFunctionDef(node)
     }
 }
 
 impl ToPyObject for StmtAsyncFunctionDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncFunctionDef<TextRange> {
+impl ToPyWrapper for ast::StmtAsyncFunctionDef<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncFunctionDef(self).to_object(py))
     }
 }
@@ -343,62 +343,62 @@ impl StmtAsyncFunctionDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_returns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.returns.to_pyo3_wrapper(py)
+        self.0.returns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ClassDef", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtClassDef(pub &'static crate::StmtClassDef<TextRange>);
+pub struct StmtClassDef(pub &'static ast::StmtClassDef<TextRange>);
 
-impl From<&'static crate::StmtClassDef<TextRange>> for StmtClassDef {
-    fn from(node: &'static crate::StmtClassDef<TextRange>) -> Self {
+impl From<&'static ast::StmtClassDef<TextRange>> for StmtClassDef {
+    fn from(node: &'static ast::StmtClassDef<TextRange>) -> Self {
         StmtClassDef(node)
     }
 }
 
 impl ToPyObject for StmtClassDef {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtClassDef<TextRange> {
+impl ToPyWrapper for ast::StmtClassDef<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtClassDef(self).to_object(py))
     }
 }
@@ -408,56 +408,56 @@ impl StmtClassDef {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_bases(&self, py: Python) -> PyResult<PyObject> {
-        self.0.bases.to_pyo3_wrapper(py)
+        self.0.bases.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_keywords(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keywords.to_pyo3_wrapper(py)
+        self.0.keywords.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
-        self.0.decorator_list.to_pyo3_wrapper(py)
+        self.0.decorator_list.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Return", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtReturn(pub &'static crate::StmtReturn<TextRange>);
+pub struct StmtReturn(pub &'static ast::StmtReturn<TextRange>);
 
-impl From<&'static crate::StmtReturn<TextRange>> for StmtReturn {
-    fn from(node: &'static crate::StmtReturn<TextRange>) -> Self {
+impl From<&'static ast::StmtReturn<TextRange>> for StmtReturn {
+    fn from(node: &'static ast::StmtReturn<TextRange>) -> Self {
         StmtReturn(node)
     }
 }
 
 impl ToPyObject for StmtReturn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtReturn<TextRange> {
+impl ToPyWrapper for ast::StmtReturn<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtReturn(self).to_object(py))
     }
 }
@@ -467,32 +467,32 @@ impl StmtReturn {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Delete", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtDelete(pub &'static crate::StmtDelete<TextRange>);
+pub struct StmtDelete(pub &'static ast::StmtDelete<TextRange>);
 
-impl From<&'static crate::StmtDelete<TextRange>> for StmtDelete {
-    fn from(node: &'static crate::StmtDelete<TextRange>) -> Self {
+impl From<&'static ast::StmtDelete<TextRange>> for StmtDelete {
+    fn from(node: &'static ast::StmtDelete<TextRange>) -> Self {
         StmtDelete(node)
     }
 }
 
 impl ToPyObject for StmtDelete {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtDelete<TextRange> {
+impl ToPyWrapper for ast::StmtDelete<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtDelete(self).to_object(py))
     }
 }
@@ -502,32 +502,32 @@ impl StmtDelete {
     #[getter]
     #[inline]
     fn get_targets(&self, py: Python) -> PyResult<PyObject> {
-        self.0.targets.to_pyo3_wrapper(py)
+        self.0.targets.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Assign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAssign(pub &'static crate::StmtAssign<TextRange>);
+pub struct StmtAssign(pub &'static ast::StmtAssign<TextRange>);
 
-impl From<&'static crate::StmtAssign<TextRange>> for StmtAssign {
-    fn from(node: &'static crate::StmtAssign<TextRange>) -> Self {
+impl From<&'static ast::StmtAssign<TextRange>> for StmtAssign {
+    fn from(node: &'static ast::StmtAssign<TextRange>) -> Self {
         StmtAssign(node)
     }
 }
 
 impl ToPyObject for StmtAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAssign<TextRange> {
+impl ToPyWrapper for ast::StmtAssign<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAssign(self).to_object(py))
     }
 }
@@ -537,44 +537,44 @@ impl StmtAssign {
     #[getter]
     #[inline]
     fn get_targets(&self, py: Python) -> PyResult<PyObject> {
-        self.0.targets.to_pyo3_wrapper(py)
+        self.0.targets.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AugAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAugAssign(pub &'static crate::StmtAugAssign<TextRange>);
+pub struct StmtAugAssign(pub &'static ast::StmtAugAssign<TextRange>);
 
-impl From<&'static crate::StmtAugAssign<TextRange>> for StmtAugAssign {
-    fn from(node: &'static crate::StmtAugAssign<TextRange>) -> Self {
+impl From<&'static ast::StmtAugAssign<TextRange>> for StmtAugAssign {
+    fn from(node: &'static ast::StmtAugAssign<TextRange>) -> Self {
         StmtAugAssign(node)
     }
 }
 
 impl ToPyObject for StmtAugAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAugAssign<TextRange> {
+impl ToPyWrapper for ast::StmtAugAssign<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAugAssign(self).to_object(py))
     }
 }
@@ -584,44 +584,44 @@ impl StmtAugAssign {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AnnAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAnnAssign(pub &'static crate::StmtAnnAssign<TextRange>);
+pub struct StmtAnnAssign(pub &'static ast::StmtAnnAssign<TextRange>);
 
-impl From<&'static crate::StmtAnnAssign<TextRange>> for StmtAnnAssign {
-    fn from(node: &'static crate::StmtAnnAssign<TextRange>) -> Self {
+impl From<&'static ast::StmtAnnAssign<TextRange>> for StmtAnnAssign {
+    fn from(node: &'static ast::StmtAnnAssign<TextRange>) -> Self {
         StmtAnnAssign(node)
     }
 }
 
 impl ToPyObject for StmtAnnAssign {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAnnAssign<TextRange> {
+impl ToPyWrapper for ast::StmtAnnAssign<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAnnAssign(self).to_object(py))
     }
 }
@@ -631,50 +631,50 @@ impl StmtAnnAssign {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_annotation(&self, py: Python) -> PyResult<PyObject> {
-        self.0.annotation.to_pyo3_wrapper(py)
+        self.0.annotation.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_simple(&self, py: Python) -> PyResult<PyObject> {
-        self.0.simple.to_pyo3_wrapper(py)
+        self.0.simple.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_For", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtFor(pub &'static crate::StmtFor<TextRange>);
+pub struct StmtFor(pub &'static ast::StmtFor<TextRange>);
 
-impl From<&'static crate::StmtFor<TextRange>> for StmtFor {
-    fn from(node: &'static crate::StmtFor<TextRange>) -> Self {
+impl From<&'static ast::StmtFor<TextRange>> for StmtFor {
+    fn from(node: &'static ast::StmtFor<TextRange>) -> Self {
         StmtFor(node)
     }
 }
 
 impl ToPyObject for StmtFor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtFor<TextRange> {
+impl ToPyWrapper for ast::StmtFor<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtFor(self).to_object(py))
     }
 }
@@ -684,56 +684,56 @@ impl StmtFor {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AsyncFor", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncFor(pub &'static crate::StmtAsyncFor<TextRange>);
+pub struct StmtAsyncFor(pub &'static ast::StmtAsyncFor<TextRange>);
 
-impl From<&'static crate::StmtAsyncFor<TextRange>> for StmtAsyncFor {
-    fn from(node: &'static crate::StmtAsyncFor<TextRange>) -> Self {
+impl From<&'static ast::StmtAsyncFor<TextRange>> for StmtAsyncFor {
+    fn from(node: &'static ast::StmtAsyncFor<TextRange>) -> Self {
         StmtAsyncFor(node)
     }
 }
 
 impl ToPyObject for StmtAsyncFor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncFor<TextRange> {
+impl ToPyWrapper for ast::StmtAsyncFor<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncFor(self).to_object(py))
     }
 }
@@ -743,56 +743,56 @@ impl StmtAsyncFor {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_While", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtWhile(pub &'static crate::StmtWhile<TextRange>);
+pub struct StmtWhile(pub &'static ast::StmtWhile<TextRange>);
 
-impl From<&'static crate::StmtWhile<TextRange>> for StmtWhile {
-    fn from(node: &'static crate::StmtWhile<TextRange>) -> Self {
+impl From<&'static ast::StmtWhile<TextRange>> for StmtWhile {
+    fn from(node: &'static ast::StmtWhile<TextRange>) -> Self {
         StmtWhile(node)
     }
 }
 
 impl ToPyObject for StmtWhile {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtWhile<TextRange> {
+impl ToPyWrapper for ast::StmtWhile<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtWhile(self).to_object(py))
     }
 }
@@ -802,44 +802,44 @@ impl StmtWhile {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_If", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtIf(pub &'static crate::StmtIf<TextRange>);
+pub struct StmtIf(pub &'static ast::StmtIf<TextRange>);
 
-impl From<&'static crate::StmtIf<TextRange>> for StmtIf {
-    fn from(node: &'static crate::StmtIf<TextRange>) -> Self {
+impl From<&'static ast::StmtIf<TextRange>> for StmtIf {
+    fn from(node: &'static ast::StmtIf<TextRange>) -> Self {
         StmtIf(node)
     }
 }
 
 impl ToPyObject for StmtIf {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtIf<TextRange> {
+impl ToPyWrapper for ast::StmtIf<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtIf(self).to_object(py))
     }
 }
@@ -849,44 +849,44 @@ impl StmtIf {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_With", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtWith(pub &'static crate::StmtWith<TextRange>);
+pub struct StmtWith(pub &'static ast::StmtWith<TextRange>);
 
-impl From<&'static crate::StmtWith<TextRange>> for StmtWith {
-    fn from(node: &'static crate::StmtWith<TextRange>) -> Self {
+impl From<&'static ast::StmtWith<TextRange>> for StmtWith {
+    fn from(node: &'static ast::StmtWith<TextRange>) -> Self {
         StmtWith(node)
     }
 }
 
 impl ToPyObject for StmtWith {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtWith<TextRange> {
+impl ToPyWrapper for ast::StmtWith<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtWith(self).to_object(py))
     }
 }
@@ -896,44 +896,44 @@ impl StmtWith {
     #[getter]
     #[inline]
     fn get_items(&self, py: Python) -> PyResult<PyObject> {
-        self.0.items.to_pyo3_wrapper(py)
+        self.0.items.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AsyncWith", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAsyncWith(pub &'static crate::StmtAsyncWith<TextRange>);
+pub struct StmtAsyncWith(pub &'static ast::StmtAsyncWith<TextRange>);
 
-impl From<&'static crate::StmtAsyncWith<TextRange>> for StmtAsyncWith {
-    fn from(node: &'static crate::StmtAsyncWith<TextRange>) -> Self {
+impl From<&'static ast::StmtAsyncWith<TextRange>> for StmtAsyncWith {
+    fn from(node: &'static ast::StmtAsyncWith<TextRange>) -> Self {
         StmtAsyncWith(node)
     }
 }
 
 impl ToPyObject for StmtAsyncWith {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAsyncWith<TextRange> {
+impl ToPyWrapper for ast::StmtAsyncWith<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAsyncWith(self).to_object(py))
     }
 }
@@ -943,44 +943,44 @@ impl StmtAsyncWith {
     #[getter]
     #[inline]
     fn get_items(&self, py: Python) -> PyResult<PyObject> {
-        self.0.items.to_pyo3_wrapper(py)
+        self.0.items.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Match", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtMatch(pub &'static crate::StmtMatch<TextRange>);
+pub struct StmtMatch(pub &'static ast::StmtMatch<TextRange>);
 
-impl From<&'static crate::StmtMatch<TextRange>> for StmtMatch {
-    fn from(node: &'static crate::StmtMatch<TextRange>) -> Self {
+impl From<&'static ast::StmtMatch<TextRange>> for StmtMatch {
+    fn from(node: &'static ast::StmtMatch<TextRange>) -> Self {
         StmtMatch(node)
     }
 }
 
 impl ToPyObject for StmtMatch {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtMatch<TextRange> {
+impl ToPyWrapper for ast::StmtMatch<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtMatch(self).to_object(py))
     }
 }
@@ -990,38 +990,38 @@ impl StmtMatch {
     #[getter]
     #[inline]
     fn get_subject(&self, py: Python) -> PyResult<PyObject> {
-        self.0.subject.to_pyo3_wrapper(py)
+        self.0.subject.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_cases(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cases.to_pyo3_wrapper(py)
+        self.0.cases.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Raise", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtRaise(pub &'static crate::StmtRaise<TextRange>);
+pub struct StmtRaise(pub &'static ast::StmtRaise<TextRange>);
 
-impl From<&'static crate::StmtRaise<TextRange>> for StmtRaise {
-    fn from(node: &'static crate::StmtRaise<TextRange>) -> Self {
+impl From<&'static ast::StmtRaise<TextRange>> for StmtRaise {
+    fn from(node: &'static ast::StmtRaise<TextRange>) -> Self {
         StmtRaise(node)
     }
 }
 
 impl ToPyObject for StmtRaise {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtRaise<TextRange> {
+impl ToPyWrapper for ast::StmtRaise<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtRaise(self).to_object(py))
     }
 }
@@ -1031,38 +1031,38 @@ impl StmtRaise {
     #[getter]
     #[inline]
     fn get_exc(&self, py: Python) -> PyResult<PyObject> {
-        self.0.exc.to_pyo3_wrapper(py)
+        self.0.exc.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_cause(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cause.to_pyo3_wrapper(py)
+        self.0.cause.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Try", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtTry(pub &'static crate::StmtTry<TextRange>);
+pub struct StmtTry(pub &'static ast::StmtTry<TextRange>);
 
-impl From<&'static crate::StmtTry<TextRange>> for StmtTry {
-    fn from(node: &'static crate::StmtTry<TextRange>) -> Self {
+impl From<&'static ast::StmtTry<TextRange>> for StmtTry {
+    fn from(node: &'static ast::StmtTry<TextRange>) -> Self {
         StmtTry(node)
     }
 }
 
 impl ToPyObject for StmtTry {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtTry<TextRange> {
+impl ToPyWrapper for ast::StmtTry<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtTry(self).to_object(py))
     }
 }
@@ -1072,50 +1072,50 @@ impl StmtTry {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_handlers(&self, py: Python) -> PyResult<PyObject> {
-        self.0.handlers.to_pyo3_wrapper(py)
+        self.0.handlers.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_finalbody(&self, py: Python) -> PyResult<PyObject> {
-        self.0.finalbody.to_pyo3_wrapper(py)
+        self.0.finalbody.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_TryStar", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtTryStar(pub &'static crate::StmtTryStar<TextRange>);
+pub struct StmtTryStar(pub &'static ast::StmtTryStar<TextRange>);
 
-impl From<&'static crate::StmtTryStar<TextRange>> for StmtTryStar {
-    fn from(node: &'static crate::StmtTryStar<TextRange>) -> Self {
+impl From<&'static ast::StmtTryStar<TextRange>> for StmtTryStar {
+    fn from(node: &'static ast::StmtTryStar<TextRange>) -> Self {
         StmtTryStar(node)
     }
 }
 
 impl ToPyObject for StmtTryStar {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtTryStar<TextRange> {
+impl ToPyWrapper for ast::StmtTryStar<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtTryStar(self).to_object(py))
     }
 }
@@ -1125,50 +1125,50 @@ impl StmtTryStar {
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_handlers(&self, py: Python) -> PyResult<PyObject> {
-        self.0.handlers.to_pyo3_wrapper(py)
+        self.0.handlers.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_finalbody(&self, py: Python) -> PyResult<PyObject> {
-        self.0.finalbody.to_pyo3_wrapper(py)
+        self.0.finalbody.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Assert", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtAssert(pub &'static crate::StmtAssert<TextRange>);
+pub struct StmtAssert(pub &'static ast::StmtAssert<TextRange>);
 
-impl From<&'static crate::StmtAssert<TextRange>> for StmtAssert {
-    fn from(node: &'static crate::StmtAssert<TextRange>) -> Self {
+impl From<&'static ast::StmtAssert<TextRange>> for StmtAssert {
+    fn from(node: &'static ast::StmtAssert<TextRange>) -> Self {
         StmtAssert(node)
     }
 }
 
 impl ToPyObject for StmtAssert {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtAssert<TextRange> {
+impl ToPyWrapper for ast::StmtAssert<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtAssert(self).to_object(py))
     }
 }
@@ -1178,38 +1178,38 @@ impl StmtAssert {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_msg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.msg.to_pyo3_wrapper(py)
+        self.0.msg.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Import", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtImport(pub &'static crate::StmtImport<TextRange>);
+pub struct StmtImport(pub &'static ast::StmtImport<TextRange>);
 
-impl From<&'static crate::StmtImport<TextRange>> for StmtImport {
-    fn from(node: &'static crate::StmtImport<TextRange>) -> Self {
+impl From<&'static ast::StmtImport<TextRange>> for StmtImport {
+    fn from(node: &'static ast::StmtImport<TextRange>) -> Self {
         StmtImport(node)
     }
 }
 
 impl ToPyObject for StmtImport {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtImport<TextRange> {
+impl ToPyWrapper for ast::StmtImport<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtImport(self).to_object(py))
     }
 }
@@ -1219,32 +1219,32 @@ impl StmtImport {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ImportFrom", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtImportFrom(pub &'static crate::StmtImportFrom<TextRange>);
+pub struct StmtImportFrom(pub &'static ast::StmtImportFrom<TextRange>);
 
-impl From<&'static crate::StmtImportFrom<TextRange>> for StmtImportFrom {
-    fn from(node: &'static crate::StmtImportFrom<TextRange>) -> Self {
+impl From<&'static ast::StmtImportFrom<TextRange>> for StmtImportFrom {
+    fn from(node: &'static ast::StmtImportFrom<TextRange>) -> Self {
         StmtImportFrom(node)
     }
 }
 
 impl ToPyObject for StmtImportFrom {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtImportFrom<TextRange> {
+impl ToPyWrapper for ast::StmtImportFrom<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtImportFrom(self).to_object(py))
     }
 }
@@ -1254,44 +1254,44 @@ impl StmtImportFrom {
     #[getter]
     #[inline]
     fn get_module(&self, py: Python) -> PyResult<PyObject> {
-        self.0.module.to_pyo3_wrapper(py)
+        self.0.module.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_level(&self, py: Python) -> PyResult<PyObject> {
-        self.0.level.to_pyo3_wrapper(py)
+        self.0.level.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Global", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtGlobal(pub &'static crate::StmtGlobal<TextRange>);
+pub struct StmtGlobal(pub &'static ast::StmtGlobal<TextRange>);
 
-impl From<&'static crate::StmtGlobal<TextRange>> for StmtGlobal {
-    fn from(node: &'static crate::StmtGlobal<TextRange>) -> Self {
+impl From<&'static ast::StmtGlobal<TextRange>> for StmtGlobal {
+    fn from(node: &'static ast::StmtGlobal<TextRange>) -> Self {
         StmtGlobal(node)
     }
 }
 
 impl ToPyObject for StmtGlobal {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtGlobal<TextRange> {
+impl ToPyWrapper for ast::StmtGlobal<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtGlobal(self).to_object(py))
     }
 }
@@ -1301,32 +1301,32 @@ impl StmtGlobal {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Nonlocal", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtNonlocal(pub &'static crate::StmtNonlocal<TextRange>);
+pub struct StmtNonlocal(pub &'static ast::StmtNonlocal<TextRange>);
 
-impl From<&'static crate::StmtNonlocal<TextRange>> for StmtNonlocal {
-    fn from(node: &'static crate::StmtNonlocal<TextRange>) -> Self {
+impl From<&'static ast::StmtNonlocal<TextRange>> for StmtNonlocal {
+    fn from(node: &'static ast::StmtNonlocal<TextRange>) -> Self {
         StmtNonlocal(node)
     }
 }
 
 impl ToPyObject for StmtNonlocal {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtNonlocal<TextRange> {
+impl ToPyWrapper for ast::StmtNonlocal<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtNonlocal(self).to_object(py))
     }
 }
@@ -1336,32 +1336,32 @@ impl StmtNonlocal {
     #[getter]
     #[inline]
     fn get_names(&self, py: Python) -> PyResult<PyObject> {
-        self.0.names.to_pyo3_wrapper(py)
+        self.0.names.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Expr", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtExpr(pub &'static crate::StmtExpr<TextRange>);
+pub struct StmtExpr(pub &'static ast::StmtExpr<TextRange>);
 
-impl From<&'static crate::StmtExpr<TextRange>> for StmtExpr {
-    fn from(node: &'static crate::StmtExpr<TextRange>) -> Self {
+impl From<&'static ast::StmtExpr<TextRange>> for StmtExpr {
+    fn from(node: &'static ast::StmtExpr<TextRange>) -> Self {
         StmtExpr(node)
     }
 }
 
 impl ToPyObject for StmtExpr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtExpr<TextRange> {
+impl ToPyWrapper for ast::StmtExpr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtExpr(self).to_object(py))
     }
 }
@@ -1371,32 +1371,32 @@ impl StmtExpr {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Pass", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtPass(pub &'static crate::StmtPass<TextRange>);
+pub struct StmtPass(pub &'static ast::StmtPass<TextRange>);
 
-impl From<&'static crate::StmtPass<TextRange>> for StmtPass {
-    fn from(node: &'static crate::StmtPass<TextRange>) -> Self {
+impl From<&'static ast::StmtPass<TextRange>> for StmtPass {
+    fn from(node: &'static ast::StmtPass<TextRange>) -> Self {
         StmtPass(node)
     }
 }
 
 impl ToPyObject for StmtPass {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtPass<TextRange> {
+impl ToPyWrapper for ast::StmtPass<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtPass(self).to_object(py))
     }
 }
@@ -1406,26 +1406,26 @@ impl StmtPass {}
 
 #[pyclass(module="rustpython_ast.ranged", name="_Break", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtBreak(pub &'static crate::StmtBreak<TextRange>);
+pub struct StmtBreak(pub &'static ast::StmtBreak<TextRange>);
 
-impl From<&'static crate::StmtBreak<TextRange>> for StmtBreak {
-    fn from(node: &'static crate::StmtBreak<TextRange>) -> Self {
+impl From<&'static ast::StmtBreak<TextRange>> for StmtBreak {
+    fn from(node: &'static ast::StmtBreak<TextRange>) -> Self {
         StmtBreak(node)
     }
 }
 
 impl ToPyObject for StmtBreak {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtBreak<TextRange> {
+impl ToPyWrapper for ast::StmtBreak<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtBreak(self).to_object(py))
     }
 }
@@ -1435,26 +1435,26 @@ impl StmtBreak {}
 
 #[pyclass(module="rustpython_ast.ranged", name="_Continue", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
-pub struct StmtContinue(pub &'static crate::StmtContinue<TextRange>);
+pub struct StmtContinue(pub &'static ast::StmtContinue<TextRange>);
 
-impl From<&'static crate::StmtContinue<TextRange>> for StmtContinue {
-    fn from(node: &'static crate::StmtContinue<TextRange>) -> Self {
+impl From<&'static ast::StmtContinue<TextRange>> for StmtContinue {
+    fn from(node: &'static ast::StmtContinue<TextRange>) -> Self {
         StmtContinue(node)
     }
 }
 
 impl ToPyObject for StmtContinue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Stmt)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::StmtContinue<TextRange> {
+impl ToPyWrapper for ast::StmtContinue<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(StmtContinue(self).to_object(py))
     }
 }
@@ -1462,12 +1462,12 @@ impl ToPyo3Wrapper for crate::StmtContinue<TextRange> {
 #[pymethods]
 impl StmtContinue {}
 
-#[pyclass(module="rustpython_ast.ranged", name="_expr", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_expr", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Expr;
 
-impl From<&'static crate::Expr<TextRange>> for Expr {
-    fn from(_node: &'static crate::Expr<TextRange>) -> Self {
+impl From<&'static ast::Expr<TextRange>> for Expr {
+    fn from(_node: &'static ast::Expr<TextRange>) -> Self {
         Expr
     }
 }
@@ -1476,7 +1476,7 @@ impl From<&'static crate::Expr<TextRange>> for Expr {
 impl Expr {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Expr {
@@ -1486,63 +1486,63 @@ impl ToPyObject for Expr {
     }
 }
 
-impl ToPyo3Wrapper for crate::Expr<TextRange> {
+impl ToPyWrapper for ast::Expr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::BoolOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::NamedExpr(cons) => cons.to_pyo3_wrapper(py),
-            Self::BinOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::UnaryOp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Lambda(cons) => cons.to_pyo3_wrapper(py),
-            Self::IfExp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Dict(cons) => cons.to_pyo3_wrapper(py),
-            Self::Set(cons) => cons.to_pyo3_wrapper(py),
-            Self::ListComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::SetComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::DictComp(cons) => cons.to_pyo3_wrapper(py),
-            Self::GeneratorExp(cons) => cons.to_pyo3_wrapper(py),
-            Self::Await(cons) => cons.to_pyo3_wrapper(py),
-            Self::Yield(cons) => cons.to_pyo3_wrapper(py),
-            Self::YieldFrom(cons) => cons.to_pyo3_wrapper(py),
-            Self::Compare(cons) => cons.to_pyo3_wrapper(py),
-            Self::Call(cons) => cons.to_pyo3_wrapper(py),
-            Self::FormattedValue(cons) => cons.to_pyo3_wrapper(py),
-            Self::JoinedStr(cons) => cons.to_pyo3_wrapper(py),
-            Self::Constant(cons) => cons.to_pyo3_wrapper(py),
-            Self::Attribute(cons) => cons.to_pyo3_wrapper(py),
-            Self::Subscript(cons) => cons.to_pyo3_wrapper(py),
-            Self::Starred(cons) => cons.to_pyo3_wrapper(py),
-            Self::Name(cons) => cons.to_pyo3_wrapper(py),
-            Self::List(cons) => cons.to_pyo3_wrapper(py),
-            Self::Tuple(cons) => cons.to_pyo3_wrapper(py),
-            Self::Slice(cons) => cons.to_pyo3_wrapper(py),
+            Self::BoolOp(cons) => cons.to_py_wrapper(py),
+            Self::NamedExpr(cons) => cons.to_py_wrapper(py),
+            Self::BinOp(cons) => cons.to_py_wrapper(py),
+            Self::UnaryOp(cons) => cons.to_py_wrapper(py),
+            Self::Lambda(cons) => cons.to_py_wrapper(py),
+            Self::IfExp(cons) => cons.to_py_wrapper(py),
+            Self::Dict(cons) => cons.to_py_wrapper(py),
+            Self::Set(cons) => cons.to_py_wrapper(py),
+            Self::ListComp(cons) => cons.to_py_wrapper(py),
+            Self::SetComp(cons) => cons.to_py_wrapper(py),
+            Self::DictComp(cons) => cons.to_py_wrapper(py),
+            Self::GeneratorExp(cons) => cons.to_py_wrapper(py),
+            Self::Await(cons) => cons.to_py_wrapper(py),
+            Self::Yield(cons) => cons.to_py_wrapper(py),
+            Self::YieldFrom(cons) => cons.to_py_wrapper(py),
+            Self::Compare(cons) => cons.to_py_wrapper(py),
+            Self::Call(cons) => cons.to_py_wrapper(py),
+            Self::FormattedValue(cons) => cons.to_py_wrapper(py),
+            Self::JoinedStr(cons) => cons.to_py_wrapper(py),
+            Self::Constant(cons) => cons.to_py_wrapper(py),
+            Self::Attribute(cons) => cons.to_py_wrapper(py),
+            Self::Subscript(cons) => cons.to_py_wrapper(py),
+            Self::Starred(cons) => cons.to_py_wrapper(py),
+            Self::Name(cons) => cons.to_py_wrapper(py),
+            Self::List(cons) => cons.to_py_wrapper(py),
+            Self::Tuple(cons) => cons.to_py_wrapper(py),
+            Self::Slice(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_BoolOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprBoolOp(pub &'static crate::ExprBoolOp<TextRange>);
+pub struct ExprBoolOp(pub &'static ast::ExprBoolOp<TextRange>);
 
-impl From<&'static crate::ExprBoolOp<TextRange>> for ExprBoolOp {
-    fn from(node: &'static crate::ExprBoolOp<TextRange>) -> Self {
+impl From<&'static ast::ExprBoolOp<TextRange>> for ExprBoolOp {
+    fn from(node: &'static ast::ExprBoolOp<TextRange>) -> Self {
         ExprBoolOp(node)
     }
 }
 
 impl ToPyObject for ExprBoolOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprBoolOp<TextRange> {
+impl ToPyWrapper for ast::ExprBoolOp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprBoolOp(self).to_object(py))
     }
 }
@@ -1552,38 +1552,38 @@ impl ExprBoolOp {
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_NamedExpr", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprNamedExpr(pub &'static crate::ExprNamedExpr<TextRange>);
+pub struct ExprNamedExpr(pub &'static ast::ExprNamedExpr<TextRange>);
 
-impl From<&'static crate::ExprNamedExpr<TextRange>> for ExprNamedExpr {
-    fn from(node: &'static crate::ExprNamedExpr<TextRange>) -> Self {
+impl From<&'static ast::ExprNamedExpr<TextRange>> for ExprNamedExpr {
+    fn from(node: &'static ast::ExprNamedExpr<TextRange>) -> Self {
         ExprNamedExpr(node)
     }
 }
 
 impl ToPyObject for ExprNamedExpr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprNamedExpr<TextRange> {
+impl ToPyWrapper for ast::ExprNamedExpr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprNamedExpr(self).to_object(py))
     }
 }
@@ -1593,38 +1593,38 @@ impl ExprNamedExpr {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_BinOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprBinOp(pub &'static crate::ExprBinOp<TextRange>);
+pub struct ExprBinOp(pub &'static ast::ExprBinOp<TextRange>);
 
-impl From<&'static crate::ExprBinOp<TextRange>> for ExprBinOp {
-    fn from(node: &'static crate::ExprBinOp<TextRange>) -> Self {
+impl From<&'static ast::ExprBinOp<TextRange>> for ExprBinOp {
+    fn from(node: &'static ast::ExprBinOp<TextRange>) -> Self {
         ExprBinOp(node)
     }
 }
 
 impl ToPyObject for ExprBinOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprBinOp<TextRange> {
+impl ToPyWrapper for ast::ExprBinOp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprBinOp(self).to_object(py))
     }
 }
@@ -1634,44 +1634,44 @@ impl ExprBinOp {
     #[getter]
     #[inline]
     fn get_left(&self, py: Python) -> PyResult<PyObject> {
-        self.0.left.to_pyo3_wrapper(py)
+        self.0.left.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_right(&self, py: Python) -> PyResult<PyObject> {
-        self.0.right.to_pyo3_wrapper(py)
+        self.0.right.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_UnaryOp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprUnaryOp(pub &'static crate::ExprUnaryOp<TextRange>);
+pub struct ExprUnaryOp(pub &'static ast::ExprUnaryOp<TextRange>);
 
-impl From<&'static crate::ExprUnaryOp<TextRange>> for ExprUnaryOp {
-    fn from(node: &'static crate::ExprUnaryOp<TextRange>) -> Self {
+impl From<&'static ast::ExprUnaryOp<TextRange>> for ExprUnaryOp {
+    fn from(node: &'static ast::ExprUnaryOp<TextRange>) -> Self {
         ExprUnaryOp(node)
     }
 }
 
 impl ToPyObject for ExprUnaryOp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprUnaryOp<TextRange> {
+impl ToPyWrapper for ast::ExprUnaryOp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprUnaryOp(self).to_object(py))
     }
 }
@@ -1681,38 +1681,38 @@ impl ExprUnaryOp {
     #[getter]
     #[inline]
     fn get_op(&self, py: Python) -> PyResult<PyObject> {
-        self.0.op.to_pyo3_wrapper(py)
+        self.0.op.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_operand(&self, py: Python) -> PyResult<PyObject> {
-        self.0.operand.to_pyo3_wrapper(py)
+        self.0.operand.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Lambda", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprLambda(pub &'static crate::ExprLambda<TextRange>);
+pub struct ExprLambda(pub &'static ast::ExprLambda<TextRange>);
 
-impl From<&'static crate::ExprLambda<TextRange>> for ExprLambda {
-    fn from(node: &'static crate::ExprLambda<TextRange>) -> Self {
+impl From<&'static ast::ExprLambda<TextRange>> for ExprLambda {
+    fn from(node: &'static ast::ExprLambda<TextRange>) -> Self {
         ExprLambda(node)
     }
 }
 
 impl ToPyObject for ExprLambda {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprLambda<TextRange> {
+impl ToPyWrapper for ast::ExprLambda<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprLambda(self).to_object(py))
     }
 }
@@ -1722,38 +1722,38 @@ impl ExprLambda {
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_IfExp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprIfExp(pub &'static crate::ExprIfExp<TextRange>);
+pub struct ExprIfExp(pub &'static ast::ExprIfExp<TextRange>);
 
-impl From<&'static crate::ExprIfExp<TextRange>> for ExprIfExp {
-    fn from(node: &'static crate::ExprIfExp<TextRange>) -> Self {
+impl From<&'static ast::ExprIfExp<TextRange>> for ExprIfExp {
+    fn from(node: &'static ast::ExprIfExp<TextRange>) -> Self {
         ExprIfExp(node)
     }
 }
 
 impl ToPyObject for ExprIfExp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprIfExp<TextRange> {
+impl ToPyWrapper for ast::ExprIfExp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprIfExp(self).to_object(py))
     }
 }
@@ -1763,44 +1763,44 @@ impl ExprIfExp {
     #[getter]
     #[inline]
     fn get_test(&self, py: Python) -> PyResult<PyObject> {
-        self.0.test.to_pyo3_wrapper(py)
+        self.0.test.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_orelse(&self, py: Python) -> PyResult<PyObject> {
-        self.0.orelse.to_pyo3_wrapper(py)
+        self.0.orelse.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Dict", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprDict(pub &'static crate::ExprDict<TextRange>);
+pub struct ExprDict(pub &'static ast::ExprDict<TextRange>);
 
-impl From<&'static crate::ExprDict<TextRange>> for ExprDict {
-    fn from(node: &'static crate::ExprDict<TextRange>) -> Self {
+impl From<&'static ast::ExprDict<TextRange>> for ExprDict {
+    fn from(node: &'static ast::ExprDict<TextRange>) -> Self {
         ExprDict(node)
     }
 }
 
 impl ToPyObject for ExprDict {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprDict<TextRange> {
+impl ToPyWrapper for ast::ExprDict<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprDict(self).to_object(py))
     }
 }
@@ -1810,38 +1810,38 @@ impl ExprDict {
     #[getter]
     #[inline]
     fn get_keys(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keys.to_pyo3_wrapper(py)
+        self.0.keys.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Set", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSet(pub &'static crate::ExprSet<TextRange>);
+pub struct ExprSet(pub &'static ast::ExprSet<TextRange>);
 
-impl From<&'static crate::ExprSet<TextRange>> for ExprSet {
-    fn from(node: &'static crate::ExprSet<TextRange>) -> Self {
+impl From<&'static ast::ExprSet<TextRange>> for ExprSet {
+    fn from(node: &'static ast::ExprSet<TextRange>) -> Self {
         ExprSet(node)
     }
 }
 
 impl ToPyObject for ExprSet {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSet<TextRange> {
+impl ToPyWrapper for ast::ExprSet<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSet(self).to_object(py))
     }
 }
@@ -1851,32 +1851,32 @@ impl ExprSet {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ListComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprListComp(pub &'static crate::ExprListComp<TextRange>);
+pub struct ExprListComp(pub &'static ast::ExprListComp<TextRange>);
 
-impl From<&'static crate::ExprListComp<TextRange>> for ExprListComp {
-    fn from(node: &'static crate::ExprListComp<TextRange>) -> Self {
+impl From<&'static ast::ExprListComp<TextRange>> for ExprListComp {
+    fn from(node: &'static ast::ExprListComp<TextRange>) -> Self {
         ExprListComp(node)
     }
 }
 
 impl ToPyObject for ExprListComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprListComp<TextRange> {
+impl ToPyWrapper for ast::ExprListComp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprListComp(self).to_object(py))
     }
 }
@@ -1886,38 +1886,38 @@ impl ExprListComp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_SetComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSetComp(pub &'static crate::ExprSetComp<TextRange>);
+pub struct ExprSetComp(pub &'static ast::ExprSetComp<TextRange>);
 
-impl From<&'static crate::ExprSetComp<TextRange>> for ExprSetComp {
-    fn from(node: &'static crate::ExprSetComp<TextRange>) -> Self {
+impl From<&'static ast::ExprSetComp<TextRange>> for ExprSetComp {
+    fn from(node: &'static ast::ExprSetComp<TextRange>) -> Self {
         ExprSetComp(node)
     }
 }
 
 impl ToPyObject for ExprSetComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSetComp<TextRange> {
+impl ToPyWrapper for ast::ExprSetComp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSetComp(self).to_object(py))
     }
 }
@@ -1927,38 +1927,38 @@ impl ExprSetComp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_DictComp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprDictComp(pub &'static crate::ExprDictComp<TextRange>);
+pub struct ExprDictComp(pub &'static ast::ExprDictComp<TextRange>);
 
-impl From<&'static crate::ExprDictComp<TextRange>> for ExprDictComp {
-    fn from(node: &'static crate::ExprDictComp<TextRange>) -> Self {
+impl From<&'static ast::ExprDictComp<TextRange>> for ExprDictComp {
+    fn from(node: &'static ast::ExprDictComp<TextRange>) -> Self {
         ExprDictComp(node)
     }
 }
 
 impl ToPyObject for ExprDictComp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprDictComp<TextRange> {
+impl ToPyWrapper for ast::ExprDictComp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprDictComp(self).to_object(py))
     }
 }
@@ -1968,44 +1968,44 @@ impl ExprDictComp {
     #[getter]
     #[inline]
     fn get_key(&self, py: Python) -> PyResult<PyObject> {
-        self.0.key.to_pyo3_wrapper(py)
+        self.0.key.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_GeneratorExp", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprGeneratorExp(pub &'static crate::ExprGeneratorExp<TextRange>);
+pub struct ExprGeneratorExp(pub &'static ast::ExprGeneratorExp<TextRange>);
 
-impl From<&'static crate::ExprGeneratorExp<TextRange>> for ExprGeneratorExp {
-    fn from(node: &'static crate::ExprGeneratorExp<TextRange>) -> Self {
+impl From<&'static ast::ExprGeneratorExp<TextRange>> for ExprGeneratorExp {
+    fn from(node: &'static ast::ExprGeneratorExp<TextRange>) -> Self {
         ExprGeneratorExp(node)
     }
 }
 
 impl ToPyObject for ExprGeneratorExp {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprGeneratorExp<TextRange> {
+impl ToPyWrapper for ast::ExprGeneratorExp<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprGeneratorExp(self).to_object(py))
     }
 }
@@ -2015,38 +2015,38 @@ impl ExprGeneratorExp {
     #[getter]
     #[inline]
     fn get_elt(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elt.to_pyo3_wrapper(py)
+        self.0.elt.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_generators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.generators.to_pyo3_wrapper(py)
+        self.0.generators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Await", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprAwait(pub &'static crate::ExprAwait<TextRange>);
+pub struct ExprAwait(pub &'static ast::ExprAwait<TextRange>);
 
-impl From<&'static crate::ExprAwait<TextRange>> for ExprAwait {
-    fn from(node: &'static crate::ExprAwait<TextRange>) -> Self {
+impl From<&'static ast::ExprAwait<TextRange>> for ExprAwait {
+    fn from(node: &'static ast::ExprAwait<TextRange>) -> Self {
         ExprAwait(node)
     }
 }
 
 impl ToPyObject for ExprAwait {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprAwait<TextRange> {
+impl ToPyWrapper for ast::ExprAwait<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprAwait(self).to_object(py))
     }
 }
@@ -2056,32 +2056,32 @@ impl ExprAwait {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Yield", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprYield(pub &'static crate::ExprYield<TextRange>);
+pub struct ExprYield(pub &'static ast::ExprYield<TextRange>);
 
-impl From<&'static crate::ExprYield<TextRange>> for ExprYield {
-    fn from(node: &'static crate::ExprYield<TextRange>) -> Self {
+impl From<&'static ast::ExprYield<TextRange>> for ExprYield {
+    fn from(node: &'static ast::ExprYield<TextRange>) -> Self {
         ExprYield(node)
     }
 }
 
 impl ToPyObject for ExprYield {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprYield<TextRange> {
+impl ToPyWrapper for ast::ExprYield<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprYield(self).to_object(py))
     }
 }
@@ -2091,32 +2091,32 @@ impl ExprYield {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_YieldFrom", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprYieldFrom(pub &'static crate::ExprYieldFrom<TextRange>);
+pub struct ExprYieldFrom(pub &'static ast::ExprYieldFrom<TextRange>);
 
-impl From<&'static crate::ExprYieldFrom<TextRange>> for ExprYieldFrom {
-    fn from(node: &'static crate::ExprYieldFrom<TextRange>) -> Self {
+impl From<&'static ast::ExprYieldFrom<TextRange>> for ExprYieldFrom {
+    fn from(node: &'static ast::ExprYieldFrom<TextRange>) -> Self {
         ExprYieldFrom(node)
     }
 }
 
 impl ToPyObject for ExprYieldFrom {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprYieldFrom<TextRange> {
+impl ToPyWrapper for ast::ExprYieldFrom<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprYieldFrom(self).to_object(py))
     }
 }
@@ -2126,32 +2126,32 @@ impl ExprYieldFrom {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Compare", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprCompare(pub &'static crate::ExprCompare<TextRange>);
+pub struct ExprCompare(pub &'static ast::ExprCompare<TextRange>);
 
-impl From<&'static crate::ExprCompare<TextRange>> for ExprCompare {
-    fn from(node: &'static crate::ExprCompare<TextRange>) -> Self {
+impl From<&'static ast::ExprCompare<TextRange>> for ExprCompare {
+    fn from(node: &'static ast::ExprCompare<TextRange>) -> Self {
         ExprCompare(node)
     }
 }
 
 impl ToPyObject for ExprCompare {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprCompare<TextRange> {
+impl ToPyWrapper for ast::ExprCompare<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprCompare(self).to_object(py))
     }
 }
@@ -2161,44 +2161,44 @@ impl ExprCompare {
     #[getter]
     #[inline]
     fn get_left(&self, py: Python) -> PyResult<PyObject> {
-        self.0.left.to_pyo3_wrapper(py)
+        self.0.left.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ops(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ops.to_pyo3_wrapper(py)
+        self.0.ops.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_comparators(&self, py: Python) -> PyResult<PyObject> {
-        self.0.comparators.to_pyo3_wrapper(py)
+        self.0.comparators.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Call", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprCall(pub &'static crate::ExprCall<TextRange>);
+pub struct ExprCall(pub &'static ast::ExprCall<TextRange>);
 
-impl From<&'static crate::ExprCall<TextRange>> for ExprCall {
-    fn from(node: &'static crate::ExprCall<TextRange>) -> Self {
+impl From<&'static ast::ExprCall<TextRange>> for ExprCall {
+    fn from(node: &'static ast::ExprCall<TextRange>) -> Self {
         ExprCall(node)
     }
 }
 
 impl ToPyObject for ExprCall {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprCall<TextRange> {
+impl ToPyWrapper for ast::ExprCall<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprCall(self).to_object(py))
     }
 }
@@ -2208,44 +2208,44 @@ impl ExprCall {
     #[getter]
     #[inline]
     fn get_func(&self, py: Python) -> PyResult<PyObject> {
-        self.0.func.to_pyo3_wrapper(py)
+        self.0.func.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_keywords(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keywords.to_pyo3_wrapper(py)
+        self.0.keywords.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_FormattedValue", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprFormattedValue(pub &'static crate::ExprFormattedValue<TextRange>);
+pub struct ExprFormattedValue(pub &'static ast::ExprFormattedValue<TextRange>);
 
-impl From<&'static crate::ExprFormattedValue<TextRange>> for ExprFormattedValue {
-    fn from(node: &'static crate::ExprFormattedValue<TextRange>) -> Self {
+impl From<&'static ast::ExprFormattedValue<TextRange>> for ExprFormattedValue {
+    fn from(node: &'static ast::ExprFormattedValue<TextRange>) -> Self {
         ExprFormattedValue(node)
     }
 }
 
 impl ToPyObject for ExprFormattedValue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprFormattedValue<TextRange> {
+impl ToPyWrapper for ast::ExprFormattedValue<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprFormattedValue(self).to_object(py))
     }
 }
@@ -2255,44 +2255,44 @@ impl ExprFormattedValue {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_conversion(&self, py: Python) -> PyResult<PyObject> {
-        self.0.conversion.to_pyo3_wrapper(py)
+        self.0.conversion.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_format_spec(&self, py: Python) -> PyResult<PyObject> {
-        self.0.format_spec.to_pyo3_wrapper(py)
+        self.0.format_spec.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_JoinedStr", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprJoinedStr(pub &'static crate::ExprJoinedStr<TextRange>);
+pub struct ExprJoinedStr(pub &'static ast::ExprJoinedStr<TextRange>);
 
-impl From<&'static crate::ExprJoinedStr<TextRange>> for ExprJoinedStr {
-    fn from(node: &'static crate::ExprJoinedStr<TextRange>) -> Self {
+impl From<&'static ast::ExprJoinedStr<TextRange>> for ExprJoinedStr {
+    fn from(node: &'static ast::ExprJoinedStr<TextRange>) -> Self {
         ExprJoinedStr(node)
     }
 }
 
 impl ToPyObject for ExprJoinedStr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprJoinedStr<TextRange> {
+impl ToPyWrapper for ast::ExprJoinedStr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprJoinedStr(self).to_object(py))
     }
 }
@@ -2302,32 +2302,32 @@ impl ExprJoinedStr {
     #[getter]
     #[inline]
     fn get_values(&self, py: Python) -> PyResult<PyObject> {
-        self.0.values.to_pyo3_wrapper(py)
+        self.0.values.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Constant", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprConstant(pub &'static crate::ExprConstant<TextRange>);
+pub struct ExprConstant(pub &'static ast::ExprConstant<TextRange>);
 
-impl From<&'static crate::ExprConstant<TextRange>> for ExprConstant {
-    fn from(node: &'static crate::ExprConstant<TextRange>) -> Self {
+impl From<&'static ast::ExprConstant<TextRange>> for ExprConstant {
+    fn from(node: &'static ast::ExprConstant<TextRange>) -> Self {
         ExprConstant(node)
     }
 }
 
 impl ToPyObject for ExprConstant {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprConstant<TextRange> {
+impl ToPyWrapper for ast::ExprConstant<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprConstant(self).to_object(py))
     }
 }
@@ -2337,38 +2337,38 @@ impl ExprConstant {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kind(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kind.to_pyo3_wrapper(py)
+        self.0.kind.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Attribute", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprAttribute(pub &'static crate::ExprAttribute<TextRange>);
+pub struct ExprAttribute(pub &'static ast::ExprAttribute<TextRange>);
 
-impl From<&'static crate::ExprAttribute<TextRange>> for ExprAttribute {
-    fn from(node: &'static crate::ExprAttribute<TextRange>) -> Self {
+impl From<&'static ast::ExprAttribute<TextRange>> for ExprAttribute {
+    fn from(node: &'static ast::ExprAttribute<TextRange>) -> Self {
         ExprAttribute(node)
     }
 }
 
 impl ToPyObject for ExprAttribute {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprAttribute<TextRange> {
+impl ToPyWrapper for ast::ExprAttribute<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprAttribute(self).to_object(py))
     }
 }
@@ -2378,44 +2378,44 @@ impl ExprAttribute {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_attr(&self, py: Python) -> PyResult<PyObject> {
-        self.0.attr.to_pyo3_wrapper(py)
+        self.0.attr.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Subscript", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSubscript(pub &'static crate::ExprSubscript<TextRange>);
+pub struct ExprSubscript(pub &'static ast::ExprSubscript<TextRange>);
 
-impl From<&'static crate::ExprSubscript<TextRange>> for ExprSubscript {
-    fn from(node: &'static crate::ExprSubscript<TextRange>) -> Self {
+impl From<&'static ast::ExprSubscript<TextRange>> for ExprSubscript {
+    fn from(node: &'static ast::ExprSubscript<TextRange>) -> Self {
         ExprSubscript(node)
     }
 }
 
 impl ToPyObject for ExprSubscript {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSubscript<TextRange> {
+impl ToPyWrapper for ast::ExprSubscript<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSubscript(self).to_object(py))
     }
 }
@@ -2425,44 +2425,44 @@ impl ExprSubscript {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_slice(&self, py: Python) -> PyResult<PyObject> {
-        self.0.slice.to_pyo3_wrapper(py)
+        self.0.slice.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Starred", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprStarred(pub &'static crate::ExprStarred<TextRange>);
+pub struct ExprStarred(pub &'static ast::ExprStarred<TextRange>);
 
-impl From<&'static crate::ExprStarred<TextRange>> for ExprStarred {
-    fn from(node: &'static crate::ExprStarred<TextRange>) -> Self {
+impl From<&'static ast::ExprStarred<TextRange>> for ExprStarred {
+    fn from(node: &'static ast::ExprStarred<TextRange>) -> Self {
         ExprStarred(node)
     }
 }
 
 impl ToPyObject for ExprStarred {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprStarred<TextRange> {
+impl ToPyWrapper for ast::ExprStarred<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprStarred(self).to_object(py))
     }
 }
@@ -2472,38 +2472,38 @@ impl ExprStarred {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Name", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprName(pub &'static crate::ExprName<TextRange>);
+pub struct ExprName(pub &'static ast::ExprName<TextRange>);
 
-impl From<&'static crate::ExprName<TextRange>> for ExprName {
-    fn from(node: &'static crate::ExprName<TextRange>) -> Self {
+impl From<&'static ast::ExprName<TextRange>> for ExprName {
+    fn from(node: &'static ast::ExprName<TextRange>) -> Self {
         ExprName(node)
     }
 }
 
 impl ToPyObject for ExprName {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprName<TextRange> {
+impl ToPyWrapper for ast::ExprName<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprName(self).to_object(py))
     }
 }
@@ -2513,38 +2513,38 @@ impl ExprName {
     #[getter]
     #[inline]
     fn get_id(&self, py: Python) -> PyResult<PyObject> {
-        self.0.id.to_pyo3_wrapper(py)
+        self.0.id.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_List", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprList(pub &'static crate::ExprList<TextRange>);
+pub struct ExprList(pub &'static ast::ExprList<TextRange>);
 
-impl From<&'static crate::ExprList<TextRange>> for ExprList {
-    fn from(node: &'static crate::ExprList<TextRange>) -> Self {
+impl From<&'static ast::ExprList<TextRange>> for ExprList {
+    fn from(node: &'static ast::ExprList<TextRange>) -> Self {
         ExprList(node)
     }
 }
 
 impl ToPyObject for ExprList {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprList<TextRange> {
+impl ToPyWrapper for ast::ExprList<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprList(self).to_object(py))
     }
 }
@@ -2554,38 +2554,38 @@ impl ExprList {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Tuple", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprTuple(pub &'static crate::ExprTuple<TextRange>);
+pub struct ExprTuple(pub &'static ast::ExprTuple<TextRange>);
 
-impl From<&'static crate::ExprTuple<TextRange>> for ExprTuple {
-    fn from(node: &'static crate::ExprTuple<TextRange>) -> Self {
+impl From<&'static ast::ExprTuple<TextRange>> for ExprTuple {
+    fn from(node: &'static ast::ExprTuple<TextRange>) -> Self {
         ExprTuple(node)
     }
 }
 
 impl ToPyObject for ExprTuple {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprTuple<TextRange> {
+impl ToPyWrapper for ast::ExprTuple<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprTuple(self).to_object(py))
     }
 }
@@ -2595,38 +2595,38 @@ impl ExprTuple {
     #[getter]
     #[inline]
     fn get_elts(&self, py: Python) -> PyResult<PyObject> {
-        self.0.elts.to_pyo3_wrapper(py)
+        self.0.elts.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ctx(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ctx.to_pyo3_wrapper(py)
+        self.0.ctx.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Slice", extends=Expr, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExprSlice(pub &'static crate::ExprSlice<TextRange>);
+pub struct ExprSlice(pub &'static ast::ExprSlice<TextRange>);
 
-impl From<&'static crate::ExprSlice<TextRange>> for ExprSlice {
-    fn from(node: &'static crate::ExprSlice<TextRange>) -> Self {
+impl From<&'static ast::ExprSlice<TextRange>> for ExprSlice {
+    fn from(node: &'static ast::ExprSlice<TextRange>) -> Self {
         ExprSlice(node)
     }
 }
 
 impl ToPyObject for ExprSlice {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Expr)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExprSlice<TextRange> {
+impl ToPyWrapper for ast::ExprSlice<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExprSlice(self).to_object(py))
     }
 }
@@ -2636,28 +2636,28 @@ impl ExprSlice {
     #[getter]
     #[inline]
     fn get_lower(&self, py: Python) -> PyResult<PyObject> {
-        self.0.lower.to_pyo3_wrapper(py)
+        self.0.lower.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_upper(&self, py: Python) -> PyResult<PyObject> {
-        self.0.upper.to_pyo3_wrapper(py)
+        self.0.upper.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_step(&self, py: Python) -> PyResult<PyObject> {
-        self.0.step.to_pyo3_wrapper(py)
+        self.0.step.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_expr_context", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_expr_context", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct ExprContext;
 
-impl From<&'static crate::ExprContext> for ExprContext {
-    fn from(_node: &'static crate::ExprContext) -> Self {
+impl From<&'static ast::ExprContext> for ExprContext {
+    fn from(_node: &'static ast::ExprContext) -> Self {
         ExprContext
     }
 }
@@ -2666,7 +2666,7 @@ impl From<&'static crate::ExprContext> for ExprContext {
 impl ExprContext {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for ExprContext {
@@ -2681,7 +2681,7 @@ pub struct ExprContextLoad;
 
 impl ToPyObject for ExprContextLoad {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2693,7 +2693,7 @@ pub struct ExprContextStore;
 
 impl ToPyObject for ExprContextStore {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2705,19 +2705,19 @@ pub struct ExprContextDel;
 
 impl ToPyObject for ExprContextDel {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(ExprContext)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_boolop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_boolop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Boolop;
 
-impl From<&'static crate::Boolop> for Boolop {
-    fn from(_node: &'static crate::Boolop) -> Self {
+impl From<&'static ast::Boolop> for Boolop {
+    fn from(_node: &'static ast::Boolop) -> Self {
         Boolop
     }
 }
@@ -2726,7 +2726,7 @@ impl From<&'static crate::Boolop> for Boolop {
 impl Boolop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Boolop {
@@ -2741,7 +2741,7 @@ pub struct BoolopAnd;
 
 impl ToPyObject for BoolopAnd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Boolop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2753,19 +2753,19 @@ pub struct BoolopOr;
 
 impl ToPyObject for BoolopOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Boolop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_operator", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_operator", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Operator;
 
-impl From<&'static crate::Operator> for Operator {
-    fn from(_node: &'static crate::Operator) -> Self {
+impl From<&'static ast::Operator> for Operator {
+    fn from(_node: &'static ast::Operator) -> Self {
         Operator
     }
 }
@@ -2774,7 +2774,7 @@ impl From<&'static crate::Operator> for Operator {
 impl Operator {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Operator {
@@ -2789,7 +2789,7 @@ pub struct OperatorAdd;
 
 impl ToPyObject for OperatorAdd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2801,7 +2801,7 @@ pub struct OperatorSub;
 
 impl ToPyObject for OperatorSub {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2813,7 +2813,7 @@ pub struct OperatorMult;
 
 impl ToPyObject for OperatorMult {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2825,7 +2825,7 @@ pub struct OperatorMatMult;
 
 impl ToPyObject for OperatorMatMult {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2837,7 +2837,7 @@ pub struct OperatorDiv;
 
 impl ToPyObject for OperatorDiv {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2849,7 +2849,7 @@ pub struct OperatorMod;
 
 impl ToPyObject for OperatorMod {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2861,7 +2861,7 @@ pub struct OperatorPow;
 
 impl ToPyObject for OperatorPow {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2873,7 +2873,7 @@ pub struct OperatorLShift;
 
 impl ToPyObject for OperatorLShift {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2885,7 +2885,7 @@ pub struct OperatorRShift;
 
 impl ToPyObject for OperatorRShift {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2897,7 +2897,7 @@ pub struct OperatorBitOr;
 
 impl ToPyObject for OperatorBitOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2909,7 +2909,7 @@ pub struct OperatorBitXor;
 
 impl ToPyObject for OperatorBitXor {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2921,7 +2921,7 @@ pub struct OperatorBitAnd;
 
 impl ToPyObject for OperatorBitAnd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2933,19 +2933,19 @@ pub struct OperatorFloorDiv;
 
 impl ToPyObject for OperatorFloorDiv {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Operator)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_unaryop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_unaryop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Unaryop;
 
-impl From<&'static crate::Unaryop> for Unaryop {
-    fn from(_node: &'static crate::Unaryop) -> Self {
+impl From<&'static ast::Unaryop> for Unaryop {
+    fn from(_node: &'static ast::Unaryop) -> Self {
         Unaryop
     }
 }
@@ -2954,7 +2954,7 @@ impl From<&'static crate::Unaryop> for Unaryop {
 impl Unaryop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Unaryop {
@@ -2969,7 +2969,7 @@ pub struct UnaryopInvert;
 
 impl ToPyObject for UnaryopInvert {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2981,7 +2981,7 @@ pub struct UnaryopNot;
 
 impl ToPyObject for UnaryopNot {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -2993,7 +2993,7 @@ pub struct UnaryopUAdd;
 
 impl ToPyObject for UnaryopUAdd {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3005,19 +3005,19 @@ pub struct UnaryopUSub;
 
 impl ToPyObject for UnaryopUSub {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Unaryop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_cmpop", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_cmpop", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Cmpop;
 
-impl From<&'static crate::Cmpop> for Cmpop {
-    fn from(_node: &'static crate::Cmpop) -> Self {
+impl From<&'static ast::Cmpop> for Cmpop {
+    fn from(_node: &'static ast::Cmpop) -> Self {
         Cmpop
     }
 }
@@ -3026,7 +3026,7 @@ impl From<&'static crate::Cmpop> for Cmpop {
 impl Cmpop {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Cmpop {
@@ -3041,7 +3041,7 @@ pub struct CmpopEq;
 
 impl ToPyObject for CmpopEq {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3053,7 +3053,7 @@ pub struct CmpopNotEq;
 
 impl ToPyObject for CmpopNotEq {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3065,7 +3065,7 @@ pub struct CmpopLt;
 
 impl ToPyObject for CmpopLt {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3077,7 +3077,7 @@ pub struct CmpopLtE;
 
 impl ToPyObject for CmpopLtE {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3089,7 +3089,7 @@ pub struct CmpopGt;
 
 impl ToPyObject for CmpopGt {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3101,7 +3101,7 @@ pub struct CmpopGtE;
 
 impl ToPyObject for CmpopGtE {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3113,7 +3113,7 @@ pub struct CmpopIs;
 
 impl ToPyObject for CmpopIs {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3125,7 +3125,7 @@ pub struct CmpopIsNot;
 
 impl ToPyObject for CmpopIsNot {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3137,7 +3137,7 @@ pub struct CmpopIn;
 
 impl ToPyObject for CmpopIn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
@@ -3149,33 +3149,33 @@ pub struct CmpopNotIn;
 
 impl ToPyObject for CmpopNotIn {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Cmpop)
             .add_subclass(Self);
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_comprehension", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_comprehension", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Comprehension(pub &'static crate::Comprehension<TextRange>);
+pub struct Comprehension(pub &'static ast::Comprehension<TextRange>);
 
-impl From<&'static crate::Comprehension<TextRange>> for Comprehension {
-    fn from(node: &'static crate::Comprehension<TextRange>) -> Self {
+impl From<&'static ast::Comprehension<TextRange>> for Comprehension {
+    fn from(node: &'static ast::Comprehension<TextRange>) -> Self {
         Comprehension(node)
     }
 }
 
 impl ToPyObject for Comprehension {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Comprehension<TextRange> {
+impl ToPyWrapper for ast::Comprehension<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Comprehension(self).to_object(py))
     }
 }
@@ -3185,34 +3185,34 @@ impl Comprehension {
     #[getter]
     #[inline]
     fn get_target(&self, py: Python) -> PyResult<PyObject> {
-        self.0.target.to_pyo3_wrapper(py)
+        self.0.target.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_iter(&self, py: Python) -> PyResult<PyObject> {
-        self.0.iter.to_pyo3_wrapper(py)
+        self.0.iter.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_ifs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.ifs.to_pyo3_wrapper(py)
+        self.0.ifs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_is_async(&self, py: Python) -> PyResult<PyObject> {
-        self.0.is_async.to_pyo3_wrapper(py)
+        self.0.is_async.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_excepthandler", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_excepthandler", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Excepthandler;
 
-impl From<&'static crate::Excepthandler<TextRange>> for Excepthandler {
-    fn from(_node: &'static crate::Excepthandler<TextRange>) -> Self {
+impl From<&'static ast::Excepthandler<TextRange>> for Excepthandler {
+    fn from(_node: &'static ast::Excepthandler<TextRange>) -> Self {
         Excepthandler
     }
 }
@@ -3221,7 +3221,7 @@ impl From<&'static crate::Excepthandler<TextRange>> for Excepthandler {
 impl Excepthandler {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Excepthandler {
@@ -3231,37 +3231,37 @@ impl ToPyObject for Excepthandler {
     }
 }
 
-impl ToPyo3Wrapper for crate::Excepthandler<TextRange> {
+impl ToPyWrapper for ast::Excepthandler<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::ExceptHandler(cons) => cons.to_pyo3_wrapper(py),
+            Self::ExceptHandler(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ExceptHandler", extends=Excepthandler, frozen)]
 #[derive(Clone, Debug)]
-pub struct ExcepthandlerExceptHandler(pub &'static crate::ExcepthandlerExceptHandler<TextRange>);
+pub struct ExcepthandlerExceptHandler(pub &'static ast::ExcepthandlerExceptHandler<TextRange>);
 
-impl From<&'static crate::ExcepthandlerExceptHandler<TextRange>> for ExcepthandlerExceptHandler {
-    fn from(node: &'static crate::ExcepthandlerExceptHandler<TextRange>) -> Self {
+impl From<&'static ast::ExcepthandlerExceptHandler<TextRange>> for ExcepthandlerExceptHandler {
+    fn from(node: &'static ast::ExcepthandlerExceptHandler<TextRange>) -> Self {
         ExcepthandlerExceptHandler(node)
     }
 }
 
 impl ToPyObject for ExcepthandlerExceptHandler {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Excepthandler)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::ExcepthandlerExceptHandler<TextRange> {
+impl ToPyWrapper for ast::ExcepthandlerExceptHandler<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(ExcepthandlerExceptHandler(self).to_object(py))
     }
 }
@@ -3271,42 +3271,42 @@ impl ExcepthandlerExceptHandler {
     #[getter]
     #[inline]
     fn get_type(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_.to_pyo3_wrapper(py)
+        self.0.type_.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_arguments", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_arguments", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arguments(pub &'static crate::Arguments<TextRange>);
+pub struct Arguments(pub &'static ast::Arguments<TextRange>);
 
-impl From<&'static crate::Arguments<TextRange>> for Arguments {
-    fn from(node: &'static crate::Arguments<TextRange>) -> Self {
+impl From<&'static ast::Arguments<TextRange>> for Arguments {
+    fn from(node: &'static ast::Arguments<TextRange>) -> Self {
         Arguments(node)
     }
 }
 
 impl ToPyObject for Arguments {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Arguments<TextRange> {
+impl ToPyWrapper for ast::Arguments<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arguments(self).to_object(py))
     }
 }
@@ -3316,66 +3316,66 @@ impl Arguments {
     #[getter]
     #[inline]
     fn get_posonlyargs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.posonlyargs.to_pyo3_wrapper(py)
+        self.0.posonlyargs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_args(&self, py: Python) -> PyResult<PyObject> {
-        self.0.args.to_pyo3_wrapper(py)
+        self.0.args.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_vararg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.vararg.to_pyo3_wrapper(py)
+        self.0.vararg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwonlyargs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwonlyargs.to_pyo3_wrapper(py)
+        self.0.kwonlyargs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kw_defaults(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kw_defaults.to_pyo3_wrapper(py)
+        self.0.kw_defaults.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwarg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwarg.to_pyo3_wrapper(py)
+        self.0.kwarg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_defaults(&self, py: Python) -> PyResult<PyObject> {
-        self.0.defaults.to_pyo3_wrapper(py)
+        self.0.defaults.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_arg", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_arg", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Arg(pub &'static crate::Arg<TextRange>);
+pub struct Arg(pub &'static ast::Arg<TextRange>);
 
-impl From<&'static crate::Arg<TextRange>> for Arg {
-    fn from(node: &'static crate::Arg<TextRange>) -> Self {
+impl From<&'static ast::Arg<TextRange>> for Arg {
+    fn from(node: &'static ast::Arg<TextRange>) -> Self {
         Arg(node)
     }
 }
 
 impl ToPyObject for Arg {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Arg<TextRange> {
+impl ToPyWrapper for ast::Arg<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Arg(self).to_object(py))
     }
 }
@@ -3385,42 +3385,42 @@ impl Arg {
     #[getter]
     #[inline]
     fn get_arg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.arg.to_pyo3_wrapper(py)
+        self.0.arg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_annotation(&self, py: Python) -> PyResult<PyObject> {
-        self.0.annotation.to_pyo3_wrapper(py)
+        self.0.annotation.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
-        self.0.type_comment.to_pyo3_wrapper(py)
+        self.0.type_comment.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_keyword", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_keyword", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Keyword(pub &'static crate::Keyword<TextRange>);
+pub struct Keyword(pub &'static ast::Keyword<TextRange>);
 
-impl From<&'static crate::Keyword<TextRange>> for Keyword {
-    fn from(node: &'static crate::Keyword<TextRange>) -> Self {
+impl From<&'static ast::Keyword<TextRange>> for Keyword {
+    fn from(node: &'static ast::Keyword<TextRange>) -> Self {
         Keyword(node)
     }
 }
 
 impl ToPyObject for Keyword {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Keyword<TextRange> {
+impl ToPyWrapper for ast::Keyword<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Keyword(self).to_object(py))
     }
 }
@@ -3430,36 +3430,36 @@ impl Keyword {
     #[getter]
     #[inline]
     fn get_arg(&self, py: Python) -> PyResult<PyObject> {
-        self.0.arg.to_pyo3_wrapper(py)
+        self.0.arg.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_alias", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_alias", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Alias(pub &'static crate::Alias<TextRange>);
+pub struct Alias(pub &'static ast::Alias<TextRange>);
 
-impl From<&'static crate::Alias<TextRange>> for Alias {
-    fn from(node: &'static crate::Alias<TextRange>) -> Self {
+impl From<&'static ast::Alias<TextRange>> for Alias {
+    fn from(node: &'static ast::Alias<TextRange>) -> Self {
         Alias(node)
     }
 }
 
 impl ToPyObject for Alias {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Alias<TextRange> {
+impl ToPyWrapper for ast::Alias<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Alias(self).to_object(py))
     }
 }
@@ -3469,36 +3469,36 @@ impl Alias {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_asname(&self, py: Python) -> PyResult<PyObject> {
-        self.0.asname.to_pyo3_wrapper(py)
+        self.0.asname.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_withitem", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_withitem", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct Withitem(pub &'static crate::Withitem<TextRange>);
+pub struct Withitem(pub &'static ast::Withitem<TextRange>);
 
-impl From<&'static crate::Withitem<TextRange>> for Withitem {
-    fn from(node: &'static crate::Withitem<TextRange>) -> Self {
+impl From<&'static ast::Withitem<TextRange>> for Withitem {
+    fn from(node: &'static ast::Withitem<TextRange>) -> Self {
         Withitem(node)
     }
 }
 
 impl ToPyObject for Withitem {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::Withitem<TextRange> {
+impl ToPyWrapper for ast::Withitem<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(Withitem(self).to_object(py))
     }
 }
@@ -3508,36 +3508,36 @@ impl Withitem {
     #[getter]
     #[inline]
     fn get_context_expr(&self, py: Python) -> PyResult<PyObject> {
-        self.0.context_expr.to_pyo3_wrapper(py)
+        self.0.context_expr.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_optional_vars(&self, py: Python) -> PyResult<PyObject> {
-        self.0.optional_vars.to_pyo3_wrapper(py)
+        self.0.optional_vars.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_match_case", extends=super::AST, frozen)]
+#[pyclass(module="rustpython_ast.ranged", name="_match_case", extends=super::Ast, frozen)]
 #[derive(Clone, Debug)]
-pub struct MatchCase(pub &'static crate::MatchCase<TextRange>);
+pub struct MatchCase(pub &'static ast::MatchCase<TextRange>);
 
-impl From<&'static crate::MatchCase<TextRange>> for MatchCase {
-    fn from(node: &'static crate::MatchCase<TextRange>) -> Self {
+impl From<&'static ast::MatchCase<TextRange>> for MatchCase {
+    fn from(node: &'static ast::MatchCase<TextRange>) -> Self {
         MatchCase(node)
     }
 }
 
 impl ToPyObject for MatchCase {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST).add_subclass(self.clone());
+        let initializer = PyClassInitializer::from(Ast).add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::MatchCase<TextRange> {
+impl ToPyWrapper for ast::MatchCase<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(MatchCase(self).to_object(py))
     }
 }
@@ -3547,28 +3547,28 @@ impl MatchCase {
     #[getter]
     #[inline]
     fn get_pattern(&self, py: Python) -> PyResult<PyObject> {
-        self.0.pattern.to_pyo3_wrapper(py)
+        self.0.pattern.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_guard(&self, py: Python) -> PyResult<PyObject> {
-        self.0.guard.to_pyo3_wrapper(py)
+        self.0.guard.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_body(&self, py: Python) -> PyResult<PyObject> {
-        self.0.body.to_pyo3_wrapper(py)
+        self.0.body.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_pattern", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_pattern", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct Pattern;
 
-impl From<&'static crate::Pattern<TextRange>> for Pattern {
-    fn from(_node: &'static crate::Pattern<TextRange>) -> Self {
+impl From<&'static ast::Pattern<TextRange>> for Pattern {
+    fn from(_node: &'static ast::Pattern<TextRange>) -> Self {
         Pattern
     }
 }
@@ -3577,7 +3577,7 @@ impl From<&'static crate::Pattern<TextRange>> for Pattern {
 impl Pattern {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for Pattern {
@@ -3587,44 +3587,44 @@ impl ToPyObject for Pattern {
     }
 }
 
-impl ToPyo3Wrapper for crate::Pattern<TextRange> {
+impl ToPyWrapper for ast::Pattern<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::MatchValue(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchSingleton(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchSequence(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchMapping(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchClass(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchStar(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchAs(cons) => cons.to_pyo3_wrapper(py),
-            Self::MatchOr(cons) => cons.to_pyo3_wrapper(py),
+            Self::MatchValue(cons) => cons.to_py_wrapper(py),
+            Self::MatchSingleton(cons) => cons.to_py_wrapper(py),
+            Self::MatchSequence(cons) => cons.to_py_wrapper(py),
+            Self::MatchMapping(cons) => cons.to_py_wrapper(py),
+            Self::MatchClass(cons) => cons.to_py_wrapper(py),
+            Self::MatchStar(cons) => cons.to_py_wrapper(py),
+            Self::MatchAs(cons) => cons.to_py_wrapper(py),
+            Self::MatchOr(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchValue", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchValue(pub &'static crate::PatternMatchValue<TextRange>);
+pub struct PatternMatchValue(pub &'static ast::PatternMatchValue<TextRange>);
 
-impl From<&'static crate::PatternMatchValue<TextRange>> for PatternMatchValue {
-    fn from(node: &'static crate::PatternMatchValue<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchValue<TextRange>> for PatternMatchValue {
+    fn from(node: &'static ast::PatternMatchValue<TextRange>) -> Self {
         PatternMatchValue(node)
     }
 }
 
 impl ToPyObject for PatternMatchValue {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchValue<TextRange> {
+impl ToPyWrapper for ast::PatternMatchValue<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchValue(self).to_object(py))
     }
 }
@@ -3634,32 +3634,32 @@ impl PatternMatchValue {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchSingleton", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchSingleton(pub &'static crate::PatternMatchSingleton<TextRange>);
+pub struct PatternMatchSingleton(pub &'static ast::PatternMatchSingleton<TextRange>);
 
-impl From<&'static crate::PatternMatchSingleton<TextRange>> for PatternMatchSingleton {
-    fn from(node: &'static crate::PatternMatchSingleton<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchSingleton<TextRange>> for PatternMatchSingleton {
+    fn from(node: &'static ast::PatternMatchSingleton<TextRange>) -> Self {
         PatternMatchSingleton(node)
     }
 }
 
 impl ToPyObject for PatternMatchSingleton {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchSingleton<TextRange> {
+impl ToPyWrapper for ast::PatternMatchSingleton<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchSingleton(self).to_object(py))
     }
 }
@@ -3669,32 +3669,32 @@ impl PatternMatchSingleton {
     #[getter]
     #[inline]
     fn get_value(&self, py: Python) -> PyResult<PyObject> {
-        self.0.value.to_pyo3_wrapper(py)
+        self.0.value.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchSequence", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchSequence(pub &'static crate::PatternMatchSequence<TextRange>);
+pub struct PatternMatchSequence(pub &'static ast::PatternMatchSequence<TextRange>);
 
-impl From<&'static crate::PatternMatchSequence<TextRange>> for PatternMatchSequence {
-    fn from(node: &'static crate::PatternMatchSequence<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchSequence<TextRange>> for PatternMatchSequence {
+    fn from(node: &'static ast::PatternMatchSequence<TextRange>) -> Self {
         PatternMatchSequence(node)
     }
 }
 
 impl ToPyObject for PatternMatchSequence {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchSequence<TextRange> {
+impl ToPyWrapper for ast::PatternMatchSequence<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchSequence(self).to_object(py))
     }
 }
@@ -3704,32 +3704,32 @@ impl PatternMatchSequence {
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchMapping", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchMapping(pub &'static crate::PatternMatchMapping<TextRange>);
+pub struct PatternMatchMapping(pub &'static ast::PatternMatchMapping<TextRange>);
 
-impl From<&'static crate::PatternMatchMapping<TextRange>> for PatternMatchMapping {
-    fn from(node: &'static crate::PatternMatchMapping<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchMapping<TextRange>> for PatternMatchMapping {
+    fn from(node: &'static ast::PatternMatchMapping<TextRange>) -> Self {
         PatternMatchMapping(node)
     }
 }
 
 impl ToPyObject for PatternMatchMapping {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchMapping<TextRange> {
+impl ToPyWrapper for ast::PatternMatchMapping<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchMapping(self).to_object(py))
     }
 }
@@ -3739,44 +3739,44 @@ impl PatternMatchMapping {
     #[getter]
     #[inline]
     fn get_keys(&self, py: Python) -> PyResult<PyObject> {
-        self.0.keys.to_pyo3_wrapper(py)
+        self.0.keys.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_rest(&self, py: Python) -> PyResult<PyObject> {
-        self.0.rest.to_pyo3_wrapper(py)
+        self.0.rest.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchClass", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchClass(pub &'static crate::PatternMatchClass<TextRange>);
+pub struct PatternMatchClass(pub &'static ast::PatternMatchClass<TextRange>);
 
-impl From<&'static crate::PatternMatchClass<TextRange>> for PatternMatchClass {
-    fn from(node: &'static crate::PatternMatchClass<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchClass<TextRange>> for PatternMatchClass {
+    fn from(node: &'static ast::PatternMatchClass<TextRange>) -> Self {
         PatternMatchClass(node)
     }
 }
 
 impl ToPyObject for PatternMatchClass {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchClass<TextRange> {
+impl ToPyWrapper for ast::PatternMatchClass<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchClass(self).to_object(py))
     }
 }
@@ -3786,50 +3786,50 @@ impl PatternMatchClass {
     #[getter]
     #[inline]
     fn get_cls(&self, py: Python) -> PyResult<PyObject> {
-        self.0.cls.to_pyo3_wrapper(py)
+        self.0.cls.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwd_attrs(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwd_attrs.to_pyo3_wrapper(py)
+        self.0.kwd_attrs.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_kwd_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.kwd_patterns.to_pyo3_wrapper(py)
+        self.0.kwd_patterns.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchStar", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchStar(pub &'static crate::PatternMatchStar<TextRange>);
+pub struct PatternMatchStar(pub &'static ast::PatternMatchStar<TextRange>);
 
-impl From<&'static crate::PatternMatchStar<TextRange>> for PatternMatchStar {
-    fn from(node: &'static crate::PatternMatchStar<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchStar<TextRange>> for PatternMatchStar {
+    fn from(node: &'static ast::PatternMatchStar<TextRange>) -> Self {
         PatternMatchStar(node)
     }
 }
 
 impl ToPyObject for PatternMatchStar {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchStar<TextRange> {
+impl ToPyWrapper for ast::PatternMatchStar<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchStar(self).to_object(py))
     }
 }
@@ -3839,32 +3839,32 @@ impl PatternMatchStar {
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchAs", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchAs(pub &'static crate::PatternMatchAs<TextRange>);
+pub struct PatternMatchAs(pub &'static ast::PatternMatchAs<TextRange>);
 
-impl From<&'static crate::PatternMatchAs<TextRange>> for PatternMatchAs {
-    fn from(node: &'static crate::PatternMatchAs<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchAs<TextRange>> for PatternMatchAs {
+    fn from(node: &'static ast::PatternMatchAs<TextRange>) -> Self {
         PatternMatchAs(node)
     }
 }
 
 impl ToPyObject for PatternMatchAs {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchAs<TextRange> {
+impl ToPyWrapper for ast::PatternMatchAs<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchAs(self).to_object(py))
     }
 }
@@ -3874,38 +3874,38 @@ impl PatternMatchAs {
     #[getter]
     #[inline]
     fn get_pattern(&self, py: Python) -> PyResult<PyObject> {
-        self.0.pattern.to_pyo3_wrapper(py)
+        self.0.pattern.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_name(&self, py: Python) -> PyResult<PyObject> {
-        self.0.name.to_pyo3_wrapper(py)
+        self.0.name.to_py_wrapper(py)
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_MatchOr", extends=Pattern, frozen)]
 #[derive(Clone, Debug)]
-pub struct PatternMatchOr(pub &'static crate::PatternMatchOr<TextRange>);
+pub struct PatternMatchOr(pub &'static ast::PatternMatchOr<TextRange>);
 
-impl From<&'static crate::PatternMatchOr<TextRange>> for PatternMatchOr {
-    fn from(node: &'static crate::PatternMatchOr<TextRange>) -> Self {
+impl From<&'static ast::PatternMatchOr<TextRange>> for PatternMatchOr {
+    fn from(node: &'static ast::PatternMatchOr<TextRange>) -> Self {
         PatternMatchOr(node)
     }
 }
 
 impl ToPyObject for PatternMatchOr {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(Pattern)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::PatternMatchOr<TextRange> {
+impl ToPyWrapper for ast::PatternMatchOr<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(PatternMatchOr(self).to_object(py))
     }
 }
@@ -3915,16 +3915,16 @@ impl PatternMatchOr {
     #[getter]
     #[inline]
     fn get_patterns(&self, py: Python) -> PyResult<PyObject> {
-        self.0.patterns.to_pyo3_wrapper(py)
+        self.0.patterns.to_py_wrapper(py)
     }
 }
 
-#[pyclass(module="rustpython_ast.ranged", name="_type_ignore", extends=super::AST, frozen, subclass)]
+#[pyclass(module="rustpython_ast.ranged", name="_type_ignore", extends=super::Ast, frozen, subclass)]
 #[derive(Clone, Debug)]
 pub struct TypeIgnore;
 
-impl From<&'static crate::TypeIgnore<TextRange>> for TypeIgnore {
-    fn from(_node: &'static crate::TypeIgnore<TextRange>) -> Self {
+impl From<&'static ast::TypeIgnore<TextRange>> for TypeIgnore {
+    fn from(_node: &'static ast::TypeIgnore<TextRange>) -> Self {
         TypeIgnore
     }
 }
@@ -3933,7 +3933,7 @@ impl From<&'static crate::TypeIgnore<TextRange>> for TypeIgnore {
 impl TypeIgnore {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(AST).add_subclass(Self)
+        PyClassInitializer::from(Ast).add_subclass(Self)
     }
 }
 impl ToPyObject for TypeIgnore {
@@ -3943,37 +3943,37 @@ impl ToPyObject for TypeIgnore {
     }
 }
 
-impl ToPyo3Wrapper for crate::TypeIgnore<TextRange> {
+impl ToPyWrapper for ast::TypeIgnore<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         match &self {
-            Self::TypeIgnore(cons) => cons.to_pyo3_wrapper(py),
+            Self::TypeIgnore(cons) => cons.to_py_wrapper(py),
         }
     }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_TypeIgnore", extends=TypeIgnore, frozen)]
 #[derive(Clone, Debug)]
-pub struct TypeIgnoreTypeIgnore(pub &'static crate::TypeIgnoreTypeIgnore<TextRange>);
+pub struct TypeIgnoreTypeIgnore(pub &'static ast::TypeIgnoreTypeIgnore<TextRange>);
 
-impl From<&'static crate::TypeIgnoreTypeIgnore<TextRange>> for TypeIgnoreTypeIgnore {
-    fn from(node: &'static crate::TypeIgnoreTypeIgnore<TextRange>) -> Self {
+impl From<&'static ast::TypeIgnoreTypeIgnore<TextRange>> for TypeIgnoreTypeIgnore {
+    fn from(node: &'static ast::TypeIgnoreTypeIgnore<TextRange>) -> Self {
         TypeIgnoreTypeIgnore(node)
     }
 }
 
 impl ToPyObject for TypeIgnoreTypeIgnore {
     fn to_object(&self, py: Python) -> PyObject {
-        let initializer = PyClassInitializer::from(AST)
+        let initializer = PyClassInitializer::from(Ast)
             .add_subclass(TypeIgnore)
             .add_subclass(self.clone());
         Py::new(py, initializer).unwrap().into_py(py)
     }
 }
 
-impl ToPyo3Wrapper for crate::TypeIgnoreTypeIgnore<TextRange> {
+impl ToPyWrapper for ast::TypeIgnoreTypeIgnore<TextRange> {
     #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(TypeIgnoreTypeIgnore(self).to_object(py))
     }
 }
@@ -3983,137 +3983,135 @@ impl TypeIgnoreTypeIgnore {
     #[getter]
     #[inline]
     fn get_lineno(&self, py: Python) -> PyResult<PyObject> {
-        self.0.lineno.to_pyo3_wrapper(py)
+        self.0.lineno.to_py_wrapper(py)
     }
 
     #[getter]
     #[inline]
     fn get_tag(&self, py: Python) -> PyResult<PyObject> {
-        self.0.tag.to_pyo3_wrapper(py)
+        self.0.tag.to_py_wrapper(py)
     }
 }
 
 pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_module(py, m)?;
-    super::init_type::<Mod, crate::generic::Mod>(py, m)?;
-    super::init_type::<ModModule, crate::generic::ModModule>(py, m)?;
-    super::init_type::<ModInteractive, crate::generic::ModInteractive>(py, m)?;
-    super::init_type::<ModExpression, crate::generic::ModExpression>(py, m)?;
-    super::init_type::<ModFunctionType, crate::generic::ModFunctionType>(py, m)?;
-    super::init_type::<Stmt, crate::generic::Stmt>(py, m)?;
-    super::init_type::<StmtFunctionDef, crate::generic::StmtFunctionDef>(py, m)?;
-    super::init_type::<StmtAsyncFunctionDef, crate::generic::StmtAsyncFunctionDef>(py, m)?;
-    super::init_type::<StmtClassDef, crate::generic::StmtClassDef>(py, m)?;
-    super::init_type::<StmtReturn, crate::generic::StmtReturn>(py, m)?;
-    super::init_type::<StmtDelete, crate::generic::StmtDelete>(py, m)?;
-    super::init_type::<StmtAssign, crate::generic::StmtAssign>(py, m)?;
-    super::init_type::<StmtAugAssign, crate::generic::StmtAugAssign>(py, m)?;
-    super::init_type::<StmtAnnAssign, crate::generic::StmtAnnAssign>(py, m)?;
-    super::init_type::<StmtFor, crate::generic::StmtFor>(py, m)?;
-    super::init_type::<StmtAsyncFor, crate::generic::StmtAsyncFor>(py, m)?;
-    super::init_type::<StmtWhile, crate::generic::StmtWhile>(py, m)?;
-    super::init_type::<StmtIf, crate::generic::StmtIf>(py, m)?;
-    super::init_type::<StmtWith, crate::generic::StmtWith>(py, m)?;
-    super::init_type::<StmtAsyncWith, crate::generic::StmtAsyncWith>(py, m)?;
-    super::init_type::<StmtMatch, crate::generic::StmtMatch>(py, m)?;
-    super::init_type::<StmtRaise, crate::generic::StmtRaise>(py, m)?;
-    super::init_type::<StmtTry, crate::generic::StmtTry>(py, m)?;
-    super::init_type::<StmtTryStar, crate::generic::StmtTryStar>(py, m)?;
-    super::init_type::<StmtAssert, crate::generic::StmtAssert>(py, m)?;
-    super::init_type::<StmtImport, crate::generic::StmtImport>(py, m)?;
-    super::init_type::<StmtImportFrom, crate::generic::StmtImportFrom>(py, m)?;
-    super::init_type::<StmtGlobal, crate::generic::StmtGlobal>(py, m)?;
-    super::init_type::<StmtNonlocal, crate::generic::StmtNonlocal>(py, m)?;
-    super::init_type::<StmtExpr, crate::generic::StmtExpr>(py, m)?;
-    super::init_type::<StmtPass, crate::generic::StmtPass>(py, m)?;
-    super::init_type::<StmtBreak, crate::generic::StmtBreak>(py, m)?;
-    super::init_type::<StmtContinue, crate::generic::StmtContinue>(py, m)?;
-    super::init_type::<Expr, crate::generic::Expr>(py, m)?;
-    super::init_type::<ExprBoolOp, crate::generic::ExprBoolOp>(py, m)?;
-    super::init_type::<ExprNamedExpr, crate::generic::ExprNamedExpr>(py, m)?;
-    super::init_type::<ExprBinOp, crate::generic::ExprBinOp>(py, m)?;
-    super::init_type::<ExprUnaryOp, crate::generic::ExprUnaryOp>(py, m)?;
-    super::init_type::<ExprLambda, crate::generic::ExprLambda>(py, m)?;
-    super::init_type::<ExprIfExp, crate::generic::ExprIfExp>(py, m)?;
-    super::init_type::<ExprDict, crate::generic::ExprDict>(py, m)?;
-    super::init_type::<ExprSet, crate::generic::ExprSet>(py, m)?;
-    super::init_type::<ExprListComp, crate::generic::ExprListComp>(py, m)?;
-    super::init_type::<ExprSetComp, crate::generic::ExprSetComp>(py, m)?;
-    super::init_type::<ExprDictComp, crate::generic::ExprDictComp>(py, m)?;
-    super::init_type::<ExprGeneratorExp, crate::generic::ExprGeneratorExp>(py, m)?;
-    super::init_type::<ExprAwait, crate::generic::ExprAwait>(py, m)?;
-    super::init_type::<ExprYield, crate::generic::ExprYield>(py, m)?;
-    super::init_type::<ExprYieldFrom, crate::generic::ExprYieldFrom>(py, m)?;
-    super::init_type::<ExprCompare, crate::generic::ExprCompare>(py, m)?;
-    super::init_type::<ExprCall, crate::generic::ExprCall>(py, m)?;
-    super::init_type::<ExprFormattedValue, crate::generic::ExprFormattedValue>(py, m)?;
-    super::init_type::<ExprJoinedStr, crate::generic::ExprJoinedStr>(py, m)?;
-    super::init_type::<ExprConstant, crate::generic::ExprConstant>(py, m)?;
-    super::init_type::<ExprAttribute, crate::generic::ExprAttribute>(py, m)?;
-    super::init_type::<ExprSubscript, crate::generic::ExprSubscript>(py, m)?;
-    super::init_type::<ExprStarred, crate::generic::ExprStarred>(py, m)?;
-    super::init_type::<ExprName, crate::generic::ExprName>(py, m)?;
-    super::init_type::<ExprList, crate::generic::ExprList>(py, m)?;
-    super::init_type::<ExprTuple, crate::generic::ExprTuple>(py, m)?;
-    super::init_type::<ExprSlice, crate::generic::ExprSlice>(py, m)?;
-    super::init_type::<ExprContext, crate::generic::ExprContext>(py, m)?;
-    super::init_type::<ExprContextLoad, crate::generic::ExprContextLoad>(py, m)?;
-    super::init_type::<ExprContextStore, crate::generic::ExprContextStore>(py, m)?;
-    super::init_type::<ExprContextDel, crate::generic::ExprContextDel>(py, m)?;
-    super::init_type::<Boolop, crate::generic::Boolop>(py, m)?;
-    super::init_type::<BoolopAnd, crate::generic::BoolopAnd>(py, m)?;
-    super::init_type::<BoolopOr, crate::generic::BoolopOr>(py, m)?;
-    super::init_type::<Operator, crate::generic::Operator>(py, m)?;
-    super::init_type::<OperatorAdd, crate::generic::OperatorAdd>(py, m)?;
-    super::init_type::<OperatorSub, crate::generic::OperatorSub>(py, m)?;
-    super::init_type::<OperatorMult, crate::generic::OperatorMult>(py, m)?;
-    super::init_type::<OperatorMatMult, crate::generic::OperatorMatMult>(py, m)?;
-    super::init_type::<OperatorDiv, crate::generic::OperatorDiv>(py, m)?;
-    super::init_type::<OperatorMod, crate::generic::OperatorMod>(py, m)?;
-    super::init_type::<OperatorPow, crate::generic::OperatorPow>(py, m)?;
-    super::init_type::<OperatorLShift, crate::generic::OperatorLShift>(py, m)?;
-    super::init_type::<OperatorRShift, crate::generic::OperatorRShift>(py, m)?;
-    super::init_type::<OperatorBitOr, crate::generic::OperatorBitOr>(py, m)?;
-    super::init_type::<OperatorBitXor, crate::generic::OperatorBitXor>(py, m)?;
-    super::init_type::<OperatorBitAnd, crate::generic::OperatorBitAnd>(py, m)?;
-    super::init_type::<OperatorFloorDiv, crate::generic::OperatorFloorDiv>(py, m)?;
-    super::init_type::<Unaryop, crate::generic::Unaryop>(py, m)?;
-    super::init_type::<UnaryopInvert, crate::generic::UnaryopInvert>(py, m)?;
-    super::init_type::<UnaryopNot, crate::generic::UnaryopNot>(py, m)?;
-    super::init_type::<UnaryopUAdd, crate::generic::UnaryopUAdd>(py, m)?;
-    super::init_type::<UnaryopUSub, crate::generic::UnaryopUSub>(py, m)?;
-    super::init_type::<Cmpop, crate::generic::Cmpop>(py, m)?;
-    super::init_type::<CmpopEq, crate::generic::CmpopEq>(py, m)?;
-    super::init_type::<CmpopNotEq, crate::generic::CmpopNotEq>(py, m)?;
-    super::init_type::<CmpopLt, crate::generic::CmpopLt>(py, m)?;
-    super::init_type::<CmpopLtE, crate::generic::CmpopLtE>(py, m)?;
-    super::init_type::<CmpopGt, crate::generic::CmpopGt>(py, m)?;
-    super::init_type::<CmpopGtE, crate::generic::CmpopGtE>(py, m)?;
-    super::init_type::<CmpopIs, crate::generic::CmpopIs>(py, m)?;
-    super::init_type::<CmpopIsNot, crate::generic::CmpopIsNot>(py, m)?;
-    super::init_type::<CmpopIn, crate::generic::CmpopIn>(py, m)?;
-    super::init_type::<CmpopNotIn, crate::generic::CmpopNotIn>(py, m)?;
-    super::init_type::<Comprehension, crate::generic::Comprehension>(py, m)?;
-    super::init_type::<Excepthandler, crate::generic::Excepthandler>(py, m)?;
-    super::init_type::<ExcepthandlerExceptHandler, crate::generic::ExcepthandlerExceptHandler>(
-        py, m,
-    )?;
-    super::init_type::<Arguments, crate::generic::Arguments>(py, m)?;
-    super::init_type::<Arg, crate::generic::Arg>(py, m)?;
-    super::init_type::<Keyword, crate::generic::Keyword>(py, m)?;
-    super::init_type::<Alias, crate::generic::Alias>(py, m)?;
-    super::init_type::<Withitem, crate::generic::Withitem>(py, m)?;
-    super::init_type::<MatchCase, crate::generic::MatchCase>(py, m)?;
-    super::init_type::<Pattern, crate::generic::Pattern>(py, m)?;
-    super::init_type::<PatternMatchValue, crate::generic::PatternMatchValue>(py, m)?;
-    super::init_type::<PatternMatchSingleton, crate::generic::PatternMatchSingleton>(py, m)?;
-    super::init_type::<PatternMatchSequence, crate::generic::PatternMatchSequence>(py, m)?;
-    super::init_type::<PatternMatchMapping, crate::generic::PatternMatchMapping>(py, m)?;
-    super::init_type::<PatternMatchClass, crate::generic::PatternMatchClass>(py, m)?;
-    super::init_type::<PatternMatchStar, crate::generic::PatternMatchStar>(py, m)?;
-    super::init_type::<PatternMatchAs, crate::generic::PatternMatchAs>(py, m)?;
-    super::init_type::<PatternMatchOr, crate::generic::PatternMatchOr>(py, m)?;
-    super::init_type::<TypeIgnore, crate::generic::TypeIgnore>(py, m)?;
-    super::init_type::<TypeIgnoreTypeIgnore, crate::generic::TypeIgnoreTypeIgnore>(py, m)?;
+    super::init_type::<Mod, ast::Mod>(py, m)?;
+    super::init_type::<ModModule, ast::ModModule>(py, m)?;
+    super::init_type::<ModInteractive, ast::ModInteractive>(py, m)?;
+    super::init_type::<ModExpression, ast::ModExpression>(py, m)?;
+    super::init_type::<ModFunctionType, ast::ModFunctionType>(py, m)?;
+    super::init_type::<Stmt, ast::Stmt>(py, m)?;
+    super::init_type::<StmtFunctionDef, ast::StmtFunctionDef>(py, m)?;
+    super::init_type::<StmtAsyncFunctionDef, ast::StmtAsyncFunctionDef>(py, m)?;
+    super::init_type::<StmtClassDef, ast::StmtClassDef>(py, m)?;
+    super::init_type::<StmtReturn, ast::StmtReturn>(py, m)?;
+    super::init_type::<StmtDelete, ast::StmtDelete>(py, m)?;
+    super::init_type::<StmtAssign, ast::StmtAssign>(py, m)?;
+    super::init_type::<StmtAugAssign, ast::StmtAugAssign>(py, m)?;
+    super::init_type::<StmtAnnAssign, ast::StmtAnnAssign>(py, m)?;
+    super::init_type::<StmtFor, ast::StmtFor>(py, m)?;
+    super::init_type::<StmtAsyncFor, ast::StmtAsyncFor>(py, m)?;
+    super::init_type::<StmtWhile, ast::StmtWhile>(py, m)?;
+    super::init_type::<StmtIf, ast::StmtIf>(py, m)?;
+    super::init_type::<StmtWith, ast::StmtWith>(py, m)?;
+    super::init_type::<StmtAsyncWith, ast::StmtAsyncWith>(py, m)?;
+    super::init_type::<StmtMatch, ast::StmtMatch>(py, m)?;
+    super::init_type::<StmtRaise, ast::StmtRaise>(py, m)?;
+    super::init_type::<StmtTry, ast::StmtTry>(py, m)?;
+    super::init_type::<StmtTryStar, ast::StmtTryStar>(py, m)?;
+    super::init_type::<StmtAssert, ast::StmtAssert>(py, m)?;
+    super::init_type::<StmtImport, ast::StmtImport>(py, m)?;
+    super::init_type::<StmtImportFrom, ast::StmtImportFrom>(py, m)?;
+    super::init_type::<StmtGlobal, ast::StmtGlobal>(py, m)?;
+    super::init_type::<StmtNonlocal, ast::StmtNonlocal>(py, m)?;
+    super::init_type::<StmtExpr, ast::StmtExpr>(py, m)?;
+    super::init_type::<StmtPass, ast::StmtPass>(py, m)?;
+    super::init_type::<StmtBreak, ast::StmtBreak>(py, m)?;
+    super::init_type::<StmtContinue, ast::StmtContinue>(py, m)?;
+    super::init_type::<Expr, ast::Expr>(py, m)?;
+    super::init_type::<ExprBoolOp, ast::ExprBoolOp>(py, m)?;
+    super::init_type::<ExprNamedExpr, ast::ExprNamedExpr>(py, m)?;
+    super::init_type::<ExprBinOp, ast::ExprBinOp>(py, m)?;
+    super::init_type::<ExprUnaryOp, ast::ExprUnaryOp>(py, m)?;
+    super::init_type::<ExprLambda, ast::ExprLambda>(py, m)?;
+    super::init_type::<ExprIfExp, ast::ExprIfExp>(py, m)?;
+    super::init_type::<ExprDict, ast::ExprDict>(py, m)?;
+    super::init_type::<ExprSet, ast::ExprSet>(py, m)?;
+    super::init_type::<ExprListComp, ast::ExprListComp>(py, m)?;
+    super::init_type::<ExprSetComp, ast::ExprSetComp>(py, m)?;
+    super::init_type::<ExprDictComp, ast::ExprDictComp>(py, m)?;
+    super::init_type::<ExprGeneratorExp, ast::ExprGeneratorExp>(py, m)?;
+    super::init_type::<ExprAwait, ast::ExprAwait>(py, m)?;
+    super::init_type::<ExprYield, ast::ExprYield>(py, m)?;
+    super::init_type::<ExprYieldFrom, ast::ExprYieldFrom>(py, m)?;
+    super::init_type::<ExprCompare, ast::ExprCompare>(py, m)?;
+    super::init_type::<ExprCall, ast::ExprCall>(py, m)?;
+    super::init_type::<ExprFormattedValue, ast::ExprFormattedValue>(py, m)?;
+    super::init_type::<ExprJoinedStr, ast::ExprJoinedStr>(py, m)?;
+    super::init_type::<ExprConstant, ast::ExprConstant>(py, m)?;
+    super::init_type::<ExprAttribute, ast::ExprAttribute>(py, m)?;
+    super::init_type::<ExprSubscript, ast::ExprSubscript>(py, m)?;
+    super::init_type::<ExprStarred, ast::ExprStarred>(py, m)?;
+    super::init_type::<ExprName, ast::ExprName>(py, m)?;
+    super::init_type::<ExprList, ast::ExprList>(py, m)?;
+    super::init_type::<ExprTuple, ast::ExprTuple>(py, m)?;
+    super::init_type::<ExprSlice, ast::ExprSlice>(py, m)?;
+    super::init_type::<ExprContext, ast::ExprContext>(py, m)?;
+    super::init_type::<ExprContextLoad, ast::ExprContextLoad>(py, m)?;
+    super::init_type::<ExprContextStore, ast::ExprContextStore>(py, m)?;
+    super::init_type::<ExprContextDel, ast::ExprContextDel>(py, m)?;
+    super::init_type::<Boolop, ast::Boolop>(py, m)?;
+    super::init_type::<BoolopAnd, ast::BoolopAnd>(py, m)?;
+    super::init_type::<BoolopOr, ast::BoolopOr>(py, m)?;
+    super::init_type::<Operator, ast::Operator>(py, m)?;
+    super::init_type::<OperatorAdd, ast::OperatorAdd>(py, m)?;
+    super::init_type::<OperatorSub, ast::OperatorSub>(py, m)?;
+    super::init_type::<OperatorMult, ast::OperatorMult>(py, m)?;
+    super::init_type::<OperatorMatMult, ast::OperatorMatMult>(py, m)?;
+    super::init_type::<OperatorDiv, ast::OperatorDiv>(py, m)?;
+    super::init_type::<OperatorMod, ast::OperatorMod>(py, m)?;
+    super::init_type::<OperatorPow, ast::OperatorPow>(py, m)?;
+    super::init_type::<OperatorLShift, ast::OperatorLShift>(py, m)?;
+    super::init_type::<OperatorRShift, ast::OperatorRShift>(py, m)?;
+    super::init_type::<OperatorBitOr, ast::OperatorBitOr>(py, m)?;
+    super::init_type::<OperatorBitXor, ast::OperatorBitXor>(py, m)?;
+    super::init_type::<OperatorBitAnd, ast::OperatorBitAnd>(py, m)?;
+    super::init_type::<OperatorFloorDiv, ast::OperatorFloorDiv>(py, m)?;
+    super::init_type::<Unaryop, ast::Unaryop>(py, m)?;
+    super::init_type::<UnaryopInvert, ast::UnaryopInvert>(py, m)?;
+    super::init_type::<UnaryopNot, ast::UnaryopNot>(py, m)?;
+    super::init_type::<UnaryopUAdd, ast::UnaryopUAdd>(py, m)?;
+    super::init_type::<UnaryopUSub, ast::UnaryopUSub>(py, m)?;
+    super::init_type::<Cmpop, ast::Cmpop>(py, m)?;
+    super::init_type::<CmpopEq, ast::CmpopEq>(py, m)?;
+    super::init_type::<CmpopNotEq, ast::CmpopNotEq>(py, m)?;
+    super::init_type::<CmpopLt, ast::CmpopLt>(py, m)?;
+    super::init_type::<CmpopLtE, ast::CmpopLtE>(py, m)?;
+    super::init_type::<CmpopGt, ast::CmpopGt>(py, m)?;
+    super::init_type::<CmpopGtE, ast::CmpopGtE>(py, m)?;
+    super::init_type::<CmpopIs, ast::CmpopIs>(py, m)?;
+    super::init_type::<CmpopIsNot, ast::CmpopIsNot>(py, m)?;
+    super::init_type::<CmpopIn, ast::CmpopIn>(py, m)?;
+    super::init_type::<CmpopNotIn, ast::CmpopNotIn>(py, m)?;
+    super::init_type::<Comprehension, ast::Comprehension>(py, m)?;
+    super::init_type::<Excepthandler, ast::Excepthandler>(py, m)?;
+    super::init_type::<ExcepthandlerExceptHandler, ast::ExcepthandlerExceptHandler>(py, m)?;
+    super::init_type::<Arguments, ast::Arguments>(py, m)?;
+    super::init_type::<Arg, ast::Arg>(py, m)?;
+    super::init_type::<Keyword, ast::Keyword>(py, m)?;
+    super::init_type::<Alias, ast::Alias>(py, m)?;
+    super::init_type::<Withitem, ast::Withitem>(py, m)?;
+    super::init_type::<MatchCase, ast::MatchCase>(py, m)?;
+    super::init_type::<Pattern, ast::Pattern>(py, m)?;
+    super::init_type::<PatternMatchValue, ast::PatternMatchValue>(py, m)?;
+    super::init_type::<PatternMatchSingleton, ast::PatternMatchSingleton>(py, m)?;
+    super::init_type::<PatternMatchSequence, ast::PatternMatchSequence>(py, m)?;
+    super::init_type::<PatternMatchMapping, ast::PatternMatchMapping>(py, m)?;
+    super::init_type::<PatternMatchClass, ast::PatternMatchClass>(py, m)?;
+    super::init_type::<PatternMatchStar, ast::PatternMatchStar>(py, m)?;
+    super::init_type::<PatternMatchAs, ast::PatternMatchAs>(py, m)?;
+    super::init_type::<PatternMatchOr, ast::PatternMatchOr>(py, m)?;
+    super::init_type::<TypeIgnore, ast::TypeIgnore>(py, m)?;
+    super::init_type::<TypeIgnoreTypeIgnore, ast::TypeIgnoreTypeIgnore>(py, m)?;
     Ok(())
 }
diff --git a/ast-pyo3/src/lib.rs b/ast-pyo3/src/lib.rs
new file mode 100644
index 00000000..5a5b6a72
--- /dev/null
+++ b/ast-pyo3/src/lib.rs
@@ -0,0 +1,5 @@
+mod py_ast;
+#[cfg(feature = "wrapper")]
+pub mod wrapper;
+
+pub use py_ast::{init, PyNode, ToPyAst};
diff --git a/ast-pyo3/src/py_ast.rs b/ast-pyo3/src/py_ast.rs
new file mode 100644
index 00000000..e53e7b2a
--- /dev/null
+++ b/ast-pyo3/src/py_ast.rs
@@ -0,0 +1,190 @@
+use num_complex::Complex64;
+use once_cell::sync::OnceCell;
+use pyo3::{
+    prelude::*,
+    types::{PyBool, PyBytes, PyList, PyString, PyTuple},
+    ToPyObject,
+};
+use rustpython_ast::{
+    self as ast, source_code::SourceRange, text_size::TextRange, ConversionFlag, Node,
+};
+
+pub trait PyNode {
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        {
+            static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+            &PY_TYPE
+        }
+    }
+}
+
+pub trait ToPyAst {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny>;
+}
+
+impl<T: ToPyAst> ToPyAst for Box<T> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        (**self).to_py_ast(py)
+    }
+}
+
+impl<T: ToPyAst> ToPyAst for Option<T> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        match self {
+            Some(ast) => ast.to_py_ast(py),
+            None => Ok(ast_cache().none_ref(py)),
+        }
+    }
+}
+
+impl<T: ToPyAst> ToPyAst for Vec<T> {
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let elts = self
+            .iter()
+            .map(|item| item.to_py_ast(py))
+            .collect::<Result<Vec<_>, _>>()?;
+        let list = PyList::new(py, elts);
+        Ok(list.into())
+    }
+}
+
+impl ToPyAst for ast::Identifier {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        Ok(PyString::new(py, self.as_str()).into())
+    }
+}
+
+impl ToPyAst for ast::String {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        Ok(PyString::new(py, self.as_str()).into())
+    }
+}
+
+impl ToPyAst for bool {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        Ok(ast_cache().bool_int(py, *self))
+    }
+}
+
+impl ToPyAst for ConversionFlag {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        Ok(ast_cache().conversion_flag(py, *self))
+    }
+}
+
+fn constant_to_object(constant: &ast::Constant, py: Python) -> PyObject {
+    let cache = ast_cache();
+    match constant {
+        ast::Constant::None => cache.none.clone_ref(py),
+        ast::Constant::Bool(bool) => cache.bool(py, *bool).into(),
+        ast::Constant::Str(string) => string.to_object(py),
+        ast::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
+        ast::Constant::Int(int) => int.to_object(py),
+        ast::Constant::Tuple(elts) => {
+            let elts: Vec<_> = elts.iter().map(|c| constant_to_object(c, py)).collect();
+            PyTuple::new(py, elts).into()
+        }
+        ast::Constant::Float(f64) => f64.to_object(py),
+        ast::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
+        ast::Constant::Ellipsis => py.Ellipsis(),
+    }
+}
+
+#[pyclass(module = "rustpython_ast", subclass)]
+pub struct Ast;
+
+#[pymethods]
+impl Ast {
+    #[new]
+    fn new() -> Self {
+        Self
+    }
+}
+
+fn cache_py_type<N: PyNode + Node>(ast_module: &PyAny) -> PyResult<()> {
+    let class = ast_module.getattr(N::NAME)?;
+    let base = if std::mem::size_of::<N>() == 0 {
+        class.call0()?
+    } else {
+        class.getattr("__new__")?
+    };
+    N::py_type_cache().get_or_init(|| (class.into(), base.into()));
+    Ok(())
+}
+
+// TODO: This cache must be bound to 'py
+struct AstCache {
+    lineno: Py<PyString>,
+    col_offset: Py<PyString>,
+    end_lineno: Py<PyString>,
+    end_col_offset: Py<PyString>,
+    none: Py<PyAny>,
+    bool_values: (Py<PyBool>, Py<PyBool>),
+    bool_int_values: (Py<PyAny>, Py<PyAny>),
+    conversion_flags: (Py<PyAny>, Py<PyAny>, Py<PyAny>, Py<PyAny>),
+}
+
+impl AstCache {
+    #[inline]
+    fn none_ref<'py>(&'static self, py: Python<'py>) -> &'py PyAny {
+        Py::<PyAny>::as_ref(&self.none, py)
+    }
+    #[inline]
+    fn bool_int<'py>(&'static self, py: Python<'py>, value: bool) -> &'py PyAny {
+        let v = &self.bool_int_values;
+        Py::<PyAny>::as_ref(if value { &v.1 } else { &v.0 }, py)
+    }
+    #[inline]
+    fn bool(&'static self, py: Python, value: bool) -> Py<PyBool> {
+        let v = &self.bool_values;
+        (if value { &v.1 } else { &v.0 }).clone_ref(py)
+    }
+    fn conversion_flag<'py>(&'static self, py: Python<'py>, value: ConversionFlag) -> &'py PyAny {
+        let v = &self.conversion_flags;
+        match value {
+            ConversionFlag::None => v.0.as_ref(py),
+            ConversionFlag::Str => v.1.as_ref(py),
+            ConversionFlag::Ascii => v.2.as_ref(py),
+            ConversionFlag::Repr => v.3.as_ref(py),
+        }
+    }
+}
+
+fn ast_cache_cell() -> &'static OnceCell<AstCache> {
+    {
+        static PY_TYPE: OnceCell<AstCache> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+fn ast_cache() -> &'static AstCache {
+    ast_cache_cell().get().unwrap()
+}
+
+pub fn init(py: Python) -> PyResult<()> {
+    ast_cache_cell().get_or_init(|| AstCache {
+        lineno: pyo3::intern!(py, "lineno").into_py(py),
+        col_offset: pyo3::intern!(py, "col_offset").into_py(py),
+        end_lineno: pyo3::intern!(py, "end_lineno").into_py(py),
+        end_col_offset: pyo3::intern!(py, "end_col_offset").into_py(py),
+        none: py.None(),
+        bool_values: (PyBool::new(py, false).into(), PyBool::new(py, true).into()),
+        bool_int_values: ((0).to_object(py), (1).to_object(py)),
+        conversion_flags: (
+            (-1).to_object(py),
+            (b's').to_object(py),
+            (b'a').to_object(py),
+            (b'r').to_object(py),
+        ),
+    });
+
+    init_types(py)
+}
+
+include!("gen/to_py_ast.rs");
diff --git a/ast-pyo3/src/wrapper.rs b/ast-pyo3/src/wrapper.rs
new file mode 100644
index 00000000..9a8b1152
--- /dev/null
+++ b/ast-pyo3/src/wrapper.rs
@@ -0,0 +1,141 @@
+use crate::PyNode;
+use num_complex::Complex64;
+use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyList, PyTuple};
+use rustpython_ast::{
+    self as ast, source_code::SourceRange, text_size::TextRange, ConversionFlag, Node,
+};
+
+pub trait ToPyWrapper {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>>;
+}
+
+impl<T: ToPyWrapper> ToPyWrapper for Box<T> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        (**self).to_py_wrapper(py)
+    }
+}
+
+impl<T: ToPyWrapper> ToPyWrapper for Option<T> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        match self {
+            Some(ast) => ast.to_py_wrapper(py),
+            None => Ok(py.None()),
+        }
+    }
+}
+
+impl ToPyWrapper for ast::Identifier {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(self.as_str().to_object(py))
+    }
+}
+
+impl ToPyWrapper for ast::String {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(self.as_str().to_object(py))
+    }
+}
+
+impl ToPyWrapper for ast::Int {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok((self.to_u32()).to_object(py))
+    }
+}
+
+impl ToPyWrapper for bool {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok((*self as u32).to_object(py))
+    }
+}
+
+impl ToPyWrapper for ConversionFlag {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok((*self as i8).to_object(py))
+    }
+}
+
+impl ToPyWrapper for ast::Constant {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        let value = match self {
+            ast::Constant::None => py.None(),
+            ast::Constant::Bool(bool) => bool.to_object(py),
+            ast::Constant::Str(string) => string.to_object(py),
+            ast::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
+            ast::Constant::Int(int) => int.to_object(py),
+            ast::Constant::Tuple(elts) => {
+                let elts: PyResult<Vec<_>> = elts.iter().map(|c| c.to_py_wrapper(py)).collect();
+                PyTuple::new(py, elts?).into()
+            }
+            ast::Constant::Float(f64) => f64.to_object(py),
+            ast::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
+            ast::Constant::Ellipsis => py.Ellipsis(),
+        };
+        Ok(value)
+    }
+}
+
+impl<T: ToPyWrapper> ToPyWrapper for Vec<T> {
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        let list = PyList::empty(py);
+        for item in self {
+            let py_item = item.to_py_wrapper(py)?;
+            list.append(py_item)?;
+        }
+        Ok(list.into())
+    }
+}
+
+#[pyclass(module = "rustpython_ast", subclass)]
+pub struct Ast;
+
+#[pymethods]
+impl Ast {
+    #[new]
+    fn new() -> Self {
+        Self
+    }
+}
+
+pub mod located {
+    pub use super::Ast;
+    use super::*;
+    include!("gen/wrapper_located.rs");
+}
+
+pub mod ranged {
+    pub use super::Ast;
+    use super::*;
+    include!("gen/wrapper_ranged.rs");
+}
+
+fn init_type<P: pyo3::PyClass, N: PyNode + Node>(py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_class::<P>()?;
+    let node = m.getattr(P::NAME)?;
+    if P::NAME != N::NAME {
+        // TODO: no idea how to escape rust keyword on #[pyclass]
+        m.setattr(P::NAME, node)?;
+    }
+    let names: Vec<&'static str> = N::FIELD_NAMES.to_vec();
+    let fields = PyTuple::new(py, names);
+    node.setattr("_fields", fields)?;
+    Ok(())
+}
+
+/// A Python module implemented in Rust.
+fn init_module(py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_class::<Ast>()?;
+
+    let ast = m.getattr("AST")?;
+    let fields = PyTuple::empty(py);
+    ast.setattr("_fields", fields)?;
+
+    Ok(())
+}
diff --git a/ast/Cargo.toml b/ast/Cargo.toml
index bee7c188..cedfa50e 100644
--- a/ast/Cargo.toml
+++ b/ast/Cargo.toml
@@ -15,11 +15,6 @@ fold = []
 unparse = ["rustpython-literal"]
 visitor = []
 all-nodes-with-ranges = []
-pyo3 = ["dep:pyo3", "num-complex", "once_cell"]
-
-# This feature is experimental
-# It reimplements AST types, but currently both slower than python AST types and limited to use in other API
-pyo3-wrapper = ["pyo3"]
 
 [dependencies]
 rustpython-parser-core = { workspace = true }
@@ -28,6 +23,5 @@ rustpython-literal = { workspace = true, optional = true }
 is-macro = { workspace = true }
 num-bigint = { workspace = true }
 static_assertions = "1.1.0"
-num-complex = { workspace = true, optional = true }
-once_cell = { workspace = true, optional = true }
+
 pyo3 = { workspace = true, optional = true, features = ["num-bigint", "num-complex"] }
diff --git a/ast/asdl_rs.py b/ast/asdl_rs.py
index 7f0edd26..9fc36393 100755
--- a/ast/asdl_rs.py
+++ b/ast/asdl_rs.py
@@ -300,10 +300,13 @@ def emit_range(self, has_attributes, depth):
 
     def visitModule(self, mod):
         self.emit_attrs(0)
-        self.emit("""
+        self.emit(
+            """
         #[derive(is_macro::Is)]
         pub enum Ast<R=TextRange> {
-        """, 0)
+        """,
+            0,
+        )
         for dfn in mod.dfns:
             rust_name = rust_type_name(dfn.name)
             generics = "" if self.type_info[dfn.name].is_simple else "<R>"
@@ -315,23 +318,29 @@ def visitModule(self, mod):
                 # "ast_" prefix to everywhere seems less useful.
                 self.emit('#[is(name = "module")]', 1)
             self.emit(f"{rust_name}({rust_name}{generics}),", 1)
-        self.emit("""
-        }
-        impl<R> Node for Ast<R> {
-            const NAME: &'static str = "AST";
-            const FIELD_NAMES: &'static [&'static str] = &[];
-        }
-        """, 0)
+        self.emit(
+            """
+            }
+            impl<R> Node for Ast<R> {
+                const NAME: &'static str = "AST";
+                const FIELD_NAMES: &'static [&'static str] = &[];
+            }
+            """,
+            0,
+        )
         for dfn in mod.dfns:
             rust_name = rust_type_name(dfn.name)
             generics = "" if self.type_info[dfn.name].is_simple else "<R>"
-            self.emit(f"""
+            self.emit(
+                f"""
             impl<R> From<{rust_name}{generics}> for Ast<R> {{
                 fn from(node: {rust_name}{generics}) -> Self {{
                     Ast::{rust_name}(node)
                 }}
             }}
-            """, 0)
+            """,
+                0,
+            )
 
         for dfn in mod.dfns:
             self.visit(dfn)
@@ -663,9 +672,7 @@ def visitConstructor(self, cons, type, depth):
 
         cons_type_name = f"{enum_name}{cons.name}"
 
-        self.emit(
-            f"impl<T, U> Foldable<T, U> for {cons_type_name}{apply_t} {{", depth
-        )
+        self.emit(f"impl<T, U> Foldable<T, U> for {cons_type_name}{apply_t} {{", depth)
         self.emit(f"type Mapped = {cons_type_name}{apply_u};", depth + 1)
         self.emit(
             "fn fold<F: Fold<T, TargetU = U> + ?Sized>(self, folder: &mut F) -> Result<Self::Mapped, F::Error> {",
@@ -1095,16 +1102,16 @@ def visitSum(self, sum, type):
 
         self.emit(
             f"""
-            impl ToPyo3Ast for crate::generic::{rust_name}{self.generics} {{
+            impl ToPyAst for ast::{rust_name}{self.generics} {{
                 #[inline]
-                fn to_pyo3_ast(&self, {"_" if simple else ""}py: Python) -> PyResult<Py<PyAny>> {{
+                fn to_py_ast<'py>(&self, {"_" if simple else ""}py: Python<'py>) -> PyResult<&'py PyAny> {{
                     let instance = match &self {{
             """,
             0,
         )
         for cons in sum.types:
             self.emit(
-                f"crate::{rust_name}::{cons.name}(cons) => cons.to_pyo3_ast(py)?,",
+                f"ast::{rust_name}::{cons.name}(cons) => cons.to_py_ast(py)?,",
                 1,
             )
         self.emit(
@@ -1128,9 +1135,9 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
         type_info = self.type_info[type.name]
         self.emit(
             f"""
-            impl ToPyo3Ast for crate::{name}{self.generics} {{
+            impl ToPyAst for ast::{name}{self.generics} {{
                 #[inline]
-                    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {{
+                    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {{
                         let cache = Self::py_type_cache().get().unwrap();
             """,
             0,
@@ -1144,12 +1151,39 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
                 1,
             )
             self.emit(
-                "let instance = cache.0.call1(py, (",
+                """
+                let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+                """,
                 1,
             )
             for field in cons.fields:
+                if field.type == "constant":
+                    self.emit(
+                        f"constant_to_object({rust_field(field.name)}, py),",
+                        3,
+                    )
+                    continue
+                if field.type == "int":
+                    if field.name == "level":
+                        assert field.opt
+                        self.emit(
+                            f"{rust_field(field.name)}.map_or_else(|| py.None(), |level| level.to_u32().to_object(py)),",
+                            3,
+                        )
+                        continue
+                    if field.name in (
+                        "lineno",
+                        "col_offset",
+                        "end_lineno",
+                        "end_col_offset",
+                    ):
+                        self.emit(
+                            f"{rust_field(field.name)}.to_u32().to_object(py),",
+                            3,
+                        )
+                        continue
                 self.emit(
-                    f"{rust_field(field.name)}.to_pyo3_ast(py)?,",
+                    f"{rust_field(field.name)}.to_py_ast(py)?,",
                     3,
                 )
             self.emit(
@@ -1158,7 +1192,7 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
             )
         else:
             self.emit(
-                "let instance = cache.0.call0(py)?;",
+                "let instance = Py::<PyAny>::as_ref(&cache.0, py).call0()?;",
                 1,
             )
             self.emit(
@@ -1168,12 +1202,12 @@ def emit_to_pyo3_with_fields(self, cons, type, name):
         if type.value.attributes and self.namespace == "located":
             self.emit(
                 """
-                let cache = ast_key_cache().get().unwrap();
-                instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-                instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
+                let cache = ast_cache();
+                instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+                instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
                 if let Some(end) = _range.end {
-                    instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-                    instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
+                    instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+                    instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
                 }
                 """,
                 1,
@@ -1218,7 +1252,7 @@ def ref_def(self):
     def ref(self):
         return "&" if self.borrow else ""
 
-    def emit_class(self, name, rust_name, simple, base="super::AST"):
+    def emit_class(self, name, rust_name, simple, base="super::Ast"):
         info = self.type_info[name]
         if simple:
             generics = ""
@@ -1230,7 +1264,7 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
             into = f"{rust_name}"
         else:
             subclass = ""
-            body = f"(pub {self.ref_def} crate::{rust_name}{generics})"
+            body = f"(pub {self.ref_def} ast::{rust_name}{generics})"
             into = f"{rust_name}(node)"
 
         self.emit(
@@ -1239,8 +1273,8 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
             #[derive(Clone, Debug)]
             pub struct {rust_name} {body};
 
-            impl From<{self.ref_def} crate::{rust_name}{generics}> for {rust_name} {{
-                fn from({"" if body else "_"}node: {self.ref_def} crate::{rust_name}{generics}) -> Self {{
+            impl From<{self.ref_def} ast::{rust_name}{generics}> for {rust_name} {{
+                fn from({"" if body else "_"}node: {self.ref_def} ast::{rust_name}{generics}) -> Self {{
                     {into}
                 }}
             }}
@@ -1254,7 +1288,7 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
                 impl {rust_name} {{
                     #[new]
                     fn new() -> PyClassInitializer<Self> {{
-                        PyClassInitializer::from(AST)
+                        PyClassInitializer::from(Ast)
                             .add_subclass(Self)
                     }}
 
@@ -1269,7 +1303,7 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
                 0,
             )
         else:
-            if base != "super::AST":
+            if base != "super::Ast":
                 add_subclass = f".add_subclass({base})"
             else:
                 add_subclass = ""
@@ -1277,7 +1311,7 @@ def emit_class(self, name, rust_name, simple, base="super::AST"):
                 f"""
                 impl ToPyObject for {rust_name} {{
                     fn to_object(&self, py: Python) -> PyObject {{
-                        let initializer = PyClassInitializer::from(AST)
+                        let initializer = PyClassInitializer::from(Ast)
                         {add_subclass}
                         .add_subclass(self.clone());
                         Py::new(py, initializer).unwrap().into_py(py)
@@ -1305,7 +1339,7 @@ def emit_getter(self, owner, type_name):
                 #[getter]
                 #[inline]
                 fn get_{field.name}(&self, py: Python) -> PyResult<PyObject> {{
-                    self.0.{rust_field(field.name)}.to_pyo3_wrapper(py)
+                    self.0.{rust_field(field.name)}.to_py_wrapper(py)
                 }}
                 """,
                 3,
@@ -1331,7 +1365,7 @@ def emit_getattr(self, owner, type_name):
 
         for field in owner.fields:
             self.emit(
-                f'"{field.name}" => self.0.{rust_field(field.name)}.to_pyo3_wrapper(py)?,',
+                f'"{field.name}" => self.0.{rust_field(field.name)}.to_py_wrapper(py)?,',
                 3,
             )
 
@@ -1349,9 +1383,9 @@ def emit_getattr(self, owner, type_name):
     def emit_wrapper(self, rust_name):
         self.emit(
             f"""
-            impl ToPyo3Wrapper for crate::{rust_name}{self.generics} {{
+            impl ToPyWrapper for ast::{rust_name}{self.generics} {{
                 #[inline]
-                fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
+                fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
                     Ok({rust_name}(self).to_object(py))
                 }}
             }}
@@ -1375,16 +1409,16 @@ def visitSum(self, sum, type, depth=0):
         if not simple:
             self.emit(
                 f"""
-                impl ToPyo3Wrapper for crate::{rust_name}{self.generics} {{
+                impl ToPyWrapper for ast::{rust_name}{self.generics} {{
                     #[inline]
-                    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
+                    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {{
                         match &self {{
                 """,
                 0,
             )
 
             for cons in sum.types:
-                self.emit(f"Self::{cons.name}(cons) => cons.to_pyo3_wrapper(py),", 3)
+                self.emit(f"Self::{cons.name}(cons) => cons.to_py_wrapper(py),", 3)
 
             self.emit(
                 """
@@ -1413,7 +1447,7 @@ def visitConstructor(self, cons, parent, simple, depth):
 
                 impl ToPyObject for {parent}{cons.name} {{
                     fn to_object(&self, py: Python) -> PyObject {{
-                        let initializer = PyClassInitializer::from(AST)
+                        let initializer = PyClassInitializer::from(Ast)
                         .add_subclass({parent})
                         .add_subclass(Self);
                         Py::new(py, initializer).unwrap().into_py(py)
@@ -1462,9 +1496,7 @@ def visitConstructor(self, cons, parent, simple, depth):
         self.emit_fields(cons.name, rust_name, simple)
 
     def emit_fields(self, name, rust_name, simple):
-        self.emit(
-            f"super::init_type::<{rust_name}, crate::generic::{rust_name}>(py, m)?;", 1
-        )
+        self.emit(f"super::init_type::<{rust_name}, ast::{rust_name}>(py, m)?;", 1)
 
 
 class StdlibClassDefVisitor(EmitVisitor):
@@ -1812,7 +1844,7 @@ def write(info: TypeInfo):
 
         f.write(
             f"""
-            impl{generics} Pyo3Node for crate::generic::{rust_name}{generics} {{
+            impl{generics} PyNode for ast::{rust_name}{generics} {{
                 #[inline]
                 fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {{
                     static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
@@ -1842,7 +1874,7 @@ def write_to_pyo3(mod, type_info, f):
 
     for info in type_info.values():
         rust_name = info.rust_sum_name
-        f.write(f"cache_py_type::<crate::generic::{rust_name}>(ast_module)?;\n")
+        f.write(f"cache_py_type::<ast::{rust_name}>(ast_module)?;\n")
     f.write("Ok(())\n}")
 
 
@@ -1856,20 +1888,20 @@ def write_to_pyo3_simple(type_info, f):
         rust_name = type_info.rust_sum_name
         f.write(
             f"""
-            impl ToPyo3Ast for crate::generic::{rust_name} {{
+            impl ToPyAst for ast::{rust_name} {{
                 #[inline]
-                fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {{
+                fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {{
                     let cell = match &self {{
             """,
         )
         for cons in type_info.type.value.types:
             f.write(
-                f"""crate::{rust_name}::{cons.name} => crate::{rust_name}{cons.name}::py_type_cache(),""",
+                f"""ast::{rust_name}::{cons.name} => ast::{rust_name}{cons.name}::py_type_cache(),""",
             )
         f.write(
             """
                     };
-                    Ok(cell.get().unwrap().1.clone())
+                    Ok(Py::<PyAny>::as_ref(&cell.get().unwrap().1, py))
                 }
             }
             """,
@@ -1887,9 +1919,9 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
             rust_name = type_info.rust_sum_name
             f.write(
                 f"""
-                impl ToPyo3Wrapper for crate::generic::{rust_name} {{
+                impl ToPyWrapper for ast::{rust_name} {{
                     #[inline]
-                    fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
+                    fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
                         match &self {{
                 """,
             )
@@ -1908,9 +1940,9 @@ def write_pyo3_wrapper(mod, type_info, namespace, f):
             for cons in type_info.type.value.types:
                 f.write(
                     f"""
-                    impl ToPyo3Wrapper for crate::generic::{rust_name}{cons.name} {{
+                    impl ToPyWrapper for ast::{rust_name}{cons.name} {{
                         #[inline]
-                        fn to_pyo3_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
+                        fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {{
                             Ok({rust_name}{cons.name}.to_object(py))
                         }}
                     }}
@@ -1949,6 +1981,7 @@ def write_ast_mod(mod, type_info, f):
 def main(
     input_filename,
     ast_dir,
+    ast_pyo3_dir,
     module_filename,
     dump_module=False,
 ):
@@ -1971,14 +2004,20 @@ def main(
         ("ranged", p(write_ranged_def, mod, type_info)),
         ("located", p(write_located_def, mod, type_info)),
         ("visitor", p(write_visitor_def, mod, type_info)),
-        ("to_pyo3", p(write_to_pyo3, mod, type_info)),
-        ("pyo3_wrapper_located", p(write_pyo3_wrapper, mod, type_info, "located")),
-        ("pyo3_wrapper_ranged", p(write_pyo3_wrapper, mod, type_info, "ranged")),
     ]:
         with (ast_dir / f"{filename}.rs").open("w") as f:
             f.write(auto_gen_msg)
             write(f)
 
+    for filename, write in [
+        ("to_py_ast", p(write_to_pyo3, mod, type_info)),
+        ("wrapper_located", p(write_pyo3_wrapper, mod, type_info, "located")),
+        ("wrapper_ranged", p(write_pyo3_wrapper, mod, type_info, "ranged")),
+    ]:
+        with (ast_pyo3_dir / f"{filename}.rs").open("w") as f:
+            f.write(auto_gen_msg)
+            write(f)
+
     with module_filename.open("w") as module_file:
         module_file.write(auto_gen_msg)
         write_ast_mod(mod, type_info, module_file)
@@ -1990,6 +2029,7 @@ def main(
     parser = ArgumentParser()
     parser.add_argument("input_file", type=Path)
     parser.add_argument("-A", "--ast-dir", type=Path, required=True)
+    parser.add_argument("-O", "--ast-pyo3-dir", type=Path, required=True)
     parser.add_argument("-M", "--module-file", type=Path, required=True)
     parser.add_argument("-d", "--dump-module", action="store_true")
 
@@ -1997,6 +2037,7 @@ def main(
     main(
         args.input_file,
         args.ast_dir,
+        args.ast_pyo3_dir,
         args.module_file,
         args.dump_module,
     )
diff --git a/ast/src/gen/to_pyo3.rs b/ast/src/gen/to_pyo3.rs
deleted file mode 100644
index c8a7478f..00000000
--- a/ast/src/gen/to_pyo3.rs
+++ /dev/null
@@ -1,4937 +0,0 @@
-// File automatically generated by ast/asdl_rs.py.
-
-impl<R> Pyo3Node for crate::generic::Mod<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ModModule<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ModInteractive<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ModExpression<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ModFunctionType<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Stmt<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtFunctionDef<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtAsyncFunctionDef<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtClassDef<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtReturn<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtDelete<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtAssign<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtAugAssign<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtAnnAssign<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtFor<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtAsyncFor<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtWhile<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtIf<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtWith<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtAsyncWith<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtMatch<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtRaise<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtTry<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtTryStar<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtAssert<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtImport<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtImportFrom<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtGlobal<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtNonlocal<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtExpr<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtPass<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtBreak<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::StmtContinue<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Expr<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprBoolOp<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprNamedExpr<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprBinOp<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprUnaryOp<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprLambda<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprIfExp<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprDict<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprSet<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprListComp<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprSetComp<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprDictComp<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprGeneratorExp<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprAwait<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprYield<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprYieldFrom<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprCompare<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprCall<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprFormattedValue<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprJoinedStr<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprConstant<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprAttribute<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprSubscript<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprStarred<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprName<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprList<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprTuple<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExprSlice<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::ExprContext {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::ExprContextLoad {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::ExprContextStore {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::ExprContextDel {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::Boolop {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::BoolopAnd {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::BoolopOr {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::Operator {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorAdd {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorSub {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorMult {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorMatMult {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorDiv {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorMod {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorPow {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorLShift {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorRShift {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorBitOr {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorBitXor {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorBitAnd {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::OperatorFloorDiv {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::Unaryop {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::UnaryopInvert {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::UnaryopNot {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::UnaryopUAdd {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::UnaryopUSub {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::Cmpop {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopEq {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopNotEq {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopLt {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopLtE {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopGt {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopGtE {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopIs {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopIsNot {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopIn {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl Pyo3Node for crate::generic::CmpopNotIn {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Comprehension<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Excepthandler<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::ExcepthandlerExceptHandler<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Arguments<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Arg<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Keyword<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Alias<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Withitem<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::MatchCase<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::Pattern<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::PatternMatchValue<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::PatternMatchSingleton<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::PatternMatchSequence<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::PatternMatchMapping<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::PatternMatchClass<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::PatternMatchStar<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::PatternMatchAs<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::PatternMatchOr<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::TypeIgnore<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl<R> Pyo3Node for crate::generic::TypeIgnoreTypeIgnore<R> {
-    #[inline]
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-impl ToPyo3Ast for crate::generic::ExprContext {
-    #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
-        let cell = match &self {
-            crate::ExprContext::Load => crate::ExprContextLoad::py_type_cache(),
-            crate::ExprContext::Store => crate::ExprContextStore::py_type_cache(),
-            crate::ExprContext::Del => crate::ExprContextDel::py_type_cache(),
-        };
-        Ok(cell.get().unwrap().1.clone())
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Boolop {
-    #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
-        let cell = match &self {
-            crate::Boolop::And => crate::BoolopAnd::py_type_cache(),
-            crate::Boolop::Or => crate::BoolopOr::py_type_cache(),
-        };
-        Ok(cell.get().unwrap().1.clone())
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Operator {
-    #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
-        let cell = match &self {
-            crate::Operator::Add => crate::OperatorAdd::py_type_cache(),
-            crate::Operator::Sub => crate::OperatorSub::py_type_cache(),
-            crate::Operator::Mult => crate::OperatorMult::py_type_cache(),
-            crate::Operator::MatMult => crate::OperatorMatMult::py_type_cache(),
-            crate::Operator::Div => crate::OperatorDiv::py_type_cache(),
-            crate::Operator::Mod => crate::OperatorMod::py_type_cache(),
-            crate::Operator::Pow => crate::OperatorPow::py_type_cache(),
-            crate::Operator::LShift => crate::OperatorLShift::py_type_cache(),
-            crate::Operator::RShift => crate::OperatorRShift::py_type_cache(),
-            crate::Operator::BitOr => crate::OperatorBitOr::py_type_cache(),
-            crate::Operator::BitXor => crate::OperatorBitXor::py_type_cache(),
-            crate::Operator::BitAnd => crate::OperatorBitAnd::py_type_cache(),
-            crate::Operator::FloorDiv => crate::OperatorFloorDiv::py_type_cache(),
-        };
-        Ok(cell.get().unwrap().1.clone())
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Unaryop {
-    #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
-        let cell = match &self {
-            crate::Unaryop::Invert => crate::UnaryopInvert::py_type_cache(),
-            crate::Unaryop::Not => crate::UnaryopNot::py_type_cache(),
-            crate::Unaryop::UAdd => crate::UnaryopUAdd::py_type_cache(),
-            crate::Unaryop::USub => crate::UnaryopUSub::py_type_cache(),
-        };
-        Ok(cell.get().unwrap().1.clone())
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Cmpop {
-    #[inline]
-    fn to_pyo3_ast(&self, _py: Python) -> PyResult<Py<PyAny>> {
-        let cell = match &self {
-            crate::Cmpop::Eq => crate::CmpopEq::py_type_cache(),
-            crate::Cmpop::NotEq => crate::CmpopNotEq::py_type_cache(),
-            crate::Cmpop::Lt => crate::CmpopLt::py_type_cache(),
-            crate::Cmpop::LtE => crate::CmpopLtE::py_type_cache(),
-            crate::Cmpop::Gt => crate::CmpopGt::py_type_cache(),
-            crate::Cmpop::GtE => crate::CmpopGtE::py_type_cache(),
-            crate::Cmpop::Is => crate::CmpopIs::py_type_cache(),
-            crate::Cmpop::IsNot => crate::CmpopIsNot::py_type_cache(),
-            crate::Cmpop::In => crate::CmpopIn::py_type_cache(),
-            crate::Cmpop::NotIn => crate::CmpopNotIn::py_type_cache(),
-        };
-        Ok(cell.get().unwrap().1.clone())
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Mod<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Mod::Module(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::Interactive(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::Expression(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::FunctionType(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ModModule<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            type_ignores,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (body.to_pyo3_ast(py)?, type_ignores.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ModInteractive<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (body.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ModExpression<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (body.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ModFunctionType<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            argtypes,
-            returns,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (argtypes.to_pyo3_ast(py)?, returns.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Stmt<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Stmt::FunctionDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncFunctionDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::ClassDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Return(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Delete(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Assign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AugAssign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AnnAssign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::For(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncFor(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::While(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::If(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::With(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncWith(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Match(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Raise(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Try(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::TryStar(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Assert(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Import(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::ImportFrom(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Global(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Nonlocal(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Expr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Pass(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Break(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Continue(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtFunctionDef<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            args,
-            body,
-            decorator_list,
-            returns,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-                returns.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAsyncFunctionDef<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            args,
-            body,
-            decorator_list,
-            returns,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-                returns.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtClassDef<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            bases,
-            keywords,
-            body,
-            decorator_list,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                bases.to_pyo3_ast(py)?,
-                keywords.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtReturn<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtDelete<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            targets,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (targets.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAssign<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            targets,
-            value,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                targets.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAugAssign<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            op,
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                op.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAnnAssign<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            annotation,
-            value,
-            simple,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                annotation.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                simple.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtFor<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            iter,
-            body,
-            orelse,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAsyncFor<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            iter,
-            body,
-            orelse,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtWhile<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            test,
-            body,
-            orelse,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtIf<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            test,
-            body,
-            orelse,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtWith<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            items,
-            body,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                items.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAsyncWith<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            items,
-            body,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                items.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtMatch<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            subject,
-            cases,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (subject.to_pyo3_ast(py)?, cases.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtRaise<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            exc,
-            cause,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (exc.to_pyo3_ast(py)?, cause.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtTry<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                body.to_pyo3_ast(py)?,
-                handlers.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                finalbody.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtTryStar<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                body.to_pyo3_ast(py)?,
-                handlers.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                finalbody.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAssert<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            test,
-            msg,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (test.to_pyo3_ast(py)?, msg.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtImport<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtImportFrom<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            module,
-            names,
-            level,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                module.to_pyo3_ast(py)?,
-                names.to_pyo3_ast(py)?,
-                level.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtGlobal<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtNonlocal<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtExpr<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtPass<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let instance = cache.0.call0(py)?;
-        let Self { range: _range } = self;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtBreak<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let instance = cache.0.call0(py)?;
-        let Self { range: _range } = self;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtContinue<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let instance = cache.0.call0(py)?;
-        let Self { range: _range } = self;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Expr<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Expr::BoolOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::NamedExpr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::BinOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::UnaryOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Lambda(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::IfExp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Dict(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Set(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::ListComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::SetComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::DictComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::GeneratorExp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Await(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Yield(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::YieldFrom(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Compare(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Call(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::FormattedValue(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::JoinedStr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Constant(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Attribute(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Subscript(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Starred(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Name(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::List(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Tuple(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Slice(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprBoolOp<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            op,
-            values,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (op.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprNamedExpr<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            value,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (target.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprBinOp<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            left,
-            op,
-            right,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                left.to_pyo3_ast(py)?,
-                op.to_pyo3_ast(py)?,
-                right.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprUnaryOp<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            op,
-            operand,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (op.to_pyo3_ast(py)?, operand.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprLambda<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            args,
-            body,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (args.to_pyo3_ast(py)?, body.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprIfExp<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            test,
-            body,
-            orelse,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprDict<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            keys,
-            values,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (keys.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprSet<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elts,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (elts.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprListComp<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elt,
-            generators,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprSetComp<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elt,
-            generators,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprDictComp<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            key,
-            value,
-            generators,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                key.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                generators.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprGeneratorExp<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elt,
-            generators,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprAwait<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprYield<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprYieldFrom<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprCompare<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            left,
-            ops,
-            comparators,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                left.to_pyo3_ast(py)?,
-                ops.to_pyo3_ast(py)?,
-                comparators.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprCall<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            func,
-            args,
-            keywords,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                func.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                keywords.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprFormattedValue<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            conversion,
-            format_spec,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                conversion.to_pyo3_ast(py)?,
-                format_spec.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprJoinedStr<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            values,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (values.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprConstant<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            kind,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (value.to_pyo3_ast(py)?, kind.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprAttribute<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            attr,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                attr.to_pyo3_ast(py)?,
-                ctx.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprSubscript<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            slice,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                slice.to_pyo3_ast(py)?,
-                ctx.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprStarred<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (value.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprName<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            id,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (id.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprList<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elts,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprTuple<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elts,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprSlice<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            lower,
-            upper,
-            step,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                lower.to_pyo3_ast(py)?,
-                upper.to_pyo3_ast(py)?,
-                step.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Comprehension<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            iter,
-            ifs,
-            is_async,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                ifs.to_pyo3_ast(py)?,
-                is_async.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Excepthandler<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Excepthandler::ExceptHandler(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            type_,
-            name,
-            body,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                type_.to_pyo3_ast(py)?,
-                name.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Arguments<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            posonlyargs,
-            args,
-            vararg,
-            kwonlyargs,
-            kw_defaults,
-            kwarg,
-            defaults,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                posonlyargs.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                vararg.to_pyo3_ast(py)?,
-                kwonlyargs.to_pyo3_ast(py)?,
-                kw_defaults.to_pyo3_ast(py)?,
-                kwarg.to_pyo3_ast(py)?,
-                defaults.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Arg<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            arg,
-            annotation,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                arg.to_pyo3_ast(py)?,
-                annotation.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Keyword<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            arg,
-            value,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (arg.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Alias<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            asname,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (name.to_pyo3_ast(py)?, asname.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Withitem<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            context_expr,
-            optional_vars,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                context_expr.to_pyo3_ast(py)?,
-                optional_vars.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::MatchCase<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            pattern,
-            guard,
-            body,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                pattern.to_pyo3_ast(py)?,
-                guard.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Pattern<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Pattern::MatchValue(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchSingleton(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchSequence(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchMapping(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchClass(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchStar(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchAs(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchOr(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchValue<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchSingleton<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchSequence<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            patterns,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (patterns.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchMapping<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            keys,
-            patterns,
-            rest,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                keys.to_pyo3_ast(py)?,
-                patterns.to_pyo3_ast(py)?,
-                rest.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchClass<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            cls,
-            patterns,
-            kwd_attrs,
-            kwd_patterns,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                cls.to_pyo3_ast(py)?,
-                patterns.to_pyo3_ast(py)?,
-                kwd_attrs.to_pyo3_ast(py)?,
-                kwd_patterns.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchStar<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (name.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchAs<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            pattern,
-            name,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (pattern.to_pyo3_ast(py)?, name.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchOr<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            patterns,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (patterns.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::TypeIgnore<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::TypeIgnore::TypeIgnore(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<TextRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            lineno,
-            tag,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (lineno.to_pyo3_ast(py)?, tag.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Mod<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Mod::Module(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::Interactive(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::Expression(cons) => cons.to_pyo3_ast(py)?,
-            crate::Mod::FunctionType(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ModModule<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            type_ignores,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (body.to_pyo3_ast(py)?, type_ignores.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ModInteractive<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (body.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ModExpression<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (body.to_pyo3_ast(py)?,))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ModFunctionType<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            argtypes,
-            returns,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (argtypes.to_pyo3_ast(py)?, returns.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Stmt<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Stmt::FunctionDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncFunctionDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::ClassDef(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Return(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Delete(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Assign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AugAssign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AnnAssign(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::For(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncFor(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::While(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::If(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::With(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::AsyncWith(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Match(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Raise(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Try(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::TryStar(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Assert(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Import(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::ImportFrom(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Global(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Nonlocal(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Expr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Pass(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Break(cons) => cons.to_pyo3_ast(py)?,
-            crate::Stmt::Continue(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtFunctionDef<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            args,
-            body,
-            decorator_list,
-            returns,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-                returns.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAsyncFunctionDef<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            args,
-            body,
-            decorator_list,
-            returns,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-                returns.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtClassDef<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            bases,
-            keywords,
-            body,
-            decorator_list,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                name.to_pyo3_ast(py)?,
-                bases.to_pyo3_ast(py)?,
-                keywords.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                decorator_list.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtReturn<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtDelete<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            targets,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (targets.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAssign<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            targets,
-            value,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                targets.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAugAssign<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            op,
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                op.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAnnAssign<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            annotation,
-            value,
-            simple,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                annotation.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                simple.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtFor<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            iter,
-            body,
-            orelse,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAsyncFor<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            iter,
-            body,
-            orelse,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtWhile<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            test,
-            body,
-            orelse,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtIf<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            test,
-            body,
-            orelse,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtWith<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            items,
-            body,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                items.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAsyncWith<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            items,
-            body,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                items.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtMatch<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            subject,
-            cases,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (subject.to_pyo3_ast(py)?, cases.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtRaise<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            exc,
-            cause,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (exc.to_pyo3_ast(py)?, cause.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtTry<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                body.to_pyo3_ast(py)?,
-                handlers.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                finalbody.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtTryStar<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                body.to_pyo3_ast(py)?,
-                handlers.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-                finalbody.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtAssert<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            test,
-            msg,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (test.to_pyo3_ast(py)?, msg.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtImport<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtImportFrom<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            module,
-            names,
-            level,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                module.to_pyo3_ast(py)?,
-                names.to_pyo3_ast(py)?,
-                level.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtGlobal<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtNonlocal<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (names.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtExpr<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtPass<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let instance = cache.0.call0(py)?;
-        let Self { range: _range } = self;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtBreak<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let instance = cache.0.call0(py)?;
-        let Self { range: _range } = self;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::StmtContinue<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let instance = cache.0.call0(py)?;
-        let Self { range: _range } = self;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Expr<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Expr::BoolOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::NamedExpr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::BinOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::UnaryOp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Lambda(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::IfExp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Dict(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Set(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::ListComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::SetComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::DictComp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::GeneratorExp(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Await(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Yield(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::YieldFrom(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Compare(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Call(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::FormattedValue(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::JoinedStr(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Constant(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Attribute(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Subscript(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Starred(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Name(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::List(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Tuple(cons) => cons.to_pyo3_ast(py)?,
-            crate::Expr::Slice(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprBoolOp<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            op,
-            values,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (op.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprNamedExpr<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            value,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (target.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprBinOp<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            left,
-            op,
-            right,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                left.to_pyo3_ast(py)?,
-                op.to_pyo3_ast(py)?,
-                right.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprUnaryOp<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            op,
-            operand,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (op.to_pyo3_ast(py)?, operand.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprLambda<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            args,
-            body,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (args.to_pyo3_ast(py)?, body.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprIfExp<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            test,
-            body,
-            orelse,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                test.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-                orelse.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprDict<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            keys,
-            values,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (keys.to_pyo3_ast(py)?, values.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprSet<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elts,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (elts.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprListComp<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elt,
-            generators,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprSetComp<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elt,
-            generators,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprDictComp<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            key,
-            value,
-            generators,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                key.to_pyo3_ast(py)?,
-                value.to_pyo3_ast(py)?,
-                generators.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprGeneratorExp<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elt,
-            generators,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elt.to_pyo3_ast(py)?, generators.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprAwait<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprYield<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprYieldFrom<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprCompare<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            left,
-            ops,
-            comparators,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                left.to_pyo3_ast(py)?,
-                ops.to_pyo3_ast(py)?,
-                comparators.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprCall<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            func,
-            args,
-            keywords,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                func.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                keywords.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprFormattedValue<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            conversion,
-            format_spec,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                conversion.to_pyo3_ast(py)?,
-                format_spec.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprJoinedStr<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            values,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (values.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprConstant<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            kind,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (value.to_pyo3_ast(py)?, kind.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprAttribute<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            attr,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                attr.to_pyo3_ast(py)?,
-                ctx.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprSubscript<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            slice,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                value.to_pyo3_ast(py)?,
-                slice.to_pyo3_ast(py)?,
-                ctx.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprStarred<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (value.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprName<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            id,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (id.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprList<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elts,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprTuple<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            elts,
-            ctx,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (elts.to_pyo3_ast(py)?, ctx.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExprSlice<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            lower,
-            upper,
-            step,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                lower.to_pyo3_ast(py)?,
-                upper.to_pyo3_ast(py)?,
-                step.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Comprehension<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            target,
-            iter,
-            ifs,
-            is_async,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                target.to_pyo3_ast(py)?,
-                iter.to_pyo3_ast(py)?,
-                ifs.to_pyo3_ast(py)?,
-                is_async.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Excepthandler<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Excepthandler::ExceptHandler(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::ExcepthandlerExceptHandler<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            type_,
-            name,
-            body,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                type_.to_pyo3_ast(py)?,
-                name.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Arguments<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            posonlyargs,
-            args,
-            vararg,
-            kwonlyargs,
-            kw_defaults,
-            kwarg,
-            defaults,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                posonlyargs.to_pyo3_ast(py)?,
-                args.to_pyo3_ast(py)?,
-                vararg.to_pyo3_ast(py)?,
-                kwonlyargs.to_pyo3_ast(py)?,
-                kw_defaults.to_pyo3_ast(py)?,
-                kwarg.to_pyo3_ast(py)?,
-                defaults.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Arg<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            arg,
-            annotation,
-            type_comment,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                arg.to_pyo3_ast(py)?,
-                annotation.to_pyo3_ast(py)?,
-                type_comment.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Keyword<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            arg,
-            value,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (arg.to_pyo3_ast(py)?, value.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Alias<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            asname,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (name.to_pyo3_ast(py)?, asname.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::Withitem<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            context_expr,
-            optional_vars,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                context_expr.to_pyo3_ast(py)?,
-                optional_vars.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::MatchCase<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            pattern,
-            guard,
-            body,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                pattern.to_pyo3_ast(py)?,
-                guard.to_pyo3_ast(py)?,
-                body.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::Pattern<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::Pattern::MatchValue(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchSingleton(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchSequence(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchMapping(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchClass(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchStar(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchAs(cons) => cons.to_pyo3_ast(py)?,
-            crate::Pattern::MatchOr(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchValue<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchSingleton<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (value.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchSequence<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            patterns,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (patterns.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchMapping<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            keys,
-            patterns,
-            rest,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                keys.to_pyo3_ast(py)?,
-                patterns.to_pyo3_ast(py)?,
-                rest.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchClass<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            cls,
-            patterns,
-            kwd_attrs,
-            kwd_patterns,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(
-            py,
-            (
-                cls.to_pyo3_ast(py)?,
-                patterns.to_pyo3_ast(py)?,
-                kwd_attrs.to_pyo3_ast(py)?,
-                kwd_patterns.to_pyo3_ast(py)?,
-            ),
-        )?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchStar<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            name,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (name.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchAs<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            pattern,
-            name,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (pattern.to_pyo3_ast(py)?, name.to_pyo3_ast(py)?))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::PatternMatchOr<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            patterns,
-            range: _range,
-        } = self;
-        let instance = cache.0.call1(py, (patterns.to_pyo3_ast(py)?,))?;
-
-        let cache = ast_key_cache().get().unwrap();
-        instance.setattr(py, cache.lineno.as_ref(py), _range.start.row.get())?;
-        instance.setattr(py, cache.col_offset.as_ref(py), _range.start.column.get())?;
-        if let Some(end) = _range.end {
-            instance.setattr(py, cache.end_lineno.as_ref(py), end.row.get())?;
-            instance.setattr(py, cache.end_col_offset.as_ref(py), end.column.get())?;
-        }
-
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::generic::TypeIgnore<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let instance = match &self {
-            crate::TypeIgnore::TypeIgnore(cons) => cons.to_pyo3_ast(py)?,
-        };
-        Ok(instance)
-    }
-}
-
-impl ToPyo3Ast for crate::TypeIgnoreTypeIgnore<SourceRange> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let cache = Self::py_type_cache().get().unwrap();
-
-        let Self {
-            lineno,
-            tag,
-            range: _range,
-        } = self;
-        let instance = cache
-            .0
-            .call1(py, (lineno.to_pyo3_ast(py)?, tag.to_pyo3_ast(py)?))?;
-
-        Ok(instance)
-    }
-}
-
-fn init_types(py: Python) -> PyResult<()> {
-    let ast_module = PyModule::import(py, "_ast")?;
-    cache_py_type::<crate::generic::Mod>(ast_module)?;
-    cache_py_type::<crate::generic::ModModule>(ast_module)?;
-    cache_py_type::<crate::generic::ModInteractive>(ast_module)?;
-    cache_py_type::<crate::generic::ModExpression>(ast_module)?;
-    cache_py_type::<crate::generic::ModFunctionType>(ast_module)?;
-    cache_py_type::<crate::generic::Stmt>(ast_module)?;
-    cache_py_type::<crate::generic::StmtFunctionDef>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAsyncFunctionDef>(ast_module)?;
-    cache_py_type::<crate::generic::StmtClassDef>(ast_module)?;
-    cache_py_type::<crate::generic::StmtReturn>(ast_module)?;
-    cache_py_type::<crate::generic::StmtDelete>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAssign>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAugAssign>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAnnAssign>(ast_module)?;
-    cache_py_type::<crate::generic::StmtFor>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAsyncFor>(ast_module)?;
-    cache_py_type::<crate::generic::StmtWhile>(ast_module)?;
-    cache_py_type::<crate::generic::StmtIf>(ast_module)?;
-    cache_py_type::<crate::generic::StmtWith>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAsyncWith>(ast_module)?;
-    cache_py_type::<crate::generic::StmtMatch>(ast_module)?;
-    cache_py_type::<crate::generic::StmtRaise>(ast_module)?;
-    cache_py_type::<crate::generic::StmtTry>(ast_module)?;
-    cache_py_type::<crate::generic::StmtTryStar>(ast_module)?;
-    cache_py_type::<crate::generic::StmtAssert>(ast_module)?;
-    cache_py_type::<crate::generic::StmtImport>(ast_module)?;
-    cache_py_type::<crate::generic::StmtImportFrom>(ast_module)?;
-    cache_py_type::<crate::generic::StmtGlobal>(ast_module)?;
-    cache_py_type::<crate::generic::StmtNonlocal>(ast_module)?;
-    cache_py_type::<crate::generic::StmtExpr>(ast_module)?;
-    cache_py_type::<crate::generic::StmtPass>(ast_module)?;
-    cache_py_type::<crate::generic::StmtBreak>(ast_module)?;
-    cache_py_type::<crate::generic::StmtContinue>(ast_module)?;
-    cache_py_type::<crate::generic::Expr>(ast_module)?;
-    cache_py_type::<crate::generic::ExprBoolOp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprNamedExpr>(ast_module)?;
-    cache_py_type::<crate::generic::ExprBinOp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprUnaryOp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprLambda>(ast_module)?;
-    cache_py_type::<crate::generic::ExprIfExp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprDict>(ast_module)?;
-    cache_py_type::<crate::generic::ExprSet>(ast_module)?;
-    cache_py_type::<crate::generic::ExprListComp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprSetComp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprDictComp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprGeneratorExp>(ast_module)?;
-    cache_py_type::<crate::generic::ExprAwait>(ast_module)?;
-    cache_py_type::<crate::generic::ExprYield>(ast_module)?;
-    cache_py_type::<crate::generic::ExprYieldFrom>(ast_module)?;
-    cache_py_type::<crate::generic::ExprCompare>(ast_module)?;
-    cache_py_type::<crate::generic::ExprCall>(ast_module)?;
-    cache_py_type::<crate::generic::ExprFormattedValue>(ast_module)?;
-    cache_py_type::<crate::generic::ExprJoinedStr>(ast_module)?;
-    cache_py_type::<crate::generic::ExprConstant>(ast_module)?;
-    cache_py_type::<crate::generic::ExprAttribute>(ast_module)?;
-    cache_py_type::<crate::generic::ExprSubscript>(ast_module)?;
-    cache_py_type::<crate::generic::ExprStarred>(ast_module)?;
-    cache_py_type::<crate::generic::ExprName>(ast_module)?;
-    cache_py_type::<crate::generic::ExprList>(ast_module)?;
-    cache_py_type::<crate::generic::ExprTuple>(ast_module)?;
-    cache_py_type::<crate::generic::ExprSlice>(ast_module)?;
-    cache_py_type::<crate::generic::ExprContext>(ast_module)?;
-    cache_py_type::<crate::generic::ExprContextLoad>(ast_module)?;
-    cache_py_type::<crate::generic::ExprContextStore>(ast_module)?;
-    cache_py_type::<crate::generic::ExprContextDel>(ast_module)?;
-    cache_py_type::<crate::generic::Boolop>(ast_module)?;
-    cache_py_type::<crate::generic::BoolopAnd>(ast_module)?;
-    cache_py_type::<crate::generic::BoolopOr>(ast_module)?;
-    cache_py_type::<crate::generic::Operator>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorAdd>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorSub>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorMult>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorMatMult>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorDiv>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorMod>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorPow>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorLShift>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorRShift>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorBitOr>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorBitXor>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorBitAnd>(ast_module)?;
-    cache_py_type::<crate::generic::OperatorFloorDiv>(ast_module)?;
-    cache_py_type::<crate::generic::Unaryop>(ast_module)?;
-    cache_py_type::<crate::generic::UnaryopInvert>(ast_module)?;
-    cache_py_type::<crate::generic::UnaryopNot>(ast_module)?;
-    cache_py_type::<crate::generic::UnaryopUAdd>(ast_module)?;
-    cache_py_type::<crate::generic::UnaryopUSub>(ast_module)?;
-    cache_py_type::<crate::generic::Cmpop>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopEq>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopNotEq>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopLt>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopLtE>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopGt>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopGtE>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopIs>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopIsNot>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopIn>(ast_module)?;
-    cache_py_type::<crate::generic::CmpopNotIn>(ast_module)?;
-    cache_py_type::<crate::generic::Comprehension>(ast_module)?;
-    cache_py_type::<crate::generic::Excepthandler>(ast_module)?;
-    cache_py_type::<crate::generic::ExcepthandlerExceptHandler>(ast_module)?;
-    cache_py_type::<crate::generic::Arguments>(ast_module)?;
-    cache_py_type::<crate::generic::Arg>(ast_module)?;
-    cache_py_type::<crate::generic::Keyword>(ast_module)?;
-    cache_py_type::<crate::generic::Alias>(ast_module)?;
-    cache_py_type::<crate::generic::Withitem>(ast_module)?;
-    cache_py_type::<crate::generic::MatchCase>(ast_module)?;
-    cache_py_type::<crate::generic::Pattern>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchValue>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchSingleton>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchSequence>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchMapping>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchClass>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchStar>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchAs>(ast_module)?;
-    cache_py_type::<crate::generic::PatternMatchOr>(ast_module)?;
-    cache_py_type::<crate::generic::TypeIgnore>(ast_module)?;
-    cache_py_type::<crate::generic::TypeIgnoreTypeIgnore>(ast_module)?;
-    Ok(())
-}
diff --git a/ast/src/lib.rs b/ast/src/lib.rs
index 21cca63e..5a3c1ff5 100644
--- a/ast/src/lib.rs
+++ b/ast/src/lib.rs
@@ -41,8 +41,3 @@ pub use visitor::Visitor;
 mod optimizer;
 #[cfg(feature = "constant-optimization")]
 pub use optimizer::ConstantOptimizer;
-
-#[cfg(feature = "pyo3")]
-pub mod pyo3;
-#[cfg(feature = "pyo3-wrapper")]
-pub mod pyo3_wrapper;
diff --git a/ast/src/pyo3.rs b/ast/src/pyo3.rs
deleted file mode 100644
index 74e51720..00000000
--- a/ast/src/pyo3.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-use crate::{source_code::SourceRange, text_size::TextRange, ConversionFlag, Node};
-use num_complex::Complex64;
-use once_cell::sync::OnceCell;
-use pyo3::{
-    prelude::*,
-    types::{PyBytes, PyList, PyString, PyTuple},
-};
-
-pub trait Pyo3Node {
-    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
-        {
-            static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
-            &PY_TYPE
-        }
-    }
-}
-
-pub trait ToPyo3Ast {
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>>;
-}
-
-impl<T: ToPyo3Ast> ToPyo3Ast for Box<T> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        (**self).to_pyo3_ast(py)
-    }
-}
-
-impl<T: ToPyo3Ast> ToPyo3Ast for Option<T> {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        match self {
-            Some(ast) => ast.to_pyo3_ast(py),
-            None => Ok(py.None()),
-        }
-    }
-}
-
-impl<T: ToPyo3Ast> ToPyo3Ast for Vec<T> {
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let elts = self
-            .iter()
-            .map(|item| item.to_pyo3_ast(py))
-            .collect::<Result<Vec<_>, _>>()?;
-        let list = PyList::new(py, elts);
-        Ok(list.into())
-    }
-}
-
-impl ToPyo3Ast for crate::Identifier {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok(self.as_str().to_object(py))
-    }
-}
-
-impl ToPyo3Ast for crate::String {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok(self.as_str().to_object(py))
-    }
-}
-
-impl ToPyo3Ast for crate::Int {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((self.to_u32()).to_object(py))
-    }
-}
-
-impl ToPyo3Ast for bool {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((*self as u32).to_object(py))
-    }
-}
-
-impl ToPyo3Ast for ConversionFlag {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((*self as i8).to_object(py))
-    }
-}
-
-impl ToPyo3Ast for crate::Constant {
-    #[inline]
-    fn to_pyo3_ast(&self, py: Python) -> PyResult<Py<PyAny>> {
-        let value = match self {
-            crate::Constant::None => py.None(),
-            crate::Constant::Bool(bool) => bool.to_object(py),
-            crate::Constant::Str(string) => string.to_object(py),
-            crate::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
-            crate::Constant::Int(int) => int.to_object(py),
-            crate::Constant::Tuple(elts) => {
-                let elts: PyResult<Vec<_>> = elts.iter().map(|c| c.to_pyo3_ast(py)).collect();
-                PyTuple::new(py, elts?).into()
-            }
-            crate::Constant::Float(f64) => f64.to_object(py),
-            crate::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
-            crate::Constant::Ellipsis => py.Ellipsis(),
-        };
-        Ok(value)
-    }
-}
-
-#[pyclass(module = "rustpython_ast", subclass)]
-pub struct AST;
-
-#[pymethods]
-impl AST {
-    #[new]
-    fn new() -> Self {
-        Self
-    }
-}
-
-fn cache_py_type<N: Pyo3Node + Node>(ast_module: &PyAny) -> PyResult<()> {
-    let class = ast_module.getattr(N::NAME)?;
-    let base = if std::mem::size_of::<N>() == 0 {
-        class.call0()?
-    } else {
-        class.getattr("__new__")?
-    };
-    N::py_type_cache().get_or_init(|| (class.into(), base.into()));
-    Ok(())
-}
-
-struct AstKeyCache {
-    lineno: Py<PyString>,
-    col_offset: Py<PyString>,
-    end_lineno: Py<PyString>,
-    end_col_offset: Py<PyString>,
-}
-
-fn ast_key_cache() -> &'static OnceCell<AstKeyCache> {
-    {
-        static PY_TYPE: OnceCell<AstKeyCache> = OnceCell::new();
-        &PY_TYPE
-    }
-}
-
-pub fn init(py: Python) -> PyResult<()> {
-    ast_key_cache().get_or_init(|| AstKeyCache {
-        lineno: pyo3::intern!(py, "lineno").into_py(py),
-        col_offset: pyo3::intern!(py, "col_offset").into_py(py),
-        end_lineno: pyo3::intern!(py, "end_lineno").into_py(py),
-        end_col_offset: pyo3::intern!(py, "end_col_offset").into_py(py),
-    });
-
-    init_types(py)
-}
-
-include!("gen/to_pyo3.rs");
diff --git a/ast/src/pyo3_wrapper.rs b/ast/src/pyo3_wrapper.rs
deleted file mode 100644
index a622ed06..00000000
--- a/ast/src/pyo3_wrapper.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use crate::pyo3::{Pyo3Node, AST};
-use crate::{source_code::SourceRange, text_size::TextRange, ConversionFlag, Node};
-use num_complex::Complex64;
-use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyList, PyTuple};
-
-pub trait ToPyo3Wrapper {
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>>;
-}
-
-impl<T: ToPyo3Wrapper> ToPyo3Wrapper for Box<T> {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        (**self).to_pyo3_wrapper(py)
-    }
-}
-
-impl<T: ToPyo3Wrapper> ToPyo3Wrapper for Option<T> {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        match self {
-            Some(ast) => ast.to_pyo3_wrapper(py),
-            None => Ok(py.None()),
-        }
-    }
-}
-
-impl ToPyo3Wrapper for crate::Identifier {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok(self.as_str().to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for crate::String {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok(self.as_str().to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for crate::Int {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((self.to_u32()).to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for bool {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((*self as u32).to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for ConversionFlag {
-    #[inline]
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        Ok((*self as i8).to_object(py))
-    }
-}
-
-impl ToPyo3Wrapper for crate::Constant {
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        let value = match self {
-            crate::Constant::None => py.None(),
-            crate::Constant::Bool(bool) => bool.to_object(py),
-            crate::Constant::Str(string) => string.to_object(py),
-            crate::Constant::Bytes(bytes) => PyBytes::new(py, bytes).into(),
-            crate::Constant::Int(int) => int.to_object(py),
-            crate::Constant::Tuple(elts) => {
-                let elts: PyResult<Vec<_>> = elts.iter().map(|c| c.to_pyo3_wrapper(py)).collect();
-                PyTuple::new(py, elts?).into()
-            }
-            crate::Constant::Float(f64) => f64.to_object(py),
-            crate::Constant::Complex { real, imag } => Complex64::new(*real, *imag).to_object(py),
-            crate::Constant::Ellipsis => py.Ellipsis(),
-        };
-        Ok(value)
-    }
-}
-
-impl<T: ToPyo3Wrapper> ToPyo3Wrapper for Vec<T> {
-    fn to_pyo3_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
-        let list = PyList::empty(py);
-        for item in self {
-            let py_item = item.to_pyo3_wrapper(py)?;
-            list.append(py_item)?;
-        }
-        Ok(list.into())
-    }
-}
-
-pub mod located {
-    use super::*;
-    pub use crate::pyo3::AST;
-    include!("gen/pyo3_wrapper_located.rs");
-}
-
-pub mod ranged {
-    use super::*;
-    pub use crate::pyo3::AST;
-    include!("gen/pyo3_wrapper_ranged.rs");
-}
-
-fn init_type<P: pyo3::PyClass, N: Pyo3Node + Node>(py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_class::<P>()?;
-    let node = m.getattr(P::NAME)?;
-    if P::NAME != N::NAME {
-        // TODO: no idea how to escape rust keyword on #[pyclass]
-        m.setattr(P::NAME, node)?;
-    }
-    let names: Vec<&'static str> = N::FIELD_NAMES.to_vec();
-    let fields = PyTuple::new(py, names);
-    node.setattr("_fields", fields)?;
-    Ok(())
-}
-
-/// A Python module implemented in Rust.
-fn init_module(py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_class::<AST>()?;
-
-    let ast = m.getattr("AST")?;
-    let fields = PyTuple::empty(py);
-    ast.setattr("_fields", fields)?;
-
-    Ok(())
-}
diff --git a/scripts/update_asdl.sh b/scripts/update_asdl.sh
index f2e3db25..af34cd22 100755
--- a/scripts/update_asdl.sh
+++ b/scripts/update_asdl.sh
@@ -4,5 +4,5 @@ set -e
 cd "$(dirname "$(dirname "$0")")"
 
 # rm ast/src/gen/*.rs
-python ast/asdl_rs.py --ast-dir ast/src/gen/ --module-file ../RustPython/vm/src/stdlib/ast/gen.rs ast/Python.asdl
-rustfmt ast/src/gen/*.rs ../RustPython/vm/src/stdlib/ast/gen.rs
+python ast/asdl_rs.py --ast-dir ast/src/gen/ --ast-pyo3-dir ast-pyo3/src/gen/ --module-file ../RustPython/vm/src/stdlib/ast/gen.rs ast/Python.asdl
+rustfmt ast/src/gen/*.rs ast-pyo3/src/gen/*.rs ../RustPython/vm/src/stdlib/ast/gen.rs