Formatting Refactor (#12)

- Updated CONTRIBUTING.md with setup and linting instructions
- Standardized formatting and import order across all modules
- Refactored robot classes (Jaka, ElephantRobotics, Dobot, Fanuc) for readability and consistency
- Improved error handling and validation logic
- Fixed trailing commas and cleaned up multi-line strings

Author: MGross21

CONTRIBUTING.md

@@ -121,3 +121,29 @@ Always test new motion commands on virtual or low-power modes first.
 
 ✅ **Docs:**  
 Update this guide or relevant docstrings if you change command interfaces. Additionally, when adding a new manufacturer integration, include links to relevant source documentation in in-line comments and/or the README inside the added manufacturer folder. This helps future contributors understand implementation details and reference official resources easily.
+
+✅ **Linting and Code Quality:**
+
+Please ensure your code adheres to the project's formatting and quality standards before submitting a pull request.
+
+**Setup:**
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install poetry
+poetry install --with dev
+```
+
+**Formatting Code:**
+
+To ensure consistency and code quality, run the following commands before submitting your changes:
+
+```bash
+poetry run black . && \
+poetry run isort . && \
+poetry run ruff format . && \
+poetry run mypy armctl
+```
+
+> All code must be properly formatted and pass type checks. Please resolve any issues reported by these tools prior to opening a pull request.

armctl/__init__.py

@@ -14,40 +14,48 @@
 
 # from .dobot import Dobot
 from .elephant_robotics import ElephantRobotics, Pro600
-from .universal_robotics import (UniversalRobotics, 
-                                 UR3, UR5, UR5e, UR10, UR16,
-                                 OnRobot)
+from .jaka import Jaka
+from .universal_robotics import (
+    UR3,
+    UR5,
+    UR10,
+    UR16,
+    OnRobot,
+    UniversalRobotics,
+    UR5e,
+)
+
 # from .fanuc import Fanuc
 from .vention import Vention
-from .jaka import Jaka
 
 __all__ = [
     "ElephantRobotics",
     "Pro600",
-
     "UniversalRobotics",
     "UR5",
     "UR5e",
     "OnRobot",
-
     "Vention",
     "Jaka",
-
     "Logger",
 ]
 
+
 class Logger:
     """Global logger utility for armctl."""
+
     @staticmethod
     def disable():
         """Disables logging."""
         import logging
+
         # Disable all logging at and below the CRITICAL level
         logging.disable(logging.CRITICAL)
-    
+
     @staticmethod
     def enable():
         """Enables logging."""
         import logging
+
         # Re-enable logging to its previous state
-        logging.disable(logging.NOTSET)
+        logging.disable(logging.NOTSET)

armctl/angle_utils.py

@@ -1,5 +1,6 @@
 import math
 
+
 class AngleUtils:
     @staticmethod
     def to_degrees_joint(joint_positions):
@@ -15,4 +16,4 @@ def to_degrees_cartesian(pose):
 
     @staticmethod
     def to_radians_cartesian(pose):
-        return pose[:3] + [math.radians(a) for a in pose[3:]]
+        return pose[:3] + [math.radians(a) for a in pose[3:]]

armctl/dobot/__init__.py

@@ -1 +1 @@
-from .dobot import Dobot
+from .dobot import Dobot

armctl/dobot/dobot.py

@@ -1,16 +1,19 @@
 from armctl.templates import SerialController as SCT
 
+
 class Dobot(SCT):
     def __init__(self, ip: str, port: int):
         super().__init__(ip, port)
         self.JOINT_RANGES = [
             (-135.00, 135.00),
             (-5.00, 80.00),
             (-10.00, 85.00),
-            (-145.00, 145.00)
+            (-145.00, 145.00),
         ]
         self.DOF = len(self.JOINT_RANGES)
-        raise NotImplementedError(f"{self.__class__.__name__.upper()} is not yet supported.")
+        raise NotImplementedError(
+            f"{self.__class__.__name__.upper()} is not yet supported."
+        )
 
     def sleep(self, seconds):
         self.send_command(f"sleep({seconds})")
@@ -23,9 +26,11 @@ def move_joints(self, pos, *args, **kwargs) -> str:
 
         for j, (lower, upper) in enumerate(self.JOINT_RANGES):
             if not (lower <= pos[j] <= upper):
-                raise ValueError(f"Joint {j+1} angle out of range: {lower} ~ {upper}")
-            
-        command = "MOVJ({})".format(','.join(map(str, pos)))
+                raise ValueError(
+                    f"Joint {j + 1} angle out of range: {lower} ~ {upper}"
+                )
+
+        command = "MOVJ({})".format(",".join(map(str, pos)))
         return self.send_command(command)
 
     def move_cartesian(self, pose) -> str:
@@ -35,30 +40,36 @@ def move_cartesian(self, pose) -> str:
             pose.append(0)
 
         # Now check again if the robot pose has 4 elements
-        if len(pose) != 4:    
-            raise ValueError("Robot pose must have 3 ([x, y, z]) or 4 elements: [x, y, z, rz]")
+        if len(pose) != 4:
+            raise ValueError(
+                "Robot pose must have 3 ([x, y, z]) or 4 elements: [x, y, z, rz]"
+            )
 
-        command = "MOVEL({})".format(','.join(map(str, pose)))
+        command = "MOVEL({})".format(",".join(map(str, pose)))
         return self.send_command(command)
 
-    def get_joint_positions(self): pass
+    def get_joint_positions(self):
+        pass
 
-    def get_cartesian_position(self): pass
+    def get_cartesian_position(self):
+        pass
 
-    def stop_motion(self): pass
+    def stop_motion(self):
+        pass
 
-    def get_robot_state(self): pass
+    def get_robot_state(self):
+        pass
 
     def move_arc(self, command):
         """The trajectory of ARC mode is an arc, which is determined by three points (the current point, any point and the end point on the arc)"""
         if len(command) != 3:
             raise ValueError("Invalid ARC command. Must have 3 points")
-        
+
         self.send_command(f"ARC({','.join(map(str, command))})")
 
     def move_jump(self, command):
         """If the movement of two points is required to lift upwards by amount of height, such as sucking up, grabbing, you can choose JUMP"""
         if len(command) != 2:
             raise ValueError("Invalid JUMP command. Must have 2 points")
-        
+
         self.send_command(f"JUMP({','.join(map(str, command))})")

armctl/elephant_robotics/__init__.py

@@ -1,2 +1,2 @@
 from .elephant_robotics import ElephantRobotics
-from .mycobot import Pro600
+from .mycobot import Pro600

armctl/elephant_robotics/elephant_robotics.py

@@ -1,6 +1,9 @@
-from armctl.templates import SocketController as SCT, Commands
 import time
 
+from armctl.templates import Commands
+from armctl.templates import SocketController as SCT
+
+
 class ElephantRobotics(SCT, Commands):
     def __init__(self, ip: str, port: int):
         super().__init__(ip, port)
@@ -10,15 +13,19 @@ def __init__(self, ip: str, port: int):
             (-150.00, 150.00),
             (-260.00, 80.00),
             (-168.00, 168.00),
-            (-174.00, 174.00)
+            (-174.00, 174.00),
         ]
         self.DOF = len(self.JOINT_RANGES)
 
     def connect(self):
         super().connect()  # Socket Connection
 
-        assert self.send_command("power_on()") == "power_on:[ok]"  # Power on the robot
-        assert self.send_command("state_on()") == "state_on:[ok]"  # Enable the system
+        assert (
+            self.send_command("power_on()") == "power_on:[ok]"
+        )  # Power on the robot
+        assert (
+            self.send_command("state_on()") == "state_on:[ok]"
+        )  # Enable the system
 
     def disconnect(self):
         self.stop_motion()  # Stop any ongoing motion
@@ -28,19 +35,22 @@ def disconnect(self):
 
     def _waitforfinish(self):
         while True:
-            if self.send_command("wait_command_done()", timeout=60) == "wait_command_done:0":
+            if (
+                self.send_command("wait_command_done()", timeout=60)
+                == "wait_command_done:0"
+            ):
                 break
             time.sleep(0.25)
 
     def sleep(self, seconds):
-        assert isinstance(seconds, (int, float)), "Seconds must be a numeric value."
+        assert isinstance(
+            seconds, (int, float)
+        ), "Seconds must be a numeric value."
         assert seconds >= 0, "Seconds must be a non-negative value."
         self.send_command(f"wait({seconds})")
         time.sleep(seconds)
 
-    def move_joints(self, 
-                    pos:list[float],
-                    speed:int=500) -> None:
+    def move_joints(self, pos: list[float], speed: int = 500) -> None:
         """
         Move the robot to the specified joint positions.
 
@@ -59,21 +69,31 @@ def move_joints(self,
 
         for i, (low, high) in enumerate(self.JOINT_RANGES):
             if not (low <= pos[i] <= high):
-                raise ValueError(f"Joint {i+1} angle out of range: {low} ~ {high}")
+                raise ValueError(
+                    f"Joint {i + 1} angle out of range: {low} ~ {high}"
+                )
 
         if not (0 <= speed <= 2000):
             raise ValueError("Speed out of range: 0 ~ 2000")
 
         command = "set_angles"
-        response = self.send_command(f"{command}({','.join(map(str, pos))},{speed})")
-        assert response == f"{command}:[ok]", f"Failed to move joints: {response}"
-
-        while any(abs(a - b) > 3 for a, b in zip(self.get_joint_positions(), pos)):
+        response = self.send_command(
+            f"{command}({','.join(map(str, pos))},{speed})"
+        )
+        assert (
+            response == f"{command}:[ok]"
+        ), f"Failed to move joints: {response}"
+
+        while any(
+            abs(a - b) > 3 for a, b in zip(self.get_joint_positions(), pos)
+        ):
             time.sleep(1)
 
-    def move_cartesian(self, 
-                       pose:tuple[float,float,float,float,float,float], 
-                       speed:int=500) -> None:
+    def move_cartesian(
+        self,
+        pose: tuple[float, float, float, float, float, float],
+        speed: int = 500,
+    ) -> None:
         """
         Move the robot to the specified Cartesian coordinates.
 
@@ -88,27 +108,45 @@ def move_cartesian(self,
         if not (0 <= speed <= 2000):
             raise ValueError("Speed out of range: 0 ~ 2000")
         if len(pose) != 6:
-            raise ValueError("Robot pose must have 6 elements: [x, y, z, rx, ry, rz]")
+            raise ValueError(
+                "Robot pose must have 6 elements: [x, y, z, rx, ry, rz]"
+            )
 
         command = f"set_coords({','.join(map(str, pose))},{speed})"
 
         assert self.send_command(command) == "set_coords:[ok]"
 
-        while not all(abs(a - b) <= 1 for a, b in zip(self.get_cartesian_position(), pose)):
+        while not all(
+            abs(a - b) <= 1 for a, b in zip(self.get_cartesian_position(), pose)
+        ):
             time.sleep(1)
 
     def get_joint_positions(self):
         response = self.send_command("get_angles()")
         if response == "[-1.0, -2.0, -3.0, -4.0, -1.0, -1.0]":
             raise ValueError("Invalid joint positions response from robot")
-        joint_positions = list(map(float, response[response.index("[")+1:response.index("]")].split(",")))  # From string list to float list
+        joint_positions = list(
+            map(
+                float,
+                response[response.index("[") + 1 : response.index("]")].split(
+                    ","
+                ),
+            )
+        )  # From string list to float list
         return [round(x, 2) for x in joint_positions]
 
     def get_cartesian_position(self):
         response = self.send_command("get_coords()")  # [x, y, z, rx, ry, rz]
         if response == "[-1.0, -2.0, -3.0, -4.0, -1.0, -1.0]":
             raise ValueError("Invalid cartesian position response from robot")
-        cartesian_position = list(map(float, response[response.index("[")+1:response.index("]")].split(",")))  # From string list to float list
+        cartesian_position = list(
+            map(
+                float,
+                response[response.index("[") + 1 : response.index("]")].split(
+                    ","
+                ),
+            )
+        )  # From string list to float list
         return [round(x, 2) for x in cartesian_position]
 
     def stop_motion(self):

armctl/elephant_robotics/mycobot.py

@@ -1,24 +1,25 @@
 from .elephant_robotics import ElephantRobotics
 
+
 class Pro600(ElephantRobotics):
-        def __init__(self, ip:str = "192.168.1.159", port:int = 5001):
-            """Elephant Robotics myCobot Pro600"""
-            super().__init__(ip, port)
-            self.HOME_POSITION = [0,-90, 90,-90,-90,0]
-            self.JOINT_RANGES = [
-                (-180.00, 180.00),
-                (-270.00, 90.00),
-                (-150.00, 150.00),
-                (-260.00, 80.00),
-                (-168.00, 168.00),
-                (-174.00, 174.00)
-            ]
-            self.DOF = len(self.JOINT_RANGES)
+    def __init__(self, ip: str = "192.168.1.159", port: int = 5001):
+        """Elephant Robotics myCobot Pro600"""
+        super().__init__(ip, port)
+        self.HOME_POSITION = [0, -90, 90, -90, -90, 0]
+        self.JOINT_RANGES = [
+            (-180.00, 180.00),
+            (-270.00, 90.00),
+            (-150.00, 150.00),
+            (-260.00, 80.00),
+            (-168.00, 168.00),
+            (-174.00, 174.00),
+        ]
+        self.DOF = len(self.JOINT_RANGES)
 
-            self.__class__.__name__ = f"{self.__class__.__bases__[0].__name__} {__name__.split('.')[-1]} {self.__class__.__name__}"
+        self.__class__.__name__ = f"{self.__class__.__bases__[0].__name__} {__name__.split('.')[-1]} {self.__class__.__name__}"
 
-        def home(self):
-            """
-            Move the robot to the home position: `[0, -90, 90, -90, -90, 0]`.
-            """
-            self.move_joints(self.HOME_POSITION, speed=750)
+    def home(self):
+        """
+        Move the robot to the home position: `[0, -90, 90, -90, -90, 0]`.
+        """
+        self.move_joints(self.HOME_POSITION, speed=750)

armctl/fanuc/__init__.py

@@ -1 +1 @@
-from .fanuc import Fanuc
+from .fanuc import Fanuc