rusttorch 0.4.0

Build, train, and run neural networks in Rust with LibTorch
Documentation
use rusttorch::{Device, DeviceSpec, RustTorchError, available_devices, resolve_device};

#[test]
fn cpu_resolves_explicitly() {
    assert_eq!(
        resolve_device(DeviceSpec::Cpu).expect("CPU must always be available"),
        Device::Cpu,
    );
}

#[test]
fn reported_capabilities_match_resolved_devices() {
    let capabilities = available_devices();

    assert!(capabilities.cpu);
    assert!(!capabilities.cudnn || capabilities.cuda);
    if capabilities.cuda {
        assert!(capabilities.cuda_device_count > 0);
        assert_eq!(
            resolve_device(DeviceSpec::Cuda(0)).expect("reported CUDA device must resolve"),
            Device::Cuda(0),
        );
    } else {
        assert_eq!(capabilities.cuda_device_count, 0);
        assert!(!capabilities.cudnn);
    }

    if capabilities.mps {
        assert_eq!(
            resolve_device(DeviceSpec::Mps).expect("reported MPS device must resolve"),
            Device::Mps,
        );
    }

    let expected_auto = if capabilities.cuda {
        Device::Cuda(0)
    } else if capabilities.mps {
        Device::Mps
    } else {
        Device::Cpu
    };
    assert_eq!(
        resolve_device(DeviceSpec::Auto).expect("automatic device selection must resolve"),
        expected_auto,
    );
}

#[test]
fn unavailable_or_out_of_range_cuda_is_an_error() {
    let capabilities = available_devices();
    let invalid_index = capabilities.cuda_device_count;

    match resolve_device(DeviceSpec::Cuda(invalid_index)) {
        Err(RustTorchError::BackendUnavailable { backend, reason }) => {
            assert_eq!(backend, "CUDA");
            assert!(!reason.is_empty());
        }
        other => panic!(
            "CUDA index {invalid_index} must be rejected when only {} device(s) are reported, got {other:?}",
            capabilities.cuda_device_count,
        ),
    }
}

#[test]
fn explicit_mps_is_resolved_or_rejected_without_fallback() {
    let capabilities = available_devices();

    match (capabilities.mps, resolve_device(DeviceSpec::Mps)) {
        (true, Ok(Device::Mps)) => {}
        (false, Err(RustTorchError::BackendUnavailable { backend, reason })) => {
            assert_eq!(backend, "MPS");
            assert!(!reason.is_empty());
        }
        (_, other) => panic!("MPS resolution contradicted reported capabilities: {other:?}"),
    }
}

#[test]
fn core_device_spec_matches_both_facade_paths() {
    let direct: rusttorch_core::DeviceSpec = rusttorch::DeviceSpec::Cpu;
    let facade: rusttorch::device::DeviceSpec = direct;
    assert_eq!(facade, rusttorch::DeviceSpec::Cpu);
}