[mlir] Apply py::module_local() to a few more classes.

mlir/lib/Bindings/Python/DialectSparseTensor.cpp

 using namespace llvm;
 using namespace mlir;
 using namespace mlir::python::adaptors;
 
 void mlir::python::populateDialectSparseTensorSubmodule(
     py::module m, const py::module &irModule) {
   auto attributeClass = irModule.attr("Attribute");
 
-  py::enum_<MlirSparseTensorDimLevelType>(m, "DimLevelType")
+  py::enum_<MlirSparseTensorDimLevelType>(m, "DimLevelType", py::module_local())
       .value("dense", MLIR_SPARSE_TENSOR_DIM_LEVEL_DENSE)
       .value("compressed", MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED)
       .value("singleton", MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON);
 
   mlir_attribute_subclass(m, "EncodingAttr",
                           mlirAttributeIsASparseTensorEncodingAttr,
                           attributeClass)
       .def_classmethod(

mlir/lib/Bindings/Python/IRModule.h

if (!DerivedTy::isaFunction(orig)) {
       throw SetPyError(PyExc_ValueError,
                        llvm::Twine("Cannot cast attribute to ") +
                            DerivedTy::pyClassName + " (from " + origRepr + ")");
     }
     return orig;
   }
 
   static void bind(pybind11::module &m) {
-    auto cls = ClassTy(m, DerivedTy::pyClassName, pybind11::buffer_protocol());
+    auto cls = ClassTy(m, DerivedTy::pyClassName, pybind11::buffer_protocol(),
+                       pybind11::module_local());
     cls.def(pybind11::init<PyAttribute &>(), pybind11::keep_alive<0, 1>());
     DerivedTy::bindDerived(cls);
   }
 
   /// Implemented by derived classes to add methods to the Python subclass.
   static void bindDerived(ClassTy &m) {}
 };
 
if (!DerivedTy::isaFunction(orig)) {
       throw SetPyError(PyExc_ValueError, llvm::Twine("Cannot cast type to ") +
                                              DerivedTy::pyClassName +
                                              " (from " + origRepr + ")");
     }
     return orig;
   }
 
   static void bind(pybind11::module &m) {
-    auto cls = ClassTy(m, DerivedTy::pyClassName);
+    auto cls = ClassTy(m, DerivedTy::pyClassName, pybind11::module_local());
     cls.def(pybind11::init<PyType &>(), pybind11::keep_alive<0, 1>());
     cls.def_static("isinstance", [](PyType &otherType) -> bool {
       return DerivedTy::isaFunction(otherType);
     });
     DerivedTy::bindDerived(cls);
   }
 
   /// Implemented by derived classes to add methods to the Python subclass.

mlir/lib/Bindings/Python/PybindUtils.h

if (!slice.compute(dunderLen(), &start, &stop, &extraStep, &sliceLength)) {
                                "attempt to access out of bounds");
     }
     return static_cast<Derived *>(this)->slice(startIndex + start * step,
                                                sliceLength, step * extraStep);
   }
 
   /// Binds the indexing and length methods in the Python class.
   static void bind(pybind11::module &m) {
-    auto clazz = pybind11::class_<Derived>(m, Derived::pyClassName)
+    auto clazz = pybind11::class_<Derived>(m, Derived::pyClassName,
+                                           pybind11::module_local())
                      .def("__len__", &Sliceable::dunderLen)
                      .def("__getitem__", &Sliceable::dunderGetItem)
                      .def("__getitem__", &Sliceable::dunderGetItemSlice);
     Derived::bindDerived(clazz);
   }
 
   /// Hook for derived classes willing to bind more methods.
   static void bindDerived(ClassTy &) {}