Merge branch 'wip_process' of https://github.com/compas-dev/compas_fab into wip_process

Author: yck011522

src/compas_fab/backends/kinematics/backend_features/analytical_inverse_kinematics.py

@@ -1,22 +1,20 @@
-from compas import IPY
+from typing import TYPE_CHECKING
+from typing import Optional
+from typing import Generator
+
+from compas.geometry import Frame
+from compas_robots import Configuration
 
 from compas_fab.backends.exceptions import BackendTargetNotSupportedError
 from compas_fab.backends.exceptions import InverseKinematicsError
 from compas_fab.backends.interfaces import InverseKinematics
 
-if not IPY:
-    from typing import TYPE_CHECKING
+from compas_fab.robots import RobotCell
+from compas_fab.robots import RobotCellState
+from compas_fab.robots import Target
 
-    if TYPE_CHECKING:  # pragma: no cover
-        from compas.geometry import Frame  # noqa: F401
-        from compas_fab.backends import AnalyticalKinematicsPlanner  # noqa: F401
-        from compas_robots import Configuration  # noqa: F401
-        from compas_fab.robots import RobotCellState  # noqa: F401
-        from compas_fab.robots import RobotCell  # noqa: F401
-        from compas_fab.robots import Target  # noqa: F401
-        from typing import Dict  # noqa: F401
-        from typing import Optional  # noqa: F401
-        from typing import Generator  # noqa: F401
+if TYPE_CHECKING:
+    from compas_fab.backends import AnalyticalKinematicsPlanner
 
 from compas_fab.robots import FrameTarget
 
@@ -40,8 +38,9 @@ class AnalyticalInverseKinematics(InverseKinematics):
     that supports ``"check_collision"``, so for now only the `PyBulletClient`.
     """
 
-    def iter_inverse_kinematics(self, target, start_state=None, group=None, options=None):
-        # type: (Target, Optional[RobotCellState], Optional[str], Optional[Dict]) -> Generator[Configuration | None]
+    def iter_inverse_kinematics(
+        self, target: Target, start_state: RobotCellState, group: Optional[str], options: Optional[dict] = None
+    ) -> Generator[Configuration | None, None, None]:
         """Calculate the robot's inverse kinematic for a given target.
 
         An iterator is returned that yields configurations.
@@ -55,8 +54,9 @@ def iter_inverse_kinematics(self, target, start_state=None, group=None, options=
         else:
             raise BackendTargetNotSupportedError()
 
-    def _iter_inverse_kinematics_frame_target(self, target, start_state=None, group=None, options=None):
-        # type: (FrameTarget, Optional[RobotCellState], Optional[str], Optional[Dict]) -> Generator[Configuration | None]
+    def _iter_inverse_kinematics_frame_target(
+        self, target: FrameTarget, start_state: RobotCellState, group: Optional[str], options: Optional[dict] = None
+    ) -> Generator[Configuration | None, None, None]:
         """Calculate the robot's inverse kinematic for a given frame target.
 
         The IK for 6-axis industrial robots returns by default 8 possible solutions.
@@ -74,8 +74,8 @@ def _iter_inverse_kinematics_frame_target(self, target, start_state=None, group=
 
         This function handles the case where the target is a :class:`compas_fab.robots.FrameTarget`.
         """
-        planner = self  # type: AnalyticalKinematicsPlanner
-        robot_cell = planner.client.robot_cell  # type: RobotCell
+        planner: AnalyticalKinematicsPlanner = self
+        robot_cell: RobotCell = planner.client.robot_cell
 
         # Scale Target and get target frame
         target = target.normalized_to_meters()
@@ -87,8 +87,9 @@ def _iter_inverse_kinematics_frame_target(self, target, start_state=None, group=
 
         return self.inverse_kinematics_ordered(target_frame, group=group, options=options)
 
-    def inverse_kinematics_ordered(self, frame_WCF, group=None, options=None):
-        # type: (Frame, Optional[str], Optional[Dict]) -> Generator[Configuration | None]
+    def inverse_kinematics_ordered(
+        self, frame_WCF: Frame, group: Optional[str] = None, options: Optional[dict] = None
+    ) -> Generator[Configuration | None, None, None]:
         """Calculate the robot's inverse kinematic (IK) for a given frame.
 
         The IK for 6-axis industrial robots returns by default 8 possible solutions.
@@ -138,8 +139,8 @@ def inverse_kinematics_ordered(self, frame_WCF, group=None, options=None):
         """
 
         options = options or {}
-        planner = self  # type: AnalyticalKinematicsPlanner
-        robot_cell = planner.client.robot_cell  # type: RobotCell
+        planner: AnalyticalKinematicsPlanner = self
+        robot_cell: RobotCell = planner.client.robot_cell
         solver = planner.kinematics_solver
 
         keep_order = options.get("keep_order", False)

src/compas_fab/backends/kinematics/backend_features/analytical_set_robot_cell.py

@@ -1,14 +1,15 @@
-from typing import Optional
-
 from copy import deepcopy
+from typing import Optional
 
 from compas_fab.backends.interfaces import SetRobotCell
 from compas_fab.robots import RobotCell
 from compas_fab.robots import RobotCellState
 
 
 class AnalyticalSetRobotCell(SetRobotCell):
-    def set_robot_cell(self, robot_cell : RobotCell, robot_cell_state : RobotCellState = None, options : Optional[dict] = None):
+    def set_robot_cell(
+        self, robot_cell: RobotCell, robot_cell_state: RobotCellState = None, options: Optional[dict] = None
+    ):
         """Pass the models in the robot cell to the Analytical Planner.
 
         The planner will use the tool information for frame transformation.

src/compas_fab/backends/kinematics/solvers/analytical_kinematics.py

@@ -1,4 +1,5 @@
 from typing import Optional
+
 from compas.geometry import Frame
 
 
@@ -32,13 +33,18 @@ class AnalyticalKinematics(object):
         Defaults to no offset.
     """
 
-    def __init__(self, base_frame : Optional[Frame] = None, flange_frame : Optional[Frame] = None, joint_offsets : Optional[list[float]] = None):
+    def __init__(
+        self,
+        base_frame: Optional[Frame] = None,
+        flange_frame: Optional[Frame] = None,
+        joint_offsets: Optional[list[float]] = None,
+    ):
         super(AnalyticalKinematics, self).__init__()
         self.base_frame = base_frame
         self.flange_frame = flange_frame
         self.joint_offsets = joint_offsets
 
-    def forward(self, joint_values : list[float]) -> Frame:
+    def forward(self, joint_values: list[float]) -> Frame:
         """Calculate the forward kinematics for the given joint configuration.
 
         Parameters
@@ -54,7 +60,7 @@ def forward(self, joint_values : list[float]) -> Frame:
         """
         pass
 
-    def inverse(self, frame_rcf : Frame) -> list[list[float]]:
+    def inverse(self, frame_rcf: Frame) -> list[list[float]]:
         """Calculate the inverse kinematics for the given end-effector frame.
 
         Parameters

src/compas_fab/backends/kinematics/solvers/offset_wrist.py

@@ -7,20 +7,12 @@
 from math import sin
 from math import sqrt
 
-from compas import IPY
 from compas.geometry import Frame
 
 from compas_fab.utilities import sign
 
-if not IPY:
-    from typing import TYPE_CHECKING
 
-    if TYPE_CHECKING:  # pragma: no cover
-        from typing import List  # noqa: F401
-
-
-def forward_kinematics_offset_wrist(joint_values, params):
-    # type: (List[float], List[float]) -> Frame
+def forward_kinematics_offset_wrist(joint_values: list[float], params: list[float]) -> Frame:
     """Forward kinematics function for offset wrist 6-axis robots.
 
     Parameters
@@ -73,8 +65,7 @@ def forward_kinematics_offset_wrist(joint_values, params):
     return frame
 
 
-def inverse_kinematics_offset_wrist(frame, params, q6_des=0.0):
-    # type: (Frame, List[float], float) -> List[List[float]]
+def inverse_kinematics_offset_wrist(frame: Frame, params: list[float], q6_des: float = 0.0) -> list[list[float]]:
     """Inverse kinematics function for offset wrist 6-axis robots.
 
     Parameters

src/compas_fab/backends/kinematics/solvers/offset_wrist_kinematics.py

@@ -1,17 +1,9 @@
-from compas import IPY
+from compas.geometry import Frame
 
 from .analytical_kinematics import AnalyticalKinematics
 from .offset_wrist import forward_kinematics_offset_wrist
 from .offset_wrist import inverse_kinematics_offset_wrist
 
-if not IPY:
-    from typing import TYPE_CHECKING
-
-    if TYPE_CHECKING:  # pragma: no cover
-        from typing import List  # noqa: F401
-
-        from compas.geometry import Frame  # noqa: F401
-
 # The following parameters for UR robots are taken from the following website:
 # https://www.universal-robots.com/articles/ur/application-installation/dh-parameters-for-calculations-of-kinematics-and-dynamics/
 
@@ -78,12 +70,10 @@ def __init__(self, params):
         super(OffsetWristKinematics, self).__init__()
         self.params = params
 
-    def forward(self, joint_values):
-        # type: (List[float]) -> Frame
+    def forward(self, joint_values: list[float]) -> Frame:
         return forward_kinematics_offset_wrist(joint_values, self.params)
 
-    def inverse(self, frame_rcf):
-        # type: (Frame) -> List[List[float]]
+    def inverse(self, frame_rcf: Frame) -> list[list[float]]:
         return inverse_kinematics_offset_wrist(frame_rcf, self.params)
 
 

src/compas_fab/backends/pybullet/backend_features/helpers.py

@@ -1,14 +1,21 @@
 from math import pi
 
 from compas_robots.model import Joint
+
 from compas_fab.backends import MPMaxJumpError
 
 __all__ = [
     "check_max_jump",
 ]
 
 
-def check_max_jump(joint_names : list[str], joint_types : list[int], start_joint_values : list[float], end_joint_values : list[float], options : dict):
+def check_max_jump(
+    joint_names: list[str],
+    joint_types: list[int],
+    start_joint_values: list[float],
+    end_joint_values: list[float],
+    options: dict,
+):
     """Check if the joint positions between two configurations exceed the maximum allowed distance.
 
     Parameters

src/compas_fab/backends/ros/backend_features/move_it_inverse_kinematics.py

@@ -1,10 +1,11 @@
-from typing import Optional
 from typing import TYPE_CHECKING
+from typing import Optional
 
-from compas_robots import Configuration
+from compas.geometry import Frame
 from compas.tolerance import TOL
 from compas.utilities import await_callback
-from compas.geometry import Frame
+from compas_robots import Configuration
+
 from compas_fab.backends.exceptions import InverseKinematicsError
 from compas_fab.backends.interfaces import InverseKinematics
 from compas_fab.backends.ros.backend_features.helpers import convert_constraints_to_rosmsg
@@ -48,7 +49,13 @@ def __init__(self):
         "/compute_ik", "GetPositionIK", GetPositionIKRequest, GetPositionIKResponse, validate_response
     )
 
-    def inverse_kinematics(self, target : FrameTarget | PointAxisTarget, robot_cell_state : "RobotCellState", group : Optional[str] = None, options : Optional[dict] = None):
+    def inverse_kinematics(
+        self,
+        target: FrameTarget | PointAxisTarget,
+        robot_cell_state: "RobotCellState",
+        group: Optional[str] = None,
+        options: Optional[dict] = None,
+    ):
         """Calculate the robot's inverse kinematic for a given target.
 
         The actual implementation can be found in the :meth:`iter_inverse_kinematics` method.
@@ -96,8 +103,8 @@ def inverse_kinematics(self, target : FrameTarget | PointAxisTarget, robot_cell_
 
         """
         # Set default group name
-        planner : MoveItPlanner = self
-        client : RosClient = planner.client
+        planner: MoveItPlanner = self
+        client: RosClient = planner.client
         group = group or client.robot_cell.main_group_name
 
         # The caching mechanism is implemented in the iter_inverse_kinematics method
@@ -111,7 +118,13 @@ def inverse_kinematics(self, target : FrameTarget | PointAxisTarget, robot_cell_
 
         return configuration
 
-    def iter_inverse_kinematics(self, target : FrameTarget | PointAxisTarget, robot_cell_state : "RobotCellState" = None, group : Optional[str] = None, options : Optional[dict] = None):
+    def iter_inverse_kinematics(
+        self,
+        target: FrameTarget | PointAxisTarget,
+        robot_cell_state: "RobotCellState" = None,
+        group: Optional[str] = None,
+        options: Optional[dict] = None,
+    ):
         """Calculate the robot's inverse kinematic for a given target.
 
         The MoveIt inverse kinematics solver make use of the IK solver pre-configured in
@@ -184,9 +197,9 @@ def iter_inverse_kinematics(self, target : FrameTarget | PointAxisTarget, robot_
             One of the possible IK configurations that reaches the target.
 
         """
-        planner : MoveItPlanner = self
-        client : RosClient = planner.client
-        robot_cell : RobotCell = client.robot_cell
+        planner: MoveItPlanner = self
+        client: RosClient = planner.client
+        robot_cell: RobotCell = client.robot_cell
         group = group or robot_cell.main_group_name
 
         # Calling the super class method, which contains input sanity checks and scale normalization
@@ -210,7 +223,9 @@ def iter_inverse_kinematics(self, target : FrameTarget | PointAxisTarget, robot_
             # Insert any checks needed here. No checks at the moment.
             yield configuration
 
-    def _iter_inverse_kinematics_frame_target(self, target : FrameTarget, robot_cell_state : "RobotCellState", group : str, options : Optional[dict] = None):
+    def _iter_inverse_kinematics_frame_target(
+        self, target: FrameTarget, robot_cell_state: "RobotCellState", group: str, options: Optional[dict] = None
+    ):
         """Calculate the robot's inverse kinematic for a given frame target.
 
         This function is not exposed to the user and therefore docstrings
@@ -219,9 +234,9 @@ def _iter_inverse_kinematics_frame_target(self, target : FrameTarget, robot_cell
         """
 
         # Housekeeping for intellisense
-        planner : MoveItPlanner = self
-        client : RosClient = planner.client
-        robot_cell : RobotCell = client.robot_cell
+        planner: MoveItPlanner = self
+        client: RosClient = planner.client
+        robot_cell: RobotCell = client.robot_cell
 
         # NOTE: group is not optional in this inner function.
         if group not in robot_cell.robot_semantics.groups:
@@ -306,7 +321,13 @@ def _iter_inverse_kinematics_frame_target(self, target : FrameTarget, robot_cell
             )
 
     def _inverse_kinematics_async(
-        self, callback, errback, frame_WCF : Frame, start_configuration : Configuration = None, group : str = None, options : Optional[dict] = None
+        self,
+        callback,
+        errback,
+        frame_WCF: Frame,
+        start_configuration: Configuration = None,
+        group: str = None,
+        options: Optional[dict] = None,
     ):
         """Asynchronous handler of MoveIt IK service."""
         base_link = options["base_link"]