vpython linting

Author: jhavl

roboticstoolbox/backend/VPython/VPython.py

@@ -16,13 +16,14 @@
     close_localhost_session
 
 
-class VPython(Connector):
+class VPython(Connector):  # pragma nocover
     """
     Graphical backend using VPython
 
     VPython is a Python API that connects to a JavaScript/WebGL 3D graphics
-    engine in a browser tab.  It supports many 3D graphical primitives including
-    meshes, boxes, ellipsoids and lines. It can not render in full color.
+    engine in a browser tab.  It supports many 3D graphical primitives
+    including meshes, boxes, ellipsoids and lines. It can not render in
+    full color.
 
     Example:
 
@@ -41,7 +42,7 @@ class VPython(Connector):
     :references:
 
         - https://vpython.org
-        
+
     """
     # TODO be able to add ellipsoids (vellipse, fellipse)
     # TODO be able add lines (for end-effector paths)
@@ -55,12 +56,15 @@ def __init__(self):
 
         # Init vars
         self.canvases = []
-        self.canvas_settings = []  # 2D array of [is_3d, height, width, title, caption, grid] per canvas
+        # 2D array of [is_3d, height, width, title, caption, grid] per canvas
+        self.canvas_settings = []
         self.robots = []
 
         self._create_empty_session()
 
-    def launch(self, is_3d=True, height=500, width=888, title='', caption='', grid=True):
+    def launch(
+            self, is_3d=True, height=500, width=888,
+            title='', caption='', grid=True):
         """
         Launch a graphical backend in a browser tab
 
@@ -71,13 +75,16 @@ def launch(self, is_3d=True, height=500, width=888, title='', caption='', grid=T
 
         super().launch()
 
-        self.canvas_settings.append([is_3d, height, width, title, caption, grid])
+        self.canvas_settings.append(
+            [is_3d, height, width, title, caption, grid])
 
         # Create the canvas with the given information
         if is_3d:
-            self.canvases.append(GraphicsCanvas3D(height, width, title, caption, grid))
+            self.canvases.append(
+                GraphicsCanvas3D(height, width, title, caption, grid))
         else:
-            self.canvases.append(GraphicsCanvas2D(height, width, title, caption, grid))
+            self.canvases.append(
+                GraphicsCanvas2D(height, width, title, caption, grid))
 
     def step(self, id, q=None, fig_num=0):
         """
@@ -88,41 +95,44 @@ def step(self, id, q=None, fig_num=0):
         :type id: :class:`~roboticstoolbox.robot.DHRobot.DHRobot`,
             :class:`roboticstoolbox.backend.VPython.graphics_robot.GraphicalRobot`
         :param q: The joint angles/configuration of the robot (Optional, if not
-            supplied will use the stored q values). 
-        :type q: float ndarray(n) 
-        :param fig_num: The canvas index to delete the robot from, defaults to the
-            initial one 
-        :type fig_num: int, optional 
+            supplied will use the stored q values).
+        :type q: float ndarray(n)
+        :param fig_num: The canvas index to delete the robot from, defaults to
+            the initial one
+        :type fig_num: int, optional
         :raises ValueError: Figure number must be between 0 and total number of
-            canvases 
+            canvases
         :raises TypeError: Input must be a DHLink or GraphicalRobot
 
         ``env.step(args)`` triggers an update of the 3D scene in the browser
         window referenced by ``env``.
 
-        .. note:: 
+        .. note::
 
             - Each robot in the scene is updated based on
               their control type (position, velocity, acceleration, or torque).
             - Upon acting, the other three of the four control types will be
-              updated in the internal state of the robot object. 
-            - The control type is defined by the robot object, and not all robot
-              objects support all control types.
+              updated in the internal state of the robot object.
+            - The control type is defined by the robot object, and not all
+              robot objects support all control types.
             - Execution is blocked for the specified interval
 
         """
 
         super().step()
 
         if fig_num < 0 or fig_num >= len(self.canvases):
-            raise ValueError("Figure number must be between 0 and total number of canvases")
+            raise ValueError(
+                "Figure number must be between 0 and total number of canvases")
 
         # If DHRobot given
         if isinstance(id, r.Robot):
             robot = None
             # Find first occurrence of it that is in the correct canvas
             for i in range(len(self.robots)):
-                if self.robots[i].robot is id and self.canvases[fig_num].is_robot_in_canvas(self.robots[i]):
+                if self.robots[i].robot is id and \
+                        self.canvases[fig_num].is_robot_in_canvas(
+                                                        self.robots[i]):
                     robot = self.robots[i]
                     break
             if robot is None:
@@ -138,7 +148,9 @@ def step(self, id, q=None, fig_num=0):
                 id.set_joint_poses(poses)
         # Else
         else:
-            raise TypeError("Input must be a Robot (or subclass) or GraphicalRobot, given {0}".format(type(id)))
+            raise TypeError(
+                "Input must be a Robot (or subclass) or "
+                "GraphicalRobot, given {0}".format(type(id)))
 
     def reset(self):
         """
@@ -168,9 +180,13 @@ def reset(self):
             for settings in self.canvas_settings:
                 # Create the canvas with the given information
                 if settings[0]:
-                    self.canvases.append(GraphicsCanvas3D(settings[1], settings[2], settings[3], settings[4], settings[5]))
+                    self.canvases.append(GraphicsCanvas3D(
+                        settings[1], settings[2], settings[3],
+                        settings[4], settings[5]))
                 else:
-                    self.canvases.append(GraphicsCanvas2D(settings[1], settings[2], settings[3], settings[4], settings[5]))
+                    self.canvases.append(GraphicsCanvas2D(
+                        settings[1], settings[2], settings[3],
+                        settings[4], settings[5]))
 
     def restart(self):
         """
@@ -184,16 +200,6 @@ def restart(self):
 
         super().restart()
 
-        # self.close()
-        # self._create_empty_session()
-        # for settings in self.canvas_settings:
-        #     # Create the canvas with the given information
-        #     if settings[0]:
-        #         self.canvases.append(GraphicsCanvas3D(settings[1], settings[2], settings[3], settings[4], settings[5]))
-        #     else:
-        #         self.canvases.append(GraphicsCanvas2D(settings[1], settings[2], settings[3], settings[4], settings[5]))
-
-        # Program on close terminates execution, so just run reset
         self.reset()
 
     def close(self):
@@ -222,21 +228,23 @@ def add(self, fig_num, name, dhrobot):
         """
         Add a robot to the graphical scene
 
-        :param fig_num: The canvas number to place the robot in 
+        :param fig_num: The canvas number to place the robot in
         :type fig_num: int
-        :param name: The name of the robot 
-        :type name: `str` 
-        :param dhrobot: The ``DHRobot`` object (if applicable) 
-        :type dhrobot: class:`~roboticstoolbox.robot.DHRobot.DHRobot`, None 
-        :raises ValueError: Figure number must be between 0 and number of figures created
+        :param name: The name of the robot
+        :type name: `str`
+        :param dhrobot: The ``DHRobot`` object (if applicable)
+        :type dhrobot: class:`~roboticstoolbox.robot.DHRobot.DHRobot`, None
+        :raises ValueError: Figure number must be between 0 and number of
+            figures created
         :return: object id within visualizer
         :rtype: int
 
-        ``id = env.add(robot)`` adds the ``robot`` to the graphical environment.
+        ``id = env.add(robot)`` adds the ``robot`` to the graphical
+            environment.
 
         .. note::
 
-            - ``robot`` must be of an appropriate class. 
+            - ``robot`` must be of an appropriate class.
             - Adds the robot object to a list of robots which will be updated
               when the ``step()`` method is called.
 
@@ -251,42 +259,48 @@ def add(self, fig_num, name, dhrobot):
 
         # Sanity check input
         if fig_num < 0 or fig_num > len(self.canvases) - 1:
-            raise ValueError("Figure number must be between 0 and number of figures created")
+            raise ValueError(
+                "Figure number must be between 0 and number "
+                "of figures created")
 
         # Add robot to canvas
-        self.robots.append(GraphicalRobot(self.canvases[fig_num], name, dhrobot))
+        self.robots.append(
+            GraphicalRobot(self.canvases[fig_num], name, dhrobot))
         # self.canvases[fig_num].add_robot(self.robots[len(self.robots)-1])
 
     def remove(self, id, fig_num=0):
         """
         Remove a robot to the graphical scene
 
-        :param id: The id of the robot to remove. Can be either the DHLink or 
+        :param id: The id of the robot to remove. Can be either the DHLink or
             GraphicalRobot
         :type id: class:`~roboticstoolbox.robot.DHRobot.DHRobot`,
                   class:`roboticstoolbox.backend.VPython.graphics_robot.GraphicalRobot`
         :param fig_num: The canvas index to delete the robot from, defaults to
              the initial one
         :type fig_num: int, optional
-        :raises ValueError: Figure number must be between 0 and total number 
+        :raises ValueError: Figure number must be between 0 and total number
             of canvases
         :raises TypeError: Input must be a DHLink or GraphicalRobot
 
-        ``env.remove(robot)`` removes the ``robot`` from the graphical environment.
+        ``env.remove(robot)`` removes the ``robot`` from the graphical
+            environment.
 
         """
 
         super().remove()
 
         if fig_num < 0 or fig_num >= len(self.canvases):
-            raise ValueError("Figure number must be between 0 and total number of canvases")
+            raise ValueError(
+                "Figure number must be between 0 and total number of canvases")
 
         # If DHLink given
         if isinstance(id, DHLink):
             robot = None
             # Find first occurrence of it that is in the correct canvas
             for i in range(len(self.robots)):
-                if self.robots[i].seriallink.equal(id) and self.canvases[fig_num].is_robot_in(self.robots[i]):
+                if self.robots[i].seriallink.equal(id) and \
+                        self.canvases[fig_num].is_robot_in(self.robots[i]):
                     robot = self.robots[i]
                     break
             if robot is None: