[Python API] Added implicit input reshaping API and extended reshape() Unit Tests.

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

@@ -533,44 +533,139 @@ void regclass_graph_Model(py::module m) {
     model.def(
         "reshape",
         [](ov::Model& self, const py::list& partial_shape, const py::dict& variables_shapes) {
-            const auto new_shape = Common::partial_shape_from_list(partial_shape);
+            const auto& inputs = self.inputs();
+
+            if (partial_shape.size() == 0) {
+                throw std::runtime_error("Shapes list cannot be empty.");
+            }
+
+            bool is_multi_input_format = false;
+            bool has_list = false;
+            bool has_int = false;
+
+            for (size_t i = 0; i < partial_shape.size(); ++i) {
+                py::handle elem = partial_shape[i];
+                if (py::isinstance<py::list>(elem)) {
+                    has_list = true;
+                } else if (py::isinstance<py::int_>(elem)) {
+                    has_int = true;
+                } else if (!py::isinstance<py::tuple>(elem)) {
+                    throw std::runtime_error("Invalid shape format");
+                }
+            }
+
+            if (has_list) {
+                is_multi_input_format = true;
+            } else {
+                is_multi_input_format = !has_int;
+            }
+
+            if (!is_multi_input_format) {
+                // FLAT FORMAT
+                const auto new_shape = Common::partial_shape_from_list(partial_shape);
+                const auto new_variables_shapes = get_variables_shapes(variables_shapes);
+                py::gil_scoped_release release;
+                self.reshape(new_shape, new_variables_shapes);
+                return;
+            }
+
+            // MULTI-INPUT FORMAT
+            std::map<std::string, ov::PartialShape> new_shapes_map;
+
+            auto parse_dimension = [](py::handle dim_obj) -> ov::Dimension {
+                if (py::isinstance<py::list>(dim_obj)) {
+                    throw std::runtime_error("Unexpected nested list in dimension specification.");
+                }
+                if (py::isinstance<py::tuple>(dim_obj)) {
+                    py::tuple t = dim_obj.cast<py::tuple>();
+                    if (t.size() != 2) {
+                        throw std::runtime_error(
+                            "Two elements are expected in tuple(lower, upper) for dynamic dimension, but " +
+                            std::to_string(t.size()) + " elements were given.");
+                    }
+                    if (!py::isinstance<py::int_>(t[0]) || !py::isinstance<py::int_>(t[1])) {
+                        throw std::runtime_error("Tuple elements must be integers.");
+                    }
+                    int lower = t[0].cast<int>();
+                    int upper = t[1].cast<int>();
+                    return ov::Dimension(lower, upper);
+                }
+                if (py::isinstance<py::int_>(dim_obj)) {
+                    return ov::Dimension(dim_obj.cast<int>());
+                }
+                throw std::runtime_error("Invalid dimension type. Must be int or (lower, upper) tuple.");
+            };
+
+            auto parse_shape = [&parse_dimension](py::sequence shape_seq) -> ov::PartialShape {
+                std::vector<ov::Dimension> dims;
+                for (size_t i = 0; i < shape_seq.size(); ++i) {
+                    dims.push_back(parse_dimension(shape_seq[i]));
+                }
+                return ov::PartialShape(dims);
+            };
+
+            if (partial_shape.size() != inputs.size()) {
+                throw std::runtime_error("Number of shapes does not match number of model inputs.");
+            }
+
+            for (size_t i = 0; i < partial_shape.size(); ++i) {
+                py::handle shape_handle = partial_shape[i];
+                if (!py::isinstance<py::list>(shape_handle) && !py::isinstance<py::tuple>(shape_handle)) {
+                    throw std::runtime_error("Each shape must be a list or tuple.");
+                }
+                py::sequence shape_seq = shape_handle.cast<py::sequence>();
+                new_shapes_map[inputs[i].get_any_name()] = parse_shape(shape_seq);
+            }
+
             const auto new_variables_shapes = get_variables_shapes(variables_shapes);
             py::gil_scoped_release release;
-            self.reshape(new_shape, new_variables_shapes);
+            self.reshape(new_shapes_map, new_variables_shapes);
         },
         py::arg("partial_shape"),
         py::arg("variables_shapes") = py::dict(),
         R"(
-                Reshape model input.
+            Reshape model input(s).
 
-                The allowed types of keys in the `variables_shapes` dictionary is `str`.
-                The allowed types of values in the `variables_shapes` are:
+            The allowed types of keys in the `variables_shapes` dictionary is `str`.
+            The allowed types of values in the `variables_shapes` are:
 
-                (1) `openvino.PartialShape`
-                (2) `list` consisting of dimensions
-                (3) `tuple` consisting of dimensions
-                (4) `str`, string representation of `openvino.PartialShape`
+            (1) `openvino.PartialShape`
+            (2) `list` consisting of dimensions
+            (3) `tuple` consisting of dimensions
+            (4) `str`, string representation of `openvino.PartialShape`
 
-                When list or tuple are used to describe dimensions, each dimension can be written in form:
+            When list or tuple are used to describe dimensions, each dimension can be written in form:
 
-                (1) non-negative `int` which means static value for the dimension
-                (2) `[min, max]`, dynamic dimension where `min` specifies lower bound and `max` specifies upper bound;
-                the range includes both `min` and `max`; using `-1` for `min` or `max` means no known bound (3) `(min,
-                max)`, the same as above (4) `-1` is a dynamic dimension without known bounds (4)
-                `openvino.Dimension` (5) `str` using next syntax:
-                    '?' - to define fully dynamic dimension
-                    '1' - to define dimension which length is 1
-                    '1..10' - to define bounded dimension
-                    '..10' or '1..' to define dimension with only lower or only upper limit
+            (1) non-negative `int` which means static value for the dimension
+            (2) `[min, max]`, dynamic dimension where `min` specifies lower bound and `max` specifies upper bound;
+            the range includes both `min` and `max`; using `-1` for `min` or `max` means no known bound (3) `(min,
+            max)`, the same as above (4) `-1` is a dynamic dimension without known bounds (4)
+            `openvino.Dimension` (5) `str` using next syntax:
+                '?' - to define fully dynamic dimension
+                '1' - to define dimension which length is 1
+                '1..10' - to define bounded dimension
+                '..10' or '1..' to define dimension with only lower or only upper limit
 
-                GIL is released while running this function.
+            Multi-input format:
+            - Pass a list of shapes: [[shape1], [shape2], ...]
+            - Number of shapes must match number of inputs
+
+            Single-input format:
+            - Pass a flat list: [dim1, dim2, ...]
 
-                :param partial_shape: New shape.
-                :type partial_shape: list
-                :param variables_shapes: New shapes for variables
-                :type variables_shapes: dict[keys, values]
-                :return : void
-             )");
+            Examples:
+                >>> model.reshape([[2, 2], [1, 3, 224, 244], [10]])  # Multi-input
+                >>> model.reshape([2, 2])  # Single-input
+                >>> model.reshape([(1, 8), 3, (112, 448), (112, 448)])  # With dynamic dims
+
+            GIL is released while running this function.
+
+            :param partial_shape: New shape(s).
+            :type partial_shape: list
+            :param variables_shapes: New shapes for variables
+            :type variables_shapes: dict[keys, values]
+            :return : void
+        )");
 
     model.def(
         "reshape",