[PyOV] Model wrappers on Python side (#18368)

* model on py side

* work with diff types

* some tests fix

* try to fix test

* fix fe tests

* codestyle

* fix post commit

src/bindings/python/src/openvino/frontend/__init__.py

@@ -17,8 +17,8 @@ from openvino._pyopenvino import get_version
 __version__ = get_version()
 
 # main classes
-from openvino._pyopenvino import FrontEndManager
-from openvino._pyopenvino import FrontEnd
+from openvino.frontend.frontend import FrontEndManager
+from openvino.frontend.frontend import FrontEnd
 from openvino._pyopenvino import InputModel
 from openvino._pyopenvino import NodeContext
 from openvino._pyopenvino import Place

src/bindings/python/src/openvino/frontend/frontend.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2023 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Union
+
+from openvino._pyopenvino import FrontEnd as FrontEndBase
+from openvino._pyopenvino import FrontEndManager as FrontEndManagerBase
+from openvino._pyopenvino import InputModel
+from openvino.runtime import Model
+
+
+class FrontEnd(FrontEndBase):
+    def __init__(self, fe: FrontEndBase) -> None:
+        super().__init__(fe)
+
+    def convert(self, model: Union[Model, InputModel]) -> Model:
+        converted_model = super().convert(model)
+        if isinstance(model, InputModel):
+            return Model(converted_model)
+        return converted_model
+
+    def convert_partially(self, model: InputModel) -> Model:
+        return Model(super().convert_partially(model))
+
+    def decode(self, model: InputModel) -> Model:
+        return Model(super().decode(model))
+
+    def normalize(self, model: Model) -> None:
+        super().normalize(model)
+
+
+class FrontEndManager(FrontEndManagerBase):
+    def load_by_framework(self, framework: str) -> Union[FrontEnd, None]:
+        fe = super().load_by_framework(framework)
+        if fe is not None:
+            return FrontEnd(fe)
+        return fe
+
+    def load_by_model(self, model: str) -> Union[FrontEnd, None]:
+        fe = super().load_by_model(model)
+        if fe is not None:
+            return FrontEnd(fe)
+        return fe

src/bindings/python/src/openvino/runtime/__init__.py

@@ -15,7 +15,6 @@ __version__ = get_version()
 
 # Openvino pybind bindings and python extended classes
 from openvino._pyopenvino import Dimension
-from openvino._pyopenvino import Model
 from openvino._pyopenvino import Input
 from openvino._pyopenvino import Output
 from openvino._pyopenvino import Node
@@ -36,6 +35,7 @@ from openvino._pyopenvino import RTMap
 from openvino.runtime.ie_api import Core
 from openvino.runtime.ie_api import CompiledModel
 from openvino.runtime.ie_api import InferRequest
+from openvino.runtime.ie_api import Model
 from openvino.runtime.ie_api import AsyncInferQueue
 from openvino._pyopenvino import Version
 from openvino._pyopenvino import Tensor

src/bindings/python/src/openvino/runtime/ie_api.py

@@ -7,12 +7,12 @@ from pathlib import Path
 
 import numpy as np
 
-from openvino._pyopenvino import Model
+from openvino._pyopenvino import Model as ModelBase
 from openvino._pyopenvino import Core as CoreBase
 from openvino._pyopenvino import CompiledModel as CompiledModelBase
 from openvino._pyopenvino import AsyncInferQueue as AsyncInferQueueBase
-from openvino._pyopenvino import ConstOutput
 from openvino._pyopenvino import Tensor
+from openvino._pyopenvino import Node
 
 from openvino.runtime.utils.data_helpers import (
     OVDict,
@@ -22,6 +22,21 @@ from openvino.runtime.utils.data_helpers import (
 )
 
 
+class Model(ModelBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        if args and not kwargs:
+            if isinstance(args[0], ModelBase):
+                super().__init__(args[0])
+            elif isinstance(args[0], Node):
+                super().__init__(*args)
+            else:
+                super().__init__(*args)
+        if args and kwargs:
+            super().__init__(*args, **kwargs)
+        if kwargs and not args:
+            super().__init__(**kwargs)
+
+
 class InferRequest(_InferRequestWrapper):
     """InferRequest class represents infer request which can be run in asynchronous or synchronous manners."""
 
@@ -160,6 +175,9 @@ class CompiledModel(CompiledModelBase):
         self._infer_request: Optional[InferRequest] = None
         super().__init__(other)
 
+    def get_runtime_model(self) -> Model:
+        return Model(super().get_runtime_model())
+
     def create_infer_request(self) -> InferRequest:
         """Creates an inference request object used to infer the compiled model.
 
@@ -368,6 +386,11 @@ class Core(CoreBase):
     between several Core instances. The recommended way is to have a single
     Core instance per application.
     """
+    def read_model(self, model: Union[str, bytes, object], weights: Union[object, str, bytes, Tensor] = None) -> Model:
+        if weights is not None:
+            return Model(super().read_model(model, weights))
+        else:
+            return Model(super().read_model(model))
 
     def compile_model(
         self,

src/bindings/python/src/pyopenvino/frontend/frontend.cpp

@@ -30,6 +30,11 @@ void regclass_frontend_FrontEnd(py::module m) {
     py::class_<FrontEnd, std::shared_ptr<FrontEnd>> fem(m, "FrontEnd", py::dynamic_attr(), py::module_local());
     fem.doc() = "openvino.frontend.FrontEnd wraps ov::frontend::FrontEnd";
 
+    fem.def(py::init([](const std::shared_ptr<FrontEnd>& other) {
+                return other;
+            }),
+            py::arg("other"));
+
     fem.def(
         "load",
         [](FrontEnd& self, const py::object& py_obj) {

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

@@ -64,6 +64,11 @@ 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";
 
+    model.def(py::init([](const std::shared_ptr<ov::Model>& other) {
+                  return other;
+              }),
+              py::arg("other"));
+
     model.def(py::init([](const ov::ResultVector& res,
                           const std::vector<std::shared_ptr<ov::Node>>& nodes,
                           const ov::ParameterVector& params,