Fix lgtm issues

Author: jhavl

roboticstoolbox/backends/PyPlot/RobotPlot.py

@@ -6,15 +6,22 @@
 import numpy as np
 import roboticstoolbox as rp
 from spatialmath import SE3
-from spatialmath import base
 
 
-class RobotPlot():
-
+class RobotPlot:
     def __init__(
-            self, robot, env, readonly, display=True,
-            jointaxes=True, jointlabels=False, eeframe=True, shadow=True,
-            name=True, options=None):
+        self,
+        robot,
+        env,
+        readonly,
+        display=True,
+        jointaxes=True,
+        jointlabels=False,
+        eeframe=True,
+        shadow=True,
+        name=True,
+        options=None,
+    ):
 
         super(RobotPlot, self).__init__()
 
@@ -55,15 +62,15 @@ def __init__(
         self.showname = name
 
         defaults = {
-            'robot': {'color': '#E16F6D', 'linewidth': 5},
-            'shadow': {'color': 'lightgrey', 'linewidth': 3},
-            'jointaxes': {'color': '#8FC1E2', 'linewidth': 2},
-            'jointlabels': {},
-            'jointaxislength': 0.2,
-            'eex': {'color': '#F84752', 'linewidth': 2}, # '#EE9494'
-            'eey': {'color': '#BADA55', 'linewidth': 2}, # '#93E7B0'
-            'eez': {'color': '#54AEFF', 'linewidth': 2},
-            'eelength': 0.06,
+            "robot": {"color": "#E16F6D", "linewidth": 5},
+            "shadow": {"color": "lightgrey", "linewidth": 3},
+            "jointaxes": {"color": "#8FC1E2", "linewidth": 2},
+            "jointlabels": {},
+            "jointaxislength": 0.2,
+            "eex": {"color": "#F84752", "linewidth": 2},  # '#EE9494'
+            "eey": {"color": "#BADA55", "linewidth": 2},  # '#93E7B0'
+            "eez": {"color": "#54AEFF", "linewidth": 2},
+            "eelength": 0.06,
         }
 
         if options is not None:
@@ -83,7 +90,7 @@ def draw(self):
 
         # compute all link frames
         T = self.robot.fkine_all(self.robot.q)
-        
+
         # draw all the line segments for the noodle plot
         for i, segment in enumerate(self.segments):
             linkframes = []
@@ -95,8 +102,8 @@ def draw(self):
             points = np.array([linkframe.t for linkframe in linkframes])
 
             self.links[i].set_xdata(points[:, 0])
-            self.links[i].set_ydata(points[:,1 ])
-            self.links[0].set_3d_properties(points[:,2 ])
+            self.links[i].set_ydata(points[:, 1])
+            self.links[0].set_3d_properties(points[:, 2])
 
             # Update the shadow of the robot links
             if self.shadow:
@@ -115,7 +122,7 @@ def draw(self):
 
         if self.eeframe:
             # Axes arrow transforms
-            len = self.options['eelength']
+            len = self.options["eelength"]
             Tjx = SE3([len, 0, 0])
             Tjy = SE3([0, len, 0])
             Tjz = SE3([0, 0, len])
@@ -129,9 +136,9 @@ def draw(self):
                 Tey = Te * Tjy
                 Tez = Te * Tjz
 
-                xaxis = self._plot_quiver(Te.t, Tex.t, self.options['eex'])
-                yaxis = self._plot_quiver(Te.t, Tey.t, self.options['eey'])
-                zaxis = self._plot_quiver(Te.t, Tez.t, self.options['eez'])
+                xaxis = self._plot_quiver(Te.t, Tex.t, self.options["eex"])
+                yaxis = self._plot_quiver(Te.t, Tey.t, self.options["eey"])
+                zaxis = self._plot_quiver(Te.t, Tez.t, self.options["eez"])
 
                 self.eeframes.extend([xaxis, yaxis, zaxis])
 
@@ -159,18 +166,17 @@ def draw(self):
                 elif link.isjoint:
                     Tj = T[link.number]
                     R = Tj.R
-                    if link.v.axis[1] == 'z':
+                    if link.v.axis[1] == "z":
                         direction = R[:, 2]  # z direction
-                    elif link.v.axis[1] == 'y':
+                    elif link.v.axis[1] == "y":
                         direction = R[:, 1]  # y direction
-                    elif link.v.axis[1] == 'x':
+                    elif link.v.axis[1] == "x":
                         direction = R[:, 0]  #  direction
 
                 if direction is not None:
                     arrow = self._plot_quiver2(Tj.t, direction, link.jindex)
                     self.joints.extend(arrow)
 
-
     def init(self):
 
         self.drawn = True
@@ -189,54 +195,50 @@ def init(self):
 
         # Plot robot name
         if self.showname:
-            self.name = self.ax.text(
-                Tb.t[0], Tb.t[1], 0.05, self.robot.name)
+            self.name = self.ax.text(Tb.t[0], Tb.t[1], 0.05, self.robot.name)
 
         # Initialize the robot links
         self.links = []
         self.sh_links = []
         for i in range(len(self.segments)):
 
-
             # Plot the shadow of the robot links, draw first so robot is always
             # in front
             if self.shadow:
-                shadow, = self.ax.plot(
-                    [0], [0],
-                    zorder=1, 
-                    **self.options['shadow'])
+                (shadow,) = self.ax.plot([0], [0], zorder=1, **self.options["shadow"])
                 self.sh_links.append(shadow)
 
-            line,  = self.ax.plot(
-                [0], [0], [0], **self.options['robot'])
+            (line,) = self.ax.plot([0], [0], [0], **self.options["robot"])
             self.links.append(line)
 
         self.eeframes = []
         self.joints = []
 
     def _plot_quiver(self, p0, p1, options):
         qv = self.ax.quiver(
-            p0[0], p0[1], p0[2],
-            p1[0] - p0[0],
-            p1[1] - p0[1],
-            p1[2] - p0[2],
-            **options
+            p0[0], p0[1], p0[2], p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2], **options
         )
         return qv
 
     def _plot_quiver2(self, p0, dir, j):
-        vec = dir * self.options['jointaxislength']
+        vec = dir * self.options["jointaxislength"]
         start = p0 - vec / 2
         qv = self.ax.quiver(
-            start[0], start[1], start[2],
-            vec[0], vec[1], vec[2],
+            start[0],
+            start[1],
+            start[2],
+            vec[0],
+            vec[1],
+            vec[2],
             zorder=5,
-            **self.options['jointaxes']
+            **self.options["jointaxes"],
         )
 
         if self.jointlabels:
             pl = p0 - vec * 0.6
-            label = self.ax.text(pl[0], pl[1], pl[2], f'$q_{j}$', **self.options['jointlabels'] )
+            label = self.ax.text(
+                pl[0], pl[1], pl[2], f"$q_{j}$", **self.options["jointlabels"]
+            )
             return [qv, label]
         else:
             return [qv]

roboticstoolbox/examples/tripleangle.py

@@ -26,19 +26,16 @@
 g1 = Mesh(
     filename=str(path / "gimbal-ring1.stl"), color=[34, 143, 201], scale=(1.0 / 3,) * 3
 )
-g1.v = [0, 0, 0, 0, 0.5, 0]
 
 g2 = Mesh(
     filename=str(path / "gimbal-ring2.stl"), color=[31, 184, 72], scale=(1.1 / 3,) * 3
 )
-g2.v = [0, 0, 0, 0.5, 0, 0]
 
 g3 = Mesh(
     filename=str(path / "gimbal-ring3.stl"),
     color=[240, 103, 103],
     scale=(1.1 ** 2 / 3,) * 3,
 )
-g3.v = [0, 0, 0, 0, 0, 0.5]
 
 plane = Mesh(
     filename=str(path / "spitfire_assy-gear_up.stl"),
@@ -231,4 +228,4 @@ def chekked(e, el):
 update_gimbals(0, 3)
 
 while True:
-    env.step(0.05)
+    env.step(0)

roboticstoolbox/models/URDF/YuMi.py

@@ -32,23 +32,17 @@ class YuMi(ERobot):
 
     def __init__(self):
 
-        links, name = self.URDF_read(
-            "yumi_description/urdf/yumi.urdf")
+        links, name = self.URDF_read("yumi_description/urdf/yumi.urdf")
 
         super().__init__(
-            links,
-            name=name,
-            manufacturer='ABB',
-            gripper_links=[links[20]]
+            links, name=name, manufacturer="ABB", gripper_links=[links[20]]
         )
 
-        # self.addconfiguration(
-        #     "qz", np.zeros((14,)))
-        # self.addconfiguration(
-        #     "qr", np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi/4]))
+        self.addconfiguration("qz", np.zeros((14,)))
+        self.addconfiguration("qr", np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4]))
 
 
-if __name__ == '__main__':   # pragma nocover
+if __name__ == "__main__":  # pragma nocover
 
     robot = YuMi()
     print(robot)

roboticstoolbox/models/list.py

@@ -1,6 +1,8 @@
+from typing import Type
 from roboticstoolbox.robot.Robot import Robot
 from roboticstoolbox.robot.ERobot import ERobot2
 from ansitable import ANSITable, Column
+
 # import importlib
 
 
@@ -32,6 +34,7 @@ def list(keywords=None, dof=None, mtype=None):
     """
 
     import roboticstoolbox.models as m
+
     # module = importlib.import_module(
     #   '.' + os.path.splitext(file)[0], package='bdsim.blocks')
 
@@ -47,33 +50,33 @@ def make_table(border):
             Column("dynamics", colalign="<"),
             Column("geometry", colalign="<"),
             Column("keywords", headalign="^", colalign="<"),
-            border=border
+            border=border,
         )
 
         if mtype is not None:
             categories = [mtype]
         else:
-            categories = ['DH', 'URDF', 'ETS']
+            categories = ["DH", "URDF", "ETS"]
         for category in categories:
             group = m.__dict__[category]
             for cls in group.__dict__.values():
                 if isinstance(cls, type) and issubclass(cls, Robot):
                     # we found a BaseRobot subclass, instantiate it
                     try:
                         robot = cls()
-                    except:
+                    except TypeError:
                         print(f"failed to load {cls}")
                     try:
                         structure = robot.structure
-                    except Exception:   # pragma nocover
+                    except Exception:  # pragma nocover
                         structure = ""
 
                     # apply filters
                     if keywords is not None:
                         if len(set(keywords) & set(robot.keywords)) == 0:
                             continue
                     if dof is not None and robot.n != dof:
-                        continue     # pragma nocover
+                        continue  # pragma nocover
 
                     dims = 0
 
@@ -90,16 +93,18 @@ def make_table(border):
                         robot.n,
                         f"{dims}d",
                         structure,
-                        'Y' if robot._hasdynamics else '',
-                        'Y' if robot._hasgeometry else '',
-                        ', '.join(robot.keywords)
+                        "Y" if robot._hasdynamics else "",
+                        "Y" if robot._hasgeometry else "",
+                        ", ".join(robot.keywords),
                     )
 
         table.print()
 
+    # make_table(border='')
+
 
-if __name__ == "__main__":   # pragma nocover
+if __name__ == "__main__":  # pragma nocover
     list()
-    list(keywords=('dynamics',))
+    list(keywords=("dynamics",))
     list(dof=6)
-    list(keywords=('dynamics',), dof=6)
+    list(keywords=("dynamics",), dof=6)