Build the generated wrapper code string and runtime defaults dict. Returns ------- A tuple of (code_str, runtime_defaults) where code

Classify a resolved field type into a schema entry. Conservative: only returns None (leaf) when we are certain the type cannot contain a data

Scan *cls.__dict__* for variant declarations. Returns ``(binders, python_entries)`` in declaration order: * *binders* — names annotated as `

Parse own annotations into :class:`Field` objects. - Skips ``ClassVar`` annotations. - Handles ``KW_ONLY`` sentinel. - Extracts ``Field``

Compile a DataclassToTupleSchema into an inline tuple expression. Parameters ---------- prefix The variable expression to unpack

Create a PyCapsule wrapping the DLPack exchange API pointer.

Create a frame object from the filename, lineno, and func.

Build a descriptive error for an unbindable bare ``ClassVar`` binder. A bare ``ClassVar[Cls]`` annotation on a cxx-backed enum means "bind to

Find the first class in cls.__mro__ that defines attr_name in its __dict__.

Auto-detect whether to use CUDA or HIP (ROCm). Returns 'hip' if ROCm/HIP is available, 'cuda' otherwise.

Discover available C-only compiler variants.

Discover GCC C++ variants (emit R_X86_64_PC32 for __dso_handle).

Discover PIE C++ variants built with -fpie. PIE objects force R_X86_64_PC32 (direct, ±2GB) for __dso_handle instead of R_X86_64_GOTPCRELX (GO

Return the live ``__ffi_enum_attrs__`` dict, registering it if absent.

Return the live ``__ffi_enum_entries__`` dict, registering it if absent.

Return the live ``__ffi_enum_value_entries__`` dict, registering it if absent.

Escape special characters for C++ string literals.

Find the bundled liborc_rt library in the same directory as the .so/.dll.

Construct a `FuncInfo` from a global function name.

Generate ``__ffi_init__`` stub from field metadata for auto-generated init.

Render ``__ffi_init__`` TypeMethod as an instance method returning None.

Generate ``__init__`` from init-eligible field metadata (auto-generated init).

Generate the content of build.ninja for building the module.

Generate the content of build.ninja for building the module on Windows.

Get the CUDA target architecture flag.

Get the ROCm target architecture flags (--offload-arch=gfxXXXX).

Import and return the class object given its module and class name.

Install a temporary ``__init__`` that completes registration on first call. Preserves a user-defined ``__init__`` if present in *cls.__dict__*;

Install ``__init__`` from ``__ffi_init__`` TypeMethod or TypeAttrColumn. Skipped if the class body already defines ``__init__``. This ensures

Install stdlib-like instance behavior for ``IntEnum`` / ``StrEnum``. Payload enums have two identities that plain ``Enum`` does not: the FFI

Construct a new variant of a cxx-backed enum without going through ``__init__``. C++-backed enums whose underlying type is registered with ``

Instantiate an enum entry and normalize construction errors.

Check user is invoking the config CLI entry.

Check if a type is definitely a leaf (no dataclass content or conversion needed). Note: list is NOT a leaf because it must be converted to a tupl

Return True when ``value`` is a callable marked by :func:`method`.

Build ``__copy__`` with ``__ffi_shallow_copy__`` resolved at install time.

Build ``__deepcopy__`` with ``DeepCopy`` resolved at install time.

Build an ``inspect.Signature`` from reflection field metadata. Walks the parent chain (parent-first) to collect all ``init=True`` fields, reo

Build ``__replace__`` with ``copy.copy`` resolved at install time.

Parse the backtrace string into a list of (filename, lineno, func). Parameters ---------- backtrace The backtrace string. Re

Compare payload enum variants by payload and accept raw payloads. Two variants of the same enum class compare like their ``value`` fields,

Return the platform-appropriate shared library filename for ``target_name``.

Move stub files into place if they do not already exist.

Raise :class:`TypeError` listing the annotations that cannot be resolved.

Phase 1: allocate type index and register the type (always succeeds).

Materialise *binders* and *python_entries* into class-attribute singletons. Processing order matches declaration order: ``binders`` first (becaus

Build the module directly by invoking compiler commands (non-Windows only).

Locates the Developer Command Prompt and runs a command within its environment.

Load object file and run all test assertions. All JIT references (functions, lib, session) are released automatically when this function retu

Set ``cls.__match_args__`` from reflected fields. Mirrors stdlib :func:`dataclasses.dataclass` semantics: the tuple contains the names of pos

Return the torch backend name used in the optional extension library name.

Return the torch backend name used in the optional extension library name.

Reject ``@method``-marked names that collide with reserved namespaces. Names in :data:`_FFI_TYPE_ATTR_NAMES` and Python-protocol dunders are

Validate all input arguments for make_kwargs_wrapper. Parameters ---------- arg_names List of positional argument names. arg_

Return the live ``Dict[Any, Enum]`` payload-to-variant index, or None.

Return project version information using setuptools_scm.

Add header to file.

Append a traceback to the given traceback. Parameters ---------- tb The traceback to append to. filename

Create an access path that indicate an array item is missing. Parameters ---------- index The index of the item t

! * \brief Read element from dict. * \param key The key * \return the corresponding element. */

Run cupy.add with one element.

Run numpy.add with one element.

Run torch.add with one element.

convert_func(cb): callback receives ffi.Tensor, does torch.from_dlpack(x) explicitly.

convert_func(cb, tensor_cls=torch.Tensor): callback sees torch.Tensor directly.

Measures overhead of running torch.utils.dlpack.to_dlpack.

Measures overhead of running dlpack via auto convert by directly take torch.Tensor as inputs.

Benchmark kwargs wrapper with integer arguments and dataclass unpacking.

Wait until an exclusive lock can be acquired, with an optional timeout. Parameters ---------- timeout: float, optional

Compile and build a C/C++/CUDA module from source files. This function compiles the given C, C++, and/or CUDA source files into a shared library

Compile and build a C++/CUDA module from inline source code. This function compiles the given C++ and/or CUDA source code into a shared library o