commit save.

Author: lvrfrc87

netcompare/check_type.py

@@ -16,14 +16,13 @@ def init(*args):
         check_type = args[0]
         if check_type == "exact_match":
             return ExactMatchType(*args)
-        elif check_type == "tolerance":
+        if check_type == "tolerance":
             return ToleranceType(*args)
-        else:
-            raise NotImplementedError
+        raise NotImplementedError
 
     @staticmethod
     def extract_value_from_json_path(
-        value: Mapping, path: Mapping, exclude: List = list()
+        value: Mapping, path: Mapping, exclude: List = None
     ) -> Union[Mapping, List, int, str, bool]:
         """Return the value contained into a Mapping for a defined path."""
         return extract_values_from_output(value, path, exclude)

netcompare/evaluator.py

@@ -1,4 +1,4 @@
-"""Diff evaluator."""
+"Diff evaluator."
 import re
 import sys
 from collections import defaultdict
@@ -109,7 +109,7 @@ def fix_deepdiff_key_names(obj: Mapping) -> Mapping:
     # root['Ethernet1'][0]['port']
     pattern = r"'([A-Za-z0-9_\./\\-]*)'"
 
-    result = dict()
+    result = {}
     for key, value in obj.items():
         key_parts = re.findall(pattern, key)
         partial_res = group_value(key_parts, value)

netcompare/runner.py

@@ -1,7 +1,7 @@
-#!/ur/bin/env python3
+"Library wrapper for output parsing."
 import re
-import jmespath
 from typing import Mapping, List, Union
+import jmespath
 from .utils.jmspath_parsers import jmspath_value_parser, jmspath_refkey_parser
 from .utils.filter_parsers import exclude_filter
 from .utils.refkey import keys_cleaner, keys_values_zipper, associate_key_of_my_value
@@ -48,11 +48,9 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
             for item in element:
                 if isinstance(item, dict):
                     raise TypeError(
-                        'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
-                            wanted_value
-                        )
+                        f'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {wanted_value}\'.'
                     )
-                elif isinstance(item, list):
+                if isinstance(item, list):
                     wanted_value = flatten_list(wanted_value)
                     break
 
@@ -64,5 +62,5 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
         wanted_reference_keys = jmespath.search(jmspath_refkey_parser(path), value)
         list_of_reference_keys = keys_cleaner(wanted_reference_keys)
         return keys_values_zipper(list_of_reference_keys, paired_key_value)
-    else:
-        return paired_key_value
+
+    return paired_key_value

netcompare/utils/filter_parsers.py

@@ -1,3 +1,4 @@
+"Filtering parsing."
 from typing import Mapping, List
 
 
@@ -36,5 +37,5 @@ def exclude_filter(data: Mapping, exclude: List):
 
     elif isinstance(data, list):
         for element in data:
-            if isinstance(element, dict) or isinstance(element, list):
+            if isinstance(element, (dict, list)):
                 exclude_filter(element, exclude)

netcompare/utils/flatten.py

@@ -1,3 +1,4 @@
+"Flatten multi-nested list."
 from typing import List, Generator
 
 

netcompare/utils/jmspath_parsers.py

@@ -1,3 +1,4 @@
+"JMSPath expresion parsers."
 import re
 
 
@@ -19,7 +20,8 @@ def jmspath_value_parser(path: str):
     if regex_normalized_value:
         normalized_value = regex_match_value.group().split("$")[1]
         return path.replace(regex_normalized_value.group(), normalized_value)
-    else: return path
+
+    return path
 
 
 def jmspath_refkey_parser(path: str):
@@ -33,13 +35,13 @@ def jmspath_refkey_parser(path: str):
     """
     splitted_jmspath = path.split(".")
 
-    for n, i in enumerate(splitted_jmspath):
-        regex_match_anchor = re.search(r"\$.*\$", i)
+    for number, element in enumerate(splitted_jmspath):
+        regex_match_anchor = re.search(r"\$.*\$", element)
 
         if regex_match_anchor:
-            splitted_jmspath[n] = regex_match_anchor.group().replace("$", "")
+            splitted_jmspath[number] = regex_match_anchor.group().replace("$", "")
 
-        if regex_match_anchor and not i.startswith("[") and not i.endswith("]"):
-            splitted_jmspath = splitted_jmspath[: n + 1]
+        if regex_match_anchor and not element.startswith("[") and not element.endswith("]"):
+            splitted_jmspath = splitted_jmspath[: number + 1]
 
     return ".".join(splitted_jmspath)

netcompare/utils/refkey.py

@@ -4,51 +4,27 @@
 def keys_cleaner(wanted_reference_keys: Mapping) -> List[Mapping]:
     """
     Get every required reference key from output.
-
-    Args:
-        wanted_reference_keys: {'10.1.0.0': {'address_family': {'ipv4': ...
-
-    Return:
-        ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
-
-    Example:
-        >>> from runner import keys_cleaner
-        >>> wanted_reference_keys = {'10.1.0.0': {'address_family': 'ipv4'}}
-        >>> keys_cleaner(wanted_reference_keys)
-        ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
     """
     if isinstance(wanted_reference_keys, list):
         return wanted_reference_keys
 
     elif isinstance(wanted_reference_keys, dict):
         my_keys_list = list()
 
-        if isinstance(wanted_reference_keys, dict): 
+        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}\'.')
-                    
+            raise TypeError(
+                f"Must be a dictionary. You have type:{type(wanted_reference_keys)} output:{wanted_reference_keys}'."
+            )
+
         return my_keys_list
 
 
 def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List) -> List:
     """
     Build dictionary zipping keys with relative values.
-
-    Args:
-        list_of_reference_keys: ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
-        wanted_value_with_key: [{'is_enabled': True, 'is_up': False}, ...
-
-    Return:
-        [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}, , ...
-
-    Example:
-        >>> from runner import keys_values_zipper
-        >>> list_of_reference_keys = ['10.1.0.0']
-        >>> wanted_value_with_key = [{'is_enabled': True, 'is_up': False}]
-        >>> keys_values_zipper(list_of_reference_keys, wanted_value_with_key)
-        [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}]
     """
     final_result = list()
 
@@ -64,19 +40,6 @@ def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List
 def associate_key_of_my_value(paths: str, wanted_value: List) -> List:
     """
     Associate each key defined in path to every value found in output.
-
-    Args:
-        paths: {"path": "global.peers.*.[is_enabled,is_up]"}
-        wanted_value: [[True, False], [True, False], [True, False], [True, False]]
-
-    Return:
-        [{'is_enabled': True, 'is_up': False}, ...
-
-    Example:
-        >>> from runner import associate_key_of_my_value
-        >>> path = {"path": "global.peers.*.[is_enabled,is_up]"}
-        >>> wanted_value = [[True, False], [True, False], [True, False], [True, False]]
-        {'is_enabled': True, 'is_up': False}, {'is_enabled': True, 'is_up': False}, ...
     """
 
     # global.peers.*.[is_enabled,is_up] / result.[*].state

tasks.py

@@ -109,42 +109,42 @@ def pytest(context, local=INVOKE_LOCAL):
 @task(help={"local": "Run locally or within the Docker container"})
 def black(context, path=".", local=INVOKE_LOCAL):
     """Run black to check that Python files adherence to black standards."""
-    exec_cmd = "black {path}".format(path=path)
+    exec_cmd = f"black {path}"
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
 def flake8(context, path=".", local=INVOKE_LOCAL):
     """Run flake8 code analysis."""
-    exec_cmd = "flake8 {path}".format(path=path)
+    exec_cmd = f"flake8 {path}"
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
 def pylint(context, path=".", local=INVOKE_LOCAL):
     """Run pylint code analysis."""
-    exec_cmd = 'find {path} -name "*.py" | xargs pylint'.format(path=path)
+    exec_cmd = f'find {path} -name "*.py" | xargs pylint'
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
 def yamllint(context, path=".", local=INVOKE_LOCAL):
     """Run yamllint to validate formatting adheres to NTC defined YAML standards."""
-    exec_cmd = "yamllint {path}".format(path=path)
+    exec_cmd = f"yamllint {path}"
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
 def pydocstyle(context, path=".", local=INVOKE_LOCAL):
     """Run pydocstyle to validate docstring formatting adheres to NTC defined standards."""
-    exec_cmd = "pydocstyle {path}".format(path=path)
+    exec_cmd = f"pydocstyle {path}"
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
 def bandit(context, path=".", local=INVOKE_LOCAL):
     """Run bandit to validate basic static code security analysis."""
-    exec_cmd = "bandit --recursive ./{path} --configfile .bandit.yml".format(path=path)
+    exec_cmd = f"bandit --recursive ./{path} --configfile .bandit.yml"
     run_cmd(context, exec_cmd, local)
 
 

tests/utility.py

@@ -8,6 +8,7 @@
 
 
 def load_json_file(folder, filename):
+    "Load mock data from json file."
     filepath = os.path.join(dirname, "mock", folder, filename)
-    with open(filepath) as filehandle:
+    with open(filepath, encoding="utf-8") as filehandle:
         return json.load(filehandle)