[MLIR][python binding] Add OpaqueAttribute to python binding.

[ftynse]

mlir/lib/Bindings/Python/IRAttributes.cpp

332

Please put DefaultingPyMlirContext as the last argument.

333

We shouldn't expose this C-level API to Python. Consider Python buffer protocol, https://pybind11.readthedocs.io/en/stable/advanced/pycpp/numpy.html#buffer-protocol, which is already used in DenseElementsAttrs here, for example, https://github.com/llvm/llvm-project/blob/main/mlir/lib/Bindings/Python/IRAttributes.cpp#L367. Accepting a buffer of bytes and failing on the rest is likely enough.

[longy]

PTAL

mlir/lib/Bindings/Python/IRAttributes.cpp

333

So your idea is to remove this get method?

[ftynse]

mlir/lib/Bindings/Python/IRAttributes.cpp

333

No, what I am suggesting is to use proper APIs and types. using an integer and a pointer is not how one is supposed to pass around a string in Python. Take a string with data here or, better, take something like bytes or bytearray as it better reflects the purpose of opaque attributes. For the latter, you may need to use the buffer protocol.

[longy]

Addressing the comments. PTAL

[longy]

mlir/lib/Bindings/Python/IRAttributes.cpp

333

Hi, I made changes accordingly, using py::buffer to pass string from python to C++ and also moving the PyMlirContext to the end.
Please take a look. Thank you.

[longy]

A gentle ping to the patch.

mlir/lib/Bindings/Python/IRAttributes.cpp

c.def_property_readonly(
         [](PyFlatSymbolRefAttribute &self) {
           MlirStringRef stringRef = mlirFlatSymbolRefAttrGetValue(self);
           return py::str(stringRef.data, stringRef.length);
         },
         "Returns the value of the FlatSymbolRef attribute as a string");
   }
 };
 
+class PyOpaqueAttribute : public PyConcreteAttribute<PyOpaqueAttribute> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAOpaque;
+  static constexpr const char *pyClassName = "OpaqueAttr";
+  using PyConcreteAttribute::PyConcreteAttribute;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](std::string dialectNamespace, DefaultingPyMlirContext context,
+           intptr_t dataLength, const char *data, PyType &type) {
+          MlirAttribute attr = mlirOpaqueAttrGet(
+              context->get(), toMlirStringRef(dialectNamespace), dataLength,
+              data, type);
+          return PyOpaqueAttribute(context->getRef(), attr);
+        },
+        py::arg("dialect_namespace"), py::arg("context") = py::none(),
+        py::arg("data_length") = py::int_(0), py::arg("data") = py::str(""),
+        py::arg("type") = py::none(), "Gets an Opaque attribute.");
+    c.def_property_readonly(
+        "dialect_namespace",
+        [](PyOpaqueAttribute &self) {
+          MlirStringRef stringRef = mlirOpaqueAttrGetDialectNamespace(self);
+          return py::str(stringRef.data, stringRef.length);
+        },
+        "Returns the dialect namespace for the Opaque attribute as a string");
+    c.def_property_readonly(
+        "data",
+        [](PyOpaqueAttribute &self) {
+          MlirStringRef stringRef = mlirOpaqueAttrGetData(self);
+          return py::str(stringRef.data, stringRef.length);
+        },
+        "Returns the data for the Opaqued attributes as a string");
+  }
+};
+
 class PyStringAttribute : public PyConcreteAttribute<PyStringAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAString;
   static constexpr const char *pyClassName = "StringAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
void mlir::python::populateIRAttributes(py::module &m) {
   PyArrayAttribute::bind(m);
   PyArrayAttribute::PyArrayAttributeIterator::bind(m);
   PyBoolAttribute::bind(m);
   PyDenseElementsAttribute::bind(m);
   PyDenseFPElementsAttribute::bind(m);
   PyDenseIntElementsAttribute::bind(m);
   PyDictAttribute::bind(m);
   PyFlatSymbolRefAttribute::bind(m);
+  PyOpaqueAttribute::bind(m);
   PyFloatAttribute::bind(m);
   PyIntegerAttribute::bind(m);
   PyStringAttribute::bind(m);
   PyTypeAttribute::bind(m);
   PyUnitAttribute::bind(m);
 }

mlir/test/python/ir/attributes.py

with Context() as ctx:
     # CHECK: symattr value: symbol
     print("symattr value:", sattr.value)
 
     # Test factory methods.
     # CHECK: default_get: @foobar
     print("default_get:", FlatSymbolRefAttr.get("foobar"))
 
 
+# CHECK-LABEL: TEST: testOpaqueAttr
+@run
+def testOpaqueAttr():
+  with Context() as ctx:
+    ctx.allow_unregistered_dialects = True
+    oattr = OpaqueAttr(Attribute.parse("#pytest_dummy.dummyattr<>"))
+    # CHECK: oattr value: pytest_dummy
+    print("oattr value:", oattr.dialect_namespace)
+    # CHECK: oattr value: dummyattr<>
+    print("oattr value:", oattr.data)
+
+    # Test factory methods.
+    # CHECK: default_get: #foobar<"12345"> : i32
+    print(
+        "default_get:",
+        OpaqueAttr.get("foobar", ctx, 5, "12345", IntegerType.get_signless(32)))
+
+
 # CHECK-LABEL: TEST: testStringAttr
 @run
 def testStringAttr():
   with Context() as ctx:
     sattr = StringAttr(Attribute.parse('"stringattr"'))
     # CHECK: sattr value: stringattr
     print("sattr value:", sattr.value)