Method numpy

src/python/lfs/py_tensor.cpp:303–466

    }

    nb::object PyTensor::numpy(bool copy) const {
        validate();
        Tensor cpu_tensor = tensor_.device() == Device::CUDA ? tensor_.cpu() : tensor_;

        // Ensure contiguous
        if (!cpu_tensor.is_contiguous()) {
            cpu_tensor = cpu_tensor.contiguous();
        }

        const auto& dims = cpu_tensor.shape().dims();
        size_t elem_size = 4;
        switch (cpu_tensor.dtype()) {
        case DataType::Float32: elem_size = 4; break;
        case DataType::Float16: elem_size = 2; break;
        case DataType::Int32: elem_size = 4; break;
        case DataType::Int64: elem_size = 8; break;
        case DataType::UInt8:
        case DataType::Bool: elem_size = 1; break;
        }

        if (copy) {
            // Copy mode: allocate new buffer and copy data
            const size_t total_bytes = cpu_tensor.numel() * elem_size;
            void* const buffer = std::malloc(total_bytes);
            if (!buffer) {
                throw std::bad_alloc();
            }
            std::memcpy(buffer, cpu_tensor.data_ptr(), total_bytes);

            // Create owner capsule for memory management
            nb::capsule owner(buffer, [](void* p) noexcept { std::free(p); });

            // Use nb::shape to create proper shape object
            switch (cpu_tensor.dtype()) {
            case DataType::Float32: {
                if (dims.size() == 1) {
                    return nb::cast(nb::ndarray<nb::numpy, float, nb::shape<-1>>(
                        buffer, {dims[0]}, owner));
                } else if (dims.size() == 2) {
                    return nb::cast(nb::ndarray<nb::numpy, float, nb::shape<-1, -1>>(
                        buffer, {dims[0], dims[1]}, owner));
                } else if (dims.size() == 3) {
                    return nb::cast(nb::ndarray<nb::numpy, float, nb::shape<-1, -1, -1>>(
                        buffer, {dims[0], dims[1], dims[2]}, owner));
                } else {
                    // Fallback for higher dimensions - use dynamic ndarray
                    std::vector<size_t> shape_vec(dims.begin(), dims.end());
                    return nb::cast(nb::ndarray<nb::numpy, float>(
                        buffer, dims.size(), shape_vec.data(), owner));
                }
            }
            case DataType::Int32: {
                if (dims.size() == 1) {
                    return nb::cast(nb::ndarray<nb::numpy, int32_t, nb::shape<-1>>(
                        buffer, {dims[0]}, owner));
                } else if (dims.size() == 2) {
                    return nb::cast(nb::ndarray<nb::numpy, int32_t, nb::shape<-1, -1>>(
                        buffer, {dims[0], dims[1]}, owner));