Function ExposeTensorListCPU

dali/python/backend_impl.cc:1540–1872

    py::class_<TensorList<Backend>, std::shared_ptr<TensorList<Backend>>>;

void ExposeTensorListCPU(py::module &m) {
    auto tensor_list_cpu_class =
      py::class_<TensorList<CPUBackend>, std::shared_ptr<TensorList<CPUBackend>>>(
          m, "TensorListCPU", py::buffer_protocol())
    .def_property_readonly_static("__module__", tensor_module_impl)
    .def(py::init([](py::capsule &capsule, std::optional<std::string> layout = {}) {
            DomainTimeRange range("TensorListCPU::init from capsule", kCPUTensorColor);
            auto t = std::make_shared<TensorList<CPUBackend>>();
            FillTensorFromDlPack(capsule, t.get(), layout);
            return t;
          }),
        "object"_a,
        "layout"_a = py::none(),
        R"code(
        List of tensors residing in the CPU memory.

        object : DLPack object
              Python DLPack object representing TensorList
        layout : str
              Layout of the data
        )code")
    .def(py::init([](TensorList<CPUBackend> *tl, std::optional<std::string> layout = {}) {
          DomainTimeRange range("TensorListCPU::init from a list of tensors", kCPUTensorColor);
          if (!tl)
            throw py::value_error("The source object must not be null");
          auto t = std::make_shared<TensorList<CPUBackend>>();
          t->ShareData(*tl);
          // If layout is not given, use the one from tl
          SetLayout(*t, layout, false);
          return t;
        }),
      "tl"_a,
      "layout"_a = py::none())
    .def(py::init([](py::buffer b, std::optional<std::string> layout = {}, bool is_pinned = false) {
         DomainTimeRange range("TensorListCPU::init from a buffer", kCPUTensorColor);
        // We need to verify that the input data is C_CONTIGUOUS
        // and of a type that we can work with in the backend
        py::buffer_info info = b.request();

        DALI_ENFORCE(info.shape.size() > 0, "Cannot create TensorList from 0-dim array.");

        // Create a list of shapes
        std::vector<Index> tensor_shape(info.shape.size()-1);
        for (size_t i = 1; i < info.shape.size(); ++i) {
          tensor_shape[i-1] = info.shape[i];
        }
        auto i_shape = uniform_list_shape(info.shape[0], tensor_shape);
        size_t bytes = volume(tensor_shape)*i_shape.size()*info.itemsize;

        // Validate the stride
        CheckContiguousTensor(info.strides, info.shape, info.itemsize);

        // TODO(klecki): Extend the constructor with stream and device_id
        // Assume that we cannot use pinned memory in CPU_ONLY mode
        int device_id = CPU_ONLY_DEVICE_ID;
        if (is_pinned) {
          CUDA_CALL(cudaGetDevice(&device_id));
        }