Function ExposePipeline

dali/python/backend_impl.cc:2474–2719

}

void ExposePipeline(py::module &m) {
  py::class_<Pipeline, PyPipeline>(m, "Pipeline")
    .def(py::init(
            [](const PipelineParams &params) {
              return std::make_unique<PyPipeline>(params);
            }),
        "params"_a
        )
    // initialize from serialized pipeline
    .def(py::init(
          [](const string &serialized_pipe,
             const PipelineParams &params) {
              return std::make_unique<PyPipeline>(serialized_pipe, params);
            }),
        "serialized_pipe"_a,
        "params"_a
        )
    .def("AddOperator",
         static_cast<int (Pipeline::*)(const OpSpec &, std::string_view)>
                                      (&Pipeline::AddOperator))
    .def("AddOperator",
         static_cast<int (Pipeline::*)(const OpSpec &, std::string_view, int)>
                                      (&Pipeline::AddOperator))
    .def("AddOperatorInstance",
         [](Pipeline *p, const OpSpec &spec, std::string_view name,
            std::unique_ptr<OperatorBase> op) {
           return p->AddOperatorInstance(spec, name, std::move(op));
         })
    .def("AddOperatorInstance",
         [](Pipeline *p, const OpSpec &spec, std::string_view name,
            std::unique_ptr<OperatorBase> op, int logical_id) {
           return p->AddOperatorInstance(spec, name, std::move(op), logical_id);
         })
    .def("GetOperatorNode", &Pipeline::GetOperatorNode)
    .def("Build",
         [](Pipeline *p, const std::vector<OutputDesc> &outputs) {
             std::vector<PipelineOutputDesc> build_args;
             for (auto& out : outputs) {
               build_args.emplace_back(to_struct<PipelineOutputDesc>(out));
             }
             p->Build(build_args);
         })
    .def("Build", [](Pipeline *p) { p->Build(); })
    .def("Shutdown", &Pipeline::Shutdown, py::call_guard<py::gil_scoped_release>())
    .def("EnableCheckpointing",
        [](Pipeline *p, bool checkpointing) {
          p->EnableCheckpointing(checkpointing);
        },
        "checkpointing"_a = true)
    .def("GetSerializedCheckpoint",
        [](Pipeline *p, const ExternalContextCheckpoint &external_ctx_cpt) -> py::bytes {
          return p->GetSerializedCheckpoint(external_ctx_cpt);
          })
    .def("RestoreFromSerializedCheckpoint",
        [](Pipeline *p, const std::string &serialized_checkpoint) {
          return p->RestoreFromSerializedCheckpoint(serialized_checkpoint);
        })
    .def("executor_statistics",