Refactor following PEP conventions

Author: shresthalucky

visualiser/visualiser.py

@@ -13,6 +13,7 @@
 dot_str_body = ""
 dot_str_end = "}"
 
+
 class Visualiser(object):
     # Total number of nodes
     node_count = 0
@@ -22,8 +23,9 @@ class Visualiser(object):
     edges = []
     nodes = []
 
-    def __init__(self, ignore_args=None, show_argument_name=True, show_return_value=True, node_properties_kwargs={}):
-        #If enabled shows keyword arguments ordered by keys
+    def __init__(self, ignore_args=None, show_argument_name=True,
+                 show_return_value=True, node_properties_kwargs={}):
+        # If enabled shows keyword arguments ordered by keys
         self.show_argument_name = show_argument_name
         # If enables shows the return value at every nodes
         self.show_return_value = show_return_value
@@ -36,8 +38,6 @@ def __init__(self, ignore_args=None, show_argument_name=True, show_return_value=
         else:
             self.ignore_args = ['node_num'] + ignore_args
 
-
-
     @classmethod
     def write_image(cls, filename="out.png"):
         try:
@@ -78,8 +78,15 @@ def make_frames(cls):
     @classmethod
     def write_gif(cls, name="out.gif", delay=3):
         images = []
-        imgs = glob.glob("frames/*.png")
-        for filename in sorted(imgs, key=lambda fn: int(fn.split("_")[1].split(".")[0])):
+
+        # sort frames images in ascending order to number in image filename
+        # image filename: frames/temp_1.png
+        sorted_images = sorted(
+            glob.glob("frames/*.png"),
+            key=lambda fn: int(fn.split("_")[1].split(".")[0])
+        )
+
+        for filename in sorted_images:
             images.append(imageio.imread(filename))
         print("Writing gif...")
         imageio.mimsave(name, images, duration=delay)
@@ -107,114 +114,138 @@ def make_animation(cls, filename="out.gif", delay=3):
         except:
             print("Error saving gif.")
 
-
-    def extract_signature_label_arg_string(self, *args, **kwargs):
+    def extract_arg_strings(self, *args, **kwargs):
         """
-        Returns function signature arguments as string and function label arguments as string.
-            label_argument string contains only the arguments that are not in ignore_args
-            signature_argument_string contains all the arguments available for the function
+        Returns function signature arguments function label arguments as
+        string.
+        label_args_string contains only the arguments that are not in
+        ignore_args.
+        signature_args_string contains all the arguments available for the
+        function.
         """
-        # If show_argument flag is True(default)
-        # Then argument_string is:
-        # a=1, b=31, c=0
-        signature_argument_string = ', '.join([repr(a) for a in args] +
-                                    [f"{key}={repr(value)}" for key, value in kwargs.items()])
-
-        label_argument_string = ', '.join([repr(a) for a in args] +
-                                                           [f"{key}={repr(value)}"
-                                                            for key, value in kwargs.items()
-                                                            if key not in self.ignore_args])
-
-        # If show_argument flag is False
-        # Then argument_string is:
-        # 1, 31, 0
-        if not self.show_argument_name:
-            signature_argument_string = ', '.join([repr(value) for value in args] +
-                                                 [f"{repr(value)}" for key, value in kwargs.items()])
-
-            label_argument_string = ', '.join([repr(a) for a in args] +
-                                              [f"{repr(value)}"
-                                               for key, value in kwargs.items()
-                                               if key not in self.ignore_args])
-
-        return signature_argument_string, label_argument_string
+
+        def get_kwargs_strings(ignore_args=[]):
+            """Returns list of kwargs in string format from given kwargs items
+
+            Args:
+                ignore_args (list, optional) : list of ignored arguments.
+                Default to [].
+
+            Returns:
+                strings_list: list of kwargs in string format
+            """
+
+            strings_list = []
+
+            for key, value in kwargs.items():
+                if key not in ignore_args:
+                    if not self.show_argument_name:
+                        strings_list.append(f"{repr(value)}")
+                    else:
+                        strings_list.append(f"{key}={repr(value)}")
+
+            return strings_list
+
+        args_string = [repr(a) for a in args]
+        signature_kwargs_string = get_kwargs_strings()
+        label_kwargs_string = get_kwargs_strings(ignore_args=self.ignore_args)
+
+        signature_args_string = ', '.join(
+            args_string + signature_kwargs_string)
+        label_args_string = ', '.join(args_string + label_kwargs_string)
+
+        return signature_args_string, label_args_string
 
     def __call__(self, fn):
-        @wraps(fn)
+        @ wraps(fn)
         def wrapper(*args, **kwargs):
             global dot_str_body
             # Increment total number of nodes when a call is made
             self.node_count += 1
 
-            # Update kwargs by adding dummy keyword node_num which helps to uniquely identify each node
+            # Update kwargs by adding dummy keyword node_num which helps to
+            # uniquely identify each node
             kwargs.update({'node_num': self.node_count})
             # Order all the keyword arguments
             kwargs = OrderedDict(sorted(kwargs.items()))
 
-
             """Details about current Function"""
             # Get signature and label arguments strings for current function
-            current_function_argument_string, current_function_label_argument_string = self.extract_signature_label_arg_string(*args, **kwargs)
+            (signature_args_string,
+             label_args_string) = self.extract_arg_strings(
+                 *args, **kwargs)
 
             # Details about current function
-            current_function_name = fn.__name__
+            function_name = fn.__name__
 
             # Current function signature looks as follows:
             # foo(1, 31, 0) or foo(a=1, b=31, c=0)
-            current_function_signature = f"{current_function_name}(" \
-                                         f"{current_function_argument_string})"
-            current_function_label = f"{current_function_name}({current_function_label_argument_string})"
+            function_signature = f"{function_name}({signature_args_string})"
+            function_label = f"{function_name}({label_args_string})"
             """"""
 
             """Details about caller function"""
-            caller_function_frame = sys._getframe(1)
+            caller_func_frame = sys._getframe(1)
             # All the argument names in caller/parent function
-            caller_function_argument_names = caller_function_frame.f_code.co_varnames[
-                                             :fn.__code__.co_argcount]
-            caller_function_locals = caller_function_frame.f_locals
+            caller_func_arg_names = caller_func_frame.f_code.co_varnames[
+                : fn.__code__.co_argcount]
+            caller_func_locals = caller_func_frame.f_locals
             # Sort all the locals of caller function
-            caller_function_locals = OrderedDict(sorted(caller_function_locals.items()))
+            caller_func_locals = OrderedDict(
+                sorted(caller_func_locals.items()))
+
+            caller_func_kwargs = dict()
+
             # Extract only those locals that are in arguments
-            caller_function_kwargs = {key: value for key, value in caller_function_locals.items() if key in caller_function_argument_names}
+            for key, value in caller_func_locals.items():
+                if key in caller_func_arg_names:
+                    caller_func_kwargs[key] = value
 
             # If the nodes has parent node get node_num from parent node
             if self.stack:
-                caller_function_kwargs.update({'node_num': self.stack[-1]})
-            caller_function_kwargs = OrderedDict(sorted(caller_function_kwargs.items()))
+                caller_func_kwargs.update({'node_num': self.stack[-1]})
+
+            caller_func_kwargs = OrderedDict(
+                sorted(caller_func_kwargs.items()))
 
-            caller_function_argument_string, caller_function_label_argument_string = self.extract_signature_label_arg_string(**caller_function_kwargs)
+            (caller_func_args_string,
+             caller_func_label_args_string) = self.extract_arg_strings(
+                **caller_func_kwargs)
 
             # Caller Function
-            caller_function_name = caller_function_frame.f_code.co_name
+            caller_func_name = caller_func_frame.f_code.co_name
 
             # Extract the names of arguments only
-            caller_func_signature = f"{caller_function_name}({caller_function_argument_string})"
-            caller_func_label = f"{caller_function_name}({caller_function_label_argument_string})"
+            caller_func_signature = "{}({})".format(
+                caller_func_name, caller_func_args_string)
+            caller_func_label = "{}({})".format(
+                caller_func_name, caller_func_label_args_string)
             """"""
 
-            if caller_function_name == '<module>':
-                print(f"Drawing for {current_function_signature}")
+            if caller_func_name == '<module>':
+                print(f"Drawing for {function_signature}")
 
             # Push node_count to stack
             self.stack.append(self.node_count)
             # Before actual function call delete keyword 'node_num' from kwargs
             del kwargs['node_num']
 
-            self.edges.append(f'"{caller_func_signature}" -> "{current_function_signature}"')
+            self.edges.append(
+                f'"{caller_func_signature}" -> "{function_signature}"')
 
             # Construct node string to be rendered in graphviz
-            node_string = f'"{current_function_signature}" [label="{current_function_label}"'
+            node_string = f'"{function_signature}" [label="{function_label}"'
 
             if self.node_properties_kwargs:
-                node_string += ", " + ", ".join([f'{key}="{value}"' for key, value in self.node_properties_kwargs.items()])
+                node_string += ", " + \
+                    ", ".join([f'{key}="{value}"' for key,
+                               value in self.node_properties_kwargs.items()])
 
-            # current_function_label = current_function_label + ", ".join([f"{key}={value}" for key, value in self.node_properties_kwargs.items()])
             self.nodes.append(node_string)
 
             # Return after function call
             result = fn(*args, **kwargs)
 
-
             # Pop from tha stack after returning
             self.stack.pop()
 
@@ -223,20 +254,24 @@ def wrapper(*args, **kwargs):
                 # If shape is set to record
                 # Then separate function label and return value by a row
                 if "record" in self.node_properties_kwargs.values():
-                    current_function_label = "{" + current_function_label + f"|{result} }}"
+                    function_label = "{" + \
+                        function_label + f"|{result} }}"
                 else:
-                    current_function_label += f"\n => {result}"
+                    function_label += f"\n => {result}"
 
-            child_node = pydot.Node(name=current_function_signature, label=current_function_label, **self.node_properties_kwargs)
+            child_node = pydot.Node(name=function_signature,
+                                    label=function_label,
+                                    **self.node_properties_kwargs)
             self.graph.add_node(child_node)
 
             # If the function is called by another function
-            if caller_function_name not in ['<module>', 'main']:
-                parent_node = pydot.Node(name=caller_func_signature, label=caller_func_label, **self.node_properties_kwargs)
+            if caller_func_name not in ['<module>', 'main']:
+                parent_node = pydot.Node(name=caller_func_signature,
+                                         label=caller_func_label,
+                                         **self.node_properties_kwargs)
                 self.graph.add_node(parent_node)
                 edge = pydot.Edge(parent_node, child_node)
                 self.graph.add_edge(edge)
 
-
             return result
-        return wrapper
+        return wrapper