void init_ops(py::module& m) {
  py::class_<mlir::Operation, std::unique_ptr<mlir::Operation, py::nodelete>>(
      m, "Operation")
      .def("getRegion", &mlir::Operation::getRegion,
           py::return_value_policy::reference)
      .def("getResult", &mlir::Operation::getResult)
      .def("dump", &mlir::Operation::dump)
      .def("getNumResults", &mlir::Operation::getNumResults);

  py::class_<mlir::OperationState>(m, "OperationState")

void init_basic_classes(py::module& m) {
  py::class_<mlir::MLIRContext>(m, "MLIRContext").def(py::init<>());

  py::class_<mlir::Location>(m, "Location");

  py::class_<mlir::UnknownLoc>(m, "UnknownLoc")
      .def("get", [](mlir::MLIRContext* context) -> mlir::Location {
        return mlir::UnknownLoc::get(context);
      });

  py::class_<mlir::Region>(m, "Region")

void init_types(py::module& m) {
  // Type
  py::class_<mlir::Type> Type(m, "Type");

  // Type Sub-classes
  py::class_<mlir::FunctionType, mlir::Type>(m, "FunctionType")
      .def("getResults",
           [](mlir::FunctionType& ft) { return ft.getResults().vec(); });

  py::class_<mlir::FloatType, mlir::Type>(m, "FloatType")
      .def("getBF16", &mlir::FloatType::getBF16)

#include "mlir/IR/Types.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/python/mlir_wrapper/mlir_wrapper.h"

void init_attrs(py::module& m) {
  py::class_<mlir::Attribute>(m, "Attribute");
  py::class_<mlir::IntegerAttr, mlir::Attribute>(m, "IntegerAttr")
      .def("get",
           py::overload_cast<mlir::Type, int64_t>(&mlir::IntegerAttr::get));

#include "mlir/IR/BuiltinAttributes.h"  // from @llvm-project
#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/python/mlir_wrapper/mlir_wrapper.h"

void init_builders(py::module& m) {
  py::class_<mlir::Builder>(m, "Builder")
      .def(py::init<mlir::MLIRContext*>())
      .def("getFunctionType",
           [](mlir::Builder& b, std::vector<mlir::Type> inputs,
              std::vector<mlir::Type> outputs) {

using ::tensorflow::quantization::RepresentativeDatasetFile;

// A "trampoline" class that redirects virtual function calls to the python
// implementation.
//
// Reference:
// https://pybind11.readthedocs.io/en/stable/advanced/classes.html#overriding-virtual-functions-in-python
class PyFunctionLibraryTrampoline : public PyFunctionLibrary {
 public:
  using PyFunctionLibrary::PyFunctionLibrary;

  /// The Float handle.
  friend class Float;
  /// The String handle.
  friend class String;
  /// The Object handle.
  friend class Object;
  /// The List handle.
  friend class List;
  /// The Dictionary handle.
  friend class Dictionary;
  /// The Tuple handle.
  friend class Tuple;
  /// The Callable handle.
  friend class Callable;
  /// The Tensor handle.
  friend class Tensor;

For example, reflective access to an internal package from another module can fail.

The configured _main class_ is also baked into the `module-info.class` file of your application Jar.
If you run the modular application directly using the `java` command, it is then sufficient to provide the module name.

			classes: []*storagev1.StorageClass{sc1, sc2},
			expect:  nil,
		},

		{
			name:    "one default storage class",
			classes: []*storagev1.StorageClass{sc1, sc2, sc3},
			expect:  sc3,
		},

		{
			name:    "two default storage class with different creation timestamp",
			classes: []*storagev1.StorageClass{sc3, sc4},
			expect:  sc4,
		},

		{

        !class2.exists()
    }

    def "zinc handles removal of stale output files after loading from cache"() {
        createJavaClass("Class1")
        def source2 = createJavaClass("Class2")
        def source3 = createJavaClass("Class3", "proto")
        def class1 = scalaClassFile('Class1.class')
        def class2 = scalaClassFile('Class2.class')
        def class3 = scalaClassFile('proto/Class3.class')