Update to new version : 4.4.0.0

Author: github-actions[bot]

underautomation/fanuc/__init__.py

@@ -0,0 +1,7 @@
+import clr
+import os
+
+_dll_path = os.path.realpath(os.path.join(os.path.dirname(__file__), 'lib', 'UnderAutomation.Fanuc.dll'))
+clr.AddReference(_dll_path)
+
+__author__ = 'UnderAutomation'

underautomation/fanuc/common/arm_front_back.py

@@ -1,15 +1,7 @@
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
-from UnderAutomation.Fanuc.Common import ArmFrontBack as arm_front_back
+from enum import IntEnum
 
-class ArmFrontBack(int):
-	Unknown = int(arm_front_back.Unknown)
-	Front = int(arm_front_back.Front)
-	Back = int(arm_front_back.Back)
-
-	def __repr__(self):
-		for name, value in vars(ArmFrontBack).items():
-			if not name.startswith('_') and isinstance(value, int) and value == self:
-				return name
-		return str(int(self))
+class ArmFrontBack(IntEnum):
+	'''Arm configuration'''
+	Unknown = 0 # Unknown
+	Front = 1 # Front : T
+	Back = 2 # Back : B

underautomation/fanuc/common/arm_left_right.py

@@ -1,15 +1,7 @@
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
-from UnderAutomation.Fanuc.Common import ArmLeftRight as arm_left_right
+from enum import IntEnum
 
-class ArmLeftRight(int):
-	Unknown = int(arm_left_right.Unknown)
-	Left = int(arm_left_right.Left)
-	Right = int(arm_left_right.Right)
-
-	def __repr__(self):
-		for name, value in vars(ArmLeftRight).items():
-			if not name.startswith('_') and isinstance(value, int) and value == self:
-				return name
-		return str(int(self))
+class ArmLeftRight(IntEnum):
+	'''Arm left right'''
+	Unknown = 0 # Unknown
+	Left = 1 # Left : L
+	Right = 2 # Right : R

underautomation/fanuc/common/arm_up_down.py

@@ -1,15 +1,7 @@
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
-from UnderAutomation.Fanuc.Common import ArmUpDown as arm_up_down
+from enum import IntEnum
 
-class ArmUpDown(int):
-	Unknown = int(arm_up_down.Unknown)
-	Up = int(arm_up_down.Up)
-	Down = int(arm_up_down.Down)
-
-	def __repr__(self):
-		for name, value in vars(ArmUpDown).items():
-			if not name.startswith('_') and isinstance(value, int) and value == self:
-				return name
-		return str(int(self))
+class ArmUpDown(IntEnum):
+	'''Arm configuration'''
+	Unknown = 0 # Unknown
+	Up = 1 # Up : U
+	Down = 2 # Down : D

underautomation/fanuc/common/cartesian_position.py

@@ -1,51 +1,88 @@
 import typing
 from underautomation.fanuc.common.configuration import Configuration
 from underautomation.fanuc.common.xyz_position import XYZPosition
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
 from UnderAutomation.Fanuc.Common import CartesianPosition as cartesian_position
 
 class CartesianPosition(XYZPosition):
+	'''Fanuc cartesian position and rotations'''
 	def __init__(self, x: float, y: float, z: float, w: float, p: float, r: float, configuration: Configuration, _internal = 0):
+		'''Constructor with position, rotations and configuration'''
 		if(_internal == 0):
 			self._instance = cartesian_position(x, y, z, w, p, r, configuration)
 		else:
 			self._instance = _internal
-	def __repr__(self):
-		return self._instance.ToString() if self._instance is not None else ""
+
+	def equals(self, obj: typing.Any) -> bool:
+		return self._instance.Equals(obj)
+
+	def get_hash_code(self) -> int:
+		return self._instance.GetHashCode()
+
 	def to_homogeneous_matrix(self) -> typing.List[float]:
+		'''Convert position to a homogeneous rotation and translation 4x4 matrix'''
 		return self._instance.ToHomogeneousMatrix()
+
 	@staticmethod
 	def from_homogeneous_matrix(R: typing.List[float]) -> 'CartesianPosition':
 		return CartesianPosition(None, None, None, None, None, None, None, cartesian_position.FromHomogeneousMatrix(R))
+
 	@staticmethod
 	def normalize_angle(angle: float) -> float:
+		'''Normalize an angle to the range ]-180, 180]'''
 		return cartesian_position.NormalizeAngle(angle)
+
 	@staticmethod
 	def normalize_angles(pose: 'CartesianPosition') -> None:
+		'''Normalize the W, P, R angles to the range ]-180, 180]'''
 		cartesian_position.NormalizeAngles(pose._instance if pose else None)
+
 	@staticmethod
 	def is_near(a: 'CartesianPosition', b: 'CartesianPosition', mmTolerance: float, degreesTolerance: float) -> bool:
+		'''Check if two Cartesian positions are near each other within specified tolerances'''
 		return cartesian_position.IsNear(a._instance if a else None, b._instance if b else None, mmTolerance, degreesTolerance)
+
 	@property
 	def w(self) -> float:
+		'''W rotation in degrees (Rx)'''
 		return self._instance.W
+
 	@w.setter
 	def w(self, value: float):
 		self._instance.W = value
+
 	@property
 	def p(self) -> float:
+		'''P rotation in degrees (Ry)'''
 		return self._instance.P
+
 	@p.setter
 	def p(self, value: float):
 		self._instance.P = value
+
 	@property
 	def r(self) -> float:
+		'''R rotation in degrees (Rz)'''
 		return self._instance.R
+
 	@r.setter
 	def r(self, value: float):
 		self._instance.R = value
+
 	@property
 	def configuration(self) -> Configuration:
+		'''Position configuration'''
 		return Configuration(None, None, None, None, None, None, None, self._instance.Configuration)
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, CartesianPosition):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/fanuc/common/cartesian_position_with_tool.py

@@ -1,21 +1,41 @@
 import typing
 from underautomation.fanuc.common.cartesian_position import CartesianPosition
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
 from UnderAutomation.Fanuc.Common import CartesianPositionWithTool as cartesian_position_with_tool
 
 class CartesianPositionWithTool(CartesianPosition):
+	'''A cartesian position with a tool ID'''
 	def __init__(self, x: float, y: float, z: float, w: float, p: float, r: float, tool: int, _internal = 0):
+		'''Constructor with position, rotations and tool ID'''
 		if(_internal == 0):
 			self._instance = cartesian_position_with_tool(x, y, z, w, p, r, tool)
 		else:
 			self._instance = _internal
-	def __repr__(self):
-		return self._instance.ToString() if self._instance is not None else ""
+
+	def equals(self, obj: typing.Any) -> bool:
+		return self._instance.Equals(obj)
+
+	def get_hash_code(self) -> int:
+		return self._instance.GetHashCode()
+
 	@property
 	def tool(self) -> int:
+		'''Tool ID'''
 		return self._instance.Tool
+
 	@tool.setter
 	def tool(self, value: int):
 		self._instance.Tool = value
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, CartesianPositionWithTool):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/fanuc/common/cartesian_position_with_user_frame.py

@@ -1,18 +1,37 @@
 import typing
 from underautomation.fanuc.common.cartesian_position_with_tool import CartesianPositionWithTool
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
 from UnderAutomation.Fanuc.Common import CartesianPositionWithUserFrame as cartesian_position_with_user_frame
 
 class CartesianPositionWithUserFrame(CartesianPositionWithTool):
+	'''A cartesian tool position with a user frame ID'''
 	def __init__(self, x: float, y: float, z: float, w: float, p: float, r: float, tool: int, frame: int, _internal = 0):
+		'''Constructor with position, rotations, tool and frame IDs'''
 		if(_internal == 0):
 			self._instance = cartesian_position_with_user_frame(x, y, z, w, p, r, tool, frame)
 		else:
 			self._instance = _internal
-	def __repr__(self):
-		return self._instance.ToString() if self._instance is not None else ""
+
+	def equals(self, obj: typing.Any) -> bool:
+		return self._instance.Equals(obj)
+
+	def get_hash_code(self) -> int:
+		return self._instance.GetHashCode()
+
 	@property
 	def frame(self) -> int:
+		'''Frame ID in the controller'''
 		return self._instance.Frame
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, CartesianPositionWithUserFrame):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/fanuc/common/configuration.py

@@ -3,67 +3,109 @@
 from underautomation.fanuc.common.arm_up_down import ArmUpDown
 from underautomation.fanuc.common.arm_left_right import ArmLeftRight
 from underautomation.fanuc.common.arm_front_back import ArmFrontBack
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
 from UnderAutomation.Fanuc.Common import Configuration as configuration
 from UnderAutomation.Fanuc.Common import WristFlip as wrist_flip
 from UnderAutomation.Fanuc.Common import ArmUpDown as arm_up_down
 from UnderAutomation.Fanuc.Common import ArmLeftRight as arm_left_right
 from UnderAutomation.Fanuc.Common import ArmFrontBack as arm_front_back
 
 class Configuration:
+	'''Fanuc arm configuration'''
 	def __init__(self, wristFlip: WristFlip, armUpDown: ArmUpDown, armLeftRight: ArmLeftRight, armFrontBack: ArmFrontBack, turnAxis1: int, turnAxis2: int, turnAxis3: int, _internal = 0):
+		'''Constructor with all configuration parameters'''
 		if(_internal == 0):
 			self._instance = configuration(wristFlip, armUpDown, armLeftRight, armFrontBack, turnAxis1, turnAxis2, turnAxis3)
 		else:
 			self._instance = _internal
-	def __repr__(self):
-		return self._instance.ToString() if self._instance is not None else ""
+
 	def from_string(self, value: str) -> None:
+		'''Parse a Fanuc configuration string representation, like : "N U T, 0, 0, 0" or "R, 0, 0, 0"'''
 		self._instance.FromString(value)
+
+	def equals(self, obj: typing.Any) -> bool:
+		return self._instance.Equals(obj)
+
+	def get_hash_code(self) -> int:
+		return self._instance.GetHashCode()
+
 	@property
 	def is_unknown(self) -> bool:
+		'''Indicates if the configuration is unknown'''
 		return self._instance.IsUnknown
+
 	@property
 	def wrist_flip(self) -> WristFlip:
-		return WristFlip(self._instance.WristFlip)
+		'''Wrist configuration'''
+		return WristFlip(int(self._instance.WristFlip))
+
 	@wrist_flip.setter
 	def wrist_flip(self, value: WristFlip):
 		self._instance.WristFlip = wrist_flip(int(value))
+
 	@property
 	def arm_up_down(self) -> ArmUpDown:
-		return ArmUpDown(self._instance.ArmUpDown)
+		'''Arm up/down configuration'''
+		return ArmUpDown(int(self._instance.ArmUpDown))
+
 	@arm_up_down.setter
 	def arm_up_down(self, value: ArmUpDown):
 		self._instance.ArmUpDown = arm_up_down(int(value))
+
 	@property
 	def arm_left_right(self) -> ArmLeftRight:
-		return ArmLeftRight(self._instance.ArmLeftRight)
+		'''Arm left/right configuration'''
+		return ArmLeftRight(int(self._instance.ArmLeftRight))
+
 	@arm_left_right.setter
 	def arm_left_right(self, value: ArmLeftRight):
 		self._instance.ArmLeftRight = arm_left_right(int(value))
+
 	@property
 	def arm_front_back(self) -> ArmFrontBack:
-		return ArmFrontBack(self._instance.ArmFrontBack)
+		'''Arm back/front configuration'''
+		return ArmFrontBack(int(self._instance.ArmFrontBack))
+
 	@arm_front_back.setter
 	def arm_front_back(self, value: ArmFrontBack):
 		self._instance.ArmFrontBack = arm_front_back(int(value))
+
 	@property
 	def turn_axis4(self) -> int:
+		'''Turn number of axis J4 (1:180° to 539°, 0:-179° to 179°, -1:-539° to -180°)'''
 		return self._instance.TurnAxis4
+
 	@turn_axis4.setter
 	def turn_axis4(self, value: int):
 		self._instance.TurnAxis4 = value
+
 	@property
 	def turn_axis5(self) -> int:
+		'''Turn number of axis J5 (1:180° to 539°, 0:-179° to 179°, -1:-539° to -180°)'''
 		return self._instance.TurnAxis5
+
 	@turn_axis5.setter
 	def turn_axis5(self, value: int):
 		self._instance.TurnAxis5 = value
+
 	@property
 	def turn_axis6(self) -> int:
+		'''Turn number of axis J6 (1:180° to 539°, 0:-179° to 179°, -1:-539° to -180°)'''
 		return self._instance.TurnAxis6
+
 	@turn_axis6.setter
 	def turn_axis6(self, value: int):
 		self._instance.TurnAxis6 = value
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, Configuration):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0