`i8dZddlmZddlmZer ddlmZddlmZddlZddl m Z ddl m Z m Z dd lmZmZd d lmZmZd d lmZgd ZGdde ZedGddejZdddZd d!dZdS)"z%Module related objects and functions.) annotations) TYPE_CHECKING)Sequence)AnyN)IntEnum)PathLikefspath)ClassVarcast)_ffi_apicore)register_object)ModuleModulePropertyMask load_module system_libceZdZdZdZdZdZdS)rzRuntime Module Property Mask.r N)__name__ __module__ __qualname____doc__BINARY_SERIALIZABLERUNNABLECOMPILATION_EXPORTABLEb/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/tvm_ffi/module.pyrr)s'''H"rrz ffi.ModuleceZdZUdZded<dZded<ed-d Zed.d Zd/d0dZ d1dZ d/d2dZ d/d3dZ d/d4dZ d5dZd1dZd6dZd7d8d!Zd9d#Zd:d%Zd;d&Zd;d'Zd;d(Zdra~Module container for dynamically loaded Module. Examples -------- .. code-block:: python import tvm_ffi # Load the module from a shared library mod = tvm_ffi.load_module("path/to/library.so") # Call exported function mod.func_name(*args) # Query function metadata (type signature) metadata = mod.get_function_metadata("func_name") # Query function documentation (if available) doc = mod.get_function_doc("func_name") See Also -------- :py:func:`tvm_ffi.load_module` :py:meth:`get_function_metadata` :py:meth:`get_function_doc` Notes ----- If you load a module within a local scope, be careful when any called function creates and returns an object. The memory deallocation routines are part of the library's code. If the module is unloaded before the object is destroyed, the deleter may call an invalid address. Keep the module loaded until all returned objects are deleted. You can safely use returned objects inside a nested function that finishes before the module goes out of scope. When possible, consider keeping the module alive in a long-lived/global scope (for example, in a global state) to avoid premature unloading. .. code-block:: python def bad_pattern(x): # Bad: unload order of `tensor` and `mod` is not guaranteed mod = tvm_ffi.load_module("path/to/library.so") # ... do something with the tensor tensor = mod.func_create_and_return_tensor(x) def good_pattern(x): # Good: `tensor` is freed before `mod` goes out of scope mod = tvm_ffi.load_module("path/to/library.so") def run_some_tests(): tensor = mod.func_create_and_return_tensor(x) # ... do something with the tensor run_some_tests() z Sequence[Any]imports_mainz ClassVar[str] entry_namereturnstrc*tj|S)zGet type key of the module.)r ModuleGetKindselfs r kindz Module.kindus%d+++r list[Module]c|jS)zgGet imported modules. Returns ------- modules The module )r"r)s r importszModule.importszs }rFname query_importsboolc.tj|||S)aReturn True if the module defines a global function. Notes ----- ``implements_function(name)`` does not guarantee that ``get_function(name)`` will return a callable, because some module kinds (e.g. a source-only module) may not provide a packed function implementation until further compilation occurs. However, a non-null result from ``get_function(name)`` should imply the module implements the function. Parameters ---------- name The name of the function query_imports Whether to also query modules imported by this module. Returns ------- True if module (or one of its imports) has a definition for name. )r ModuleImplementsFunction)r*r/r0s r implements_functionzModule.implements_functions20t]KKKr core.Functionc ||}||j|<|S#t$rtd|dwxYw)z2Accessor to allow getting functions as attributes.Module has no function '') get_function__dict__AttributeError)r*r/funcs r __getattr__zModule.__getattr__se E$$T**D"&DM$ K E E E !CD!C!C!CDD D Es #Actj|||}ttj|}|t d|d|S)aGet function from the module. Parameters ---------- name The name of the function query_imports Whether to also query modules imported by this module. Returns ------- The result function. Nr7r8)r ModuleGetFunctionr rFunctionr;)r*r/r0r<s r r9zModule.get_functionsM )$mDDDM4(( < !CD!C!C!CDD D rdict[str, Any] | Nonec^tj|||}|dStj|S)aGet metadata for a function exported from the module. This retrieves metadata for functions exported via c:macro:`TVM_FFI_DLL_EXPORT_TYPED_FUNC` and when c:macro:`TVM_FFI_DLL_EXPORT_INCLUDE_METADATA` is on, which includes type schema information. Parameters ---------- name The name of the function query_imports Whether to also query modules imported by this module. Returns ------- metadata A dictionary containing function metadata. The ``type_schema`` field encodes the callable signature. Examples -------- .. code-block:: python import tvm_ffi from tvm_ffi.core import TypeSchema import json mod = tvm_ffi.load_module("add_one_cpu.so") metadata = mod.get_function_metadata("add_one_cpu") schema = TypeSchema.from_json_str(metadata["type_schema"]) print(schema) # Shows function signature See Also -------- :py:func:`tvm_ffi.get_global_func_metadata` Get metadata for global registry functions. N)r ModuleGetFunctionMetadatajsonloads)r*r/r0 metadata_strs r get_function_metadatazModule.get_function_metadatas4T 9$mTT  4z,'''r str | Nonec:tj|||}|r|ndS)a^Get documentation string for a function exported from the module. This retrieves documentation for functions exported via c:macro:`TVM_FFI_DLL_EXPORT_TYPED_FUNC_DOC`. Parameters ---------- name The name of the function query_imports Whether to also query modules imported by this module. Returns ------- doc : str or None The documentation string if available, None otherwise. Examples -------- .. code-block:: python import tvm_ffi mod = tvm_ffi.load_module("mylib.so") doc = mod.get_function_doc("process_batch") if doc: print(doc) See Also -------- :py:meth:`get_function_metadata` Get metadata including type schema. N)r ModuleGetFunctionDoc)r*r/r0doc_strs r get_function_doczModule.get_function_docs(F/dMJJ!+wwt+rmoduleNonec0tj||dS)zAdd module to the import list of current one. Parameters ---------- module The other module. N)r ModuleImportModule)r*rMs r import_modulezModule.import_modules #D&11111rctt|tstd||S)z;Return function by name using item access (module["func"]).z%Can only take string as function name) isinstancer& ValueErrorr9)r*r/s r __getitem__zModule.__getitem__ s8$$$ FDEE E  &&&rargsrc|j|S)z*Call the module's entry function (`main`).)r#)r*rVs r __call__zModule.__call__&sty$rfmtc,tj||S)zGet source code from module, if available. Parameters ---------- fmt The specified format. Returns ------- The result source code. )r ModuleInspectSource)r*rZs r inspect_sourcezModule.inspect_source+s+D#666r Sequence[str]c*tj|S)zGet the format of the module.)r ModuleGetWriteFormatsr)s r get_write_formatszModule.get_write_formats:s-d333rintc*tj|S)zGet the runtime module property mask. The mapping is stated in ModulePropertyMask. Returns ------- Bitmask of runtime module property )r ModuleGetPropertyMaskr)s r get_property_maskzModule.get_property_mask>s-d333rcL|tjzdkS)zReturn whether the module is binary serializable (supports save_to_bytes). Returns ------- True if the module is binary serializable. r)rerrr)s r is_binary_serializablezModule.is_binary_serializableHs%&&((+=+QQVWWWrcL|tjzdkS)zReturn whether the module is runnable (supports get_function). Returns ------- True if the module is runnable. r)rerrr)s r is_runnablezModule.is_runnableRs$&&((+=+FF1LLrcL|tjzdkS)zReturn whether the module is compilation exportable. write_to_file is supported for object or source. Returns ------- True if the module is compilation exportable. r)rerrr)s r is_compilation_exportablez Module.is_compilation_exportable\s%&&((+=+TTYZZZrc.tj|dS)z!Remove all imports of the module.N)r ModuleClearImportsr)s r clear_importszModule.clear_importshs#D)))))r file_namec2tj|||dS)a*Write the current module to file. Parameters ---------- file_name The name of the file. fmt The format of the file. See Also -------- tvm.runtime.Module.export_library : export the module to shared library. N)r ModuleWriteToFile)r*rorZs r write_to_filezModule.write_to_filels "4C88888rN)r%r&)r%r,)F)r/r&r0r1r%r1)r/r&r%r5)r/r&r0r1r%r5)r/r&r0r1r%rA)r/r&r0r1r%rH)rMrr%rN)rVrr%rrY)rZr&r%r&)r%r^)r%rb)r%r1)r%rN)ror&rZr&r%rN)rrrr__annotations__r$propertyr+r.r4r=r9rGrLrQrUrXr]rarergrirkrnrrrrr rr1s88x!'J&&&& ,,,X,   X LLLLL6EEEE.05-(-(-(-(-(^$,$,$,$,$,L 2 2 2 2''''     7 7 7 7 744444444XXXXMMMM [ [ [ [****9999999rrrY symbol_prefixr&r%c*tj|S)aGet system-wide library module singleton with functions prefixed by ``__tvm_ffi_{symbol_prefix}``. The library module contains symbols that are registered via :cpp:func:`TVMFFIEnvModRegisterSystemLibSymbol`. .. note:: The system lib is intended to be statically linked and loaded during the entire lifecycle of the program. If you want dynamic loading features, use DSO modules instead. Parameters ---------- symbol_prefix Optional symbol prefix that can be used for search. When we lookup a symbol symbol_prefix + name will first be searched, then the name without symbol_prefix. Returns ------- The system-wide library module. Examples -------- Register the function ``test_symbol_add_one`` in C++ with the name ``__tvm_ffi_test_symbol_add_one`` via :cpp:func:`TVMFFIEnvModRegisterSystemLibSymbol`. .. code-block:: cpp // A function to be registered in the system lib static int test_symbol_add_one(void*, const TVMFFIAny* args, int32_t num_args, TVMFFIAny* ret) { TVM_FFI_SAFE_CALL_BEGIN(); TVM_FFI_CHECK(num_args == 1, "Expected 1 argument, but got: " + std::to_string(num_args)); int64_t x = reinterpret_cast(args)[0].cast(); reinterpret_cast(ret)[0] = x + 1; TVM_FFI_SAFE_CALL_END(); } // Register the function with name `test_symbol_add_one` prefixed by `__tvm_ffi_` int _ = TVMFFIEnvModRegisterSystemLibSymbol("__tvm_ffi_testing.add_one", reinterpret_cast(test_symbol_add_one)); Look up and call the function from Python: .. code-block:: python import tvm_ffi mod: tvm_ffi.Module = tvm_ffi.system_lib( "testing." ) # symbols prefixed with `__tvm_ffi_testing.` func: tvm_ffi.Function = mod["add_one"] # looks up `__tvm_ffi_testing.add_one` assert func(10) == 11 )r SystemLib)rvs r rr~sf  m , ,,rTpathstr | PathLikekeep_module_aliver1cxt|}tj|}|rtj||S)aLoad module from file. Parameters ---------- path The path to the module file. keep_module_alive Whether to keep the module alive. If True, the module will be kept alive for the duration of the program until libtvm_ffi.so is unloaded. Returns ------- The loaded module Examples -------- .. code-block:: python import tvm_ffi from pathlib import Path # Works with string paths mod = tvm_ffi.load_module("path/to/module.so") # Also works with pathlib.Path objects mod = tvm_ffi.load_module(Path("path/to/module.so")) mod.func_name(*args) See Also -------- :py:class:`tvm_ffi.Module` )r r ModuleLoadFromFileModuleGlobalsAdd)ryr{mods r rrs>F $<rs",+ #""""" (((((( !!!!!!!!%%%%%% G G G########I9I9I9I9I9T[I9I9I9X 3-3-3-3-3-l'''''''r