Update errors raising cases in modules versions checker in MO (#5141)

* Change error raising to message printing

* Update modules versions check

* Update check and add unit test

* Fix wrong function call

* Update unit tests

* Fix test

Co-authored-by: achetver <anton.chetverikov@.intel.com>

model-optimizer/mo/utils/versions_checker.py

@@ -77,7 +77,7 @@ def parse_and_filter_versions_list(required_fw_versions, version_list, env_setup
             not_satisfied_list = []
             for name, key, required_version in env_req_version_list:
                 version_check(name, installed_python_version, required_version,
-                              key, not_satisfied_list, 0)
+                              key, not_satisfied_list)
             if len(not_satisfied_list) > 0:
                 # this python_version requirement is not satisfied to required environment
                 # and requirement for a dependency will be skipped
@@ -131,7 +131,7 @@ def get_module_version_list_from_file(file_name, env_setup):
     return req_dict
 
 
-def version_check(name, installed_v, required_v, sign, not_satisfied_v, exit_code):
+def version_check(name, installed_v, required_v, sign, not_satisfied_v):
     """
     Please do not add parameter type annotations (param:type).
     Because we import this file while checking Python version.
@@ -144,8 +144,6 @@ def version_check(name, installed_v, required_v, sign, not_satisfied_v, exit_cod
     :param required_v: required version of module
     :param sign: sing for comparison of required and installed versions
     :param not_satisfied_v: list of modules with not satisfying versions
-    :param exit_code: flag of successful execution (0 - successful, 1 - error)
-    :return: exit code
     """
     if sign is not None:
         req_ver = LooseVersion(required_v)
@@ -166,9 +164,6 @@ def version_check(name, installed_v, required_v, sign, not_satisfied_v, exit_cod
         satisfied = True
     if not satisfied:
         not_satisfied_v.append((name, 'installed: {}'.format(installed_v), 'required: {} {}'.format(sign, required_v)))
-        if name in critical_modules:
-            exit_code = 1
-    return exit_code
 
 
 def get_environment_setup():
@@ -223,9 +218,12 @@ def check_requirements(framework=None):
             importable_name = modules.get(name, name)
             exec("import {}".format(importable_name))
             installed_version = sys.modules[importable_name].__version__
-            exit_code = version_check(name, installed_version, required_version, key, not_satisfied_versions, exit_code)
+            version_check(name, installed_version, required_version, key, not_satisfied_versions)
             exec("del {}".format(importable_name))
         except (AttributeError, ImportError):
+            # we need to raise error only in cases when import of critical modules is failed
+            if name in critical_modules:
+                exit_code = 1
             if key is not None and required_version is not None:
                 not_satisfied_versions.append((name, 'not installed', 'required: {} {}'.format(key, required_version)))
             else:

model-optimizer/unit_tests/mo/utils/versions_checker_test.py

@@ -5,7 +5,7 @@ import unittest
 import unittest.mock as mock
 from unittest.mock import mock_open
 
-from mo.utils.versions_checker import get_module_version_list_from_file, parse_and_filter_versions_list
+from mo.utils.versions_checker import get_module_version_list_from_file, parse_and_filter_versions_list, version_check
 
 
 class TestingVersionsChecker(unittest.TestCase):
@@ -74,3 +74,83 @@ class TestingVersionsChecker(unittest.TestCase):
                     ('mxnet', '<=', '1.3.1')]
         for i, v in enumerate(req_list):
             self.assertEqual(v, ref_list[i])
+
+    def test_version_check_equal(self):
+        modules_versions_list = [('module_1', '==', '2.0', '2.0'),
+                                 ('module_2', '==', '2.0', '2.0.1'),
+                                 ]
+
+        ref_list = [('module_2', 'installed: 2.0.1', 'required: == 2.0'),
+                    ]
+
+        not_satisfied_versions = []
+
+        for name, key, required_version, installed_version in modules_versions_list:
+            version_check(name, installed_version, required_version, key, not_satisfied_versions)
+        self.assertEqual(not_satisfied_versions, ref_list)
+
+    def test_version_check_less_equal(self):
+        modules_versions_list = [('module_1', '>=', '1.12.0', '1.09.2'),
+                                 ('module_2', '>=', '1.12.0', '1.12.0'),
+                                 ('module_3', '>=', '1.12.0', '1.12.1'),
+                                 ('module_4', '>=', '1.12.0', '1.20.0'),
+                                 ]
+
+        ref_list = [('module_1', 'installed: 1.09.2', 'required: >= 1.12.0'),
+                    ]
+
+        not_satisfied_versions = []
+
+        for name, key, required_version, installed_version in modules_versions_list:
+            version_check(name, installed_version, required_version, key, not_satisfied_versions)
+        self.assertEqual(not_satisfied_versions, ref_list)
+
+    def test_version_check_greater_equal(self):
+        modules_versions_list = [('module_1', '>=', '1.12.0', '1.09.2'),
+                                 ('module_2', '>=', '1.12.0', '1.12.0'),
+                                 ('module_3', '>=', '1.12.0', '1.12.1'),
+                                 ('module_4', '>=', '1.12.0', '1.20.0'),
+                                 ]
+
+        ref_list = [('module_1', 'installed: 1.09.2', 'required: >= 1.12.0')
+                    ]
+
+        not_satisfied_versions = []
+
+        for name, key, required_version, installed_version in modules_versions_list:
+            version_check(name, installed_version, required_version, key, not_satisfied_versions)
+        self.assertEqual(not_satisfied_versions, ref_list)
+
+    def test_version_check_less(self):
+        modules_versions_list = [('module_1', '<', '1.11', '1.01'),
+                                 ('module_2', '<', '1.11', '1.10.1'),
+                                 ('module_3', '<', '1.11', '1.11'),
+                                 ('module_4', '<', '1.11', '1.20'),
+                                 ]
+
+        ref_list = [('module_3', 'installed: 1.11', 'required: < 1.11'),
+                    ('module_4', 'installed: 1.20', 'required: < 1.11'),
+                    ]
+
+        not_satisfied_versions = []
+
+        for name, key, required_version, installed_version in modules_versions_list:
+            version_check(name, installed_version, required_version, key, not_satisfied_versions)
+        self.assertEqual(not_satisfied_versions, ref_list)
+
+    def test_version_check_greater(self):
+        modules_versions_list = [('module_1', '>', '1.11', '1.01'),
+                                 ('module_2', '>', '1.11', '1.11'),
+                                 ('module_3', '>', '1.11', '1.11.1'),
+                                 ('module_4', '>', '1.11', '1.20'),
+                                 ]
+
+        ref_list = [('module_1', 'installed: 1.01', 'required: > 1.11'),
+                    ('module_2', 'installed: 1.11', 'required: > 1.11'),
+                    ]
+
+        not_satisfied_versions = []
+
+        for name, key, required_version, installed_version in modules_versions_list:
+            version_check(name, installed_version, required_version, key, not_satisfied_versions)
+        self.assertEqual(not_satisfied_versions, ref_list)