[Docs][PyOV] Documentation for Custom Python Operation

docs/articles_en/assets/snippets/ov_custom_op.py

@@ -0,0 +1,57 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+# ! [op:common_include]
+import numpy as np
+from openvino import Op
+from openvino.runtime import DiscreteTypeInfo
+# ! [op:common_include]
+
+
+
+# ! [op:header]
+class Identity(Op):
+    class_type_info = DiscreteTypeInfo("Identity", "extension")
+
+    def get_type_info(self):
+        return Identity.class_type_info
+# ! [op:header]
+
+# ! [op:ctor]
+    def __init__(self, inputs, attrs=None):
+        super().__init__(self)
+        self.set_arguments(inputs)
+        self.constructor_validate_and_infer_types()
+        if attrs is not None:
+            self._attrs = attrs
+# ! [op:ctor]
+
+# ! [op:validate]
+    def validate_and_infer_types(self):
+        self.set_output_type(0, self.get_input_element_type(0), self.get_input_partial_shape(0))
+# ! [op:validate]
+
+# ! [op:copy]
+    def clone_with_new_inputs(self, new_inputs):
+        return Identity(new_inputs)
+# ! [op:copy]
+
+# ! [op:evaluate]
+    def evaluate(self, outputs, inputs):
+        if np.array_equal(outputs[0].data, inputs[0].data):  # Nothing to do
+            return True
+        outputs[0].shape = inputs[0].shape
+        inputs[0].copy_to(outputs[0])
+        return True
+
+    def has_evaluate(self):
+        return True
+# ! [op:evaluate]
+
+# ! [op:visit_attributes]
+    def visit_attributes(self, visitor):
+        if hasattr(self, "_attrs"):
+            visitor.on_attributes(self._attrs)
+        return True
+# ! [op:visit_attributes]

docs/articles_en/documentation/openvino-extensibility.rst

@@ -124,7 +124,7 @@ The ``Identity`` is a custom operation class defined in :doc:`Custom Operation G
          :language: cpp
          :fragment: [add_frontend_extension]
 
-When Python API is used, there is no way to implement a custom OpenVINO operation. Even if custom OpenVINO operation is implemented in C++ and loaded into the runtime by a shared library, there is still no way to add a frontend mapping extension that refers to this custom operation. In this case, use C++ shared library approach to implement both operations semantics and framework mapping.
+The Python API now supports the implementation of custom OpenVINO operations, allowing for direct integration within Python code. Even if custom OpenVINO operation is implemented in C++ and loaded into the runtime by a shared library, there is still no way to add a frontend mapping extension that refers to this custom operation. In this case, use C++ shared library approach to implement both operations semantics and framework mapping.
 
 Python can still be used to map and decompose operations when only operations from the standard OpenVINO operation set are used.
 

docs/articles_en/documentation/openvino-extensibility/custom-openvino-operations.rst

@@ -9,20 +9,54 @@ Custom OpenVINO Operations
                  custom operations to support models with operations
                  not supported by OpenVINO.
 
-OpenVINO™ Extension API allows you to register custom operations to support models with operations which OpenVINO™ does not support out-of-the-box. This capability requires writing code in C++, so if you are using Python to develop your application you need to build a separate shared library implemented in C++ first and load it in Python using ``add_extension`` API. Please refer to :ref:`Create library with extensions <create_a_library_with_extensions>` for more details on library creation and usage. The remaining part of this document describes how to implement an operation class.
+OpenVINO™ Extension API allows you to register custom operations to support models with operations which OpenVINO™ does not support out-of-the-box. While this process historically involved writing C++ code and constructing a separate shared library to be subsequently loaded into Python using the ``add_extension`` API, it is now also possible to implement custom operations directly within the Python API.
+
+For those who still wish to use C++, the capability to create a shared library with custom operation implementations is maintained. Please refer to :ref:`Create library with extensions <create_a_library_with_extensions>` for more details on library creation and usage. The remaining part of this document describes how to implement an operation class using both the C++ API and Python API.
 
 Operation Class
 ###############
 
 To add your custom operation, create a new class that extends ``ov::Op``, which is in turn derived from ``ov::Node``, the base class for all graph operations in OpenVINO™. To add ``ov::Op``, include the next file:
 
-.. doxygensnippet:: src/core/template_extension/identity.hpp
-   :language: cpp
-   :fragment: [op:common_include]
+.. tab-set::
+
+   .. tab-item:: C++
+      :sync: cpp
+
+      .. doxygensnippet:: src/core/template_extension/identity.hpp
+         :language: cpp
+         :fragment: [op:common_include]
+
+   .. tab-item:: Python
+      :sync: py
+
+      .. doxygensnippet:: docs/articles_en/assets/snippets/ov_custom_op.py
+         :language: python
+         :fragment: [op:common_include]
 
 Follow the steps below to add a custom operation:
 
-1. Add the ``OPENVINO_OP`` macro which defines a ``NodeTypeInfo`` object that identifies the type of the operation to the graph users and helps with dynamic type resolution. The type info of an operation currently consists of a string operation identifier and a string for operation version.
+1. Define the operation type information:
+
+   a. For the C++ API, add the ``OPENVINO_OP`` macro which defines a ``NodeTypeInfo`` object that identifies the type of the operation to the graph users and helps with dynamic type resolution. The type info of an operation currently consists of a string operation identifier and a string for operation version.
+
+   b. For the Python API, define the ``class_type_info`` attribute in your custom operation class. This attribute should be an instance of ``DiscreteTypeInfo``, encapsulating both the operation name, which serves as a unique string identifier, and the operation version or namespace, represented as a second string.
+
+.. tab-set::
+
+   .. tab-item:: C++
+      :sync: cpp
+
+      .. doxygensnippet:: src/core/template_extension/identity.hpp
+         :language: cpp
+         :fragment: [op:header]
+
+   .. tab-item:: Python
+      :sync: py
+
+      .. doxygensnippet:: docs/articles_en/assets/snippets/ov_custom_op.py
+         :language: python
+         :fragment: [op:header]
 
 2. Implement default constructor and constructors that optionally take the operation inputs and attributes as parameters.
 
@@ -45,43 +79,103 @@ OpenVINO™ operation contains two constructors:
 * Default constructor, which enables you to create an operation without attributes
 * Constructor that creates and validates an operation with specified inputs and attributes
 
-.. doxygensnippet:: src/core/template_extension/identity.cpp
-   :language: cpp
-   :fragment: [op:ctor]
+.. tab-set::
+
+   .. tab-item:: C++
+      :sync: cpp
+
+      .. doxygensnippet:: src/core/template_extension/identity.cpp
+         :language: cpp
+         :fragment: [op:ctor]
+
+   .. tab-item:: Python
+      :sync: py
+
+      .. doxygensnippet:: docs/articles_en/assets/snippets/ov_custom_op.py
+         :language: python
+         :fragment: [op:ctor]
 
 ``validate_and_infer_types()``
 ++++++++++++++++++++++++++++++
 
 ``ov::Node::validate_and_infer_types`` method validates operation attributes and calculates output shapes using attributes of the operation.
 
-.. doxygensnippet:: src/core/template_extension/identity.cpp
-   :language: cpp
-   :fragment: [op:validate]
+.. tab-set::
+
+   .. tab-item:: C++
+      :sync: cpp
+
+      .. doxygensnippet:: src/core/template_extension/identity.cpp
+         :language: cpp
+         :fragment: [op:validate]
+
+   .. tab-item:: Python
+      :sync: py
+
+      .. doxygensnippet:: docs/articles_en/assets/snippets/ov_custom_op.py
+         :language: python
+         :fragment: [op:validate]
 
 ``clone_with_new_inputs()``
 +++++++++++++++++++++++++++
 
 ``ov::Node::clone_with_new_inputs`` method creates a copy of the operation with new inputs.
 
-.. doxygensnippet:: src/core/template_extension/identity.cpp
-   :language: cpp
-   :fragment: [op:copy]
+.. tab-set::
+
+   .. tab-item:: C++
+      :sync: cpp
+
+      .. doxygensnippet:: src/core/template_extension/identity.cpp
+         :language: cpp
+         :fragment: [op:copy]
+
+   .. tab-item:: Python
+      :sync: py
+
+      .. doxygensnippet:: docs/articles_en/assets/snippets/ov_custom_op.py
+         :language: python
+         :fragment: [op:copy]
 
 ``visit_attributes()``
 ++++++++++++++++++++++
 
 ``ov::Node::visit_attributes`` method enables you to visit all operation attributes.
 
-.. doxygensnippet:: src/core/template_extension/identity.cpp
-   :language: cpp
-   :fragment: [op:visit_attributes]
+.. tab-set::
+
+   .. tab-item:: C++
+      :sync: cpp
+
+      .. doxygensnippet:: src/core/template_extension/identity.cpp
+         :language: cpp
+         :fragment: [op:visit_attributes]
+
+   .. tab-item:: Python
+      :sync: py
+
+      .. doxygensnippet:: docs/articles_en/assets/snippets/ov_custom_op.py
+         :language: python
+         :fragment: [op:visit_attributes]
 
 ``evaluate() and has_evaluate()``
 +++++++++++++++++++++++++++++++++
 
 ``ov::Node::evaluate`` method enables you to apply constant folding to an operation.
 
-.. doxygensnippet:: src/core/template_extension/identity.cpp
-   :language: cpp
-   :fragment: [op:evaluate]
+.. tab-set::
+
+   .. tab-item:: C++
+      :sync: cpp
+
+      .. doxygensnippet:: src/core/template_extension/identity.cpp
+         :language: cpp
+         :fragment: [op:evaluate]
+
+   .. tab-item:: Python
+      :sync: py
+
+      .. doxygensnippet:: docs/articles_en/assets/snippets/ov_custom_op.py
+         :language: python
+         :fragment: [op:evaluate]