Refactor + missing typing (#48)

* Refactor + missing typing

* Removed keys_cleaner() as a result of refactor.

Co-authored-by: Patryk Szulczewski <patryk.szulczewski@networktocode.com>

Author: pszulczewski

netcompare/check_types.py

@@ -7,7 +7,6 @@
     jmespath_value_parser,
     jmespath_refkey_parser,
     associate_key_of_my_value,
-    keys_cleaner,
     keys_values_zipper,
 )
 from .utils.data_normalization import exclude_filter, flatten_list
@@ -91,7 +90,7 @@ def get_value(output: Union[Mapping, List], path: str, exclude: List = None) ->
             wanted_reference_keys = jmespath.search(jmespath_refkey_parser(path), output)
 
             if isinstance(wanted_reference_keys, dict):  # when wanted_reference_keys is dict() type
-                list_of_reference_keys = keys_cleaner(wanted_reference_keys)
+                list_of_reference_keys = list(wanted_reference_keys.keys())
             elif any(
                 isinstance(element, list) for element in wanted_reference_keys
             ):  # when wanted_reference_keys is a nested list
@@ -165,7 +164,7 @@ def evaluate(self, value_to_compare: Any, reference_data: Any, tolerance: int) -
     def _remove_within_tolerance(self, diff: Dict, tolerance: int) -> None:
         """Recursively look into diff and apply tolerance check, remove reported difference when within tolerance."""
 
-        def _make_float(value):
+        def _make_float(value: Any) -> float:
             """Make float, treat non-convertable as 0."""
             try:
                 return float(value)

netcompare/evaluators.py

@@ -110,6 +110,4 @@ def operator_evaluator(referance_data: Mapping, value_to_compare: Mapping) -> Di
     # {'mode': 'all-same', 'operator_data': True}
     operator_mode = referance_data["mode"].replace("-", "_")
     operator = Operator(referance_data["operator_data"], value_to_compare)
-
-    result = getattr(operator, operator_mode)()
-    return result
+    return getattr(operator, operator_mode)()

netcompare/operator.py

@@ -1,11 +1,12 @@
 """Operator diff."""
 import operator
+from typing import Any, List, Tuple
 
 
 class Operator:
     """Operator class implementation."""
 
-    def __init__(self, referance_data, value_to_compare) -> None:
+    def __init__(self, referance_data: Any, value_to_compare: Any) -> None:
         """__init__ method."""
         # [{'7.7.7.7': {'peerGroup': 'EVPN-OVERLAY-SPINE', 'vrf': 'default', 'state': 'Idle'}},
         # {'10.1.0.0': {'peerGroup': 'IPv4-UNDERLAY-SPINE', 'vrf': 'default', 'state': 'Idle'}},
@@ -14,8 +15,8 @@ def __init__(self, referance_data, value_to_compare) -> None:
         self.referance_data = referance_data
         self.value_to_compare = value_to_compare
 
-    def _loop_through_wrapper(self, call_ops):
-        """Wrappoer method for operator evaluation."""
+    def _loop_through_wrapper(self, call_ops: str) -> Tuple[bool, List]:
+        """Wrapper method for operator evaluation."""
         ops = {
             ">": operator.gt,
             "<": operator.lt,
@@ -52,14 +53,14 @@ def _loop_through_wrapper(self, call_ops):
             return (True, result)
         return (False, result)
 
-    def all_same(self):
+    def all_same(self) -> Tuple[bool, Any]:
         """All same operator implementation."""
         list_of_values = []
         result = []
 
         for item in self.value_to_compare:
             for value in item.values():
-                # Create a list for compare valiues.
+                # Create a list for compare values.
                 list_of_values.append(value)
 
         for element in list_of_values:
@@ -76,34 +77,34 @@ def all_same(self):
             return (True, self.value_to_compare)
         return (False, self.value_to_compare)
 
-    def contains(self):
+    def contains(self) -> Tuple[bool, List]:
         """Contains operator implementation."""
         return self._loop_through_wrapper("contains")
 
-    def not_contains(self):
+    def not_contains(self) -> Tuple[bool, List]:
         """Not contains operator implementation."""
         return self._loop_through_wrapper("not_contains")
 
-    def is_gt(self):
+    def is_gt(self) -> Tuple[bool, List]:
         """Is greather than operator implementation."""
         return self._loop_through_wrapper(">")
 
-    def is_lt(self):
+    def is_lt(self) -> Tuple[bool, List]:
         """Is lower than operator implementation."""
         return self._loop_through_wrapper("<")
 
-    def is_in(self):
+    def is_in(self) -> Tuple[bool, List]:
         """Is in operator implementation."""
         return self._loop_through_wrapper("is_in")
 
-    def not_in(self):
+    def not_in(self) -> Tuple[bool, List]:
         """Is not in operator implementation."""
         return self._loop_through_wrapper("not_in")
 
-    def in_range(self):
+    def in_range(self) -> Tuple[bool, List]:
         """Is in range operator implementation."""
         return self._loop_through_wrapper("in_range")
 
-    def not_range(self):
+    def not_range(self) -> Tuple[bool, List]:
         """Is not in range operator implementation."""
         return self._loop_through_wrapper("not_range")

netcompare/utils/jmespath_parsers.py

@@ -1,6 +1,6 @@
 """jmespath expression parsers and related utilities."""
 import re
-from typing import Mapping, List, Optional
+from typing import Mapping, List, Union
 
 
 def jmespath_value_parser(path: str):
@@ -84,25 +84,17 @@ def associate_key_of_my_value(paths: str, wanted_value: List) -> List:
     return final_list
 
 
-def keys_cleaner(wanted_reference_keys: Mapping) -> Optional[List[Mapping]]:
+def keys_cleaner(wanted_reference_keys: Union[Mapping, List]) -> List:
     """Get every required reference key from output."""
     if isinstance(wanted_reference_keys, list):
-        return wanted_reference_keys
-
-    if isinstance(wanted_reference_keys, dict):
-        my_keys_list = []
-
-        if isinstance(wanted_reference_keys, dict):
-            for key in wanted_reference_keys.keys():
-                my_keys_list.append(key)
-        else:
-            raise TypeError(
-                f"Must be a dictionary. You have type:{type(wanted_reference_keys)} output:{wanted_reference_keys}'."
-            )
-
-        return my_keys_list
-
-    return None
+        final_result = wanted_reference_keys
+    elif isinstance(wanted_reference_keys, dict):
+        final_result = list(wanted_reference_keys.keys())
+    else:
+        raise TypeError(
+            f"Must be a dictionary. You have type:{type(wanted_reference_keys)} output:{wanted_reference_keys}'."
+        )
+    return final_result
 
 
 def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List) -> List:

tests/test_jmespath_parsers.py

@@ -3,7 +3,6 @@
 from netcompare.utils.jmespath_parsers import (
     jmespath_value_parser,
     jmespath_refkey_parser,
-    keys_cleaner,
     keys_values_zipper,
     associate_key_of_my_value,
 )
@@ -72,11 +71,6 @@ def test_keyref_parser(path, expected_output):
     assert expected_output == output, ASSERT_FAIL_MESSAGE.format(output=output, expected_output=expected_output)
 
 
-keys_cleaner_case_1 = (
-    {"10.1.0.0": {"address_family": "ipv4"}},
-    ["10.1.0.0"],
-)
-
 keys_zipper_case_1 = (
     ["10.1.0.0", "10.2.0.0"],
     [{"is_enabled": False, "is_up": False}, {"is_enabled": True, "is_up": True}],
@@ -89,9 +83,6 @@ def test_keyref_parser(path, expected_output):
     [{"is_enabled": True, "is_up": False}, {"is_enabled": True, "is_up": False}],
 )
 
-keys_cleaner_tests = [
-    keys_cleaner_case_1,
-]
 
 keys_zipper_tests = [
     keys_zipper_case_1,
@@ -102,12 +93,6 @@ def test_keyref_parser(path, expected_output):
 ]
 
 
-@pytest.mark.parametrize("wanted_key, expected_output", keys_cleaner_tests)
-def test_keys_cleaner(wanted_key, expected_output):
-    output = keys_cleaner(wanted_key)
-    assert expected_output == output, ASSERT_FAIL_MESSAGE.format(output=output, expected_output=expected_output)
-
-
 @pytest.mark.parametrize("ref_keys, wanted_values, expected_output", keys_zipper_tests)
 def test_keys_zipper(ref_keys, wanted_values, expected_output):
     output = keys_values_zipper(ref_keys, wanted_values)