diff --git a/.ci/all_requirements.txt b/.ci/all_requirements.txt index ac9682a09bec1..dea9646f648ad 100644 --- a/.ci/all_requirements.txt +++ b/.ci/all_requirements.txt @@ -194,9 +194,9 @@ ml-dtypes==0.5.1 ; python_version < "3.13" \ --hash=sha256:d13755f8e8445b3870114e5b6240facaa7cb0c3361e54beba3e07fa912a6e12b \ --hash=sha256:fd918d4e6a4e0c110e2e05be7a7814d10dc1b95872accbf6512b80a109b71ae1 # via -r mlir/python/requirements.txt -nanobind==2.9.2 \ - --hash=sha256:c37957ffd5eac7eda349cff3622ecd32e5ee1244ecc912c99b5bc8188bafd16e \ - --hash=sha256:e7608472de99d375759814cab3e2c94aba3f9ec80e62cfef8ced495ca5c27d6e +nanobind==2.7.0 \ + --hash=sha256:73b12d0e751d140d6c1bf4b215e18818a8debfdb374f08dc3776ad208d808e74 \ + --hash=sha256:f9f1b160580c50dcf37b6495a0fd5ec61dc0d95dae5f8004f87dd9ad7eb46b34 # via -r mlir/python/requirements.txt numpy==2.0.2 \ --hash=sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a \ @@ -383,10 +383,6 @@ swig==4.3.1 \ --hash=sha256:efec16327029f682f649a26da726bb0305be8800bd0f1fa3e81bf0769cf5b476 \ --hash=sha256:fc496c0d600cf1bb2d91e28d3d6eae9c4301e5ea7a0dec5a4281b5efed4245a8 # via -r lldb/test/requirements.txt -typing-extensions==4.15.0 \ - --hash=sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466 \ - --hash=sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548 - # via -r mlir/python/requirements.txt urllib3==2.5.0 \ --hash=sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760 \ --hash=sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index ee6c87a8b635e..2b883558d33c6 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -99,63 +99,6 @@ function(declare_mlir_python_sources name) endif() endfunction() -# Function: generate_type_stubs -# Turns on automatic type stub generation (via nanobind's stubgen) for extension modules. -# Arguments: -# MODULE_NAME: The name of the extension module as specified in declare_mlir_python_extension. -# DEPENDS_TARGET: The dso target corresponding to the extension module -# (e.g., something like StandalonePythonModules.extension._standaloneDialectsNanobind.dso) -# MLIR_DEPENDS_TARGET: The dso target corresponding to the main/core extension module -# (e.g., something like StandalonePythonModules.extension._mlir.dso) -# OUTPUT_DIR: The root output directory to emit the type stubs into. -# Outputs: -# NB_STUBGEN_CUSTOM_TARGET: The target corresponding to generation which other targets can depend on. -function(generate_type_stubs MODULE_NAME DEPENDS_TARGET MLIR_DEPENDS_TARGET OUTPUT_DIR) - cmake_parse_arguments(ARG - "" - "" - "OUTPUTS" - ${ARGN}) - if(EXISTS ${nanobind_DIR}/../src/stubgen.py) - set(NB_STUBGEN "${nanobind_DIR}/../src/stubgen.py") - elseif(EXISTS ${nanobind_DIR}/../stubgen.py) - set(NB_STUBGEN "${nanobind_DIR}/../stubgen.py") - else() - message(FATAL_ERROR "generate_type_stubs(): could not locate 'stubgen.py'!") - endif() - file(REAL_PATH "${NB_STUBGEN}" NB_STUBGEN) - - set(_module "${MLIR_PYTHON_PACKAGE_PREFIX}._mlir_libs.${MODULE_NAME}") - file(REAL_PATH "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}/.." _import_path) - - set(NB_STUBGEN_CMD - "${Python_EXECUTABLE}" - "${NB_STUBGEN}" - --module - "${_module}" - -i - "${_import_path}" - --recursive - --include-private - --output-dir - "${OUTPUT_DIR}" - --quiet) - - list(TRANSFORM ARG_OUTPUTS PREPEND "${OUTPUT_DIR}/" OUTPUT_VARIABLE _generated_type_stubs) - add_custom_command( - OUTPUT ${_generated_type_stubs} - COMMAND ${NB_STUBGEN_CMD} - WORKING_DIRECTORY "${CMAKE_CURRENT_FUNCTION_LIST_DIR}" - DEPENDS - "${MLIR_DEPENDS_TARGET}.extension._mlir.dso" - "${MLIR_DEPENDS_TARGET}.sources.MLIRPythonSources.Core.Python" - "${DEPENDS_TARGET}" - ) - set(_name "MLIRPythonModuleStubs_${_module}") - add_custom_target("${_name}" ALL DEPENDS ${_generated_type_stubs}) - set(NB_STUBGEN_CUSTOM_TARGET "${_name}" PARENT_SCOPE) -endfunction() - # Function: declare_mlir_python_extension # Declares a buildable python extension from C++ source files. The built # module is considered a python source file and included as everything else. @@ -172,12 +115,11 @@ endfunction() # on. These will be collected for all extensions and put into an # aggregate dylib that is linked against. # PYTHON_BINDINGS_LIBRARY: Either pybind11 or nanobind. -# GENERATE_TYPE_STUBS: List of generated type stubs expected from stubgen relative to _mlir_libs. function(declare_mlir_python_extension name) cmake_parse_arguments(ARG "" "ROOT_DIR;MODULE_NAME;ADD_TO_PARENT;PYTHON_BINDINGS_LIBRARY" - "SOURCES;PRIVATE_LINK_LIBS;EMBED_CAPI_LINK_LIBS;GENERATE_TYPE_STUBS" + "SOURCES;PRIVATE_LINK_LIBS;EMBED_CAPI_LINK_LIBS" ${ARGN}) if(NOT ARG_ROOT_DIR) @@ -193,13 +135,12 @@ function(declare_mlir_python_extension name) set_target_properties(${name} PROPERTIES # Yes: Leading-lowercase property names are load bearing and the recommended # way to do this: https://gitlab.kitware.com/cmake/cmake/-/issues/19261 - EXPORT_PROPERTIES "mlir_python_SOURCES_TYPE;mlir_python_EXTENSION_MODULE_NAME;mlir_python_EMBED_CAPI_LINK_LIBS;mlir_python_DEPENDS;mlir_python_BINDINGS_LIBRARY;mlir_python_GENERATE_TYPE_STUBS" + EXPORT_PROPERTIES "mlir_python_SOURCES_TYPE;mlir_python_EXTENSION_MODULE_NAME;mlir_python_EMBED_CAPI_LINK_LIBS;mlir_python_DEPENDS;mlir_python_BINDINGS_LIBRARY" mlir_python_SOURCES_TYPE extension mlir_python_EXTENSION_MODULE_NAME "${ARG_MODULE_NAME}" mlir_python_EMBED_CAPI_LINK_LIBS "${ARG_EMBED_CAPI_LINK_LIBS}" mlir_python_DEPENDS "" mlir_python_BINDINGS_LIBRARY "${ARG_PYTHON_BINDINGS_LIBRARY}" - mlir_python_GENERATE_TYPE_STUBS "${ARG_GENERATE_TYPE_STUBS}" ) # Set the interface source and link_libs properties of the target @@ -302,32 +243,6 @@ function(add_mlir_python_modules name) ) add_dependencies(${modules_target} ${_extension_target}) mlir_python_setup_extension_rpath(${_extension_target}) - get_target_property(_generate_type_stubs ${sources_target} mlir_python_GENERATE_TYPE_STUBS) - if(_generate_type_stubs) - generate_type_stubs( - ${_module_name} - ${_extension_target} - ${name} - "${CMAKE_CURRENT_BINARY_DIR}/_mlir_libs" - OUTPUTS "${_generate_type_stubs}" - ) - add_dependencies("${modules_target}" "${NB_STUBGEN_CUSTOM_TARGET}") - set(_stubgen_target "${MLIR_PYTHON_PACKAGE_PREFIX}.${_module_name}_type_stub_gen") - declare_mlir_python_sources( - ${_stubgen_target} - ROOT_DIR "${CMAKE_CURRENT_BINARY_DIR}/_mlir_libs" - ADD_TO_PARENT "${sources_target}" - SOURCES "${_generate_type_stubs}" - ) - set(_pure_sources_target "${modules_target}.sources.${sources_target}_type_stub_gen") - add_mlir_python_sources_target(${_pure_sources_target} - INSTALL_COMPONENT ${modules_target} - INSTALL_DIR "${ARG_INSTALL_PREFIX}/_mlir_libs" - OUTPUT_DIRECTORY "${ARG_ROOT_PREFIX}/_mlir_libs" - SOURCES_TARGETS ${_stubgen_target} - ) - add_dependencies(${modules_target} ${_pure_sources_target}) - endif() else() message(SEND_ERROR "Unrecognized source type '${_source_type}' for python source target ${sources_target}") return() @@ -763,28 +678,26 @@ function(add_mlir_python_extension libname extname) # the super project handle compile options as it wishes. get_property(NB_LIBRARY_TARGET_NAME TARGET ${libname} PROPERTY LINK_LIBRARIES) target_compile_options(${NB_LIBRARY_TARGET_NAME} - PRIVATE - -Wall -Wextra -Wpedantic - -Wno-c++98-compat-extra-semi - -Wno-cast-qual - -Wno-covered-switch-default - -Wno-deprecated-literal-operator - -Wno-nested-anon-types - -Wno-unused-parameter - -Wno-zero-length-array - ${eh_rtti_enable}) + PRIVATE + -Wall -Wextra -Wpedantic + -Wno-c++98-compat-extra-semi + -Wno-cast-qual + -Wno-covered-switch-default + -Wno-nested-anon-types + -Wno-unused-parameter + -Wno-zero-length-array + ${eh_rtti_enable}) target_compile_options(${libname} - PRIVATE - -Wall -Wextra -Wpedantic - -Wno-c++98-compat-extra-semi - -Wno-cast-qual - -Wno-covered-switch-default - -Wno-deprecated-literal-operator - -Wno-nested-anon-types - -Wno-unused-parameter - -Wno-zero-length-array - ${eh_rtti_enable}) + PRIVATE + -Wall -Wextra -Wpedantic + -Wno-c++98-compat-extra-semi + -Wno-cast-qual + -Wno-covered-switch-default + -Wno-nested-anon-types + -Wno-unused-parameter + -Wno-zero-length-array + ${eh_rtti_enable}) endif() if(APPLE) diff --git a/mlir/examples/standalone/python/CMakeLists.txt b/mlir/examples/standalone/python/CMakeLists.txt index cb10518e94e33..a0eca9c095775 100644 --- a/mlir/examples/standalone/python/CMakeLists.txt +++ b/mlir/examples/standalone/python/CMakeLists.txt @@ -39,7 +39,6 @@ declare_mlir_python_extension(StandalonePythonSources.NanobindExtension EMBED_CAPI_LINK_LIBS StandaloneCAPI PYTHON_BINDINGS_LIBRARY nanobind - GENERATE_TYPE_STUBS ) diff --git a/mlir/python/CMakeLists.txt b/mlir/python/CMakeLists.txt index 8e7949480f21e..c983914722ce1 100644 --- a/mlir/python/CMakeLists.txt +++ b/mlir/python/CMakeLists.txt @@ -1,9 +1,5 @@ include(AddMLIRPython) -# Specifies that all MLIR packages are co-located under the `mlir_standalone` -# top level package (the API has been embedded in a relocatable way). -add_compile_definitions("MLIR_PYTHON_PACKAGE_PREFIX=${MLIR_PYTHON_PACKAGE_PREFIX}.") - ################################################################################ # Structural groupings. ################################################################################ @@ -27,6 +23,11 @@ declare_mlir_python_sources(MLIRPythonSources.Core.Python passmanager.py rewrite.py dialects/_ods_common.py + + # The main _mlir module has submodules: include stubs from each. + _mlir_libs/_mlir/__init__.pyi + _mlir_libs/_mlir/ir.pyi + _mlir_libs/_mlir/passmanager.pyi ) declare_mlir_python_sources(MLIRPythonSources.Core.Python.Extras @@ -42,6 +43,7 @@ declare_mlir_python_sources(MLIRPythonSources.ExecutionEngine ADD_TO_PARENT MLIRPythonSources SOURCES execution_engine.py + _mlir_libs/_mlirExecutionEngine.pyi SOURCES_GLOB runtime/*.py ) @@ -193,6 +195,7 @@ declare_mlir_dialect_python_bindings( TD_FILE dialects/TransformOps.td SOURCES dialects/transform/__init__.py + _mlir_libs/_mlir/dialects/transform/__init__.pyi DIALECT_NAME transform GEN_ENUM_BINDINGS_TD_FILE "../../include/mlir/Dialect/Transform/IR/TransformAttrs.td" @@ -364,7 +367,8 @@ declare_mlir_python_sources( ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" GEN_ENUM_BINDINGS SOURCES - dialects/quant.py) + dialects/quant.py + _mlir_libs/_mlir/dialects/quant.pyi) declare_mlir_dialect_python_bindings( ADD_TO_PARENT MLIRPythonSources.Dialects @@ -380,6 +384,7 @@ declare_mlir_dialect_python_bindings( TD_FILE dialects/PDLOps.td SOURCES dialects/pdl.py + _mlir_libs/_mlir/dialects/pdl.pyi DIALECT_NAME pdl) declare_mlir_dialect_python_bindings( @@ -505,11 +510,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Core # Dialects MLIRCAPIFunc - GENERATE_TYPE_STUBS - "_mlir/__init__.pyi" - "_mlir/ir.pyi" - "_mlir/passmanager.pyi" - "_mlir/rewrite.pyi" ) # This extension exposes an API to register all dialects, extensions, and passes @@ -531,8 +531,6 @@ declare_mlir_python_extension(MLIRPythonExtension.RegisterEverything MLIRCAPIConversion MLIRCAPITransforms MLIRCAPIRegisterEverything - GENERATE_TYPE_STUBS - "_mlirRegisterEverything.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.Linalg.Pybind @@ -547,8 +545,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.Linalg.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPILinalg - GENERATE_TYPE_STUBS - "_mlirDialectsLinalg.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.GPU.Pybind @@ -563,8 +559,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.GPU.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPIGPU - GENERATE_TYPE_STUBS - "_mlirDialectsGPU.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.LLVM.Pybind @@ -579,8 +573,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.LLVM.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPILLVM - GENERATE_TYPE_STUBS - "_mlirDialectsLLVM.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.Quant.Pybind @@ -595,8 +587,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.Quant.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPIQuant - GENERATE_TYPE_STUBS - "_mlirDialectsQuant.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.NVGPU.Pybind @@ -611,8 +601,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.NVGPU.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPINVGPU - GENERATE_TYPE_STUBS - "_mlirDialectsNVGPU.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.PDL.Pybind @@ -627,8 +615,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.PDL.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPIPDL - GENERATE_TYPE_STUBS - "_mlirDialectsPDL.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.SparseTensor.Pybind @@ -643,8 +629,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.SparseTensor.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPISparseTensor - GENERATE_TYPE_STUBS - "_mlirDialectsSparseTensor.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.Transform.Pybind @@ -659,8 +643,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.Transform.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPITransformDialect - GENERATE_TYPE_STUBS - "_mlirDialectsTransform.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.AsyncDialectPasses @@ -674,8 +656,6 @@ declare_mlir_python_extension(MLIRPythonExtension.AsyncDialectPasses LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPIAsync - GENERATE_TYPE_STUBS - "_mlirAsyncPasses.pyi" ) if(MLIR_ENABLE_EXECUTION_ENGINE) @@ -690,8 +670,6 @@ if(MLIR_ENABLE_EXECUTION_ENGINE) LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPIExecutionEngine - GENERATE_TYPE_STUBS - "_mlirExecutionEngine.pyi" ) endif() @@ -706,8 +684,6 @@ declare_mlir_python_extension(MLIRPythonExtension.GPUDialectPasses LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPIGPU - GENERATE_TYPE_STUBS - "_mlirGPUPasses.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.LinalgPasses @@ -721,8 +697,6 @@ declare_mlir_python_extension(MLIRPythonExtension.LinalgPasses LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPILinalg - GENERATE_TYPE_STUBS - "_mlirLinalgPasses.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.SMT.Pybind @@ -740,8 +714,6 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.SMT.Pybind MLIRCAPIIR MLIRCAPISMT MLIRCAPIExportSMTLIB - GENERATE_TYPE_STUBS - "_mlirDialectsSMT.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.SparseTensorDialectPasses @@ -755,8 +727,6 @@ declare_mlir_python_extension(MLIRPythonExtension.SparseTensorDialectPasses LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPISparseTensor - GENERATE_TYPE_STUBS - "_mlirSparseTensorPasses.pyi" ) declare_mlir_python_extension(MLIRPythonExtension.TransformInterpreter @@ -770,8 +740,6 @@ declare_mlir_python_extension(MLIRPythonExtension.TransformInterpreter LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPITransformDialectTransforms - GENERATE_TYPE_STUBS - "_mlirTransformInterpreter.pyi" ) # TODO: Figure out how to put this in the test tree. @@ -830,8 +798,6 @@ if(MLIR_INCLUDE_TESTS) LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPIPythonTestDialect - GENERATE_TYPE_STUBS - "_mlirPythonTestNanobind.pyi" ) endif() @@ -851,7 +817,7 @@ endif() add_mlir_python_common_capi_library(MLIRPythonCAPI INSTALL_COMPONENT MLIRPythonModules INSTALL_DESTINATION "${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}/_mlir_libs" - OUTPUT_DIRECTORY "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}/_mlir_libs" + OUTPUT_DIRECTORY "${MLIR_BINARY_DIR}/python_packages/mlir_core/mlir/_mlir_libs" RELATIVE_INSTALL_ROOT "../../../.." DECLARED_HEADERS MLIRPythonCAPI.HeaderSources @@ -880,7 +846,7 @@ endif() ################################################################################ add_mlir_python_modules(MLIRPythonModules - ROOT_PREFIX "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}" + ROOT_PREFIX "${MLIR_BINARY_DIR}/python_packages/mlir_core/mlir" INSTALL_PREFIX "${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}" DECLARED_SOURCES MLIRPythonSources diff --git a/mlir/python/mlir/_mlir_libs/.gitignore b/mlir/python/mlir/_mlir_libs/.gitignore deleted file mode 100644 index 8f0c82ab0aac9..0000000000000 --- a/mlir/python/mlir/_mlir_libs/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -_mlir/**/*.pyi -*.pyi diff --git a/mlir/python/mlir/_mlir_libs/_mlir/__init__.pyi b/mlir/python/mlir/_mlir_libs/_mlir/__init__.pyi new file mode 100644 index 0000000000000..03449b70b7fa3 --- /dev/null +++ b/mlir/python/mlir/_mlir_libs/_mlir/__init__.pyi @@ -0,0 +1,12 @@ + +globals: "_Globals" + +class _Globals: + dialect_search_modules: list[str] + def _register_dialect_impl(self, dialect_namespace: str, dialect_class: type) -> None: ... + def _register_operation_impl(self, operation_name: str, operation_class: type) -> None: ... + def append_dialect_search_prefix(self, module_name: str) -> None: ... + def _check_dialect_module_loaded(self, dialect_namespace: str) -> bool: ... + +def register_dialect(dialect_class: type) -> type: ... +def register_operation(dialect_class: type, *, replace: bool = ...) -> type: ... diff --git a/mlir/python/mlir/_mlir_libs/_mlir/dialects/pdl.pyi b/mlir/python/mlir/_mlir_libs/_mlir/dialects/pdl.pyi new file mode 100644 index 0000000000000..d12c6839deaba --- /dev/null +++ b/mlir/python/mlir/_mlir_libs/_mlir/dialects/pdl.pyi @@ -0,0 +1,63 @@ +# 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 Type, Context + +__all__ = [ + 'PDLType', + 'AttributeType', + 'OperationType', + 'RangeType', + 'TypeType', + 'ValueType', +] + + +class PDLType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + +class AttributeType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + @staticmethod + def get(context: Context | None = None) -> AttributeType: ... + + +class OperationType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + @staticmethod + def get(context: Context | None = None) -> OperationType: ... + + +class RangeType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + @staticmethod + def get(element_type: Type) -> RangeType: ... + + @property + def element_type(self) -> Type: ... + + +class TypeType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + @staticmethod + def get(context: Context | None = None) -> TypeType: ... + + +class ValueType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + @staticmethod + def get(context: Context | None = None) -> ValueType: ... diff --git a/mlir/python/mlir/_mlir_libs/_mlir/dialects/quant.pyi b/mlir/python/mlir/_mlir_libs/_mlir/dialects/quant.pyi new file mode 100644 index 0000000000000..3f5304584edef --- /dev/null +++ b/mlir/python/mlir/_mlir_libs/_mlir/dialects/quant.pyi @@ -0,0 +1,142 @@ +# 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 DenseElementsAttr, Type + +__all__ = [ + "QuantizedType", + "AnyQuantizedType", + "UniformQuantizedType", + "UniformQuantizedPerAxisType", + "CalibratedQuantizedType", +] + +class QuantizedType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + @staticmethod + def default_minimum_for_integer(is_signed: bool, integral_width: int) -> int: + ... + + @staticmethod + def default_maximum_for_integer(is_signed: bool, integral_width: int) -> int: + ... + + @property + def expressed_type(self) -> Type: ... + + @property + def flags(self) -> int: ... + + @property + def is_signed(self) -> bool: ... + + @property + def storage_type(self) -> Type: ... + + @property + def storage_type_min(self) -> int: ... + + @property + def storage_type_max(self) -> int: ... + + @property + def storage_type_integral_width(self) -> int: ... + + def is_compatible_expressed_type(self, candidate: Type) -> bool: ... + + @property + def quantized_element_type(self) -> Type: ... + + def cast_from_storage_type(self, candidate: Type) -> Type: ... + + @staticmethod + def cast_to_storage_type(type: Type) -> Type: ... + + def cast_from_expressed_type(self, candidate: Type) -> Type: ... + + @staticmethod + def cast_to_expressed_type(type: Type) -> Type: ... + + def cast_expressed_to_storage_type(self, candidate: Type) -> Type: ... + + +class AnyQuantizedType(QuantizedType): + + @classmethod + def get(cls, flags: int, storage_type: Type, expressed_type: Type, + storage_type_min: int, storage_type_max: int) -> Type: + ... + + +class UniformQuantizedType(QuantizedType): + + @classmethod + def get(cls, flags: int, storage_type: Type, expressed_type: Type, + scale: float, zero_point: int, storage_type_min: int, + storage_type_max: int) -> Type: ... + + @property + def scale(self) -> float: ... + + @property + def zero_point(self) -> int: ... + + @property + def is_fixed_point(self) -> bool: ... + + +class UniformQuantizedPerAxisType(QuantizedType): + + @classmethod + def get(cls, flags: int, storage_type: Type, expressed_type: Type, + scales: list[float], zero_points: list[int], quantized_dimension: int, + storage_type_min: int, storage_type_max: int): + ... + + @property + def scales(self) -> list[float]: ... + + @property + def zero_points(self) -> list[int]: ... + + @property + def quantized_dimension(self) -> int: ... + + @property + def is_fixed_point(self) -> bool: ... + +class UniformQuantizedSubChannelType(QuantizedType): + + @classmethod + def get(cls, flags: int, storage_type: Type, expressed_type: Type, + scales: DenseElementsAttr, zero_points: DenseElementsAttr, + quantized_dimensions: list[int], block_sizes: list[int], + storage_type_min: int, storage_type_max: int): + ... + + @property + def quantized_dimensions(self) -> list[int]: ... + + @property + def block_sizes(self) -> list[int]: ... + + @property + def scales(self) -> DenseElementsAttr: ... + + @property + def zero_points(self) -> DenseElementsAttr: ... + +def CalibratedQuantizedType(QuantizedType): + + @classmethod + def get(cls, expressed_type: Type, min: float, max: float): ... + + @property + def min(self) -> float: ... + + @property + def max(self) -> float: ... \ No newline at end of file diff --git a/mlir/python/mlir/_mlir_libs/_mlir/dialects/transform/__init__.pyi b/mlir/python/mlir/_mlir_libs/_mlir/dialects/transform/__init__.pyi new file mode 100644 index 0000000000000..a3f1b09102379 --- /dev/null +++ b/mlir/python/mlir/_mlir_libs/_mlir/dialects/transform/__init__.pyi @@ -0,0 +1,25 @@ +# 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 Type, Context + + +class AnyOpType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + @staticmethod + def get(context: Context | None = None) -> AnyOpType: ... + + +class OperationType(Type): + @staticmethod + def isinstance(type: Type) -> bool: ... + + @staticmethod + def get(operation_name: str, context: Context | None = None) -> OperationType: ... + + @property + def operation_name(self) -> str: ... diff --git a/mlir/python/mlir/_mlir_libs/_mlir/ir.pyi b/mlir/python/mlir/_mlir_libs/_mlir/ir.pyi new file mode 100644 index 0000000000000..dcae3dd742940 --- /dev/null +++ b/mlir/python/mlir/_mlir_libs/_mlir/ir.pyi @@ -0,0 +1,2846 @@ +# Originally imported via: +# pybind11-stubgen --print-invalid-expressions-as-is mlir._mlir_libs._mlir.ir +# but with the following diff (in order to remove pipes from types, +# which we won't support until bumping minimum python to 3.10) +# +# --------------------- diff begins ------------------------------------ +# +# diff --git a/pybind11_stubgen/printer.py b/pybind11_stubgen/printer.py +# index 1f755aa..4924927 100644 +# --- a/pybind11_stubgen/printer.py +# +++ b/pybind11_stubgen/printer.py +# @@ -283,14 +283,6 @@ class Printer: +# return split[0] + "..." +# +# def print_type(self, type_: ResolvedType) -> str: +# - if ( +# - str(type_.name) == "typing.Optional" +# - and type_.parameters is not None +# - and len(type_.parameters) == 1 +# - ): +# - return f"{self.print_annotation(type_.parameters[0])} | None" +# - if str(type_.name) == "typing.Union" and type_.parameters is not None: +# - return " | ".join(self.print_annotation(p) for p in type_.parameters) +# if type_.parameters: +# param_str = ( +# "[" +# +# --------------------- diff ends ------------------------------------ +# +# Local modifications: +# * Rewrite references to 'mlir.ir' to local types. +# * Drop `typing.` everywhere (top-level import instead). +# * List -> List, dict -> Dict, Tuple -> Tuple. +# * copy-paste Buffer type from typing_extensions. +# * Shuffle _OperationBase, AffineExpr, Attribute, Type, Value to the top. +# * Patch raw C++ types (like "PyAsmState") with a regex like `Py(.*)`. +# * _BaseContext -> Context, MlirType -> Type, MlirTypeID -> TypeID, MlirAttribute -> Attribute. +# * Local edits to signatures and types that pybind11-stubgen did not auto detect (or detected incorrectly). +# * Add MLIRError, _GlobalDebug, _OperationBase to __all__ by hand. +# * Fill in `Any`s where possible. +# * black formatting. + +from __future__ import annotations + +import abc +import collections +from collections.abc import Callable, Sequence +from pathlib import Path +from typing import Any, BinaryIO, ClassVar, Literal, TypeVar, overload + +__all__ = [ + "AffineAddExpr", + "AffineBinaryExpr", + "AffineCeilDivExpr", + "AffineConstantExpr", + "AffineDimExpr", + "AffineExpr", + "AffineExprList", + "AffineFloorDivExpr", + "AffineMap", + "AffineMapAttr", + "AffineModExpr", + "AffineMulExpr", + "AffineSymbolExpr", + "ArrayAttr", + "ArrayAttributeIterator", + "AsmState", + "AttrBuilder", + "Attribute", + "BF16Type", + "Block", + "BlockArgument", + "BlockArgumentList", + "BlockIterator", + "BlockList", + "BoolAttr", + "ComplexType", + "Context", + "DenseBoolArrayAttr", + "DenseBoolArrayIterator", + "DenseElementsAttr", + "DenseF32ArrayAttr", + "DenseF32ArrayIterator", + "DenseF64ArrayAttr", + "DenseF64ArrayIterator", + "DenseFPElementsAttr", + "DenseI16ArrayAttr", + "DenseI16ArrayIterator", + "DenseI32ArrayAttr", + "DenseI32ArrayIterator", + "DenseI64ArrayAttr", + "DenseI64ArrayIterator", + "DenseI8ArrayAttr", + "DenseI8ArrayIterator", + "DenseIntElementsAttr", + "DenseResourceElementsAttr", + "Diagnostic", + "DiagnosticHandler", + "DiagnosticInfo", + "DiagnosticSeverity", + "Dialect", + "DialectDescriptor", + "DialectRegistry", + "Dialects", + "DictAttr", + "F16Type", + "F32Type", + "F64Type", + "FlatSymbolRefAttr", + "Float4E2M1FNType", + "Float6E2M3FNType", + "Float6E3M2FNType", + "Float8E3M4Type", + "Float8E4M3B11FNUZType", + "Float8E4M3FNType", + "Float8E4M3FNUZType", + "Float8E4M3Type", + "Float8E5M2FNUZType", + "Float8E5M2Type", + "Float8E8M0FNUType", + "FloatAttr", + "FloatTF32Type", + "FloatType", + "FunctionType", + "IndexType", + "InferShapedTypeOpInterface", + "InferTypeOpInterface", + "InsertionPoint", + "IntegerAttr", + "IntegerSet", + "IntegerSetAttr", + "IntegerSetConstraint", + "IntegerSetConstraintList", + "IntegerType", + "Location", + "MemRefType", + "Module", + "NamedAttribute", + "NoneType", + "OpAttributeMap", + "OpOperand", + "OpOperandIterator", + "OpOperandList", + "OpResult", + "OpResultList", + "OpSuccessors", + "OpView", + "OpaqueAttr", + "OpaqueType", + "Operation", + "OperationIterator", + "OperationList", + "RankedTensorType", + "Region", + "RegionIterator", + "RegionSequence", + "ShapedType", + "ShapedTypeComponents", + "StridedLayoutAttr", + "StringAttr", + "SymbolRefAttr", + "SymbolTable", + "TupleType", + "Type", + "TypeAttr", + "TypeID", + "UnitAttr", + "UnrankedMemRefType", + "UnrankedTensorType", + "Value", + "VectorType", + "_GlobalDebug", + "_OperationBase", +] + +if hasattr(collections.abc, "Buffer"): + Buffer = collections.abc.Buffer +else: + class Buffer(abc.ABC): + pass + +class _OperationBase: + @overload + def __eq__(self, arg0: _OperationBase) -> bool: ... + @overload + def __eq__(self, arg0: _OperationBase) -> bool: ... + def __hash__(self) -> int: ... + def __str__(self) -> str: + """ + Returns the assembly form of the operation. + """ + def clone(self, ip: InsertionPoint = None) -> OpView: ... + def detach_from_parent(self) -> OpView: + """ + Detaches the operation from its parent block. + """ + + @property + def attached(self) -> bool: + """ + Reports if the operation is attached to its parent block. + """ + + def erase(self) -> None: ... + + @overload + def get_asm( + binary: Literal[True], + large_elements_limit: int | None = None, + large_resource_limit: int | None = None, + enable_debug_info: bool = False, + pretty_debug_info: bool = False, + print_generic_op_form: bool = False, + use_local_scope: bool = False, + assume_verified: bool = False, + skip_regions: bool = False, + ) -> bytes: ... + @overload + def get_asm( + self, + binary: bool = False, + large_elements_limit: int | None = None, + large_resource_limit: int | None = None, + enable_debug_info: bool = False, + pretty_debug_info: bool = False, + print_generic_op_form: bool = False, + use_local_scope: bool = False, + assume_verified: bool = False, + skip_regions: bool = False, + ) -> str: + """ + Returns the assembly form of the operation. + + See the print() method for common keyword arguments for configuring + the output. + """ + + def move_after(self, other: _OperationBase) -> None: + """ + Puts self immediately after the other operation in its parent block. + """ + def move_before(self, other: _OperationBase) -> None: + """ + Puts self immediately before the other operation in its parent block. + """ + @overload + def print( + self, + state: AsmState, + file: Any | None = None, + binary: bool = False, + ) -> None: + """ + Prints the assembly form of the operation to a file like object. + + Args: + file: The file like object to write to. Defaults to sys.stdout. + binary: Whether to write bytes (True) or str (False). Defaults to False. + state: AsmState capturing the operation numbering and flags. + """ + @overload + def print( + self, + large_elements_limit: int | None = None, + large_resource_limit: int | None = None, + enable_debug_info: bool = False, + pretty_debug_info: bool = False, + print_generic_op_form: bool = False, + use_local_scope: bool = False, + assume_verified: bool = False, + file: Any | None = None, + binary: bool = False, + skip_regions: bool = False, + ) -> None: + """ + Prints the assembly form of the operation to a file like object. + + Args: + file: The file like object to write to. Defaults to sys.stdout. + binary: Whether to write bytes (True) or str (False). Defaults to False. + large_elements_limit: Whether to elide elements attributes above this + number of elements. Defaults to None (no limit). + large_resource_limit: Whether to elide resource strings above this + number of characters. Defaults to None (no limit). If large_elements_limit + is set and this is None, the behavior will be to use large_elements_limit + as large_resource_limit. + enable_debug_info: Whether to print debug/location information. Defaults + to False. + pretty_debug_info: Whether to format debug information for easier reading + by a human (warning: the result is unparseable). + print_generic_op_form: Whether to print the generic assembly forms of all + ops. Defaults to False. + use_local_Scope: Whether to print in a way that is more optimized for + multi-threaded access but may not be consistent with how the overall + module prints. + assume_verified: By default, if not printing generic form, the verifier + will be run and if it fails, generic form will be printed with a comment + about failed verification. While a reasonable default for interactive use, + for systematic use, it is often better for the caller to verify explicitly + and report failures in a more robust fashion. Set this to True if doing this + in order to avoid running a redundant verification. If the IR is actually + invalid, behavior is undefined. + skip_regions: Whether to skip printing regions. Defaults to False. + """ + def verify(self) -> bool: + """ + Verify the operation. Raises MLIRError if verification fails, and returns true otherwise. + """ + def write_bytecode(self, file: BinaryIO | str, desired_version: int | None = None) -> None: + """ + Write the bytecode form of the operation to a file like object. + + Args: + file: The file like object or path to write to. + desired_version: The version of bytecode to emit. + Returns: + The bytecode writer status. + """ + @property + def _CAPIPtr(self) -> object: ... + @property + def attributes(self) -> OpAttributeMap: ... + @property + def context(self) -> Context: + """ + Context that owns the Operation + """ + @property + def location(self) -> Location: + """ + Returns the source location the operation was defined or derived from. + """ + @property + def name(self) -> str: ... + @property + def operands(self) -> OpOperandList: ... + @property + def parent(self) -> _OperationBase | None: ... + @property + def regions(self) -> RegionSequence: ... + @property + def result(self) -> OpResult: + """ + Shortcut to get an op result if it has only one (throws an error otherwise). + """ + @property + def results(self) -> OpResultList: + """ + Returns the List of Operation results. + """ + +_TOperation = TypeVar("_TOperation", bound=_OperationBase) + +class AffineExpr: + @staticmethod + @overload + def get_add(arg0: AffineExpr, arg1: AffineExpr) -> AffineAddExpr: + """ + Gets an affine expression containing a sum of two expressions. + """ + @staticmethod + @overload + def get_add(arg0: int, arg1: AffineExpr) -> AffineAddExpr: + """ + Gets an affine expression containing a sum of a constant and another expression. + """ + @staticmethod + @overload + def get_add(arg0: AffineExpr, arg1: int) -> AffineAddExpr: + """ + Gets an affine expression containing a sum of an expression and a constant. + """ + @staticmethod + @overload + def get_ceil_div(arg0: AffineExpr, arg1: AffineExpr) -> AffineCeilDivExpr: + """ + Gets an affine expression containing the rounded-up result of dividing one expression by another. + """ + @staticmethod + @overload + def get_ceil_div(arg0: int, arg1: AffineExpr) -> AffineCeilDivExpr: + """ + Gets a semi-affine expression containing the rounded-up result of dividing a constant by an expression. + """ + @staticmethod + @overload + def get_ceil_div(arg0: AffineExpr, arg1: int) -> AffineCeilDivExpr: + """ + Gets an affine expression containing the rounded-up result of dividing an expression by a constant. + """ + @staticmethod + def get_constant( + value: int, context: Context | None = None + ) -> AffineConstantExpr: + """ + Gets a constant affine expression with the given value. + """ + @staticmethod + def get_dim(position: int, context: Context | None = None) -> AffineDimExpr: + """ + Gets an affine expression of a dimension at the given position. + """ + @staticmethod + @overload + def get_floor_div(arg0: AffineExpr, arg1: AffineExpr) -> AffineFloorDivExpr: + """ + Gets an affine expression containing the rounded-down result of dividing one expression by another. + """ + @staticmethod + @overload + def get_floor_div(arg0: int, arg1: AffineExpr) -> AffineFloorDivExpr: + """ + Gets a semi-affine expression containing the rounded-down result of dividing a constant by an expression. + """ + @staticmethod + @overload + def get_floor_div(arg0: AffineExpr, arg1: int) -> AffineFloorDivExpr: + """ + Gets an affine expression containing the rounded-down result of dividing an expression by a constant. + """ + @staticmethod + @overload + def get_mod(arg0: AffineExpr, arg1: AffineExpr) -> AffineModExpr: + """ + Gets an affine expression containing the modulo of dividing one expression by another. + """ + @staticmethod + @overload + def get_mod(arg0: int, arg1: AffineExpr) -> AffineModExpr: + """ + Gets a semi-affine expression containing the modulo of dividing a constant by an expression. + """ + @staticmethod + @overload + def get_mod(arg0: AffineExpr, arg1: int) -> AffineModExpr: + """ + Gets an affine expression containing the module of dividingan expression by a constant. + """ + @staticmethod + @overload + def get_mul(arg0: AffineExpr, arg1: AffineExpr) -> AffineMulExpr: + """ + Gets an affine expression containing a product of two expressions. + """ + @staticmethod + @overload + def get_mul(arg0: int, arg1: AffineExpr) -> AffineMulExpr: + """ + Gets an affine expression containing a product of a constant and another expression. + """ + @staticmethod + @overload + def get_mul(arg0: AffineExpr, arg1: int) -> AffineMulExpr: + """ + Gets an affine expression containing a product of an expression and a constant. + """ + @staticmethod + def get_symbol( + position: int, context: Context | None = None + ) -> AffineSymbolExpr: + """ + Gets an affine expression of a symbol at the given position. + """ + def _CAPICreate(self) -> AffineExpr: ... + @overload + def __add__(self, arg0: AffineExpr) -> AffineAddExpr: ... + @overload + def __add__(self, arg0: int) -> AffineAddExpr: ... + @overload + def __eq__(self, arg0: AffineExpr) -> bool: ... + @overload + def __eq__(self, arg0: Any) -> bool: ... + def __hash__(self) -> int: ... + @overload + def __mod__(self, arg0: AffineExpr) -> AffineModExpr: ... + @overload + def __mod__(self, arg0: int) -> AffineModExpr: ... + @overload + def __mul__(self, arg0: AffineExpr) -> AffineMulExpr: ... + @overload + def __mul__(self, arg0: int) -> AffineMulExpr: ... + def __radd__(self, arg0: int) -> AffineAddExpr: ... + def __rmod__(self, arg0: int) -> AffineModExpr: ... + def __rmul__(self, arg0: int) -> AffineMulExpr: ... + def __rsub__(self, arg0: int) -> AffineAddExpr: ... + @overload + def __sub__(self, arg0: AffineExpr) -> AffineAddExpr: ... + @overload + def __sub__(self, arg0: int) -> AffineAddExpr: ... + def compose(self, arg0: AffineMap) -> AffineExpr: ... + def dump(self) -> None: + """ + Dumps a debug representation of the object to stderr. + """ + @property + def _CAPIPtr(self) -> object: ... + @property + def context(self) -> Context: ... + +class Attribute: + @staticmethod + def parse(asm: str | bytes, context: Context | None = None) -> Attribute: + """ + Parses an attribute from an assembly form. Raises an MLIRError on failure. + """ + def _CAPICreate(self) -> Attribute: ... + @overload + def __eq__(self, arg0: Attribute) -> bool: ... + @overload + def __eq__(self, arg0: object) -> bool: ... + def __hash__(self) -> int: ... + def __init__(self, cast_from_type: Attribute) -> None: + """ + Casts the passed attribute to the generic Attribute + """ + def __str__(self) -> str: + """ + Returns the assembly form of the Attribute. + """ + def dump(self) -> None: + """ + Dumps a debug representation of the object to stderr. + """ + def get_named(self, arg0: str) -> NamedAttribute: + """ + Binds a name to the attribute + """ + def maybe_downcast(self) -> Any: ... + @property + def _CAPIPtr(self) -> object: ... + @property + def context(self) -> Context: + """ + Context that owns the Attribute + """ + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class Type: + @staticmethod + def parse(asm: str | bytes, context: Context | None = None) -> Type: + """ + Parses the assembly form of a type. + + Returns a Type object or raises an MLIRError if the type cannot be parsed. + + See also: https://mlir.llvm.org/docs/LangRef/#type-system + """ + def _CAPICreate(self) -> Type: ... + @overload + def __eq__(self, arg0: Type) -> bool: ... + @overload + def __eq__(self, arg0: object) -> bool: ... + def __hash__(self) -> int: ... + def __init__(self, cast_from_type: Type) -> None: + """ + Casts the passed type to the generic Type + """ + def __str__(self) -> str: + """ + Returns the assembly form of the type. + """ + def dump(self) -> None: + """ + Dumps a debug representation of the object to stderr. + """ + def maybe_downcast(self) -> Any: ... + @property + def _CAPIPtr(self) -> object: ... + @property + def context(self) -> Context: + """ + Context that owns the Type + """ + @property + def typeid(self) -> TypeID: ... + +class Value: + def _CAPICreate(self) -> Value: ... + @overload + def __eq__(self, arg0: Value) -> bool: ... + @overload + def __eq__(self, arg0: object) -> bool: ... + def __hash__(self) -> int: ... + def __init__(self, value: Value) -> None: ... + def __str__(self) -> str: + """ + Returns the string form of the value. + + If the value is a block argument, this is the assembly form of its type and the + position in the argument List. If the value is an operation result, this is + equivalent to printing the operation that produced it. + """ + def dump(self) -> None: + """ + Dumps a debug representation of the object to stderr. + """ + @overload + def get_name(self, use_local_scope: bool = False, use_name_loc_as_prefix: bool = True) -> str: ... + @overload + def get_name(self, state: AsmState) -> str: + """ + Returns the string form of value as an operand (i.e., the ValueID). + """ + def maybe_downcast(self) -> Any: ... + def replace_all_uses_with(self, arg0: Value) -> None: + """ + Replace all uses of value with the new value, updating anything in + the IR that uses 'self' to use the other value instead. + """ + def set_type(self, type: Type) -> None: ... + @property + def _CAPIPtr(self) -> object: ... + @property + def context(self) -> Context: + """ + Context in which the value lives. + """ + @property + def owner(self) -> _OperationBase: ... + @property + def type(self) -> Type: ... + @property + def uses(self) -> OpOperandIterator: ... + +class AffineAddExpr(AffineBinaryExpr): + @staticmethod + def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineAddExpr: ... + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + +class AffineBinaryExpr(AffineExpr): + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + @property + def lhs(self) -> AffineExpr: ... + @property + def rhs(self) -> AffineExpr: ... + +class AffineCeilDivExpr(AffineBinaryExpr): + @staticmethod + def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineCeilDivExpr: ... + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + +class AffineConstantExpr(AffineExpr): + @staticmethod + def get(value: int, context: Context | None = None) -> AffineConstantExpr: ... + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + @property + def value(self) -> int: ... + +class AffineDimExpr(AffineExpr): + @staticmethod + def get(position: int, context: Context | None = None) -> AffineDimExpr: ... + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + @property + def position(self) -> int: ... + +class AffineExprList: + def __add__(self, arg0: AffineExprList) -> list[AffineExpr]: ... + +class AffineFloorDivExpr(AffineBinaryExpr): + @staticmethod + def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineFloorDivExpr: ... + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + +class AffineMap: + @staticmethod + def compress_unused_symbols( + arg0: list, arg1: Context | None + ) -> list[AffineMap]: ... + @staticmethod + def get( + dim_count: int, + symbol_count: int, + exprs: list, + context: Context | None = None, + ) -> AffineMap: + """ + Gets a map with the given expressions as results. + """ + @staticmethod + def get_constant(value: int, context: Context | None = None) -> AffineMap: + """ + Gets an affine map with a single constant result + """ + @staticmethod + def get_empty(context: Context | None = None) -> AffineMap: + """ + Gets an empty affine map. + """ + @staticmethod + def get_identity(n_dims: int, context: Context | None = None) -> AffineMap: + """ + Gets an identity map with the given number of dimensions. + """ + @staticmethod + def get_minor_identity( + n_dims: int, n_results: int, context: Context | None = None + ) -> AffineMap: + """ + Gets a minor identity map with the given number of dimensions and results. + """ + @staticmethod + def get_permutation( + permutation: list[int], context: Context | None = None + ) -> AffineMap: + """ + Gets an affine map that permutes its inputs. + """ + def _CAPICreate(self) -> AffineMap: ... + @overload + def __eq__(self, arg0: AffineMap) -> bool: ... + @overload + def __eq__(self, arg0: object) -> bool: ... + def __hash__(self) -> int: ... + def dump(self) -> None: + """ + Dumps a debug representation of the object to stderr. + """ + def get_major_submap(self, n_results: int) -> AffineMap: ... + def get_minor_submap(self, n_results: int) -> AffineMap: ... + def get_submap(self, result_positions: list[int]) -> AffineMap: ... + def replace( + self, + expr: AffineExpr, + replacement: AffineExpr, + n_result_dims: int, + n_result_syms: int, + ) -> AffineMap: ... + @property + def _CAPIPtr(self) -> object: ... + @property + def context(self) -> Context: + """ + Context that owns the Affine Map + """ + @property + def is_permutation(self) -> bool: ... + @property + def is_projected_permutation(self) -> bool: ... + @property + def n_dims(self) -> int: ... + @property + def n_inputs(self) -> int: ... + @property + def n_symbols(self) -> int: ... + @property + def results(self) -> AffineMapExprList: ... + +class AffineMapAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(affine_map: AffineMap) -> AffineMapAttr: + """ + Gets an attribute wrapping an AffineMap. + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class AffineModExpr(AffineBinaryExpr): + @staticmethod + def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineModExpr: ... + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + +class AffineMulExpr(AffineBinaryExpr): + @staticmethod + def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineMulExpr: ... + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + +class AffineSymbolExpr(AffineExpr): + @staticmethod + def get(position: int, context: Context | None = None) -> AffineSymbolExpr: ... + @staticmethod + def isinstance(other: AffineExpr) -> bool: ... + def __init__(self, expr: AffineExpr) -> None: ... + @property + def position(self) -> int: ... + +class ArrayAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(attributes: list, context: Context | None = None) -> ArrayAttr: + """ + Gets a uniqued Array attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __add__(self, arg0: list) -> ArrayAttr: ... + def __getitem__(self, arg0: int) -> Attribute: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __iter__( + self, + ) -> ArrayAttributeIterator: ... + def __len__(self) -> int: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class ArrayAttributeIterator: + def __iter__(self) -> ArrayAttributeIterator: ... + def __next__(self) -> Attribute: ... + +class AsmState: + @overload + def __init__(self, value: Value, use_local_scope: bool = False) -> None: ... + @overload + def __init__(self, op: _OperationBase, use_local_scope: bool = False) -> None: ... + +class AttrBuilder: + @staticmethod + def contains(arg0: str) -> bool: ... + @staticmethod + def get(arg0: str) -> Callable: ... + @staticmethod + def insert( + attribute_kind: str, attr_builder: Callable, replace: bool = False + ) -> None: + """ + Register an attribute builder for building MLIR attributes from python values. + """ + +class BF16Type(Type): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> BF16Type: + """ + Create a bf16 type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Block: + @staticmethod + def create_at_start( + parent: Region, + arg_types: list[Type], + arg_locs: Sequence | None = None, + ) -> Block: + """ + Creates and returns a new Block at the beginning of the given region (with given argument types and locations). + """ + @overload + def __eq__(self, arg0: Block) -> bool: ... + @overload + def __eq__(self, arg0: Any) -> bool: ... + def __hash__(self) -> int: ... + def __iter__(self) -> OperationIterator: + """ + Iterates over operations in the block. + """ + def __str__(self) -> str: + """ + Returns the assembly form of the block. + """ + def append(self, operation: _OperationBase) -> None: + """ + Appends an operation to this block. If the operation is currently in another block, it will be moved. + """ + def append_to(self, arg0: Region) -> None: + """ + Append this block to a region, transferring ownership if necessary + """ + def create_after(self, *args, arg_locs: Sequence | None = None) -> Block: + """ + Creates and returns a new Block after this block (with given argument types and locations). + """ + def create_before(self, *args, arg_locs: Sequence | None = None) -> Block: + """ + Creates and returns a new Block before this block (with given argument types and locations). + """ + @property + def _CAPIPtr(self) -> object: ... + @property + def arguments(self) -> BlockArgumentList: + """ + Returns a List of block arguments. + """ + @property + def operations(self) -> OperationList: + """ + Returns a forward-optimized sequence of operations. + """ + @property + def owner(self) -> OpView: + """ + Returns the owning operation of this block. + """ + @property + def region(self) -> Region: + """ + Returns the owning region of this block. + """ + +class BlockArgument(Value): + @staticmethod + def isinstance(other_value: Value) -> bool: ... + def __init__(self, value: Value) -> None: ... + def maybe_downcast(self) -> Any: ... + def set_type(self, type: Type) -> None: ... + @property + def arg_number(self) -> int: ... + @property + def owner(self) -> Block: ... + +class BlockArgumentList: + @overload + def __getitem__(self, arg0: int) -> BlockArgument: ... + @overload + def __getitem__(self, arg0: slice) -> BlockArgumentList: ... + def __len__(self) -> int: ... + def __add__(self, arg0: BlockArgumentList) -> list[BlockArgument]: ... + @property + def types(self) -> list[Type]: ... + +class BlockIterator: + def __iter__(self) -> BlockIterator: ... + def __next__(self) -> Block: ... + +class BlockList: + def __getitem__(self, arg0: int) -> Block: ... + def __iter__(self) -> BlockIterator: ... + def __len__(self) -> int: ... + def append(self, *args, arg_locs: Sequence | None = None) -> Block: + """ + Appends a new block, with argument types as positional args. + + Returns: + The created block. + """ + +class BoolAttr(Attribute): + @staticmethod + def get(value: bool, context: Context | None = None) -> BoolAttr: + """ + Gets an uniqued bool attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __bool__(self: Attribute) -> bool: + """ + Converts the value of the bool attribute to a Python bool + """ + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + @property + def value(self) -> bool: + """ + Returns the value of the bool attribute + """ + +class ComplexType(Type): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(arg0: Type) -> ComplexType: + """ + Create a complex type + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def element_type(self) -> Type: + """ + Returns element type. + """ + @property + def typeid(self) -> TypeID: ... + +class Context: + current: ClassVar[Context] = ... # read-only + allow_unregistered_dialects: bool + @staticmethod + def _get_live_count() -> int: ... + def _CAPICreate(self) -> object: ... + def __enter__(self) -> Context: ... + def __exit__(self, arg0: Any, arg1: Any, arg2: Any) -> None: ... + def __init__(self) -> None: ... + def _clear_live_operations(self) -> int: ... + def _get_context_again(self) -> Context: ... + def _get_live_module_count(self) -> int: ... + def _get_live_operation_count(self) -> int: ... + def _get_live_operation_objects(self) -> list[Operation]: ... + def append_dialect_registry(self, registry: DialectRegistry) -> None: ... + def attach_diagnostic_handler( + self, callback: Callable[[Diagnostic], bool] + ) -> DiagnosticHandler: + """ + Attaches a diagnostic handler that will receive callbacks + """ + def enable_multithreading(self, enable: bool) -> None: ... + def get_dialect_descriptor(self, dialect_name: str) -> DialectDescriptor: + """ + Gets or loads a dialect by name, returning its descriptor object + """ + def is_registered_operation(self, operation_name: str) -> bool: ... + def load_all_available_dialects(self) -> None: ... + @property + def _CAPIPtr(self) -> object: ... + @property + def d(self) -> Dialects: + """ + Alias for 'dialect' + """ + @property + def dialects(self) -> Dialects: + """ + Gets a container for accessing dialects by name + """ + +class DenseBoolArrayAttr(Attribute): + @staticmethod + def get( + values: Sequence[bool], context: Context | None = None + ) -> DenseBoolArrayAttr: + """ + Gets a uniqued dense array attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __add__(self, arg0: list) -> DenseBoolArrayAttr: ... + def __getitem__(self, arg0: int) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __iter__( + self, + ) -> DenseBoolArrayIterator: ... + def __len__(self) -> int: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseBoolArrayIterator: + def __iter__(self) -> DenseBoolArrayIterator: ... + def __next__(self) -> bool: ... + +class DenseElementsAttr(Attribute): + @staticmethod + def get( + array: Buffer, + signless: bool = True, + type: Type | None = None, + shape: list[int] | None = None, + context: Context | None = None, + ) -> DenseElementsAttr: + """ + Gets a DenseElementsAttr from a Python buffer or array. + + When `type` is not provided, then some limited type inferencing is done based + on the buffer format. Support presently exists for 8/16/32/64 signed and + unsigned integers and float16/float32/float64. DenseElementsAttrs of these + types can also be converted back to a corresponding buffer. + + For conversions outside of these types, a `type=` must be explicitly provided + and the buffer contents must be bit-castable to the MLIR internal + representation: + + * Integer types (except for i1): the buffer must be byte aligned to the + next byte boundary. + * Floating point types: Must be bit-castable to the given floating point + size. + * i1 (bool): Bit packed into 8bit words where the bit pattern matches a + row major ordering. An arbitrary Numpy `bool_` array can be bit packed to + this specification with: `np.packbits(ary, axis=None, bitorder='little')`. + + If a single element buffer is passed (or for i1, a single byte with value 0 + or 255), then a splat will be created. + + Args: + array: The array or buffer to convert. + signless: If inferring an appropriate MLIR type, use signless types for + integers (defaults True). + type: Skips inference of the MLIR element type and uses this instead. The + storage size must be consistent with the actual contents of the buffer. + shape: Overrides the shape of the buffer when constructing the MLIR + shaped type. This is needed when the physical and logical shape differ (as + for i1). + context: Explicit context, if not from context manager. + + Returns: + DenseElementsAttr on success. + + Raises: + ValueError: If the type of the buffer or array cannot be matched to an MLIR + type or if the buffer does not meet expectations. + """ + @staticmethod + def get_splat(shaped_type: Type, element_attr: Attribute) -> DenseElementsAttr: + """ + Gets a DenseElementsAttr where all values are the same + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __len__(self) -> int: ... + def get_splat_value(self) -> Attribute: ... + @property + def is_splat(self) -> bool: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseF32ArrayAttr(Attribute): + @staticmethod + def get( + values: Sequence[float], context: Context | None = None + ) -> DenseF32ArrayAttr: + """ + Gets a uniqued dense array attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __add__(self, arg0: list) -> DenseF32ArrayAttr: ... + def __getitem__(self, arg0: int) -> float: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __iter__( + self, + ) -> DenseF32ArrayIterator: ... + def __len__(self) -> int: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseF32ArrayIterator: + def __iter__(self) -> DenseF32ArrayIterator: ... + def __next__(self) -> float: ... + +class DenseF64ArrayAttr(Attribute): + @staticmethod + def get( + values: Sequence[float], context: Context | None = None + ) -> DenseF64ArrayAttr: + """ + Gets a uniqued dense array attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __add__(self, arg0: list) -> DenseF64ArrayAttr: ... + def __getitem__(self, arg0: int) -> float: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __iter__( + self, + ) -> DenseF64ArrayIterator: ... + def __len__(self) -> int: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseF64ArrayIterator: + def __iter__(self) -> DenseF64ArrayIterator: ... + def __next__(self) -> float: ... + +class DenseFPElementsAttr(DenseElementsAttr): + @staticmethod + def get( + array: Buffer, + signless: bool = True, + type: Type | None = None, + shape: list[int] | None = None, + context: Context | None = None, + ) -> DenseFPElementsAttr: ... + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __getitem__(self, arg0: int) -> float: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseI16ArrayAttr(Attribute): + @staticmethod + def get(values: Sequence[int], context: Context | None = None) -> DenseI16ArrayAttr: + """ + Gets a uniqued dense array attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __add__(self, arg0: list) -> DenseI16ArrayAttr: ... + def __getitem__(self, arg0: int) -> int: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __iter__( + self, + ) -> DenseI16ArrayIterator: ... + def __len__(self) -> int: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseI16ArrayIterator: + def __iter__(self) -> DenseI16ArrayIterator: ... + def __next__(self) -> int: ... + +class DenseI32ArrayAttr(Attribute): + @staticmethod + def get(values: Sequence[int], context: Context | None = None) -> DenseI32ArrayAttr: + """ + Gets a uniqued dense array attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __add__(self, arg0: list) -> DenseI32ArrayAttr: ... + def __getitem__(self, arg0: int) -> int: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __iter__( + self, + ) -> DenseI32ArrayIterator: ... + def __len__(self) -> int: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseI32ArrayIterator: + def __iter__(self) -> DenseI32ArrayIterator: ... + def __next__(self) -> int: ... + +class DenseI64ArrayAttr(Attribute): + @staticmethod + def get(values: Sequence[int], context: Context | None = None) -> DenseI64ArrayAttr: + """ + Gets a uniqued dense array attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __add__(self, arg0: list) -> DenseI64ArrayAttr: ... + def __getitem__(self, arg0: int) -> int: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __iter__( + self, + ) -> DenseI16ArrayIterator: ... + def __len__(self) -> int: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseI64ArrayIterator: + def __iter__(self) -> DenseI64ArrayIterator: ... + def __next__(self) -> int: ... + +class DenseI8ArrayAttr(Attribute): + @staticmethod + def get(values: Sequence[int], context: Context | None = None) -> DenseI8ArrayAttr: + """ + Gets a uniqued dense array attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __add__(self, arg0: list) -> DenseI8ArrayAttr: ... + def __getitem__(self, arg0: int) -> int: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __iter__( + self, + ) -> DenseI8ArrayIterator: ... + def __len__(self) -> int: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseI8ArrayIterator: + def __iter__(self) -> DenseI8ArrayIterator: ... + def __next__(self) -> int: ... + +class DenseIntElementsAttr(DenseElementsAttr): + @staticmethod + def get( + array: Buffer, + signless: bool = True, + type: Type | None = None, + shape: list[int] | None = None, + context: Context | None = None, + ) -> DenseIntElementsAttr: ... + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __getitem__(self, arg0: int) -> int: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class DenseResourceElementsAttr(Attribute): + @staticmethod + def get_from_buffer( + array: Buffer, + name: str, + type: Type, + alignment: int | None = None, + is_mutable: bool = False, + context: Context | None = None, + ) -> DenseResourceElementsAttr: + """ + Gets a DenseResourceElementsAttr from a Python buffer or array. + + This function does minimal validation or massaging of the data, and it is + up to the caller to ensure that the buffer meets the characteristics + implied by the shape. + + The backing buffer and any user objects will be retained for the lifetime + of the resource blob. This is typically bounded to the context but the + resource can have a shorter lifespan depending on how it is used in + subsequent processing. + + Args: + buffer: The array or buffer to convert. + name: Name to provide to the resource (may be changed upon collision). + type: The explicit ShapedType to construct the attribute with. + context: Explicit context, if not from context manager. + + Returns: + DenseResourceElementsAttr on success. + + Raises: + ValueError: If the type of the buffer or array cannot be matched to an MLIR + type or if the buffer does not meet expectations. + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class Diagnostic: + @property + def location(self) -> Location: ... + @property + def message(self) -> str: ... + @property + def notes(self) -> tuple[Diagnostic]: ... + @property + def severity(self) -> DiagnosticSeverity: ... + +class DiagnosticHandler: + def __enter__(self) -> DiagnosticHandler: ... + def __exit__(self, arg0: object, arg1: object, arg2: object) -> None: ... + def detach(self) -> None: ... + @property + def attached(self) -> bool: ... + @property + def had_error(self) -> bool: ... + +class DiagnosticInfo: + def __init__(self, arg0: Diagnostic) -> None: ... + @property + def location(self) -> Location: ... + @property + def message(self) -> str: ... + @property + def notes(self) -> list[DiagnosticInfo]: ... + @property + def severity(self) -> DiagnosticSeverity: ... + +class DiagnosticSeverity: + """ + Members: + + ERROR + + WARNING + + NOTE + + REMARK + """ + + ERROR: ClassVar[DiagnosticSeverity] # value = + NOTE: ClassVar[DiagnosticSeverity] # value = + REMARK: ClassVar[DiagnosticSeverity] # value = + WARNING: ClassVar[DiagnosticSeverity] # value = + __members__: ClassVar[ + dict[str, DiagnosticSeverity] + ] # value = {'ERROR': , 'WARNING': , 'NOTE': , 'REMARK': } + def __eq__(self, other: Any) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: Any) -> bool: ... + def __setstate__(self, state: int) -> None: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + +class Dialect: + def __init__(self, descriptor: DialectDescriptor) -> None: ... + @property + def descriptor(self) -> DialectDescriptor: ... + +class DialectDescriptor: + @property + def namespace(self) -> str: ... + +class DialectRegistry: + def _CAPICreate(self) -> DialectRegistry: ... + def __init__(self) -> None: ... + @property + def _CAPIPtr(self) -> object: ... + +class Dialects: + def __getattr__(self, arg0: str) -> Dialect: ... + def __getitem__(self, arg0: str) -> Dialect: ... + +class DictAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(value: dict = {}, context: Context | None = None) -> DictAttr: + """ + Gets an uniqued Dict attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __contains__(self, arg0: str) -> bool: ... + @overload + def __getitem__(self, arg0: str) -> Attribute: ... + @overload + def __getitem__(self, arg0: int) -> NamedAttribute: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __len__(self) -> int: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class FloatType(Type): + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def width(self) -> int: + """ + Returns the width of the floating-point type. + """ + +class F16Type(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> F16Type: + """ + Create a f16 type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class F32Type(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> F32Type: + """ + Create a f32 type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class F64Type(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> F64Type: + """ + Create a f64 type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class FlatSymbolRefAttr(Attribute): + @staticmethod + def get(value: str, context: Context | None = None) -> FlatSymbolRefAttr: + """ + Gets a uniqued FlatSymbolRef attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + @property + def value(self) -> str: + """ + Returns the value of the FlatSymbolRef attribute as a string + """ + +class Float4E2M1FNType(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float4E2M1FNType: + """ + Create a float4_e2m1fn type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float6E2M3FNType(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float6E2M3FNType: + """ + Create a float6_e2m3fn type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float6E3M2FNType(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float6E3M2FNType: + """ + Create a float6_e3m2fn type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float8E3M4Type(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float8E3M4Type: + """ + Create a float8_e3m4 type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float8E4M3B11FNUZType(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float8E4M3B11FNUZType: + """ + Create a float8_e4m3b11fnuz type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float8E4M3FNType(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float8E4M3FNType: + """ + Create a float8_e4m3fn type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float8E4M3FNUZType(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float8E4M3FNUZType: + """ + Create a float8_e4m3fnuz type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float8E4M3Type(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float8E4M3Type: + """ + Create a float8_e4m3 type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float8E5M2FNUZType(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float8E5M2FNUZType: + """ + Create a float8_e5m2fnuz type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float8E5M2Type(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float8E5M2Type: + """ + Create a float8_e5m2 type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class Float8E8M0FNUType(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> Float8E8M0FNUType: + """ + Create a float8_e8m0fnu type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class FloatAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(type: Type, value: float, loc: Location | None = None) -> FloatAttr: + """ + Gets an uniqued float point attribute associated to a type + """ + @staticmethod + def get_f32(value: float, context: Context | None = None) -> FloatAttr: + """ + Gets an uniqued float point attribute associated to a f32 type + """ + @staticmethod + def get_f64(value: float, context: Context | None = None) -> FloatAttr: + """ + Gets an uniqued float point attribute associated to a f64 type + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __float__(self: Attribute) -> float: + """ + Converts the value of the float attribute to a Python float + """ + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + @property + def value(self) -> float: + """ + Returns the value of the float attribute + """ + +class FloatTF32Type(FloatType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> FloatTF32Type: + """ + Create a tf32 type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class FunctionType(Type): + static_typeid: ClassVar[TypeID] + @staticmethod + def get( + inputs: list[Type], results: list[Type], context: Context | None = None + ) -> FunctionType: + """ + Gets a FunctionType from a List of input and result types + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def inputs(self) -> list: + """ + Returns the List of input types in the FunctionType. + """ + @property + def results(self) -> list: + """ + Returns the List of result types in the FunctionType. + """ + @property + def typeid(self) -> TypeID: ... + +class IndexType(Type): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> IndexType: + """ + Create a index type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class InferShapedTypeOpInterface: + def __init__(self, object: object, context: Context | None = None) -> None: + """ + Creates an interface from a given operation/opview object or from a + subclass of OpView. Raises ValueError if the operation does not implement the + interface. + """ + def inferReturnTypeComponents( + self, + operands: list | None = None, + attributes: Attribute | None = None, + properties=None, + regions: list[Region] | None = None, + context: Context | None = None, + loc: Location | None = None, + ) -> list[ShapedTypeComponents]: + """ + Given the arguments required to build an operation, attempts to infer + its return shaped type components. Raises ValueError on failure. + """ + @property + def operation(self) -> Operation: + """ + Returns an Operation for which the interface was constructed. + """ + @property + def opview(self) -> OpView: + """ + Returns an OpView subclass _instance_ for which the interface was + constructed + """ + +class InferTypeOpInterface: + def __init__(self, object: object, context: Context | None = None) -> None: + """ + Creates an interface from a given operation/opview object or from a + subclass of OpView. Raises ValueError if the operation does not implement the + interface. + """ + def inferReturnTypes( + self, + operands: list | None = None, + attributes: Attribute | None = None, + properties=None, + regions: list[Region] | None = None, + context: Context | None = None, + loc: Location | None = None, + ) -> list[Type]: + """ + Given the arguments required to build an operation, attempts to infer + its return types. Raises ValueError on failure. + """ + @property + def operation(self) -> Operation: + """ + Returns an Operation for which the interface was constructed. + """ + @property + def opview(self) -> OpView: + """ + Returns an OpView subclass _instance_ for which the interface was + constructed + """ + +class InsertionPoint: + current: ClassVar[InsertionPoint] = ... # read-only + @staticmethod + def at_block_begin(block: Block) -> InsertionPoint: + """ + Inserts at the beginning of the block. + """ + @staticmethod + def at_block_terminator(block: Block) -> InsertionPoint: + """ + Inserts before the block terminator. + """ + def __enter__(self) -> InsertionPoint: ... + def __exit__(self, arg0: Any, arg1: Any, arg2: Any) -> None: ... + @overload + def __init__(self, block: Block) -> None: + """ + Inserts after the last operation but still inside the block. + """ + @overload + def __init__(self, beforeOperation: _OperationBase) -> None: + """ + Inserts before a referenced operation. + """ + def insert(self, operation: _OperationBase) -> None: + """ + Inserts an operation. + """ + @property + def block(self) -> Block: + """ + Returns the block that this InsertionPoint points to. + """ + @property + def ref_operation(self) -> _OperationBase | None: + """ + The reference operation before which new operations are inserted, or None if the insertion point is at the end of the block + """ + +class IntegerAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(type: Type, value: int) -> IntegerAttr: + """ + Gets an uniqued integer attribute associated to a type + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + def __int__(self) -> int: + """ + Converts the value of the integer attribute to a Python int + """ + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + @property + def value(self) -> int: + """ + Returns the value of the integer attribute + """ + +class IntegerSet: + @staticmethod + def get( + num_dims: int, + num_symbols: int, + exprs: list, + eq_flags: list[bool], + context: Context | None = None, + ) -> IntegerSet: ... + @staticmethod + def get_empty( + num_dims: int, num_symbols: int, context: Context | None = None + ) -> IntegerSet: ... + def _CAPICreate(self) -> IntegerSet: ... + @overload + def __eq__(self, arg0: IntegerSet) -> bool: ... + @overload + def __eq__(self, arg0: object) -> bool: ... + def __hash__(self) -> int: ... + def dump(self) -> None: + """ + Dumps a debug representation of the object to stderr. + """ + def get_replaced( + self, + dim_exprs: list, + symbol_exprs: list, + num_result_dims: int, + num_result_symbols: int, + ) -> IntegerSet: ... + @property + def _CAPIPtr(self) -> object: ... + @property + def constraints(self) -> IntegerSetConstraintList: ... + @property + def context(self) -> Context: ... + @property + def is_canonical_empty(self) -> bool: ... + @property + def n_dims(self) -> int: ... + @property + def n_equalities(self) -> int: ... + @property + def n_inequalities(self) -> int: ... + @property + def n_inputs(self) -> int: ... + @property + def n_symbols(self) -> int: ... + +class IntegerSetAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(integer_set) -> IntegerSetAttr: + """ + Gets an attribute wrapping an IntegerSet. + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class IntegerSetConstraint: + def __init__(self, *args, **kwargs) -> None: ... + @property + def expr(self) -> AffineExpr: ... + @property + def is_eq(self) -> bool: ... + +class IntegerSetConstraintList: + def __init__(self, *args, **kwargs) -> None: ... + def __add__(self, arg0: IntegerSetConstraintList) -> list[IntegerSetConstraint]: ... + @overload + def __getitem__(self, arg0: int) -> IntegerSetConstraint: ... + @overload + def __getitem__(self, arg0: slice) -> IntegerSetConstraintList: ... + def __len__(self) -> int: ... + +class IntegerType(Type): + static_typeid: ClassVar[TypeID] + @staticmethod + def get_signed(width: int, context: Context | None = None) -> IntegerType: + """ + Create a signed integer type + """ + @staticmethod + def get_signless(width: int, context: Context | None = None) -> IntegerType: + """ + Create a signless integer type + """ + @staticmethod + def get_unsigned(width: int, context: Context | None = None) -> IntegerType: + """ + Create an unsigned integer type + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def is_signed(self) -> bool: + """ + Returns whether this is a signed integer + """ + @property + def is_signless(self) -> bool: + """ + Returns whether this is a signless integer + """ + @property + def is_unsigned(self) -> bool: + """ + Returns whether this is an unsigned integer + """ + @property + def typeid(self) -> TypeID: ... + @property + def width(self) -> int: + """ + Returns the width of the integer type + """ + +class Location: + current: ClassVar[Location] = ... # read-only + __hash__: ClassVar[None] = None + @staticmethod + def callsite( + callee: Location, frames: Sequence[Location], context: Context | None = None + ) -> Location: + """ + Gets a Location representing a caller and callsite + """ + @staticmethod + def file( + filename: str, line: int, col: int, context: Context | None = None + ) -> Location: + """ + Gets a Location representing a file, line and column + """ + @staticmethod + def from_attr(attribute: Attribute, context: Context | None = None) -> Location: + """ + Gets a Location from a LocationAttr + """ + @staticmethod + def fused( + locations: Sequence[Location], + metadata: Attribute | None = None, + context: Context | None = None, + ) -> Location: + """ + Gets a Location representing a fused location with optional metadata + """ + @staticmethod + def name( + name: str, + childLoc: Location | None = None, + context: Context | None = None, + ) -> Location: + """ + Gets a Location representing a named location with optional child location + """ + @staticmethod + def unknown(context: Context | None = None) -> Location: + """ + Gets a Location representing an unknown location + """ + def _CAPICreate(self) -> Location: ... + def __enter__(self) -> Location: ... + @overload + def __eq__(self, arg0: Location) -> bool: ... + @overload + def __eq__(self, arg0: Location) -> bool: ... + def __exit__(self, arg0: object, arg1: object, arg2: object) -> None: ... + def emit_error(self, message: str) -> None: + """ + Emits an error at this location + """ + @property + def _CAPIPtr(self) -> object: ... + @property + def attr(self) -> Attribute: + """ + Get the underlying LocationAttr + """ + @property + def context(self) -> Context: + """ + Context that owns the Location + """ + +class MemRefType(ShapedType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get( + shape: list[int], + element_type: Type, + layout: Attribute = None, + memory_space: Attribute = None, + loc: Location | None = None, + ) -> MemRefType: + """ + Create a memref type + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def affine_map(self) -> AffineMap: + """ + The layout of the MemRef type as an affine map. + """ + @property + def layout(self) -> Attribute: + """ + The layout of the MemRef type. + """ + @property + def memory_space(self) -> Attribute | None: + """ + Returns the memory space of the given MemRef type. + """ + @property + def typeid(self) -> TypeID: ... + def get_strides_and_offset(self) -> tuple[list[int], int]: + """ + The strides and offset of the MemRef type. + """ + +class Module: + @staticmethod + def create(loc: Location | None = None) -> Module: + """ + Creates an empty module + """ + @staticmethod + def parse(asm: str | bytes, context: Context | None = None) -> Module: + """ + Parses a module's assembly format from a string. + + Returns a new MlirModule or raises an MLIRError if the parsing fails. + + See also: https://mlir.llvm.org/docs/LangRef/ + """ + @staticmethod + def parseFile(path: str, context: Context | None = None) -> Module: + """ + Parses a module's assembly format from file. + + Returns a new MlirModule or raises an MLIRError if the parsing fails. + + See also: https://mlir.llvm.org/docs/LangRef/ + """ + def _CAPICreate(self) -> Any: ... + def __str__(self) -> str: + """ + Gets the assembly form of the operation with default options. + + If more advanced control over the assembly formatting or I/O options is needed, + use the dedicated print or get_asm method, which supports keyword arguments to + customize behavior. + """ + def dump(self) -> None: + """ + Dumps a debug representation of the object to stderr. + """ + @property + def _CAPIPtr(self) -> object: ... + @property + def body(self) -> Block: + """ + Return the block for this module + """ + @property + def context(self) -> Context: + """ + Context that created the Module + """ + @property + def operation(self) -> Operation: + """ + Accesses the module as an operation + """ + +class MLIRError(Exception): + def __init__( + self, message: str, error_diagnostics: list[DiagnosticInfo] + ) -> None: ... + +class NamedAttribute: + @property + def attr(self) -> Attribute: + """ + The underlying generic attribute of the NamedAttribute binding + """ + @property + def name(self) -> str: + """ + The name of the NamedAttribute binding + """ + +class NoneType(Type): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> NoneType: + """ + Create a none type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class OpAttributeMap: + def __contains__(self, arg0: str) -> bool: ... + def __delitem__(self, arg0: str) -> None: ... + @overload + def __getitem__(self, arg0: str) -> Attribute: ... + @overload + def __getitem__(self, arg0: int) -> NamedAttribute: ... + def __len__(self) -> int: ... + def __setitem__(self, arg0: str, arg1: Attribute) -> None: ... + +class OpOperand: + @property + def operand_number(self) -> int: ... + @property + def owner(self) -> _OperationBase: ... + +class OpOperandIterator: + def __iter__(self) -> OpOperandIterator: ... + def __next__(self) -> OpOperand: ... + +class OpOperandList: + def __add__(self, arg0: OpOperandList) -> list[Value]: ... + @overload + def __getitem__(self, arg0: int) -> Value: ... + @overload + def __getitem__(self, arg0: slice) -> OpOperandList: ... + def __len__(self) -> int: ... + def __setitem__(self, arg0: int, arg1: Value) -> None: ... + +class OpResult(Value): + @staticmethod + def isinstance(other_value: Value) -> bool: ... + def __init__(self, value: Value) -> None: ... + @staticmethod + def isinstance(arg: Any) -> bool: ... + @property + def owner(self) -> _OperationBase: ... + @property + def result_number(self) -> int: ... + +class OpResultList: + def __add__(self, arg0: OpResultList) -> list[OpResult]: ... + @overload + def __getitem__(self, arg0: int) -> OpResult: ... + @overload + def __getitem__(self, arg0: slice) -> OpResultList: ... + def __len__(self) -> int: ... + @property + def owner(self) -> _OperationBase: ... + @property + def types(self) -> list[Type]: ... + +class OpSuccessors: + def __add__(self, arg0: OpSuccessors) -> list[Block]: ... + @overload + def __getitem__(self, arg0: int) -> Block: ... + @overload + def __getitem__(self, arg0: slice) -> OpSuccessors: ... + def __setitem__(self, arg0: int, arg1: Block) -> None: ... + def __len__(self) -> int: ... + +class OpView(_OperationBase): + _ODS_OPERAND_SEGMENTS: ClassVar[None] = ... + _ODS_REGIONS: ClassVar[tuple] = ... + _ODS_RESULT_SEGMENTS: ClassVar[None] = ... + def __init__(self, operation: _OperationBase) -> None: ... + @classmethod + def build_generic( + cls: type[_TOperation], + results: Sequence[Type] | None = None, + operands: Sequence[Value] | None = None, + attributes: dict[str, Attribute] | None = None, + successors: Sequence[Block] | None = None, + regions: int | None = None, + loc: Location | None = None, + ip: InsertionPoint | None = None, + ) -> _TOperation: + """ + Builds a specific, generated OpView based on class level attributes. + """ + @classmethod + def parse( + cls: type[_TOperation], + source: str | bytes, + *, + source_name: str = "", + context: Context | None = None, + ) -> _TOperation: + """ + Parses a specific, generated OpView based on class level attributes + """ + def __init__(self, operation: _OperationBase) -> None: ... + @property + def operation(self) -> _OperationBase: ... + @property + def opview(self) -> OpView: ... + @property + def successors(self) -> OpSuccessors: + """ + Returns the List of Operation successors. + """ + +class OpaqueAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get( + dialect_namespace: str, + buffer: Buffer, + type: Type, + context: Context | None = None, + ) -> OpaqueAttr: + """ + Gets an Opaque attribute. + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def data(self) -> bytes: + """ + Returns the data for the Opaqued attributes as `bytes` + """ + @property + def dialect_namespace(self) -> str: + """ + Returns the dialect namespace for the Opaque attribute as a string + """ + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class OpaqueType(Type): + static_typeid: ClassVar[TypeID] + @staticmethod + def get( + dialect_namespace: str, buffer: str, context: Context | None = None + ) -> OpaqueType: + """ + Create an unregistered (opaque) dialect type. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def data(self) -> str: + """ + Returns the data for the Opaque type as a string. + """ + @property + def dialect_namespace(self) -> str: + """ + Returns the dialect namespace for the Opaque type as a string. + """ + @property + def typeid(self) -> TypeID: ... + +class Operation(_OperationBase): + def _CAPICreate(self) -> object: ... + @staticmethod + def create( + name: str, + results: Sequence[Type] | None = None, + operands: Sequence[Value] | None = None, + attributes: dict[str, Attribute] | None = None, + successors: Sequence[Block] | None = None, + regions: int = 0, + loc: Location | None = None, + ip: InsertionPoint | None = None, + infer_type: bool = False, + ) -> Operation: + """ + Creates a new operation. + + Args: + name: Operation name (e.g. "dialect.operation"). + results: Sequence of Type representing op result types. + attributes: Dict of str:Attribute. + successors: List of Block for the operation's successors. + regions: Number of regions to create. + loc: A Location object (defaults to resolve from context manager). + ip: An InsertionPoint (defaults to resolve from context manager or set to + False to disable insertion, even with an insertion point set in the + context manager). + infer_type: Whether to infer result types. + Returns: + A new "detached" Operation object. Detached operations can be added + to blocks, which causes them to become "attached." + """ + @staticmethod + def parse( + source: str | bytes, *, source_name: str = "", context: Context | None = None + ) -> Operation: + """ + Parses an operation. Supports both text assembly format and binary bytecode format. + """ + def _CAPICreate(self) -> object: ... + @property + def _CAPIPtr(self) -> object: ... + @property + def operation(self) -> Operation: ... + @property + def opview(self) -> OpView: ... + @property + def successors(self) -> OpSuccessors: + """ + Returns the List of Operation successors. + """ + +class OperationIterator: + def __iter__(self) -> OperationIterator: ... + def __next__(self) -> OpView: ... + +class OperationList: + def __getitem__(self, arg0: int) -> OpView: ... + def __iter__(self) -> OperationIterator: ... + def __len__(self) -> int: ... + +class RankedTensorType(ShapedType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get( + shape: list[int], + element_type: Type, + encoding: Attribute | None = None, + loc: Location | None = None, + ) -> RankedTensorType: + """ + Create a ranked tensor type + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def encoding(self) -> Attribute | None: ... + @property + def typeid(self) -> TypeID: ... + +class Region: + __hash__: ClassVar[None] = None + @overload + def __eq__(self, arg0: Region) -> bool: ... + @overload + def __eq__(self, arg0: object) -> bool: ... + def __iter__(self) -> BlockIterator: + """ + Iterates over blocks in the region. + """ + @property + def blocks(self) -> BlockList: + """ + Returns a forward-optimized sequence of blocks. + """ + @property + def owner(self) -> OpView: + """ + Returns the operation owning this region. + """ + +class RegionIterator: + def __iter__(self) -> RegionIterator: ... + def __next__(self) -> Region: ... + +class RegionSequence: + @overload + def __getitem__(self, arg0: int) -> Region: ... + @overload + def __getitem__(self, arg0: slice) -> Sequence[Region]: ... + def __iter__(self) -> RegionIterator: ... + def __len__(self) -> int: ... + +class ShapedType(Type): + @staticmethod + def get_dynamic_size() -> int: + """ + Returns the value used to indicate dynamic dimensions in shaped types. + """ + @staticmethod + def get_dynamic_stride_or_offset() -> int: + """ + Returns the value used to indicate dynamic strides or offsets in shaped types. + """ + @staticmethod + def is_dynamic_size(dim_size: int) -> bool: + """ + Returns whether the given dimension size indicates a dynamic dimension. + """ + @staticmethod + def is_static_size(dim_size: int) -> bool: + """ + Returns whether the given dimension size indicates a static dimension. + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + def get_dim_size(self, dim: int) -> int: + """ + Returns the dim-th dimension of the given ranked shaped type. + """ + def is_dynamic_dim(self, dim: int) -> bool: + """ + Returns whether the dim-th dimension of the given shaped type is dynamic. + """ + def is_static_dim(self, dim: int) -> bool: + """ + Returns whether the dim-th dimension of the given shaped type is static. + """ + def is_dynamic_stride_or_offset(self, dim_size: int) -> bool: + """ + Returns whether the given value is used as a placeholder for dynamic strides and offsets in shaped types. + """ + def is_static_stride_or_offset(self, dim_size: int) -> bool: + """ + Returns whether the given shaped type stride or offset value is statically-sized. + """ + @property + def element_type(self) -> Type: + """ + Returns the element type of the shaped type. + """ + @property + def has_rank(self) -> bool: + """ + Returns whether the given shaped type is ranked. + """ + @property + def has_static_shape(self) -> bool: + """ + Returns whether the given shaped type has a static shape. + """ + @property + def rank(self) -> int: + """ + Returns the rank of the given ranked shaped type. + """ + @property + def shape(self) -> list[int]: + """ + Returns the shape of the ranked shaped type as a List of integers. + """ + @property + def static_typeid(self) -> TypeID: ... + @property + def typeid(self) -> TypeID: ... + +class ShapedTypeComponents: + @staticmethod + @overload + def get(element_type: Type) -> ShapedTypeComponents: + """ + Create an shaped type components object with only the element type. + """ + @staticmethod + @overload + def get(shape: list, element_type: Type) -> ShapedTypeComponents: + """ + Create a ranked shaped type components object. + """ + @staticmethod + @overload + def get( + shape: list, element_type: Type, attribute: Attribute + ) -> ShapedTypeComponents: + """ + Create a ranked shaped type components object with attribute. + """ + @property + def element_type(self) -> Type: + """ + Returns the element type of the shaped type components. + """ + @property + def has_rank(self) -> bool: + """ + Returns whether the given shaped type component is ranked. + """ + @property + def rank(self) -> int: + """ + Returns the rank of the given ranked shaped type components. If the shaped type components does not have a rank, None is returned. + """ + @property + def shape(self) -> list[int]: + """ + Returns the shape of the ranked shaped type components as a List of integers. Returns none if the shaped type component does not have a rank. + """ + +class StridedLayoutAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get( + offset: int, strides: list[int], context: Context | None = None + ) -> StridedLayoutAttr: + """ + Gets a strided layout attribute. + """ + @staticmethod + def get_fully_dynamic( + rank: int, context: Context | None = None + ) -> StridedLayoutAttr: + """ + Gets a strided layout attribute with dynamic offset and strides of a given rank. + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def offset(self) -> int: + """ + Returns the value of the float point attribute + """ + @property + def strides(self) -> list[int]: + """ + Returns the value of the float point attribute + """ + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class StringAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(value: str | bytes, context: Context | None = None) -> StringAttr: + """ + Gets a uniqued string attribute + """ + @staticmethod + def get_typed(type: Type, value: str) -> StringAttr: + """ + Gets a uniqued string attribute associated to a type + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + @property + def value(self) -> str: + """ + Returns the value of the string attribute + """ + @property + def value_bytes(self) -> bytes: + """ + Returns the value of the string attribute as `bytes` + """ + +class SymbolRefAttr(Attribute): + @staticmethod + def get(symbols: list[str], context: Context | None = None) -> Attribute: + """ + Gets a uniqued SymbolRef attribute from a List of symbol names + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def static_typeid(self) -> TypeID: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + @property + def value(self) -> list[str]: + """ + Returns the value of the SymbolRef attribute as a List[str] + """ + +class SymbolTable: + @staticmethod + def get_symbol_name(symbol: _OperationBase) -> Attribute: ... + @staticmethod + def get_visibility(symbol: _OperationBase) -> Attribute: ... + @staticmethod + def replace_all_symbol_uses( + old_symbol: str, new_symbol: str, from_op: _OperationBase + ) -> None: ... + @staticmethod + def set_symbol_name(symbol: _OperationBase, name: str) -> None: ... + @staticmethod + def set_visibility(symbol: _OperationBase, visibility: str) -> None: ... + @staticmethod + def walk_symbol_tables( + from_op: _OperationBase, + all_sym_uses_visible: bool, + callback: Callable[[_OperationBase, bool], None], + ) -> None: ... + def __contains__(self, arg0: str) -> bool: ... + def __delitem__(self, arg0: str) -> None: ... + def __getitem__(self, arg0: str) -> OpView: ... + def __init__(self, arg0: _OperationBase) -> None: ... + def erase(self, operation: _OperationBase) -> None: ... + def insert(self, operation: _OperationBase) -> Attribute: ... + +class TupleType(Type): + static_typeid: ClassVar[TypeID] + @staticmethod + def get_tuple(elements: list[Type], context: Context | None = None) -> TupleType: + """ + Create a Tuple type + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + def get_type(self, pos: int) -> Type: + """ + Returns the pos-th type in the Tuple type. + """ + @property + def num_types(self) -> int: + """ + Returns the number of types contained in a Tuple. + """ + @property + def typeid(self) -> TypeID: ... + +class TypeAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(value: Type, context: Context | None = None) -> TypeAttr: + """ + Gets a uniqued Type attribute + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + @property + def value(self) -> Type: ... + +class TypeID: + def _CAPICreate(self) -> TypeID: ... + @overload + def __eq__(self, arg0: TypeID) -> bool: ... + @overload + def __eq__(self, arg0: Any) -> bool: ... + def __hash__(self) -> int: ... + @property + def _CAPIPtr(self) -> object: ... + +class UnitAttr(Attribute): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(context: Context | None = None) -> UnitAttr: + """ + Create a Unit attribute. + """ + @staticmethod + def isinstance(other: Attribute) -> bool: ... + def __init__(self, cast_from_attr: Attribute) -> None: ... + @property + def type(self) -> Type: ... + @property + def typeid(self) -> TypeID: ... + +class UnrankedMemRefType(ShapedType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get( + element_type: Type, memory_space: Attribute, loc: Location | None = None + ) -> UnrankedMemRefType: + """ + Create a unranked memref type + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def memory_space(self) -> Attribute | None: + """ + Returns the memory space of the given Unranked MemRef type. + """ + @property + def typeid(self) -> TypeID: ... + +class UnrankedTensorType(ShapedType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get(element_type: Type, loc: Location | None = None) -> UnrankedTensorType: + """ + Create a unranked tensor type + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def typeid(self) -> TypeID: ... + +class VectorType(ShapedType): + static_typeid: ClassVar[TypeID] + @staticmethod + def get( + shape: list[int], + element_type: Type, + *, + scalable: list | None = None, + scalable_dims: list[int] | None = None, + loc: Location | None = None, + ) -> VectorType: + """ + Create a vector type + """ + @staticmethod + def isinstance(other: Type) -> bool: ... + def __init__(self, cast_from_type: Type) -> None: ... + @property + def scalable(self) -> bool: ... + @property + def scalable_dims(self) -> list[bool]: ... + @property + def typeid(self) -> TypeID: ... + +class _GlobalDebug: + flag: ClassVar[bool] = False diff --git a/mlir/python/mlir/_mlir_libs/_mlir/passmanager.pyi b/mlir/python/mlir/_mlir_libs/_mlir/passmanager.pyi new file mode 100644 index 0000000000000..1010daddae2aa --- /dev/null +++ b/mlir/python/mlir/_mlir_libs/_mlir/passmanager.pyi @@ -0,0 +1,36 @@ +# Originally imported via: +# stubgen {...} -m mlir._mlir_libs._mlir.passmanager +# Local modifications: +# * Relative imports for cross-module references. +# * Add __all__ + + +from . import ir as _ir + +__all__ = [ + "PassManager", +] + +class PassManager: + def __init__(self, context: _ir.Context | None = None) -> None: ... + def _CAPICreate(self) -> object: ... + def _testing_release(self) -> None: ... + def enable_ir_printing( + self, + print_before_all: bool = False, + print_after_all: bool = True, + print_module_scope: bool = False, + print_after_change: bool = False, + print_after_failure: bool = False, + large_elements_limit: int | None = None, + large_resource_limit: int | None = None, + enable_debug_info: bool = False, + print_generic_op_form: bool = False, + tree_printing_dir_path: str | None = None, + ) -> None: ... + def enable_verifier(self, enable: bool) -> None: ... + @staticmethod + def parse(pipeline: str, context: _ir.Context | None = None) -> PassManager: ... + def run(self, module: _ir._OperationBase) -> None: ... + @property + def _CAPIPtr(self) -> object: ... diff --git a/mlir/python/mlir/_mlir_libs/_mlirExecutionEngine.pyi b/mlir/python/mlir/_mlir_libs/_mlirExecutionEngine.pyi new file mode 100644 index 0000000000000..4b82c78489295 --- /dev/null +++ b/mlir/python/mlir/_mlir_libs/_mlirExecutionEngine.pyi @@ -0,0 +1,24 @@ +# Originally imported via: +# stubgen {...} -m mlir._mlir_libs._mlirExecutionEngine +# Local modifications: +# * Relative imports for cross-module references. +# * Add __all__ + +from collections.abc import Sequence + +from ._mlir import ir as _ir + +__all__ = [ + "ExecutionEngine", +] + +class ExecutionEngine: + def __init__(self, module: _ir.Module, opt_level: int = 2, shared_libs: Sequence[str] = ...) -> None: ... + def _CAPICreate(self) -> object: ... + def _testing_release(self) -> None: ... + def dump_to_object_file(self, file_name: str) -> None: ... + def raw_lookup(self, func_name: str) -> int: ... + def raw_register_runtime(self, name: str, callback: object) -> None: ... + def init() -> None: ... + @property + def _CAPIPtr(self) -> object: ... diff --git a/mlir/python/requirements.txt b/mlir/python/requirements.txt index abe09259bb1e8..1a0075e829aef 100644 --- a/mlir/python/requirements.txt +++ b/mlir/python/requirements.txt @@ -1,7 +1,6 @@ -nanobind>=2.9, <3.0 +nanobind>=2.4, <3.0 numpy>=1.19.5, <=2.1.2 pybind11>=2.10.0, <=2.13.6 PyYAML>=5.4.0, <=6.0.1 ml_dtypes>=0.1.0, <=0.6.0; python_version<"3.13" # provides several NumPy dtype extensions, including the bf16 -ml_dtypes>=0.5.0, <=0.6.0; python_version>="3.13" -typing_extensions>=4.12.2 +ml_dtypes>=0.5.0, <=0.6.0; python_version>="3.13" \ No newline at end of file