Add get_sink_index method to Python API. (#25415)

### Details:
 - Adds `get_sink_index` method to the Python API. 
 - Adds tests.  

### Tickets:
 - 131043

This PR links issue #25116

---------

Co-authored-by: Pawel Raasz <pawel.raasz@intel.com>
Co-authored-by: Anastasia Kuporosova <anastasia.kuporosova@intel.com>

Author: 3 people

src/bindings/python/src/pyopenvino/graph/model.cpp

@@ -128,6 +128,18 @@ static std::unordered_map<std::string, ov::PartialShape> get_variables_shapes(co
     return variables_shape_map;
 }
 
+template <typename T>
+static int64_t find_sink_position(const ov::SinkVector& sinks, const std::shared_ptr<T>& sink) {
+    int64_t pos = 0;
+    for (const auto& s : sinks) {
+        if (s == sink) {
+            return pos;
+        }
+        pos++;
+    };
+    return -1;
+}
+
 void regclass_graph_Model(py::module m) {
     py::class_<ov::Model, std::shared_ptr<ov::Model>> model(m, "Model", py::module_local());
     model.doc() = "openvino.runtime.Model wraps ov::Model";
@@ -750,6 +762,75 @@ void regclass_graph_Model(py::module m) {
                 :rtype: int
              )");
 
+    model.def(
+        "get_sink_index",
+        [](ov::Model& self, const ov::Output<ov::Node>& value) -> int64_t {
+            auto node = value.get_node_shared_ptr();
+            if (ov::is_type<ov::op::v6::Assign>(node)) {
+                return find_sink_position(self.get_sinks(), std::dynamic_pointer_cast<ov::op::Sink>(node));
+            } else {
+                throw py::type_error("Incorrect argument type. Output sink node is expected as argument.");
+            }
+        },
+        py::arg("value"),
+        R"(
+                    Return index of sink.
+
+                    Return -1 if `value` not matched.
+
+                    :param value: Output sink node handle
+                    :type value: openvino.runtime.Output
+                    :return: Index of sink node referenced by output handle.
+                    :rtype: int
+                  )");
+
+    model.def(
+        "get_sink_index",
+        [](ov::Model& self, const ov::Output<const ov::Node>& value) -> int64_t {
+            auto node = value.get_node_shared_ptr();
+            if (ov::is_type<ov::op::v6::Assign>(node)) {
+                return find_sink_position(self.get_sinks(), std::dynamic_pointer_cast<const ov::op::Sink>(node));
+            } else {
+                throw py::type_error("Incorrect argument type. Output sink node is expected as argument.");
+            }
+        },
+        py::arg("value"),
+        R"(
+                    Return index of sink.
+
+                    Return -1 if `value` not matched.
+
+                    :param value: Output sink node handle
+                    :type value: openvino.runtime.Output
+                    :return: Index of sink node referenced by output handle.
+                    :rtype: int
+                  )");
+
+    model.def(
+        "get_sink_index",
+        [](ov::Model& self, const py::object& node) -> int64_t {
+            if (py::isinstance<ov::op::v6::Assign>(node)) {
+                auto sink = std::dynamic_pointer_cast<ov::op::Sink>(node.cast<std::shared_ptr<ov::op::v6::Assign>>());
+                return find_sink_position(self.get_sinks(), sink);
+            } else if (py::isinstance<ov::Node>(node)) {
+                auto sink = std::dynamic_pointer_cast<ov::op::Sink>(node.cast<std::shared_ptr<ov::Node>>());
+                return find_sink_position(self.get_sinks(), sink);
+            } else {
+                throw py::type_error("Incorrect argument type. Sink node is expected as argument.");
+            }
+        },
+        py::arg("sink"),
+        R"(
+                    Return index of sink node.
+
+                    Return -1 if `sink` not matched.
+
+                    :param sink: Sink node.
+                    :type sink: openvino.runtime.Node
+                    :return: Index of sink node.
+                    :rtype: int
+                 )");
+
     model.def("get_name",
               &ov::Model::get_name,
               R"(

src/bindings/python/tests/test_runtime/test_model.py

@@ -204,6 +204,35 @@ def test_replace_parameter():
     assert model.get_parameter_index(param1) == -1
 
 
+def test_get_sink_index(device):
+    input_shape = PartialShape([2, 2])
+    param = ops.parameter(input_shape, dtype=np.float64, name="data")
+    relu1 = ops.relu(param, name="relu1")
+    relu1.get_output_tensor(0).set_names({"relu_t1"})
+    model = Model(relu1, [param], "TestModel")
+
+    # test get_sink_index with openvino.runtime.Node argument
+    assign = ops.assign()
+    assign2 = ops.assign()
+    assign3 = ops.assign()
+    model.add_sinks([assign, assign2, assign3])
+    assign_nodes = model.sinks
+    assert model.get_sink_index(assign_nodes[2]) == 2
+    assert model.get_sink_index(relu1) == -1
+
+    # test get_sink_index with openvino.runtime.Output argument
+    assign4 = ops.assign(relu1, "assign4")
+    model.add_sinks([assign4])
+    assert model.get_sink_index(assign4.output(0)) == 3
+
+    # check exceptions
+    with pytest.raises(TypeError) as e:
+        model.get_sink_index(0)
+    assert (
+        "Incorrect argument type. Sink node is expected as argument." in str(e.value)
+    )
+
+
 @pytest.mark.parametrize(("args1", "args2", "expectation", "raise_msg"), [
     (Tensor("float32", Shape([2, 1])),
      [Tensor(np.array([2, 1], dtype=np.float32).reshape(2, 1)),