Build uploaded using `kernels`.

build/torch210-cxx11-cu126-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch210-cxx11-cu126-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch210-cxx11-cu126-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4f5cdcbad9720748c4cf71224cc978424700cdccaad1d462173cf72eafe6e42c
-size 2116384

build/torch210-cxx11-cu126-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch210-cxx11-cu126-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cxx11-cu128-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch210-cxx11-cu128-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch210-cxx11-cu128-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9653aedd35c1c268cf5f4cd8ba5a4e1f240f3e19c80a23c9ffbe901fcef83bca
-size 2318744

build/torch210-cxx11-cu128-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch210-cxx11-cu128-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cxx11-cu130-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch210-cxx11-cu130-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch210-cxx11-cu130-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7baf2eff9e1002104d19e31763d294d524e34264cd18867f98c419f0607cad08
-size 2348224

build/torch210-cxx11-cu130-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch210-cxx11-cu130-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch28-cxx11-cu126-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch28-cxx11-cu126-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch28-cxx11-cu126-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:39086c2154f82e14222211b31e101bc79834a2cafdebaf749c63bd1e6ed4e8a2
-size 2111504

build/torch28-cxx11-cu126-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch28-cxx11-cu126-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch28-cxx11-cu128-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch28-cxx11-cu128-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch28-cxx11-cu128-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4a65b5086f8d8c9a29a210f5c37e68e97712d68e8884fd3084a2d3005a2c54dd
-size 2318032

build/torch28-cxx11-cu128-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch28-cxx11-cu128-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch28-cxx11-cu129-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch28-cxx11-cu129-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch28-cxx11-cu129-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:43c6ab910e3286ed53a60ca6cc4292b15734bb26c706e297d366313d07f67266
-size 2335432

build/torch28-cxx11-cu129-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch28-cxx11-cu129-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch29-cxx11-cu126-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch29-cxx11-cu126-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch29-cxx11-cu126-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:eaed9fa222b7cb56faadc9a92d91e0e9acf1a2635e794de99d59e32b68a2d8aa
-size 2111480

build/torch29-cxx11-cu126-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch29-cxx11-cu126-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch29-cxx11-cu128-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch29-cxx11-cu128-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch29-cxx11-cu128-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f4286b12bc927f8f66e912917ed774b706314e0515a624219a87f9db059963f5
-size 2318000

build/torch29-cxx11-cu128-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch29-cxx11-cu128-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch29-cxx11-cu130-x86_64-linux/__init__.py

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-
-
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-
-
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-
-
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-
-
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-
-    Writes gradients into the provided tensors in-place.
-
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-
-
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-
-
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

build/torch29-cxx11-cu130-x86_64-linux/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _rwkv_d5e72cf
-ops = torch.ops._rwkv_d5e72cf
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_rwkv_d5e72cf::{op_name}"

build/torch29-cxx11-cu130-x86_64-linux/_rwkv_d5e72cf.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:492b7547a3aaf00db089b5c10a379cae2889f127578a318b6a242aa89f40b46d
-size 2343392

build/torch29-cxx11-cu130-x86_64-linux/metadata.json

@@ -1 +0,0 @@
-{"python-depends":[]}

build/torch29-cxx11-cu130-x86_64-linux/rwkv/__init__.py

@@ -1,26 +0,0 @@
-import ctypes
-import sys
-
-import importlib
-from pathlib import Path
-from types import ModuleType
-
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))