Revert "Fix linter and CI issues"

This reverts commit 446f1da.

Author: Jarvis2001

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

@@ -540,40 +540,26 @@ void regclass_graph_Model(py::module m) {
             }
 
             bool is_multi_input_format = false;
-            bool all_containers = true;
+            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::int_>(elem)) {
+                if (py::isinstance<py::list>(elem)) {
+                    has_list = true;
+                } else if (py::isinstance<py::int_>(elem)) {
                     has_int = true;
-                    all_containers = false;
-                } else if (py::isinstance<py::list>(elem) || py::isinstance<py::tuple>(elem)) {
-                    // list/tuple are treated as shape containers at the top level
-                } else {
+                } else if (!py::isinstance<py::tuple>(elem)) {
                     throw std::runtime_error("Invalid shape format");
                 }
             }
 
-            // If the number of provided shapes matches the number of model inputs
-            // but top-level elements are not all containers, the user likely
-            // intended multi-input format but provided an invalid element type.
-            if ((partial_shape.size() == inputs.size()) && !all_containers) {
-                throw std::runtime_error("Each shape must be a list or tuple.");
-            }
-
-            // If all top-level elements are containers but the number of shapes
-            // does not match number of model inputs, report a clear error instead
-            // of trying to parse the whole thing as a flat shape.
-            if (all_containers && (partial_shape.size() != inputs.size())) {
-                throw std::runtime_error("Number of shapes does not match number of model inputs.");
+            if (has_list) {
+                is_multi_input_format = true;
+            } else {
+                is_multi_input_format = !has_int;
             }
 
-            // Multi-input format is used only when the number of provided shapes
-            // matches the number of model inputs and all top-level elements are
-            // shape containers (lists/tuples). Otherwise treat as a flat shape.
-            is_multi_input_format = (partial_shape.size() == inputs.size()) && all_containers;
-
             if (!is_multi_input_format) {
                 // FLAT FORMAT
                 const auto new_shape = Common::partial_shape_from_list(partial_shape);
@@ -586,18 +572,36 @@ void regclass_graph_Model(py::module m) {
             // MULTI-INPUT FORMAT
             std::map<std::string, ov::PartialShape> new_shapes_map;
 
-            // Reuse existing helper to parse inner shape containers so that all
-            // dimension notation forms supported elsewhere (ints, [min,max],
-            // (min,max), -1, strings, openvino.Dimension, etc.) are accepted
-            // here too. This avoids divergence between flat and multi-input
-            // parsing behavior.
-            auto parse_shape = [](py::handle shape_handle) -> ov::PartialShape {
-                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.");
+            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]));
                 }
-                // Common::partial_shape_from_list expects a py::list
-                py::list shape_list = shape_handle.cast<py::list>();
-                return Common::partial_shape_from_list(shape_list);
+                return ov::PartialShape(dims);
             };
 
             if (partial_shape.size() != inputs.size()) {
@@ -606,7 +610,11 @@ void regclass_graph_Model(py::module m) {
 
             for (size_t i = 0; i < partial_shape.size(); ++i) {
                 py::handle shape_handle = partial_shape[i];
-                new_shapes_map[inputs[i].get_any_name()] = parse_shape(shape_handle);
+                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);
@@ -629,9 +637,21 @@ void regclass_graph_Model(py::module m) {
             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) `-1` is a dynamic dimension without known bounds
+            (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
+
+            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, ...]
 
             Examples:
                 >>> model.reshape([[2, 2], [1, 3, 224, 244], [10]])  # Multi-input

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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2018-2026 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
@@ -10,18 +11,16 @@
 
 import numpy as np
 import pytest
-from tests.utils.helpers import (
-    create_filenames_for_ir,
-    generate_add_model,
-    generate_model_with_memory,
-    generate_multi_input_model,
-    generate_single_input_model,
-    generate_two_input_model,
-)
+from tests.utils.helpers import (create_filenames_for_ir, generate_add_model,
+                                 generate_model_with_memory,
+                                 generate_multi_input_model,
+                                 generate_single_input_model,
+                                 generate_two_input_model)
 
 import openvino.opset13 as ops
-from openvino import Core, Dimension, Layout, Model, Output, OVAny, \
-    PartialShape, Shape, Tensor, Type, get_batch, save_model, serialize, set_batch
+from openvino import (Core, Dimension, Layout, Model, Output, OVAny,
+                      PartialShape, Shape, Tensor, Type, get_batch, save_model,
+                      serialize, set_batch)
 from openvino.op.util import Variable, VariableInfo
 
 
@@ -261,16 +260,16 @@ def test_model_sink_ctors():
 
     # Model(list[openvino._pyopenvino.op.Result], list[ov::Output<ov::Node>],
     # list[openvino._pyopenvino.op.Parameter], list[openvino._pyopenvino.op.util.Variable], str = '')
-    model = Model(results=[res], sinks=[assign.output(0)],
-                  parameters=[input_data], variables=[variable_1], name="TestModel")
+    model = Model(results=[res], sinks=[assign.output(0)], parameters=[
+              input_data], variables=[variable_1], name="TestModel")
     model.validate_nodes_and_infer_types()
     assert model.sinks[0].get_output_shape(0) == Shape([2, 2])
     assert sinks == [sink.get_type_name() for sink in model.get_sinks()]
 
     # Model(list[ov::Output<ov::Node>, list[ov::Output<ov::Node>],
     # list[openvino._pyopenvino.op.Parameter], list[openvino._pyopenvino.op.util.Variable], str = '')
-    model = Model(results=[res.output(0)], sinks=[assign.output(0)],
-                  parameters=[input_data], variables=[variable_1], name="TestModel")
+    model = Model(results=[res.output(0)], sinks=[assign.output(0)], parameters=[
+              input_data], variables=[variable_1], name="TestModel")
     model.validate_nodes_and_infer_types()
     assert model.sinks[0].get_output_shape(0) == Shape([2, 2])
     assert sinks == [sink.get_type_name() for sink in model.get_sinks()]
@@ -509,15 +508,13 @@ def check_shape(new_shape):
     shape10 = [1, 1, 1, 1]
     with pytest.raises(TypeError) as e:
         model.reshape({model.input().node: shape10})
-    expected_msg = "Incorrect key type <class 'openvino._pyopenvino.op.Parameter'> to reshape a model, " \
-        "expected keys as openvino.Output, int or str."
-    assert expected_msg in str(e.value)
+    assert "Incorrect key type <class 'openvino._pyopenvino.op.Parameter'> to reshape a model, " "expected keys as openvino.Output, int or str." in str(
+        e.value)
 
     with pytest.raises(TypeError) as e:
         model.reshape({0: range(1, 9)})
-    expected_msg = "Incorrect value type <class 'range'> to reshape a model, " \
-        "expected values as openvino.PartialShape, str, list or tuple."
-    assert expected_msg in str(e.value)
+    assert "Incorrect value type <class 'range'> to reshape a model, " "expected values as openvino.PartialShape, str, list or tuple." in str(
+      e.value)
 
 
 def test_reshape_with_python_types_for_variable():
@@ -590,31 +587,31 @@ def check_shape(new_shape):
 
     with pytest.raises(TypeError) as e:
         model.reshape({0: shape10}, {var_id: range(1, 9)})
-    assert "Incorrect value type <class 'range'> to reshape a model, " \
-        "expected values as openvino.PartialShape, str, list or tuple." in str(e.value)
+    assert "Incorrect value type <class 'range'> to reshape a model, " "expected values as openvino.PartialShape, str, list or tuple." in str(
+      e.value)
 
 
 @pytest.fixture
-def multi_input_model():
+def model():
     return generate_multi_input_model()
 
 
-def test_reshape_list_of_shapes(multi_input_model):
+def test_reshape_list_of_shapes(model):
     """Multi-input: list-of-lists reshapes all inputs in order."""
     input_shapes = [[2, 2], [1, 3, 224, 244], [10]]
 
-    multi_input_model.reshape(input_shapes)
+    model.reshape(input_shapes)
 
-    assert multi_input_model.input("A").shape == (2, 2)
-    assert multi_input_model.input("B").shape == (1, 3, 224, 244)
-    assert multi_input_model.input("C").shape == (10,)
+    assert model.input("A").shape == (2, 2)
+    assert model.input("B").shape == (1, 3, 224, 244)
+    assert model.input("C").shape == (10,)
 
 
-def test_reshape_list_of_shapes_wrong_size(multi_input_model):
+def test_reshape_list_of_shapes_wrong_size(model):
     """Providing wrong number of shapes should raise an error."""
     input_shapes = [[2, 2], [1, 3, 224, 244]]  # Missing third input
     with pytest.raises(RuntimeError, match="Number of shapes does not match"):
-        multi_input_model.reshape(input_shapes)
+        model.reshape(input_shapes)
 
 
 def test_reshape_single_input_flat_list():
@@ -633,22 +630,15 @@ def test_reshape_with_dynamic_dimensions():
     model.reshape(input_shapes)
 
     assert model.input("A").shape == (2, 2)
-
-
-def test_reshape_single_input_flat_list_with_list_intervals():
-    """Single-input flat list: ensure list-based dim intervals are treated as flat."""
-    param = ops.parameter([1, 3, 224, 224])
-    model = Model(ops.relu(param), [param])
-
-    # Use list-based intervals (inner lists) for dimensions — should be treated
-    # as a flat shape for single-input models and parsed as PartialShape.
-    shape = [1, 3, [224, 256], [224, 256]]
-    model.reshape(shape)
-
-    expected = PartialShape([Dimension(1), Dimension(3), Dimension(224, 256), Dimension(224, 256)])
-    for inp in model.inputs:
-        assert inp.partial_shape == expected
-    # single-input model: no inputs named "B", further checks not applicable
+    b_shape = model.input("B").get_partial_shape()
+    assert b_shape[0] == 1
+    assert b_shape[1] == 3
+    assert b_shape[2].is_dynamic
+    assert b_shape[2].get_min_length() == 224
+    assert b_shape[2].get_max_length() == 256
+    assert b_shape[3].is_dynamic
+    assert b_shape[3].get_min_length() == 224
+    assert b_shape[3].get_max_length() == 256
 
 
 def test_reshape_with_tuple_shapes_multi_input():
@@ -837,20 +827,20 @@ def check_rt_info(model):
 
         assert model.get_rt_info(["config", "type_of_model"]).astype(str) == "classification"
         assert model.get_rt_info(["config", "converter_type"]).astype(str) == "classification"
-        assert math.isclose(model.get_rt_info(
-            ["config", "model_parameters", "threshold"]).astype(float), 13.23, rel_tol=0.0001)
-        assert math.isclose(model.get_rt_info(
-            ["config", "model_parameters", "min"]).astype(float), -3.24543, rel_tol=0.0001)
-        assert math.isclose(model.get_rt_info(
-            ["config", "model_parameters", "max"]).astype(float), 3.234223, rel_tol=0.0001)
+        assert math.isclose(model.get_rt_info(["config", "model_parameters",
+                            "threshold"]).astype(float), 13.23, rel_tol=0.0001)
+        assert math.isclose(model.get_rt_info(["config", "model_parameters",
+                            "min"]).astype(float), -3.24543, rel_tol=0.0001)
+        assert math.isclose(model.get_rt_info(["config", "model_parameters",
+                            "max"]).astype(float), 3.234223, rel_tol=0.0001)
         assert model.get_rt_info(["config", "model_parameters", "labels", "label_tree", "type"]).astype(str) == "tree"
-        assert model.get_rt_info(
-            ["config", "model_parameters", "labels", "label_tree", "directed"]).astype(bool) is True
+        assert model.get_rt_info(["config", "model_parameters", "labels",
+                                  "label_tree", "directed"]).astype(bool) is True
 
         assert model.get_rt_info(["config", "model_parameters", "labels", "label_tree", "float_empty"]).aslist() == []
         assert model.get_rt_info(["config", "model_parameters", "labels", "label_tree", "nodes"]).aslist() == []
-        assert model.get_rt_info(
-            ["config", "model_parameters", "labels", "label_groups", "ids"]).aslist(str) == ["sasd", "fdfdfsdf"]
+        assert model.get_rt_info(["config", "model_parameters", "labels", "label_groups",
+                                  "ids"]).aslist(str) == ["sasd", "fdfdfsdf"]
         assert model.get_rt_info(["config", "model_parameters", "mean_values"]).aslist(float) == [22.3, 33.11, 44.0]
         assert model.get_rt_info("enum_info_int").astype(int) == 1
         assert model.get_rt_info("enum_info_str").astype(str) == "info_str"

src/bindings/python/tests/utils/helpers.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2018-2026 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
@@ -242,8 +243,8 @@ def generate_add_model(input_shape: list[int] = None, input_dtype=np.float32) ->
     return Model(add, [param1, param2], "TestModel")
 
 
-def generate_multi_input_model() -> openvino.Model:
-    """Generate a model with three inputs and three corresponding addition outputs."""
+def generate_multi_input_model():
+
     input_a = ops.parameter([2, 2], name="A")
     input_b = ops.parameter([1, 3, 224, 244], name="B")
     input_c = ops.parameter([10], name="C")