Program Listing for File messages.cpp

Return to documentation for file (morpheus/_lib/src/python_modules/messages.cpp)

Copy
Copied!
            

#include "morpheus/messages/memory/inference_memory.hpp" #include "morpheus/messages/memory/inference_memory_fil.hpp" #include "morpheus/messages/memory/inference_memory_nlp.hpp" #include "morpheus/messages/memory/response_memory.hpp" #include "morpheus/messages/memory/response_memory_probs.hpp" #include "morpheus/messages/memory/tensor_memory.hpp" #include "morpheus/messages/meta.hpp" #include "morpheus/messages/multi.hpp" #include "morpheus/messages/multi_inference.hpp" #include "morpheus/messages/multi_inference_fil.hpp" #include "morpheus/messages/multi_inference_nlp.hpp" #include "morpheus/messages/multi_response.hpp" #include "morpheus/messages/multi_response_probs.hpp" #include "morpheus/objects/data_table.hpp" #include "morpheus/utilities/cudf_util.hpp" #include <mrc/channel/status.hpp>// for Status #include <mrc/edge/edge_connector.hpp> #include <mrc/node/port_registry.hpp> #include <pybind11/functional.h>// IWYU pragma: keep #include <pybind11/pybind11.h> #include <pybind11/pytypes.h> #include <pybind11/stl.h>// IWYU pragma: keep #include <pymrc/edge_adapter.hpp> #include <pymrc/node.hpp> #include <pymrc/port_builders.hpp> #include <pymrc/utils.hpp>// for pymrc::import #include <cstddef> #include <filesystem> #include <memory> #include <string> #include <vector> namespace morpheus { namespace fs = std::filesystem; namespace py = pybind11; // Define the pybind11 module m, as 'pipeline'. PYBIND11_MODULE(messages, m) { m.doc() = R"pbdoc( ----------------------- .. currentmodule:: morpheus.messages .. autosummary:: :toctree: _generate )pbdoc"; // Load the cudf helpers load_cudf_helpers(); mrc::pymrc::import(m, "cupy"); mrc::pymrc::import(m, "morpheus._lib.common"); // Required for SegmentObject mrc::pymrc::import(m, "mrc.core.node"); // Allows python objects to keep DataTable objects alive py::class_<IDataTable, std::shared_ptr<IDataTable>>(m, "DataTable"); mrc::pymrc::PortBuilderUtil::register_port_util<std::shared_ptr<MessageMeta>>(); mrc::pymrc::PortBuilderUtil::register_port_util<std::shared_ptr<MultiMessage>>(); mrc::pymrc::PortBuilderUtil::register_port_util<std::shared_ptr<MultiInferenceMessage>>(); mrc::pymrc::PortBuilderUtil::register_port_util<std::shared_ptr<MultiInferenceFILMessage>>(); mrc::pymrc::PortBuilderUtil::register_port_util<std::shared_ptr<MultiInferenceNLPMessage>>(); mrc::pymrc::PortBuilderUtil::register_port_util<std::shared_ptr<MultiResponseMessage>>(); mrc::pymrc::PortBuilderUtil::register_port_util<std::shared_ptr<MultiResponseProbsMessage>>(); // EdgeConnectors for derived classes of MultiMessage to MultiMessage mrc::edge::EdgeConnector<std::shared_ptr<morpheus::MultiInferenceMessage>, std::shared_ptr<morpheus::MultiMessage>>::register_converter(); mrc::edge::EdgeConnector<std::shared_ptr<morpheus::MultiInferenceFILMessage>, std::shared_ptr<morpheus::MultiInferenceMessage>>::register_converter(); mrc::edge::EdgeConnector<std::shared_ptr<morpheus::MultiInferenceFILMessage>, std::shared_ptr<morpheus::MultiMessage>>::register_converter(); mrc::edge::EdgeConnector<std::shared_ptr<morpheus::MultiInferenceNLPMessage>, std::shared_ptr<morpheus::MultiInferenceMessage>>::register_converter(); mrc::edge::EdgeConnector<std::shared_ptr<morpheus::MultiInferenceNLPMessage>, std::shared_ptr<morpheus::MultiMessage>>::register_converter(); mrc::edge::EdgeConnector<std::shared_ptr<morpheus::MultiResponseMessage>, std::shared_ptr<morpheus::MultiMessage>>::register_converter(); mrc::edge::EdgeConnector<std::shared_ptr<morpheus::MultiResponseProbsMessage>, std::shared_ptr<morpheus::MultiResponseMessage>>::register_converter(); mrc::edge::EdgeConnector<std::shared_ptr<morpheus::MultiResponseProbsMessage>, std::shared_ptr<morpheus::MultiMessage>>::register_converter(); py::class_<MessageMeta, std::shared_ptr<MessageMeta>>(m, "MessageMeta") .def(py::init<>(&MessageMetaInterfaceProxy::init_python), py::arg("df")) .def_property_readonly("count", &MessageMetaInterfaceProxy::count) .def_property_readonly("df", &MessageMetaInterfaceProxy::get_data_frame, py::return_value_policy::move) .def_static("make_from_file", &MessageMetaInterfaceProxy::init_cpp); py::class_<MultiMessage, std::shared_ptr<MultiMessage>>(m, "MultiMessage") .def(py::init<>(&MultiMessageInterfaceProxy::init), py::arg("meta"), py::arg("mess_offset"), py::arg("mess_count")) .def_property_readonly("meta", &MultiMessageInterfaceProxy::meta) .def_property_readonly("mess_offset", &MultiMessageInterfaceProxy::mess_offset) .def_property_readonly("mess_count", &MultiMessageInterfaceProxy::mess_count) .def("get_meta", static_cast<pybind11::object (*)(MultiMessage&)>(&MultiMessageInterfaceProxy::get_meta), py::return_value_policy::move) .def("get_meta", static_cast<pybind11::object (*)(MultiMessage&, std::string)>(&MultiMessageInterfaceProxy::get_meta), py::return_value_policy::move) .def("get_meta", static_cast<pybind11::object (*)(MultiMessage&, std::vector<std::string>)>( &MultiMessageInterfaceProxy::get_meta), py::return_value_policy::move) .def("set_meta", &MultiMessageInterfaceProxy::set_meta, py::return_value_policy::move) .def("get_slice", &MultiMessageInterfaceProxy::get_slice, py::return_value_policy::reference_internal) .def("copy_ranges", &MultiMessageInterfaceProxy::copy_ranges, py::arg("ranges"), py::arg("num_selected_rows") = py::none(), py::return_value_policy::move) .def("get_meta_list", &MultiMessageInterfaceProxy::get_meta_list, py::return_value_policy::move); py::class_<InferenceMemory, std::shared_ptr<InferenceMemory>>(m, "InferenceMemory") .def_property_readonly("count", &InferenceMemoryInterfaceProxy::get_count); py::class_<InferenceMemoryNLP, InferenceMemory, std::shared_ptr<InferenceMemoryNLP>>(m, "InferenceMemoryNLP") .def(py::init<>(&InferenceMemoryNLPInterfaceProxy::init), py::arg("count"), py::arg("input_ids"), py::arg("input_mask"), py::arg("seq_ids")) .def_property_readonly("count", &InferenceMemoryNLPInterfaceProxy::count) .def_property("input_ids", &InferenceMemoryNLPInterfaceProxy::get_input_ids, &InferenceMemoryNLPInterfaceProxy::set_input_ids) .def_property("input_mask", &InferenceMemoryNLPInterfaceProxy::get_input_mask, &InferenceMemoryNLPInterfaceProxy::set_input_mask) .def_property( "seq_ids", &InferenceMemoryNLPInterfaceProxy::get_seq_ids, &InferenceMemoryNLPInterfaceProxy::set_seq_ids); py::class_<InferenceMemoryFIL, InferenceMemory, std::shared_ptr<InferenceMemoryFIL>>(m, "InferenceMemoryFIL") .def(py::init<>(&InferenceMemoryFILInterfaceProxy::init), py::arg("count"), py::arg("input__0"), py::arg("seq_ids")) .def_property_readonly("count", &InferenceMemoryFILInterfaceProxy::count) .def("get_tensor", &InferenceMemoryFILInterfaceProxy::get_tensor) .def_property("input__0", &InferenceMemoryFILInterfaceProxy::get_input__0, &InferenceMemoryFILInterfaceProxy::set_input__0) .def_property( "seq_ids", &InferenceMemoryFILInterfaceProxy::get_seq_ids, &InferenceMemoryFILInterfaceProxy::set_seq_ids); py::class_<MultiInferenceMessage, MultiMessage, std::shared_ptr<MultiInferenceMessage>>(m, "MultiInferenceMessage") .def(py::init<>(&MultiInferenceMessageInterfaceProxy::init), py::arg("meta"), py::arg("mess_offset"), py::arg("mess_count"), py::arg("memory"), py::arg("offset"), py::arg("count")) .def_property_readonly("memory", &MultiInferenceMessageInterfaceProxy::memory) .def_property_readonly("offset", &MultiInferenceMessageInterfaceProxy::offset) .def_property_readonly("count", &MultiInferenceMessageInterfaceProxy::count) .def("get_input", &MultiInferenceMessageInterfaceProxy::get_input) .def("get_slice", &MultiInferenceMessageInterfaceProxy::get_slice, py::return_value_policy::reference_internal); py::class_<MultiInferenceNLPMessage, MultiInferenceMessage, std::shared_ptr<MultiInferenceNLPMessage>>( m, "MultiInferenceNLPMessage") .def(py::init<>(&MultiInferenceNLPMessageInterfaceProxy::init), py::arg("meta"), py::arg("mess_offset"), py::arg("mess_count"), py::arg("memory"), py::arg("offset"), py::arg("count")) .def_property_readonly("memory", &MultiInferenceNLPMessageInterfaceProxy::memory) .def_property_readonly("offset", &MultiInferenceNLPMessageInterfaceProxy::offset) .def_property_readonly("count", &MultiInferenceNLPMessageInterfaceProxy::count) .def_property_readonly("input_ids", &MultiInferenceNLPMessageInterfaceProxy::input_ids) .def_property_readonly("input_mask", &MultiInferenceNLPMessageInterfaceProxy::input_mask) .def_property_readonly("seq_ids", &MultiInferenceNLPMessageInterfaceProxy::seq_ids); py::class_<MultiInferenceFILMessage, MultiInferenceMessage, std::shared_ptr<MultiInferenceFILMessage>>( m, "MultiInferenceFILMessage") .def(py::init<>(&MultiInferenceFILMessageInterfaceProxy::init), py::arg("meta"), py::arg("mess_offset"), py::arg("mess_count"), py::arg("memory"), py::arg("offset"), py::arg("count")) .def_property_readonly("memory", &MultiInferenceFILMessageInterfaceProxy::memory) .def_property_readonly("offset", &MultiInferenceFILMessageInterfaceProxy::offset) .def_property_readonly("count", &MultiInferenceFILMessageInterfaceProxy::count); py::class_<TensorMemory, std::shared_ptr<TensorMemory>>(m, "TensorMemory") .def_readonly("count", &TensorMemory::count); py::class_<ResponseMemory, std::shared_ptr<ResponseMemory>>(m, "ResponseMemory") .def_readonly("count", &ResponseMemory::count) .def("get_output", &ResponseMemoryInterfaceProxy::get_output, py::return_value_policy::reference_internal) .def("get_output_tensor", &ResponseMemoryInterfaceProxy::get_output_tensor, py::return_value_policy::reference_internal); py::class_<ResponseMemoryProbs, ResponseMemory, std::shared_ptr<ResponseMemoryProbs>>(m, "ResponseMemoryProbs") .def(py::init<>(&ResponseMemoryProbsInterfaceProxy::init), py::arg("count"), py::arg("probs")) .def_property_readonly("count", &ResponseMemoryProbsInterfaceProxy::count) .def_property( "probs", &ResponseMemoryProbsInterfaceProxy::get_probs, &ResponseMemoryProbsInterfaceProxy::set_probs); py::class_<MultiResponseMessage, MultiMessage, std::shared_ptr<MultiResponseMessage>>(m, "MultiResponseMessage") .def(py::init<>(&MultiResponseMessageInterfaceProxy::init), py::arg("meta"), py::arg("mess_offset"), py::arg("mess_count"), py::arg("memory"), py::arg("offset"), py::arg("count")) .def_property_readonly("memory", &MultiResponseMessageInterfaceProxy::memory) .def_property_readonly("offset", &MultiResponseMessageInterfaceProxy::offset) .def_property_readonly("count", &MultiResponseMessageInterfaceProxy::count) .def("get_output", &MultiResponseMessageInterfaceProxy::get_output); py::class_<MultiResponseProbsMessage, MultiResponseMessage, std::shared_ptr<MultiResponseProbsMessage>>( m, "MultiResponseProbsMessage") .def(py::init<>(&MultiResponseProbsMessageInterfaceProxy::init), py::arg("meta"), py::arg("mess_offset"), py::arg("mess_count"), py::arg("memory"), py::arg("offset"), py::arg("count")) .def_property_readonly("memory", &MultiResponseProbsMessageInterfaceProxy::memory) .def_property_readonly("offset", &MultiResponseProbsMessageInterfaceProxy::offset) .def_property_readonly("count", &MultiResponseProbsMessageInterfaceProxy::count) .def_property_readonly("probs", &MultiResponseProbsMessageInterfaceProxy::probs); #ifdef VERSION_INFO m.attr("__version__") = MACRO_STRINGIFY(VERSION_INFO); #else m.attr("__version__") = "dev"; #endif } } // namespace morpheus

© Copyright 2023, NVIDIA. Last updated on Feb 3, 2023.