[mlir][python] Reorganize MLIR python into namespace packages.

[stellaraccident]

Summary

• Only leaf packages are non-namespace packages. This allows most of the top levels to be split into different directories or deployment packages. In the previous state, the presence of __init__.py files at each level meant that the entire tree could only ever exist in one physical directory on the path.
• This changes the API usage slightly: import mlir will no longer do a deep import of mlir.ir, etc. This may necessitate some client code changes.
• Dialect gen code was restructured so that the user is responsible for providing the my_dialect.py file, which then must import its peer _my_dialect_ops_gen. This gives complete control of the dialect namespace to the user instead of to tablegen code, allowing further dialect-specific python APIs.
• Correspondingly, the previous extension modules _my_dialect.py are now _my_dialect_ops_ext.py.
• Now that the linalg namespace is open, moved the linalg_opdsl tool into it.
• This may require some corresponding downstream adjustments to npcomp, circt, et al:
  • Probably some shallow imports need to be converted to deep imports (i.e. not import mlir brings in the world).
  • Each tablegen generated dialect now needs an explicit foo.py which does a from ._foo_ops_gen import *. This is similar to the way that generated code operates in the C++ world.
  • If providing dialect op extensions, those need to be moved from _foo.py -> _foo_ops_ext.py.

[stellaraccident]

Remove cmake cache errantly committed.

[mikeurbach]

Not sure that I am qualified to accept this revision, but I do approve in general. The points in the summary make sense and sound good to me.

We haven't started using the dialect binding generators in CIRCT, but I will be looking at that this week. If this is the direction things are going, I will make sure to keep CIRCT on top of the latest here.

[mehdi_amini]

Sweet!

mlir/lib/Bindings/Python/mlir/_cext_loader.py

66

Nice! I was actually wondering why we were doing this when I added my modules there, but punted on digging.

[stellaraccident]

mlir/lib/Bindings/Python/mlir/_cext_loader.py

66

Yeah, just cruft. When all of this started, there was only the "ir" package! I had forgotten that we had this in there like this.

mlir/cmake/modules/AddMLIRPythonExtension.cmake

 
 function(add_mlir_dialect_python_bindings tblgen_target)
   cmake_parse_arguments(ARG
     ""
     "TD_FILE;DIALECT_NAME"
     "DEPENDS"
     ${ARGN})
 
+  set(dialect_filename "_${ARG_DIALECT_NAME}_ops_gen.py")
   set(LLVM_TARGET_DEFINITIONS ${ARG_TD_FILE})
-  mlir_tablegen("${ARG_DIALECT_NAME}.py" -gen-python-op-bindings
+  mlir_tablegen("${dialect_filename}" -gen-python-op-bindings
                 -bind-dialect=${ARG_DIALECT_NAME})
   add_public_tablegen_target(
     ${tblgen_target})
   if(ARG_DEPENDS)
     add_dependencies(${tblgen_target} ${ARG_DEPENDS})
   endif()
 
   add_custom_command(
     TARGET ${tblgen_target} POST_BUILD
-    COMMENT "Copying generated python source \"dialects/${ARG_DIALECT_NAME}.py\""
+    COMMENT "Copying generated python source \"dialects/${dialect_filename}\""
     COMMAND "${CMAKE_COMMAND}" -E copy_if_different
-      "${CMAKE_CURRENT_BINARY_DIR}/${ARG_DIALECT_NAME}.py"
-      "${PROJECT_BINARY_DIR}/python/mlir/dialects/${ARG_DIALECT_NAME}.py")
+      "${CMAKE_CURRENT_BINARY_DIR}/${dialect_filename}"
+      "${PROJECT_BINARY_DIR}/python/mlir/dialects/${dialect_filename}")
 endfunction()
 

mlir/docs/Bindings/Python.md

 included "in the box" and covers things like dialect registration,
 pass registration, etc.
 
 ### Loader
 
 LLVM/MLIR is a non-trivial python-native project that is likely to co-exist with
 other non-trivial native extensions. As such, the native extension (i.e. the
 `.so`/`.pyd`/`.dylib`) is exported as a notionally private top-level symbol
-(`_mlir`), while a small set of Python code is provided in `mlir/__init__.py`
-and siblings which loads and re-exports it. This split provides a place to stage
-code that needs to prepare the environment *before* the shared library is loaded
-into the Python runtime, and also provides a place that one-time initialization
-code can be invoked apart from module constructors.
+(`_mlir`), while a small set of Python code is provided in
+`mlir/_cext_loader.py` and siblings which loads and re-exports it. This
+split provides a place to stage code that needs to prepare the environment
+*before* the shared library is loaded into the Python runtime, and also
+provides a place that one-time initialization code can be invoked apart from
+module constructors.
+
+It is recommended to avoid using `__init__.py` files to the extent possible,
+until reaching a leaf package that represents a discrete component. The rule
+to keep in mind is that the presence of an `__init__.py` file prevents the
+ability to split anything at that level or below in the namespace into
+different directories, deployment packages, wheels, etc.
 
-To start with the `mlir/__init__.py` loader shim can be very simple and scale to
-future need:
-
-```python
-from _mlir import *
-```
+See the documentation for more information and advice:
+https://packaging.python.org/guides/packaging-namespace-packages/
 
 ### Use the C-API
 
 The Python APIs should seek to layer on top of the C-API to the degree possible.
 Especially for the core, dialect-independent parts, such a binding enables
 packaging decisions that would be difficult or impossible if spanning a C++ ABI
 boundary. In addition, factoring in this way side-steps some very difficult
 issues that arise when combining RTTI-based modules (which pybind derived things

 ## Integration with ODS
 
 The MLIR Python bindings integrate with the tablegen-based ODS system for
 providing user-friendly wrappers around MLIR dialects and operations. There
 are multiple parts to this integration, outlined below. Most details have
 been elided: refer to the build rules and python sources under `mlir.dialects`
 for the canonical way to use this facility.
 
-### Generating `{DIALECT_NAMESPACE}.py` wrapper modules
+Users are responsible for providing a `{DIALECT_NAMESPACE}.py` (or an
+equivalent directory with `__init__.py` file) as the entrypoint.
+
+### Generating `_{DIALECT_NAMESPACE}_ops_gen.py` wrapper modules
 
 Each dialect with a mapping to python requires that an appropriate
-`{DIALECT_NAMESPACE}.py` wrapper module is created. This is done by invoking
-`mlir-tblgen` on a python-bindings specific tablegen wrapper that includes
-the boilerplate and actual dialect specific `td` file. An example, for the
-`StandardOps` (which is assigned the namespace `std` as a special case):
+`_{DIALECT_NAMESPACE}_ops_gen.py` wrapper module is created. This is done by
+invoking `mlir-tblgen` on a python-bindings specific tablegen wrapper that
+includes the boilerplate and actual dialect specific `td` file. An example, for
+the `StandardOps` (which is assigned the namespace `std` as a special case):
 
 ```tablegen
 #ifndef PYTHON_BINDINGS_STANDARD_OPS
 #define PYTHON_BINDINGS_STANDARD_OPS
 
 include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/StandardOps/IR/Ops.td"
 
 #endif
 ```
 
 In the main repository, building the wrapper is done via the CMake function
 `add_mlir_dialect_python_bindings`, which invokes:
 
 ```
 mlir-tblgen -gen-python-op-bindings -bind-dialect={DIALECT_NAMESPACE} \
     {PYTHON_BINDING_TD_FILE}
 ```
 
+The generates op classes must be included in the `{DIALECT_NAMESPACE}.py` file
+in a similar way that generated headers are included for C++ generated code:
+
+```python
+from ._my_dialect_ops_gen import *
+```
+
 ### Extending the search path for wrapper modules
 
 When the python bindings need to locate a wrapper module, they consult the
 `dialect_search_path` and use it to find an appropriately named module. For
 the main repository, this search path is hard-coded to include the
 `mlir.dialects` module, which is where wrappers are emitted by the abobe build
 rule. Out of tree dialects and add their modules to the search path by calling:
 

mlir/lib/Bindings/Python/mlir/_cext_loader.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-# Note that the only function of this module is currently to load the
-# native module and re-export its symbols. In the future, this file is
-# reserved as a trampoline to handle environment specific loading needs
-# and arbitrate any one-time initialization needed in various shared-library
-# scenarios.
-
-__all__ = [
-  "ir",
-  "execution_engine",
-  "passmanager",
-]
+"""Common module for looking up and manipulating C-Extensions."""
 
 # Packaged installs have a top-level _mlir_libs package with symbols:
 #   load_extension(name): Loads a named extension module
 #   preload_dependency(public_name): Loads a shared-library/DLL into the
 #     namespace. TODO: Remove this in favor of a more robust mechanism.
 # Conditionally switch based on whether we are in a package context.
 try:
   import _mlir_libs
 except ModuleNotFoundError:
   # Assume that we are in-tree.
   # The _dlloader takes care of platform specific setup before we try to
   # load a shared library.
   from ._dlloader import preload_dependency as _preload_dependency
 
   def _load_extension(name):
     import importlib
     return importlib.import_module(name)  # i.e. '_mlir' at the top level
 else:
   # Packaged distribution.
   _load_extension = _mlir_libs.load_extension
   _preload_dependency = _mlir_libs.preload_dependency
 
 _preload_dependency("MLIRPublicAPI")
+
 # Expose the corresponding C-Extension module with a well-known name at this
 # top-level module. This allows relative imports like the following to
 # function:
-#   from .. import _cext
+#   from .._cext_loader import _cext
 # This reduces coupling, allowing embedding of the python sources into another
 # project that can just vary based on this top-level loader module.
 _cext = _load_extension("_mlir")
 
+
 def _reexport_cext(cext_module_name, target_module_name):
   """Re-exports a named sub-module of the C-Extension into another module.
 
   Typically:
-    from . import _reexport_cext
+    from ._cext_loader import _reexport_cext
     _reexport_cext("ir", __name__)
     del _reexport_cext
   """
   import sys
   target_module = sys.modules[target_module_name]
   source_module = getattr(_cext, cext_module_name)
   for attr_name in dir(source_module):
     if not attr_name.startswith("__"):
       setattr(target_module, attr_name, getattr(source_module, attr_name))
 
 
-# Import sub-modules. Since these may import from here, this must come after
-# any exported definitions.
-from . import ir, execution_engine, passmanager
-
 # Add our 'dialects' parent module to the search path for implementations.
 _cext.globals.append_dialect_search_prefix("mlir.dialects")

mlir/lib/Bindings/Python/mlir/conversions/__init__.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 # Expose the corresponding C-Extension module with a well-known name at this
 # level.
-from .. import _load_extension
+from .._cext_loader import _load_extension
 _cextConversions = _load_extension("_mlirConversions")

mlir/lib/Bindings/Python/mlir/dialects/_builtin_ops_ext.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-from mlir.ir import *
+from ..ir import *
 
 
 class ModuleOp:
   """Specialization for the module op class."""
 
   def __init__(self, *, loc=None, ip=None):
-    super().__init__(
-        self.build_generic(results=[], operands=[], loc=loc, ip=ip))
+    super().__init__(self.build_generic(results=[], operands=[], loc=loc,
+                                        ip=ip))
     body = self.regions[0].blocks.append()
     with InsertionPoint(body):
       Operation.create("module_terminator")
 
   @property
   def body(self):
     return self.regions[0].blocks[0]
 
class FuncOp:
 
   @property
   def entry_block(self):
     if self.is_external:
       raise IndexError('External function does not have a body')
     return self.regions[0].blocks[0]
 
   def add_entry_block(self):
-    '''
-    Add an entry block to the function body using the function signature to infer block arguments
+    """
+    Add an entry block to the function body using the function signature to
+    infer block arguments.
     Returns the newly created block
-    '''
+    """
     if not self.is_external:
       raise IndexError('The function already has an entry block!')
     self.body.blocks.append(*self.type.inputs)
     return self.body.blocks[0]

mlir/lib/Bindings/Python/mlir/dialects/_ods_common.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 # Re-export the parent _cext so that every level of the API can get it locally.
-from .. import _cext
+from .._cext_loader import _cext
 
 __all__ = [
     "equally_sized_accessor",
     "extend_opview_class",
     "get_default_loc_context",
     "segmented_accessor",
 ]
 

mlir/lib/Bindings/Python/mlir/dialects/builtin.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# Simply a wrapper around the extension module of the same name.
-from . import _reexport_cext
-_reexport_cext("ir", __name__)
-del _reexport_cext
+from ._builtin_ops_gen import *

mlir/lib/Bindings/Python/mlir/dialects/linalg/__init__.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# Simply a wrapper around the extension module of the same name.
-from . import _reexport_cext
-_reexport_cext("ir", __name__)
-del _reexport_cext
+from .._linalg_ops_gen import *

mlir/lib/Bindings/Python/mlir/dialects/linalg/opdsl/dump_oplib.py

 
 
 def main(args):
   # Load all configs.
   configs = []
   modules = []
   for module_name in args.modules:
     modules.append(
-        importlib.import_module(module_name, package="mlir.tools.linalg_opdsl"))
+        importlib.import_module(module_name,
+                                package="mlir.dialects.linalg.opdsl"))
   for i, file_path in enumerate(args.file or []):
     modules.append(load_module_from_file(f"_mlir_eval_oplib{i}", file_path))
   for m in modules:
     for attr_name, value in m.__dict__.items():
       # TODO: This class layering is awkward.
       if isinstance(value, DefinedOpCallable):
         try:
           linalg_config = LinalgOpConfig.from_linalg_op_def(value.model)

mlir/lib/Bindings/Python/mlir/dialects/python_test.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# Simply a wrapper around the extension module of the same name.
-from . import _reexport_cext
-_reexport_cext("ir", __name__)
-del _reexport_cext
+from ._python_test_ops_gen import *

mlir/lib/Bindings/Python/mlir/dialects/shape.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# Simply a wrapper around the extension module of the same name.
-from . import _reexport_cext
-_reexport_cext("ir", __name__)
-del _reexport_cext
+from ._shape_ops_gen import *

mlir/lib/Bindings/Python/mlir/dialects/std.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# Simply a wrapper around the extension module of the same name.
-from . import _reexport_cext
-_reexport_cext("ir", __name__)
-del _reexport_cext
+from ._std_ops_gen import *

mlir/lib/Bindings/Python/mlir/dialects/tensor.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# Simply a wrapper around the extension module of the same name.
-from . import _reexport_cext
-_reexport_cext("ir", __name__)
-del _reexport_cext
+from ._tensor_ops_gen import *

mlir/lib/Bindings/Python/mlir/execution_engine.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 # Simply a wrapper around the extension module of the same name.
-from . import _cext
+from ._cext_loader import _cext
 import ctypes
 
 class ExecutionEngine(_cext.execution_engine.ExecutionEngine):
 
   def lookup(self, name):
     """Lookup a function emitted with the `llvm.emit_c_interface`
     attribute and returns a ctype callable.
     Raise a RuntimeError if the function isn't found.

mlir/lib/Bindings/Python/mlir/ir.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 # Simply a wrapper around the extension module of the same name.
-from . import _reexport_cext
+from ._cext_loader import _reexport_cext
 _reexport_cext("ir", __name__)
 del _reexport_cext

mlir/lib/Bindings/Python/mlir/passmanager.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 # Simply a wrapper around the extension module of the same name.
-from . import _reexport_cext
+from ._cext_loader import _reexport_cext
 _reexport_cext("passmanager", __name__)
 del _reexport_cext

mlir/lib/Bindings/Python/mlir/transforms/__init__.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 # Expose the corresponding C-Extension module with a well-known name at this
 # level.
-from .. import _load_extension
+from .._cext_loader import _load_extension
 _cextTransforms = _load_extension("_mlirTransforms")

mlir/test/Bindings/Python/context_lifecycle.py

 # RUN: %PYTHON %s
 # Standalone sanity check of context life-cycle.
 import gc
-import mlir
+import mlir.ir
 
 assert mlir.ir.Context._get_live_count() == 0
 
 # Create first context.
 print("CREATE C1")
 c1 = mlir.ir.Context()
 assert mlir.ir.Context._get_live_count() == 1
 c1_repr = repr(c1)

mlir/test/Bindings/Python/dialects.py

 
 # CHECK-LABEL: TEST: testUserDialectClass
 def testUserDialectClass():
   ctx = Context()
   # Access using attribute.
   d = ctx.dialects.std
   # Note that the standard dialect namespace prints as ''. Others will print
   # as "<Dialect %namespace (..."
-  # CHECK: <Dialect (class mlir.dialects.std._Dialect)>
+  # CHECK: <Dialect (class mlir.dialects._std_ops_gen._Dialect)>
   print(d)
   try:
     _ = ctx.dialects.not_existing
   except AttributeError:
     pass
   else:
     assert False, "Expected exception"
 
   # Access using index.
   d = ctx.dialects["std"]
-  # CHECK: <Dialect (class mlir.dialects.std._Dialect)>
+  # CHECK: <Dialect (class mlir.dialects._std_ops_gen._Dialect)>
   print(d)
   try:
     _ = ctx.dialects["not_existing"]
   except IndexError:
     pass
   else:
     assert False, "Expected exception"
 
   # Using the 'd' alias.
   d = ctx.d["std"]
-  # CHECK: <Dialect (class mlir.dialects.std._Dialect)>
+  # CHECK: <Dialect (class mlir.dialects._std_ops_gen._Dialect)>
   print(d)
 
 run(testUserDialectClass)
 
 
 # CHECK-LABEL: TEST: testCustomOpView
 # This test uses the standard dialect AddFOp as an example of a user op.
 # TODO: Op creation and access is still quite verbose: simplify this test as

mlir/test/Bindings/Python/dialects/linalg/opdsl/assignments.py

-# RUN: %PYTHON -m mlir.tools.linalg_opdsl.dump_oplib --file %s | FileCheck %s
+# RUN: %PYTHON -m mlir.dialects.linalg.opdsl.dump_oplib --file %s | FileCheck %s
 
-from mlir.tools.linalg_opdsl.lang import *
+from mlir.dialects.linalg.opdsl.lang import *
 
 # CHECK: ---
 # CHECK-LABEL: matmul
 # CHECK: assignments:
 # CHECK:  -
 # CHECK:    arg: C
 # CHECK:    value:
 # CHECK:      scalar_apply:

mlir/test/Bindings/Python/dialects/linalg/opdsl/doctests.py

 # RUN: %PYTHON %s
 
 import doctest
 import importlib
 
 def test_module(module_name):
   print(f"--- Testing module: {module_name}")
   m = importlib.import_module(module_name)
   doctest.testmod(m, verbose=True, raise_on_error=True, report=True)
 
 
-test_module("mlir.tools.linalg_opdsl.lang.affine")
-test_module("mlir.tools.linalg_opdsl.lang.types")
+test_module("mlir.dialects.linalg.opdsl.lang.affine")
+test_module("mlir.dialects.linalg.opdsl.lang.types")

mlir/test/Bindings/Python/dialects/linalg/opdsl/interfaces.py

-# RUN: %PYTHON -m mlir.tools.linalg_opdsl.dump_oplib --file %s | FileCheck %s
+# RUN: %PYTHON -m mlir.dialects.linalg.opdsl.dump_oplib --file %s | FileCheck %s
 
-from mlir.tools.linalg_opdsl.lang import *
+from mlir.dialects.linalg.opdsl.lang import *
 
 # CHECK: ---
 # CHECK-LABEL: matmul
 # CHECK:      implements:
 # CHECK-NEXT: - LinalgContractionOpInterface
 @linalg_structured_op
 def matmul(A=TensorDef(T, S.M, S.K),
            B=TensorDef(T, S.K, S.N),
            C=TensorDef(U, S.M, S.N, output=True)):
   implements(ContractionOpInterface)
   C[D.m, D.n] += cast(U, A[D.m, D.k]) * cast(U, B[D.k, D.n])

mlir/test/Bindings/Python/dialects/linalg/opdsl/shape_maps_iteration.py

-# RUN: %PYTHON -m mlir.tools.linalg_opdsl.dump_oplib --file %s | FileCheck %s
+# RUN: %PYTHON -m mlir.dialects.linalg.opdsl.dump_oplib --file %s | FileCheck %s
 
-from mlir.tools.linalg_opdsl.lang import *
+from mlir.dialects.linalg.opdsl.lang import *
 
 
 # Verify that simple case with iteration order defined lexically and reduction
 # dims auto discovered emits the right shape, indexing maps and iterator types.
 # CHECK: ---
 # CHECK-LABEL: matmul
 # CHECK: shape: affine_map<()[s0, s1, s2] -> (s0, s2)>
 # CHECK: shape: affine_map<()[s0, s1, s2] -> (s2, s1)>

mlir/test/Bindings/Python/dialects/linalg/opdsl/test_core_named_ops.py

+# RUN: %PYTHON -m mlir.dialects.linalg.opdsl.dump_oplib .ops.core_named_ops | FileCheck %s
+
+# Just verify that at least one known op is generated.
+# CHECK: name: matmul

mlir/test/Bindings/Python/ir_operation.py

module = Module.parse(r"""
       %2 = "custom.f32"() : () -> f32
       %3 = addf %1, %2 : f32
     """)
     print(module)
 
     # addf should map to a known OpView class in the std dialect.
     # We know the OpView for it defines an 'lhs' attribute.
     addf = module.body.operations[2]
-    # CHECK: <mlir.dialects.std._AddFOp object
+    # CHECK: <mlir.dialects._std_ops_gen._AddFOp object
     print(repr(addf))
     # CHECK: "custom.f32"()
     print(addf.lhs)
 
     # One of the custom ops should resolve to the default OpView.
     custom = module.body.operations[0]
     # CHECK: <_mlir.ir.OpView object
     print(repr(custom))

mlir/test/Bindings/Python/tools/linalg_opdsl/test_core_named_ops.py

-# RUN: %PYTHON -m mlir.tools.linalg_opdsl.dump_oplib .ops.core_named_ops | FileCheck %s
-
-# Just verify that at least one known op is generated.
-# CHECK: name: matmul

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

 using namespace mlir;
 using namespace mlir::tblgen;
 
 /// File header and includes.
 ///   {0} is the dialect namespace.
 constexpr const char *fileHeader = R"Py(
 # Autogenerated by mlir-tblgen; don't manually edit.
 
-from . import _cext as _ods_cext
-from . import extend_opview_class as _ods_extend_opview_class, segmented_accessor as _ods_segmented_accessor, equally_sized_accessor as _ods_equally_sized_accessor, get_default_loc_context as _ods_get_default_loc_context
+from ._ods_common import _cext as _ods_cext
+from ._ods_common import extend_opview_class as _ods_extend_opview_class, segmented_accessor as _ods_segmented_accessor, equally_sized_accessor as _ods_equally_sized_accessor, get_default_loc_context as _ods_get_default_loc_context
 _ods_ir = _ods_cext.ir
 
 try:
-  from . import _{0} as _ods_ext_module
+  from . import _{0}_ops_ext as _ods_ext_module
 except ImportError:
   _ods_ext_module = None
 
 )Py";
 
 /// Template for dialect class:
 ///   {0} is the dialect namespace.
 constexpr const char *dialectClassTemplate = R"Py(