From 272d47bc45374feb800673725dc6611fea82f1ba Mon Sep 17 00:00:00 2001 From: makslevental Date: Wed, 27 Aug 2025 23:30:01 -0400 Subject: [PATCH 01/16] [MLIR][Python] enable type stub auto-generation --- mlir/cmake/modules/AddMLIRPython.cmake | 43 + mlir/python/CMakeLists.txt | 20 +- mlir/python/mlir/_mlir_libs/.gitignore | 1 + .../python/mlir/_mlir_libs/_mlir/__init__.pyi | 12 - .../mlir/_mlir_libs/_mlir/dialects/pdl.pyi | 63 - .../mlir/_mlir_libs/_mlir/dialects/quant.pyi | 142 - .../_mlir/dialects/transform/__init__.pyi | 25 - mlir/python/mlir/_mlir_libs/_mlir/ir.pyi | 2846 ----------------- .../mlir/_mlir_libs/_mlir/passmanager.pyi | 36 - .../mlir/_mlir_libs/_mlirExecutionEngine.pyi | 24 - mlir/python/requirements.txt | 2 +- 11 files changed, 52 insertions(+), 3162 deletions(-) create mode 100644 mlir/python/mlir/_mlir_libs/.gitignore delete mode 100644 mlir/python/mlir/_mlir_libs/_mlir/__init__.pyi delete mode 100644 mlir/python/mlir/_mlir_libs/_mlir/dialects/pdl.pyi delete mode 100644 mlir/python/mlir/_mlir_libs/_mlir/dialects/quant.pyi delete mode 100644 mlir/python/mlir/_mlir_libs/_mlir/dialects/transform/__init__.pyi delete mode 100644 mlir/python/mlir/_mlir_libs/_mlir/ir.pyi delete mode 100644 mlir/python/mlir/_mlir_libs/_mlir/passmanager.pyi delete mode 100644 mlir/python/mlir/_mlir_libs/_mlirExecutionEngine.pyi diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index 2b883558d33c6..f0e36f85feabf 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -99,6 +99,38 @@ function(declare_mlir_python_sources name) endif() endfunction() +function(generate_type_stubs module_name depends_target output_dir) + 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() + + set(NB_STUBGEN_CMD + "${Python_EXECUTABLE}" + "${NB_STUBGEN}" + --module + "${MLIR_PYTHON_PACKAGE_PREFIX}._mlir_libs.${module_name}" + -i + "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}/.." + --recursive + --include-private + --output-dir + "${output_dir}") + + set(NB_STUBGEN_OUTPUT "${output_dir}/${module_name}.pyi") + add_custom_command( + OUTPUT ${NB_STUBGEN_OUTPUT} + COMMAND ${NB_STUBGEN_CMD} + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + DEPENDS ${depends_target}) + set(_name "MLIRPythonModuleStubs_${module_name}") + add_custom_target("${_name}" ALL DEPENDS ${NB_STUBGEN_OUTPUT}) + 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. @@ -243,6 +275,17 @@ function(add_mlir_python_modules name) ) add_dependencies(${modules_target} ${_extension_target}) mlir_python_setup_extension_rpath(${_extension_target}) + generate_type_stubs( + ${_module_name} + ${_extension_target} + "${CMAKE_CURRENT_SOURCE_DIR}/mlir/_mlir_libs/_mlir" + ) + declare_mlir_python_sources("_${_module_name}_type_stub_gen" + ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" + ADD_TO_PARENT "${sources_target}" + SOURCES_GLOB "_mlir_libs/${_module_name}/**/*.pyi" + ) + add_dependencies("${modules_target}" "${NB_STUBGEN_CUSTOM_TARGET}") else() message(SEND_ERROR "Unrecognized source type '${_source_type}' for python source target ${sources_target}") return() diff --git a/mlir/python/CMakeLists.txt b/mlir/python/CMakeLists.txt index 7a0c95ebb8200..961de0a9f45f3 100644 --- a/mlir/python/CMakeLists.txt +++ b/mlir/python/CMakeLists.txt @@ -1,5 +1,9 @@ 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. ################################################################################ @@ -23,11 +27,6 @@ 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 @@ -43,7 +42,6 @@ declare_mlir_python_sources(MLIRPythonSources.ExecutionEngine ADD_TO_PARENT MLIRPythonSources SOURCES execution_engine.py - _mlir_libs/_mlirExecutionEngine.pyi SOURCES_GLOB runtime/*.py ) @@ -195,7 +193,6 @@ 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" @@ -367,8 +364,7 @@ declare_mlir_python_sources( ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" GEN_ENUM_BINDINGS SOURCES - dialects/quant.py - _mlir_libs/_mlir/dialects/quant.pyi) + dialects/quant.py) declare_mlir_dialect_python_bindings( ADD_TO_PARENT MLIRPythonSources.Dialects @@ -384,7 +380,6 @@ 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( @@ -809,7 +804,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}/python_packages/mlir_core/mlir/_mlir_libs" + OUTPUT_DIRECTORY "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}/_mlir_libs" RELATIVE_INSTALL_ROOT "../../../.." DECLARED_HEADERS MLIRPythonCAPI.HeaderSources @@ -838,7 +833,7 @@ endif() ################################################################################ add_mlir_python_modules(MLIRPythonModules - ROOT_PREFIX "${MLIR_BINARY_DIR}/python_packages/mlir_core/mlir" + ROOT_PREFIX "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}" INSTALL_PREFIX "${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}" DECLARED_SOURCES MLIRPythonSources @@ -847,4 +842,3 @@ add_mlir_python_modules(MLIRPythonModules COMMON_CAPI_LINK_LIBS MLIRPythonCAPI ) - diff --git a/mlir/python/mlir/_mlir_libs/.gitignore b/mlir/python/mlir/_mlir_libs/.gitignore new file mode 100644 index 0000000000000..10c6f95d3ce42 --- /dev/null +++ b/mlir/python/mlir/_mlir_libs/.gitignore @@ -0,0 +1 @@ +_mlir/**/*.pyi \ No newline at end of file diff --git a/mlir/python/mlir/_mlir_libs/_mlir/__init__.pyi b/mlir/python/mlir/_mlir_libs/_mlir/__init__.pyi deleted file mode 100644 index 03449b70b7fa3..0000000000000 --- a/mlir/python/mlir/_mlir_libs/_mlir/__init__.pyi +++ /dev/null @@ -1,12 +0,0 @@ - -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 deleted file mode 100644 index d12c6839deaba..0000000000000 --- a/mlir/python/mlir/_mlir_libs/_mlir/dialects/pdl.pyi +++ /dev/null @@ -1,63 +0,0 @@ -# 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 deleted file mode 100644 index 3f5304584edef..0000000000000 --- a/mlir/python/mlir/_mlir_libs/_mlir/dialects/quant.pyi +++ /dev/null @@ -1,142 +0,0 @@ -# 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 deleted file mode 100644 index a3f1b09102379..0000000000000 --- a/mlir/python/mlir/_mlir_libs/_mlir/dialects/transform/__init__.pyi +++ /dev/null @@ -1,25 +0,0 @@ -# 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 deleted file mode 100644 index dcae3dd742940..0000000000000 --- a/mlir/python/mlir/_mlir_libs/_mlir/ir.pyi +++ /dev/null @@ -1,2846 +0,0 @@ -# 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 deleted file mode 100644 index 1010daddae2aa..0000000000000 --- a/mlir/python/mlir/_mlir_libs/_mlir/passmanager.pyi +++ /dev/null @@ -1,36 +0,0 @@ -# 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 deleted file mode 100644 index 4b82c78489295..0000000000000 --- a/mlir/python/mlir/_mlir_libs/_mlirExecutionEngine.pyi +++ /dev/null @@ -1,24 +0,0 @@ -# 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 1a0075e829aef..8fe75a117a973 100644 --- a/mlir/python/requirements.txt +++ b/mlir/python/requirements.txt @@ -1,4 +1,4 @@ -nanobind>=2.4, <3.0 +nanobind @ git+https://github.com/wjakob/nanobind@53dce4e numpy>=1.19.5, <=2.1.2 pybind11>=2.10.0, <=2.13.6 PyYAML>=5.4.0, <=6.0.1 From 46c84af8984ffc660837d5bf5f08bd71dcf293e1 Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Thu, 28 Aug 2025 02:41:44 -0400 Subject: [PATCH 02/16] Update requirements.txt --- mlir/python/requirements.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mlir/python/requirements.txt b/mlir/python/requirements.txt index 8fe75a117a973..a0b2c3736b214 100644 --- a/mlir/python/requirements.txt +++ b/mlir/python/requirements.txt @@ -1,6 +1,6 @@ -nanobind @ git+https://github.com/wjakob/nanobind@53dce4e +nanobind @ git+https://github.com/wjakob/nanobind 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" \ No newline at end of file +ml_dtypes>=0.5.0, <=0.6.0; python_version>="3.13" From f7a431dc83caa2852b3a07c5da0df5e74349268c Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Thu, 28 Aug 2025 03:11:17 -0400 Subject: [PATCH 03/16] Update monolithic-linux.sh --- .ci/monolithic-linux.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/.ci/monolithic-linux.sh b/.ci/monolithic-linux.sh index 5abb8d72df028..3010515e0cf9e 100755 --- a/.ci/monolithic-linux.sh +++ b/.ci/monolithic-linux.sh @@ -34,6 +34,7 @@ lit_args="-v --xunit-xml-output ${BUILD_DIR}/test-results.xml --use-unique-outpu start-group "CMake" export PIP_BREAK_SYSTEM_PACKAGES=1 pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt +pip install "nanobind @ git+https://github.com/wjakob/nanobind" # Set the system llvm-symbolizer as preferred. export LLVM_SYMBOLIZER_PATH=`which llvm-symbolizer` From 0523d165c4272c6de7c36ca9169ba1356378e421 Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Thu, 28 Aug 2025 03:12:00 -0400 Subject: [PATCH 04/16] Update monolithic-windows.sh --- .ci/monolithic-windows.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/.ci/monolithic-windows.sh b/.ci/monolithic-windows.sh index 14dea04c04291..d773213d257a4 100755 --- a/.ci/monolithic-windows.sh +++ b/.ci/monolithic-windows.sh @@ -22,6 +22,7 @@ runtimes_targets="${4}" start-group "CMake" pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt +pip install "nanobind @ git+https://github.com/wjakob/nanobind" export CC=cl export CXX=cl From b10c6e5e5a89740d07c038719c2da0e4dab86d56 Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Thu, 28 Aug 2025 08:09:43 -0400 Subject: [PATCH 05/16] Update AddMLIRPython.cmake --- mlir/cmake/modules/AddMLIRPython.cmake | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index f0e36f85feabf..71ff59e9a264c 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -99,7 +99,7 @@ function(declare_mlir_python_sources name) endif() endfunction() -function(generate_type_stubs module_name depends_target output_dir) +function(generate_type_stubs module_name depends_target mlir_depends_target output_dir) if(EXISTS ${nanobind_DIR}/../src/stubgen.py) set(NB_STUBGEN "${nanobind_DIR}/../src/stubgen.py") elseif(EXISTS ${nanobind_DIR}/../stubgen.py) @@ -108,11 +108,12 @@ function(generate_type_stubs module_name depends_target output_dir) message(FATAL_ERROR "generate_type_stubs(): could not locate 'stubgen.py'!") endif() + set(_module "${MLIR_PYTHON_PACKAGE_PREFIX}._mlir_libs.${module_name}") set(NB_STUBGEN_CMD "${Python_EXECUTABLE}" "${NB_STUBGEN}" --module - "${MLIR_PYTHON_PACKAGE_PREFIX}._mlir_libs.${module_name}" + "${_module}" -i "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}/.." --recursive @@ -125,8 +126,8 @@ function(generate_type_stubs module_name depends_target output_dir) OUTPUT ${NB_STUBGEN_OUTPUT} COMMAND ${NB_STUBGEN_CMD} WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" - DEPENDS ${depends_target}) - set(_name "MLIRPythonModuleStubs_${module_name}") + DEPENDS "${mlir_depends_target}" "${depends_target}") + set(_name "MLIRPythonModuleStubs_${_module}") add_custom_target("${_name}" ALL DEPENDS ${NB_STUBGEN_OUTPUT}) set(NB_STUBGEN_CUSTOM_TARGET "${_name}" PARENT_SCOPE) endfunction() @@ -278,9 +279,11 @@ function(add_mlir_python_modules name) generate_type_stubs( ${_module_name} ${_extension_target} + "${modules_target}.extension._mlir.dso" "${CMAKE_CURRENT_SOURCE_DIR}/mlir/_mlir_libs/_mlir" ) - declare_mlir_python_sources("_${_module_name}_type_stub_gen" + declare_mlir_python_sources( + "${MLIR_PYTHON_PACKAGE_PREFIX}.${_module_name}_type_stub_gen" ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" ADD_TO_PARENT "${sources_target}" SOURCES_GLOB "_mlir_libs/${_module_name}/**/*.pyi" From 84063b84884d44d73d8f188f5550cf24049f0c3a Mon Sep 17 00:00:00 2001 From: makslevental Date: Thu, 28 Aug 2025 23:38:57 -0400 Subject: [PATCH 06/16] add typing_extensions to windows --- .ci/monolithic-windows.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/.ci/monolithic-windows.sh b/.ci/monolithic-windows.sh index d773213d257a4..a7659a0eba27d 100755 --- a/.ci/monolithic-windows.sh +++ b/.ci/monolithic-windows.sh @@ -23,6 +23,7 @@ runtimes_targets="${4}" start-group "CMake" pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt pip install "nanobind @ git+https://github.com/wjakob/nanobind" +pip install typing_extensions export CC=cl export CXX=cl From 4aa5845a9b8e85d1e24ed66e13d121434530ccbc Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Fri, 29 Aug 2025 18:13:33 -0400 Subject: [PATCH 07/16] fix stubgen failure pybind11 --- .ci/monolithic-linux.sh | 1 - .ci/monolithic-windows.sh | 1 - mlir/cmake/modules/AddMLIRPython.cmake | 40 ++++++++++++++++---------- mlir/python/requirements.txt | 3 +- 4 files changed, 27 insertions(+), 18 deletions(-) diff --git a/.ci/monolithic-linux.sh b/.ci/monolithic-linux.sh index 3010515e0cf9e..5abb8d72df028 100755 --- a/.ci/monolithic-linux.sh +++ b/.ci/monolithic-linux.sh @@ -34,7 +34,6 @@ lit_args="-v --xunit-xml-output ${BUILD_DIR}/test-results.xml --use-unique-outpu start-group "CMake" export PIP_BREAK_SYSTEM_PACKAGES=1 pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt -pip install "nanobind @ git+https://github.com/wjakob/nanobind" # Set the system llvm-symbolizer as preferred. export LLVM_SYMBOLIZER_PATH=`which llvm-symbolizer` diff --git a/.ci/monolithic-windows.sh b/.ci/monolithic-windows.sh index a7659a0eba27d..afd210e25eb1f 100755 --- a/.ci/monolithic-windows.sh +++ b/.ci/monolithic-windows.sh @@ -22,7 +22,6 @@ runtimes_targets="${4}" start-group "CMake" pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt -pip install "nanobind @ git+https://github.com/wjakob/nanobind" pip install typing_extensions export CC=cl diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index 71ff59e9a264c..37b080229a22c 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -151,7 +151,7 @@ endfunction() function(declare_mlir_python_extension name) cmake_parse_arguments(ARG "" - "ROOT_DIR;MODULE_NAME;ADD_TO_PARENT;PYTHON_BINDINGS_LIBRARY" + "ROOT_DIR;MODULE_NAME;ADD_TO_PARENT;PYTHON_BINDINGS_LIBRARY;GENERATE_TYPE_STUBS" "SOURCES;PRIVATE_LINK_LIBS;EMBED_CAPI_LINK_LIBS" ${ARGN}) @@ -163,17 +163,24 @@ function(declare_mlir_python_extension name) if(NOT ARG_PYTHON_BINDINGS_LIBRARY) set(ARG_PYTHON_BINDINGS_LIBRARY "pybind11") endif() + if(ARG_PYTHON_BINDINGS_LIBRARY STREQUAL "pybind11") + set(ARG_GENERATE_TYPE_STUBS OFF) + endif() + if(NOT DEFINED ARG_GENERATE_TYPE_STUBS) + set(ARG_GENERATE_TYPE_STUBS ON) + endif() add_library(${name} INTERFACE) 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" + 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" 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 @@ -276,19 +283,22 @@ function(add_mlir_python_modules name) ) add_dependencies(${modules_target} ${_extension_target}) mlir_python_setup_extension_rpath(${_extension_target}) - generate_type_stubs( - ${_module_name} - ${_extension_target} - "${modules_target}.extension._mlir.dso" - "${CMAKE_CURRENT_SOURCE_DIR}/mlir/_mlir_libs/_mlir" - ) - declare_mlir_python_sources( - "${MLIR_PYTHON_PACKAGE_PREFIX}.${_module_name}_type_stub_gen" - ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" - ADD_TO_PARENT "${sources_target}" - SOURCES_GLOB "_mlir_libs/${_module_name}/**/*.pyi" - ) - add_dependencies("${modules_target}" "${NB_STUBGEN_CUSTOM_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} + "${modules_target}.extension._mlir.dso" + "${CMAKE_CURRENT_SOURCE_DIR}/mlir/_mlir_libs/_mlir" + ) + declare_mlir_python_sources( + "${MLIR_PYTHON_PACKAGE_PREFIX}.${_module_name}_type_stub_gen" + ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir" + ADD_TO_PARENT "${sources_target}" + SOURCES_GLOB "_mlir_libs/${_module_name}/**/*.pyi" + ) + add_dependencies("${modules_target}" "${NB_STUBGEN_CUSTOM_TARGET}") + endif() else() message(SEND_ERROR "Unrecognized source type '${_source_type}' for python source target ${sources_target}") return() diff --git a/mlir/python/requirements.txt b/mlir/python/requirements.txt index a0b2c3736b214..cfb64caae03bc 100644 --- a/mlir/python/requirements.txt +++ b/mlir/python/requirements.txt @@ -1,6 +1,7 @@ -nanobind @ git+https://github.com/wjakob/nanobind +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 \ No newline at end of file From 122fc23d623905e064d73255cd82cef2cefb5ff1 Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Fri, 29 Aug 2025 20:28:17 -0400 Subject: [PATCH 08/16] fix windows --- mlir/cmake/modules/AddMLIRPython.cmake | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index 37b080229a22c..dab098bf7a6d2 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -103,19 +103,23 @@ function(generate_type_stubs module_name depends_target mlir_depends_target outp 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") + set(NB_STUBGEN "${nanobind_DIR}/../stubgen.py") else() - message(FATAL_ERROR "generate_type_stubs(): could not locate 'stubgen.py'!") + 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) + # file(TO_NATIVE_PATH ${_import_path} _import_path) + set(NB_STUBGEN_CMD "${Python_EXECUTABLE}" "${NB_STUBGEN}" --module "${_module}" -i - "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}/.." + "${_import_path}" --recursive --include-private --output-dir @@ -125,7 +129,7 @@ function(generate_type_stubs module_name depends_target mlir_depends_target outp add_custom_command( OUTPUT ${NB_STUBGEN_OUTPUT} COMMAND ${NB_STUBGEN_CMD} - WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + WORKING_DIRECTORY "${CMAKE_CURRENT_FUNCTION_LIST_DIR}" DEPENDS "${mlir_depends_target}" "${depends_target}") set(_name "MLIRPythonModuleStubs_${_module}") add_custom_target("${_name}" ALL DEPENDS ${NB_STUBGEN_OUTPUT}) From b5934b5b4eede54febec0f6e70a032a852c0fcac Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Sat, 30 Aug 2025 00:14:22 -0400 Subject: [PATCH 09/16] Update monolithic-windows.sh --- .ci/monolithic-windows.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/.ci/monolithic-windows.sh b/.ci/monolithic-windows.sh index afd210e25eb1f..1426f70b1d61f 100755 --- a/.ci/monolithic-windows.sh +++ b/.ci/monolithic-windows.sh @@ -23,6 +23,7 @@ runtimes_targets="${4}" start-group "CMake" pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt pip install typing_extensions +pip install "nanobind @ git+https://github.com/wjakob/nanobind" --force export CC=cl export CXX=cl From 549c7721eab50034726185818cceb85e710a9505 Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Sat, 30 Aug 2025 01:09:27 -0400 Subject: [PATCH 10/16] Update AddMLIRPython.cmake --- mlir/cmake/modules/AddMLIRPython.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index dab098bf7a6d2..63d32e0939c06 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -130,7 +130,7 @@ function(generate_type_stubs module_name depends_target mlir_depends_target outp OUTPUT ${NB_STUBGEN_OUTPUT} COMMAND ${NB_STUBGEN_CMD} WORKING_DIRECTORY "${CMAKE_CURRENT_FUNCTION_LIST_DIR}" - DEPENDS "${mlir_depends_target}" "${depends_target}") + DEPENDS "${mlir_depends_target}" "${depends_target}" MLIRPythonSources.Core.Python) set(_name "MLIRPythonModuleStubs_${_module}") add_custom_target("${_name}" ALL DEPENDS ${NB_STUBGEN_OUTPUT}) set(NB_STUBGEN_CUSTOM_TARGET "${_name}" PARENT_SCOPE) From 72ca8d47a573bec4cfdbc60856e218cf1032a365 Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Sat, 30 Aug 2025 01:38:06 -0400 Subject: [PATCH 11/16] Update AddMLIRPython.cmake --- mlir/cmake/modules/AddMLIRPython.cmake | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index 63d32e0939c06..11cffb6383a1c 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -130,7 +130,11 @@ function(generate_type_stubs module_name depends_target mlir_depends_target outp OUTPUT ${NB_STUBGEN_OUTPUT} COMMAND ${NB_STUBGEN_CMD} WORKING_DIRECTORY "${CMAKE_CURRENT_FUNCTION_LIST_DIR}" - DEPENDS "${mlir_depends_target}" "${depends_target}" MLIRPythonSources.Core.Python) + 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 ${NB_STUBGEN_OUTPUT}) set(NB_STUBGEN_CUSTOM_TARGET "${_name}" PARENT_SCOPE) @@ -292,7 +296,7 @@ function(add_mlir_python_modules name) generate_type_stubs( ${_module_name} ${_extension_target} - "${modules_target}.extension._mlir.dso" + ${name} "${CMAKE_CURRENT_SOURCE_DIR}/mlir/_mlir_libs/_mlir" ) declare_mlir_python_sources( From d7c172aeeb7b3bf970c6d1eaaab0abaa2870d8a7 Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Mon, 1 Sep 2025 22:54:25 -0400 Subject: [PATCH 12/16] update all-requirements --- .ci/all_requirements.txt | 12 +++++--- .ci/monolithic-linux.sh | 1 + .ci/monolithic-windows.sh | 3 +- mlir/cmake/modules/AddMLIRPython.cmake | 38 ++++++++++++++------------ mlir/python/mlir/_mlir_libs/.gitignore | 2 +- mlir/python/requirements.txt | 4 +-- 6 files changed, 33 insertions(+), 27 deletions(-) diff --git a/.ci/all_requirements.txt b/.ci/all_requirements.txt index dea9646f648ad..ca41dec0c1bf7 100644 --- a/.ci/all_requirements.txt +++ b/.ci/all_requirements.txt @@ -194,10 +194,10 @@ ml-dtypes==0.5.1 ; python_version < "3.13" \ --hash=sha256:d13755f8e8445b3870114e5b6240facaa7cb0c3361e54beba3e07fa912a6e12b \ --hash=sha256:fd918d4e6a4e0c110e2e05be7a7814d10dc1b95872accbf6512b80a109b71ae1 # via -r mlir/python/requirements.txt -nanobind==2.7.0 \ - --hash=sha256:73b12d0e751d140d6c1bf4b215e18818a8debfdb374f08dc3776ad208d808e74 \ - --hash=sha256:f9f1b160580c50dcf37b6495a0fd5ec61dc0d95dae5f8004f87dd9ad7eb46b34 - # via -r mlir/python/requirements.txt +# # WARNING: pip install will require the following package to be hashed. +# # Consider using a hashable URL like https://github.com/jazzband/pip-tools/archive/SOMECOMMIT.zip +# nanobind @ git+https://github.com/wjakob/nanobind +# # via -r mlir/python/requirements.txt numpy==2.0.2 \ --hash=sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a \ --hash=sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195 \ @@ -383,6 +383,10 @@ 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/.ci/monolithic-linux.sh b/.ci/monolithic-linux.sh index 5abb8d72df028..cc4a0ece9b391 100755 --- a/.ci/monolithic-linux.sh +++ b/.ci/monolithic-linux.sh @@ -34,6 +34,7 @@ lit_args="-v --xunit-xml-output ${BUILD_DIR}/test-results.xml --use-unique-outpu start-group "CMake" export PIP_BREAK_SYSTEM_PACKAGES=1 pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt +pip install -q "nanobind @ git+https://github.com/wjakob/nanobind#53dce4e" # Set the system llvm-symbolizer as preferred. export LLVM_SYMBOLIZER_PATH=`which llvm-symbolizer` diff --git a/.ci/monolithic-windows.sh b/.ci/monolithic-windows.sh index 1426f70b1d61f..afcdaa4d1c05f 100755 --- a/.ci/monolithic-windows.sh +++ b/.ci/monolithic-windows.sh @@ -22,8 +22,7 @@ runtimes_targets="${4}" start-group "CMake" pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt -pip install typing_extensions -pip install "nanobind @ git+https://github.com/wjakob/nanobind" --force +pip install -q "nanobind @ git+https://github.com/wjakob/nanobind#53dce4e" export CC=cl export CXX=cl diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index 11cffb6383a1c..fa783349856e1 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -742,26 +742,28 @@ 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-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-deprecated-literal-operator + -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-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-deprecated-literal-operator + -Wno-nested-anon-types + -Wno-unused-parameter + -Wno-zero-length-array + ${eh_rtti_enable}) endif() if(APPLE) diff --git a/mlir/python/mlir/_mlir_libs/.gitignore b/mlir/python/mlir/_mlir_libs/.gitignore index 10c6f95d3ce42..1d6765818d346 100644 --- a/mlir/python/mlir/_mlir_libs/.gitignore +++ b/mlir/python/mlir/_mlir_libs/.gitignore @@ -1 +1 @@ -_mlir/**/*.pyi \ No newline at end of file +_mlir/**/*.pyi diff --git a/mlir/python/requirements.txt b/mlir/python/requirements.txt index cfb64caae03bc..5e2de3e512899 100644 --- a/mlir/python/requirements.txt +++ b/mlir/python/requirements.txt @@ -1,7 +1,7 @@ -nanobind>=2.4, <3.0 +nanobind @ git+https://github.com/wjakob/nanobind#53dce4e 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 \ No newline at end of file +typing_extensions>=4.12.2 From 337038ca0a60c6f4419fa230073902a7921fa6c6 Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Tue, 2 Sep 2025 10:56:35 -0400 Subject: [PATCH 13/16] fix generate_type_stubs doc string --- mlir/cmake/modules/AddMLIRPython.cmake | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index fa783349856e1..704fd3b4e4156 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -99,7 +99,18 @@ function(declare_mlir_python_sources name) endif() endfunction() -function(generate_type_stubs module_name depends_target mlir_depends_target output_dir) +# 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) if(EXISTS ${nanobind_DIR}/../src/stubgen.py) set(NB_STUBGEN "${nanobind_DIR}/../src/stubgen.py") elseif(EXISTS ${nanobind_DIR}/../stubgen.py) @@ -109,9 +120,8 @@ function(generate_type_stubs module_name depends_target mlir_depends_target outp endif() file(REAL_PATH "${NB_STUBGEN}" NB_STUBGEN) - set(_module "${MLIR_PYTHON_PACKAGE_PREFIX}._mlir_libs.${module_name}") + set(_module "${MLIR_PYTHON_PACKAGE_PREFIX}._mlir_libs.${MODULE_NAME}") file(REAL_PATH "${MLIR_BINARY_DIR}/${MLIR_BINDINGS_PYTHON_INSTALL_PREFIX}/.." _import_path) - # file(TO_NATIVE_PATH ${_import_path} _import_path) set(NB_STUBGEN_CMD "${Python_EXECUTABLE}" @@ -123,17 +133,17 @@ function(generate_type_stubs module_name depends_target mlir_depends_target outp --recursive --include-private --output-dir - "${output_dir}") + "${OUTPUT_DIR}") - set(NB_STUBGEN_OUTPUT "${output_dir}/${module_name}.pyi") + set(NB_STUBGEN_OUTPUT "${OUTPUT_DIR}/${MODULE_NAME}.pyi") add_custom_command( OUTPUT ${NB_STUBGEN_OUTPUT} 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}" + "${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 ${NB_STUBGEN_OUTPUT}) From acfe5955886c7d6e3ec190b416806cc3528a4daa Mon Sep 17 00:00:00 2001 From: Maksim Levental Date: Tue, 2 Sep 2025 10:57:02 -0400 Subject: [PATCH 14/16] remove pybind11 limitation --- mlir/cmake/modules/AddMLIRPython.cmake | 3 --- 1 file changed, 3 deletions(-) diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index 704fd3b4e4156..71b6667d5b87f 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -181,9 +181,6 @@ function(declare_mlir_python_extension name) if(NOT ARG_PYTHON_BINDINGS_LIBRARY) set(ARG_PYTHON_BINDINGS_LIBRARY "pybind11") endif() - if(ARG_PYTHON_BINDINGS_LIBRARY STREQUAL "pybind11") - set(ARG_GENERATE_TYPE_STUBS OFF) - endif() if(NOT DEFINED ARG_GENERATE_TYPE_STUBS) set(ARG_GENERATE_TYPE_STUBS ON) endif() From 8395098adb5a2fc20f94452db0bd28ef7353ec50 Mon Sep 17 00:00:00 2001 From: makslevental Date: Thu, 4 Sep 2025 09:26:07 -0700 Subject: [PATCH 15/16] bump nanobind to support stubgen --- .ci/all_requirements.txt | 8 ++++---- .ci/monolithic-linux.sh | 1 - .ci/monolithic-windows.sh | 1 - mlir/python/requirements.txt | 2 +- 4 files changed, 5 insertions(+), 7 deletions(-) diff --git a/.ci/all_requirements.txt b/.ci/all_requirements.txt index ca41dec0c1bf7..ac9682a09bec1 100644 --- a/.ci/all_requirements.txt +++ b/.ci/all_requirements.txt @@ -194,10 +194,10 @@ ml-dtypes==0.5.1 ; python_version < "3.13" \ --hash=sha256:d13755f8e8445b3870114e5b6240facaa7cb0c3361e54beba3e07fa912a6e12b \ --hash=sha256:fd918d4e6a4e0c110e2e05be7a7814d10dc1b95872accbf6512b80a109b71ae1 # via -r mlir/python/requirements.txt -# # WARNING: pip install will require the following package to be hashed. -# # Consider using a hashable URL like https://github.com/jazzband/pip-tools/archive/SOMECOMMIT.zip -# nanobind @ git+https://github.com/wjakob/nanobind -# # via -r mlir/python/requirements.txt +nanobind==2.9.2 \ + --hash=sha256:c37957ffd5eac7eda349cff3622ecd32e5ee1244ecc912c99b5bc8188bafd16e \ + --hash=sha256:e7608472de99d375759814cab3e2c94aba3f9ec80e62cfef8ced495ca5c27d6e + # via -r mlir/python/requirements.txt numpy==2.0.2 \ --hash=sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a \ --hash=sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195 \ diff --git a/.ci/monolithic-linux.sh b/.ci/monolithic-linux.sh index cc4a0ece9b391..5abb8d72df028 100755 --- a/.ci/monolithic-linux.sh +++ b/.ci/monolithic-linux.sh @@ -34,7 +34,6 @@ lit_args="-v --xunit-xml-output ${BUILD_DIR}/test-results.xml --use-unique-outpu start-group "CMake" export PIP_BREAK_SYSTEM_PACKAGES=1 pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt -pip install -q "nanobind @ git+https://github.com/wjakob/nanobind#53dce4e" # Set the system llvm-symbolizer as preferred. export LLVM_SYMBOLIZER_PATH=`which llvm-symbolizer` diff --git a/.ci/monolithic-windows.sh b/.ci/monolithic-windows.sh index afcdaa4d1c05f..14dea04c04291 100755 --- a/.ci/monolithic-windows.sh +++ b/.ci/monolithic-windows.sh @@ -22,7 +22,6 @@ runtimes_targets="${4}" start-group "CMake" pip install -q -r "${MONOREPO_ROOT}"/.ci/all_requirements.txt -pip install -q "nanobind @ git+https://github.com/wjakob/nanobind#53dce4e" export CC=cl export CXX=cl diff --git a/mlir/python/requirements.txt b/mlir/python/requirements.txt index 5e2de3e512899..abe09259bb1e8 100644 --- a/mlir/python/requirements.txt +++ b/mlir/python/requirements.txt @@ -1,4 +1,4 @@ -nanobind @ git+https://github.com/wjakob/nanobind#53dce4e +nanobind>=2.9, <3.0 numpy>=1.19.5, <=2.1.2 pybind11>=2.10.0, <=2.13.6 PyYAML>=5.4.0, <=6.0.1 From 33d52b9d647f358b09d975aa128d005710ba8632 Mon Sep 17 00:00:00 2001 From: makslevental Date: Thu, 4 Sep 2025 09:54:15 -0700 Subject: [PATCH 16/16] fix GENERATE_TYPE_STUBS --- mlir/cmake/modules/AddMLIRPython.cmake | 8 +++----- mlir/examples/standalone/python/CMakeLists.txt | 1 + mlir/python/CMakeLists.txt | 18 ++++++++++++++++++ 3 files changed, 22 insertions(+), 5 deletions(-) diff --git a/mlir/cmake/modules/AddMLIRPython.cmake b/mlir/cmake/modules/AddMLIRPython.cmake index 71b6667d5b87f..7d97e34147f06 100644 --- a/mlir/cmake/modules/AddMLIRPython.cmake +++ b/mlir/cmake/modules/AddMLIRPython.cmake @@ -166,10 +166,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: Enable type stub generation. function(declare_mlir_python_extension name) cmake_parse_arguments(ARG - "" - "ROOT_DIR;MODULE_NAME;ADD_TO_PARENT;PYTHON_BINDINGS_LIBRARY;GENERATE_TYPE_STUBS" + "GENERATE_TYPE_STUBS" + "ROOT_DIR;MODULE_NAME;ADD_TO_PARENT;PYTHON_BINDINGS_LIBRARY" "SOURCES;PRIVATE_LINK_LIBS;EMBED_CAPI_LINK_LIBS" ${ARGN}) @@ -181,9 +182,6 @@ function(declare_mlir_python_extension name) if(NOT ARG_PYTHON_BINDINGS_LIBRARY) set(ARG_PYTHON_BINDINGS_LIBRARY "pybind11") endif() - if(NOT DEFINED ARG_GENERATE_TYPE_STUBS) - set(ARG_GENERATE_TYPE_STUBS ON) - endif() add_library(${name} INTERFACE) set_target_properties(${name} PROPERTIES diff --git a/mlir/examples/standalone/python/CMakeLists.txt b/mlir/examples/standalone/python/CMakeLists.txt index a0eca9c095775..cb10518e94e33 100644 --- a/mlir/examples/standalone/python/CMakeLists.txt +++ b/mlir/examples/standalone/python/CMakeLists.txt @@ -39,6 +39,7 @@ 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 961de0a9f45f3..21eb7e2059024 100644 --- a/mlir/python/CMakeLists.txt +++ b/mlir/python/CMakeLists.txt @@ -497,6 +497,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Core # Dialects MLIRCAPIFunc + GENERATE_TYPE_STUBS ) # This extension exposes an API to register all dialects, extensions, and passes @@ -518,6 +519,7 @@ declare_mlir_python_extension(MLIRPythonExtension.RegisterEverything MLIRCAPIConversion MLIRCAPITransforms MLIRCAPIRegisterEverything + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.Linalg.Pybind @@ -532,6 +534,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.Linalg.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPILinalg + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.GPU.Pybind @@ -546,6 +549,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.GPU.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPIGPU + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.LLVM.Pybind @@ -560,6 +564,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.LLVM.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPILLVM + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.Quant.Pybind @@ -574,6 +579,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.Quant.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPIQuant + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.NVGPU.Pybind @@ -588,6 +594,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.NVGPU.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPINVGPU + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.PDL.Pybind @@ -602,6 +609,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.PDL.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPIPDL + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.SparseTensor.Pybind @@ -616,6 +624,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.SparseTensor.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPISparseTensor + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.Transform.Pybind @@ -630,6 +639,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.Transform.Pybind EMBED_CAPI_LINK_LIBS MLIRCAPIIR MLIRCAPITransformDialect + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.AsyncDialectPasses @@ -643,6 +653,7 @@ declare_mlir_python_extension(MLIRPythonExtension.AsyncDialectPasses LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPIAsync + GENERATE_TYPE_STUBS ) if(MLIR_ENABLE_EXECUTION_ENGINE) @@ -657,6 +668,7 @@ if(MLIR_ENABLE_EXECUTION_ENGINE) LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPIExecutionEngine + GENERATE_TYPE_STUBS ) endif() @@ -671,6 +683,7 @@ declare_mlir_python_extension(MLIRPythonExtension.GPUDialectPasses LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPIGPU + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.LinalgPasses @@ -684,6 +697,7 @@ declare_mlir_python_extension(MLIRPythonExtension.LinalgPasses LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPILinalg + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.Dialects.SMT.Pybind @@ -701,6 +715,7 @@ declare_mlir_python_extension(MLIRPythonExtension.Dialects.SMT.Pybind MLIRCAPIIR MLIRCAPISMT MLIRCAPIExportSMTLIB + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.SparseTensorDialectPasses @@ -714,6 +729,7 @@ declare_mlir_python_extension(MLIRPythonExtension.SparseTensorDialectPasses LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPISparseTensor + GENERATE_TYPE_STUBS ) declare_mlir_python_extension(MLIRPythonExtension.TransformInterpreter @@ -727,6 +743,7 @@ declare_mlir_python_extension(MLIRPythonExtension.TransformInterpreter LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPITransformDialectTransforms + GENERATE_TYPE_STUBS ) # TODO: Figure out how to put this in the test tree. @@ -785,6 +802,7 @@ if(MLIR_INCLUDE_TESTS) LLVMSupport EMBED_CAPI_LINK_LIBS MLIRCAPIPythonTestDialect + GENERATE_TYPE_STUBS ) endif()