[PYTHON] Add method to_dtype() to Type class (#11433)

* Add Type method to_dtype()

* Clang formatting

* Add Type __init__ binding

* Add Type constructor

* Add numpy types classes to test

src/bindings/python/src/pyopenvino/graph/types/element_type.cpp

@@ -8,6 +8,7 @@
 #include <pybind11/stl.h>
 
 #include "openvino/op/parameter.hpp"
+#include "pyopenvino/core/common.hpp"
 #include "pyopenvino/graph/types/element_type.hpp"
 
 namespace py = pybind11;
@@ -15,6 +16,20 @@ namespace py = pybind11;
 void regclass_graph_Type(py::module m) {
     py::class_<ov::element::Type, std::shared_ptr<ov::element::Type>> type(m, "Type");
     type.doc() = "openvino.runtime.Type wraps ov::element::Type";
+
+    type.def(py::init([](py::object& np_literal) {
+                 return Common::dtype_to_ov_type().at(py::str(py::dtype::from_args(np_literal)));
+             }),
+             py::arg("dtype"),
+             R"(
+            Convert numpy dtype into OpenVINO type
+
+            :param dtype: numpy dtype
+            :type dtype: numpy.dtype
+            :return: OpenVINO type object
+            :rtype: ov.Type
+        )");
+
     type.attr("boolean") = ov::element::boolean;
     type.attr("f16") = ov::element::f16;
     type.attr("f32") = ov::element::f32;
@@ -42,7 +57,6 @@ void regclass_graph_Type(py::module m) {
         }
         return "<Type: 'u" + self.c_type_string() + bitwidth + "'>";
     });
-
     type.def("__hash__", &ov::element::Type::hash);
     type.def(
         "__eq__",
@@ -50,8 +64,19 @@ void regclass_graph_Type(py::module m) {
             return a == b;
         },
         py::is_operator());
+    type.def("get_type_name", &ov::element::Type::get_type_name);
+    type.def(
+        "to_dtype",
+        [](ov::element::Type& self) {
+            return Common::ov_type_to_dtype().at(self);
+        },
+        R"(
+            Convert Type to numpy dtype
+
+            :return: dtype object
+            :rtype: numpy.dtype
+        )");
 
     type.def_property_readonly("bitwidth", &ov::element::Type::bitwidth);
     type.def_property_readonly("is_real", &ov::element::Type::is_real);
-    type.def("get_type_name", &ov::element::Type::get_type_name);
 }

src/bindings/python/tests/test_transformations/test_public_transformations.py

@@ -1,7 +1,9 @@
 # Copyright (C) 2022 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 import os
+import pytest
 import numpy as np
+import openvino.runtime as ov
 
 from openvino.runtime import Model, PartialShape, Shape, opset8, Core
 from openvino.runtime.passes import Manager, ConstantFolding, MakeStateful,\
@@ -46,14 +48,14 @@ def test_constant_folding():
 
 def test_convert_precision():
     model = get_model()
+    assert model.get_parameters()[0].get_element_type().to_dtype() == np.float32
 
     m = Manager()
     m.register_pass(ConvertFP32ToFP16())
     m.run_passes(model)
 
     assert model is not None
-    # TODO: fix bug 82773 with float16 type comparison
-    # assert model.get_parameters()[0].get_element_type() == np.float16
+    assert model.get_parameters()[0].get_element_type().to_dtype() == np.float16
 
 
 def test_low_latency2():
@@ -112,3 +114,23 @@ def test_serialize_pass():
 
     os.remove(xml_path)
     os.remove(bin_path)
+
+
+@pytest.mark.parametrize("dtype_string, dtype, ovtype", [
+    ("float16", np.float16, ov.Type.f16),
+    ("float32", np.float32, ov.Type.f32),
+    ("float64", np.float64, ov.Type.f64),
+    ("int8", np.int8, ov.Type.i8),
+    ("int16", np.int16, ov.Type.i16),
+    ("int32", np.int32, ov.Type.i32),
+    ("int64", np.int64, ov.Type.i64),
+    ("uint8", np.uint8, ov.Type.u8),
+    ("uint16", np.uint16, ov.Type.u16),
+    ("uint32", np.uint32, ov.Type.u32),
+    ("uint64", np.uint64, ov.Type.u64),
+    ("bool", np.bool_, ov.Type.boolean),
+])
+def test_dtype_ovtype_conversion(dtype_string, dtype, ovtype):
+    assert ovtype.to_dtype() == dtype
+    assert ov.Type(dtype_string) == ovtype
+    assert ov.Type(dtype) == ovtype