UnderAutomation.Fanuc 2.2.0.0__py3-none-any.whl → 3.0.0.0__py3-none-any.whl

underautomation/fanuc/kinematics/crx/i_crx_dhm_parameters.py

@@ -0,0 +1,24 @@
+import typing
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics.Crx import ICrxDhmParameters as i_crx_dhm_parameters
+
+class ICrxDhmParameters:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = i_crx_dhm_parameters()
+		else:
+			self._instance = _internal
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@property
+	def d6(self) -> float:
+		return self._instance.D6

underautomation/fanuc/kinematics/crx10ia_l_dhm_parameters.py

@@ -0,0 +1,31 @@
+import typing
+from underautomation.fanuc.kinematics.i_dh_parameters import IDhParameters
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import Crx10iaLDhmParameters as crx10ia_l_dhm_parameters
+
+class Crx10iaLDhmParameters(IDhParameters):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = crx10ia_l_dhm_parameters()
+		else:
+			self._instance = _internal
+	@property
+	def a1(self) -> float:
+		return self._instance.A1
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@property
+	def a3(self) -> float:
+		return self._instance.A3
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@property
+	def d6(self) -> float:
+		return self._instance.D6

underautomation/fanuc/kinematics/dh_parameters.py

@@ -0,0 +1,77 @@
+import typing
+from underautomation.fanuc.kinematics.i_dh_parameters import IDhParameters
+from underautomation.fanuc.kinematics.kinematics_category import KinematicsCategory
+from underautomation.fanuc.kinematics.arm_kinematic_models import ArmKinematicModels
+from underautomation.fanuc.ftp.variables.symotn_file import SymotnFile
+from underautomation.fanuc.ftp.variables.mrr_grp_variable_type import MrrGrpVariableType
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import DhParameters as dh_parameters
+
+class DhParameters(IDhParameters):
+	def __init__(self, d4: float, d5: float, d6: float, a1: float, a2: float, a3: float, _internal = 0):
+		if(_internal == 0):
+			self._instance = dh_parameters(d4, d5, d6, a1, a2, a3)
+		else:
+			self._instance = _internal
+	@staticmethod
+	def from_arm_kinematic_model(model: ArmKinematicModels) -> 'DhParameters':
+		return DhParameters(None, None, None, None, None, None, dh_parameters.FromArmKinematicModel(model))
+	@staticmethod
+	def from_opw_parameters(a1: float, a2: float, c2: float, c3: float, c4: float) -> 'DhParameters':
+		return DhParameters(None, None, None, None, None, None, dh_parameters.FromOpwParameters(a1, a2, c2, c3, c4))
+	@staticmethod
+	def from_def_file(doc: typing.Any) -> typing.List['DhParameters']:
+		return [DhParameters(x) for x in dh_parameters.FromDefFile(doc)]
+	@staticmethod
+	def from_symotn_file(file: SymotnFile) -> typing.List['DhParameters']:
+		return [DhParameters(x) for x in dh_parameters.FromSymotnFile(file._instance if file else None)]
+	@staticmethod
+	def from_mrr_grp(mrrGrp: MrrGrpVariableType) -> 'DhParameters':
+		return DhParameters(None, None, None, None, None, None, dh_parameters.FromMrrGrp(mrrGrp._instance if mrrGrp else None))
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@d4.setter
+	def d4(self, value: float):
+		self._instance.D4 = value
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@d5.setter
+	def d5(self, value: float):
+		self._instance.D5 = value
+	@property
+	def d6(self) -> float:
+		return self._instance.D6
+	@d6.setter
+	def d6(self, value: float):
+		self._instance.D6 = value
+	@property
+	def a1(self) -> float:
+		return self._instance.A1
+	@a1.setter
+	def a1(self, value: float):
+		self._instance.A1 = value
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@a2.setter
+	def a2(self, value: float):
+		self._instance.A2 = value
+	@property
+	def a3(self) -> float:
+		return self._instance.A3
+	@a3.setter
+	def a3(self, value: float):
+		self._instance.A3 = value
+	@property
+	def kinematics_category(self) -> KinematicsCategory:
+		return KinematicsCategory(self._instance.KinematicsCategory)
+	@property
+	def tag(self) -> typing.Any:
+		return self._instance.Tag
+	@tag.setter
+	def tag(self, value: typing.Any):
+		self._instance.Tag = value

underautomation/fanuc/kinematics/i_dh_parameters.py

@@ -0,0 +1,30 @@
+import typing
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import IDhParameters as i_dh_parameters
+
+class IDhParameters:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = i_dh_parameters()
+		else:
+			self._instance = _internal
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@property
+	def d6(self) -> float:
+		return self._instance.D6
+	@property
+	def a1(self) -> float:
+		return self._instance.A1
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@property
+	def a3(self) -> float:
+		return self._instance.A3

underautomation/fanuc/kinematics/internal/arm_model_attribute.py

@@ -0,0 +1,31 @@
+import typing
+from underautomation.fanuc.kinematics.i_dh_parameters import IDhParameters
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics.Internal import ArmModelAttribute as arm_model_attribute
+
+class ArmModelAttribute(IDhParameters):
+	def __init__(self, description: str, d4: float, d5: float, d6: float, a1: float, a2: float, a3: float, _internal = 0):
+		if(_internal == 0):
+			self._instance = arm_model_attribute(description, d4, d5, d6, a1, a2, a3)
+		else:
+			self._instance = _internal
+	@property
+	def d4(self) -> float:
+		return self._instance.D4
+	@property
+	def d5(self) -> float:
+		return self._instance.D5
+	@property
+	def d6(self) -> float:
+		return self._instance.D6
+	@property
+	def a1(self) -> float:
+		return self._instance.A1
+	@property
+	def a2(self) -> float:
+		return self._instance.A2
+	@property
+	def a3(self) -> float:
+		return self._instance.A3

underautomation/fanuc/kinematics/kinematics_category.py

@@ -0,0 +1,9 @@
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import KinematicsCategory as kinematics_category
+
+class KinematicsCategory(int):
+	Invalid = kinematics_category.Invalid
+	Crx = kinematics_category.Crx
+	Opw = kinematics_category.Opw

underautomation/fanuc/kinematics/kinematics_utils.py

@@ -0,0 +1,24 @@
+import typing
+from underautomation.fanuc.common.cartesian_position import CartesianPosition
+from underautomation.fanuc.common.joints_position import JointsPosition
+from underautomation.fanuc.kinematics.dh_parameters import DhParameters
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics import KinematicsUtils as kinematics_utils
+
+class KinematicsUtils:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = kinematics_utils()
+		else:
+			self._instance = _internal
+	@staticmethod
+	def forward_kinematics(jointAnglesRad: typing.List[float], dhParameters: DhParameters) -> CartesianPosition:
+		return CartesianPosition(None, None, None, None, None, None, None, kinematics_utils.ForwardKinematics(jointAnglesRad, dhParameters._instance if dhParameters else None))
+	@staticmethod
+	def inverse_kinematics(position: CartesianPosition, parameters: DhParameters) -> typing.List[JointsPosition]:
+		return [JointsPosition(x) for x in kinematics_utils.InverseKinematics(position._instance if position else None, parameters._instance if parameters else None)]
+	@staticmethod
+	def mul(A: typing.List[float], B: typing.List[float]) -> typing.List[float]:
+		return kinematics_utils.Mul(A, B)

underautomation/fanuc/kinematics/opw/opw_kinematics_utils.py

@@ -0,0 +1,21 @@
+import typing
+from underautomation.fanuc.common.cartesian_position import CartesianPosition
+from underautomation.fanuc.kinematics.dh_parameters import DhParameters
+from underautomation.fanuc.common.joints_position import JointsPosition
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Kinematics.Opw import OpwKinematicsUtils as opw_kinematics_utils
+
+class OpwKinematicsUtils:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = opw_kinematics_utils()
+		else:
+			self._instance = _internal
+	@staticmethod
+	def forward_kinematics(jointAnglesRad: typing.List[float], dhParameters: DhParameters) -> CartesianPosition:
+		return CartesianPosition(None, None, None, None, None, None, None, opw_kinematics_utils.ForwardKinematics(jointAnglesRad, dhParameters._instance if dhParameters else None))
+	@staticmethod
+	def inverse_kinematics(pose: CartesianPosition, dhParameters: DhParameters) -> typing.List[JointsPosition]:
+		return [JointsPosition(x) for x in opw_kinematics_utils.InverseKinematics(pose._instance if pose else None, dhParameters._instance if dhParameters else None)]

underautomation/fanuc/lib/version.txt

@@ -1 +1 @@
-2.2.0.0
+3.0.0.0

underautomation/fanuc/rmi/internal/rmi_client_base.py

@@ -48,15 +48,15 @@ class RmiClientBase:
 	def read_u_frame(self, number: int) -> IndexedFrame:
 		return IndexedFrame(self._instance.ReadUFrame(number))
 	def write_u_frame(self, number: int, frame: Frame) -> None:
-		self._instance.WriteUFrame(number, frame._instance)
+		self._instance.WriteUFrame(number, frame._instance if frame else None)
 	def read_u_tool(self, number: int) -> IndexedFrame:
 		return IndexedFrame(self._instance.ReadUTool(number))
 	def write_u_tool(self, number: int, frame: Frame) -> None:
-		self._instance.WriteUTool(number, frame._instance)
+		self._instance.WriteUTool(number, frame._instance if frame else None)
 	def read_din(self, portNumber: int) -> DigitalInputValue:
 		return DigitalInputValue(self._instance.ReadDIN(portNumber))
 	def write_dout(self, portNumber: int, value: OnOff) -> None:
-		self._instance.WriteDOUT(portNumber, value._instance)
+		self._instance.WriteDOUT(portNumber, value)
 	def read_cartesian_position(self) -> CartesianPosition:
 		return CartesianPosition(self._instance.ReadCartesianPosition())
 	def read_joint_angles(self) -> JointAnglesSample:
@@ -68,11 +68,11 @@ class RmiClientBase:
 	def read_position_register(self, number: int) -> PositionRegisterData:
 		return PositionRegisterData(self._instance.ReadPositionRegister(number))
 	def write_position_register(self, number: int, cfg: MotionConfiguration, frame: Frame) -> None:
-		self._instance.WritePositionRegister(number, cfg._instance, frame._instance)
+		self._instance.WritePositionRegister(number, cfg._instance if cfg else None, frame._instance if frame else None)
 	def read_tcp_speed(self) -> TcpSpeed:
 		return TcpSpeed(self._instance.ReadTcpSpeed())
 	def wait_din(self, sequenceId: int, portNumber: int, value: OnOff) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.WaitDin(sequenceId, portNumber, value._instance))
+		return RmiSequenceResponse(self._instance.WaitDin(sequenceId, portNumber, value))
 	def set_u_frame_instruction(self, sequenceId: int, frameNumber: int) -> RmiSequenceResponse:
 		return RmiSequenceResponse(self._instance.SetUFrameInstruction(sequenceId, frameNumber))
 	def set_u_tool_instruction(self, sequenceId: int, toolNumber: int) -> RmiSequenceResponse:
@@ -82,21 +82,21 @@ class RmiClientBase:
 	def set_payload(self, sequenceId: int, scheduleNumber: int) -> RmiSequenceResponse:
 		return RmiSequenceResponse(self._instance.SetPayload(sequenceId, scheduleNumber))
 	def linear_motion(self, sequenceId: int, config: MotionConfiguration, position: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, wristJoint: bool, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.LinearMotion(sequenceId, config._instance, position._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.LinearMotion(sequenceId, config._instance if config else None, position._instance if position else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def linear_relative(self, sequenceId: int, config: MotionConfiguration, delta: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, wristJoint: bool, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.LinearRelative(sequenceId, config._instance, delta._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.LinearRelative(sequenceId, config._instance if config else None, delta._instance if delta else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def joint_motion(self, sequenceId: int, config: MotionConfiguration, position: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.JointMotion(sequenceId, config._instance, position._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.JointMotion(sequenceId, config._instance if config else None, position._instance if position else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def joint_relative(self, sequenceId: int, config: MotionConfiguration, delta: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.JointRelative(sequenceId, config._instance, delta._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.JointRelative(sequenceId, config._instance if config else None, delta._instance if delta else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def circular_motion(self, sequenceId: int, config: MotionConfiguration, position: Frame, viaConfig: MotionConfiguration, viaPosition: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, wristJoint: bool, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.CircularMotion(sequenceId, config._instance, position._instance, viaConfig._instance, viaPosition._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.CircularMotion(sequenceId, config._instance if config else None, position._instance if position else None, viaConfig._instance if viaConfig else None, viaPosition._instance if viaPosition else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def circular_relative(self, sequenceId: int, config: MotionConfiguration, delta: Frame, viaConfig: MotionConfiguration, viaDelta: Frame, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, wristJoint: bool, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.CircularRelative(sequenceId, config._instance, delta._instance, viaConfig._instance, viaDelta._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.CircularRelative(sequenceId, config._instance if config else None, delta._instance if delta else None, viaConfig._instance if viaConfig else None, viaDelta._instance if viaDelta else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, wristJoint, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def joint_motion_j_rep(self, sequenceId: int, joints: JointAngles, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.JointMotionJRep(sequenceId, joints._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.JointMotionJRep(sequenceId, joints._instance if joints else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def joint_relative_j_rep(self, sequenceId: int, deltaJoints: JointAngles, speedType: SpeedType, speed: int, termType: TerminationType, termValue: int, acc: typing.Any, offsetPr: typing.Any, visionPr: typing.Any, mrot: bool, lcbType: str, lcbValue: typing.Any, portType: typing.Any, portNumber: typing.Any, portValue: typing.Any) -> RmiSequenceResponse:
-		return RmiSequenceResponse(self._instance.JointRelativeJRep(sequenceId, deltaJoints._instance, speedType._instance, speed, termType._instance, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
+		return RmiSequenceResponse(self._instance.JointRelativeJRep(sequenceId, deltaJoints._instance if deltaJoints else None, speedType, speed, termType, termValue, acc, offsetPr, visionPr, mrot, lcbType, lcbValue, portType, portNumber, portValue))
 	def dispose(self) -> None:
 		self._instance.Dispose()
 	@property

underautomation/fanuc/rmi/internal/rmi_connect_parameters_base.py

@@ -28,21 +28,9 @@ class RmiConnectParametersBase:
 	@write_timeout_ms.setter
 	def write_timeout_ms(self, value: int):
 		self._instance.WriteTimeoutMs = value
-	@property
-	def defaul_t__port(self) -> int:
-		return self._instance.DEFAULT_PORT
-	@defaul_t__port.setter
-	def defaul_t__port(self, value: int):
-		self._instance.DEFAULT_PORT = value
-	@property
-	def defaul_t__rea_d__timeou_t__ms(self) -> int:
-		return self._instance.DEFAULT_READ_TIMEOUT_MS
-	@defaul_t__rea_d__timeou_t__ms.setter
-	def defaul_t__rea_d__timeou_t__ms(self, value: int):
-		self._instance.DEFAULT_READ_TIMEOUT_MS = value
-	@property
-	def defaul_t__writ_e__timeou_t__ms(self) -> int:
-		return self._instance.DEFAULT_WRITE_TIMEOUT_MS
-	@defaul_t__writ_e__timeou_t__ms.setter
-	def defaul_t__writ_e__timeou_t__ms(self, value: int):
-		self._instance.DEFAULT_WRITE_TIMEOUT_MS = value
+
+RmiConnectParametersBase.defaul_t__port = RmiConnectParametersBase(rmi_connect_parameters_base.DEFAULT_PORT)
+
+RmiConnectParametersBase.defaul_t__rea_d__timeou_t__ms = RmiConnectParametersBase(rmi_connect_parameters_base.DEFAULT_READ_TIMEOUT_MS)
+
+RmiConnectParametersBase.defaul_t__writ_e__timeou_t__ms = RmiConnectParametersBase(rmi_connect_parameters_base.DEFAULT_WRITE_TIMEOUT_MS)

underautomation/fanuc/snpx/internal/batch_assignment_2.py

@@ -13,8 +13,8 @@ class BatchAssignment2(typing.Generic[TValue, TIndex]):
 			self._instance = batch_assignment_2()
 		else:
 			self._instance = _internal
-	def read(self) -> typing.Any:
-		return self._instance.Read()
+	def read(self) -> typing.List[TValue]:
+		return list(self._instance.Read())
 	@property
 	def assignments(self) -> typing.List[Assignment1]:
 		return [Assignment1(x) for x in self._instance.Assignments]

underautomation/fanuc/snpx/internal/position_registers.py

@@ -17,6 +17,6 @@ class PositionRegisters(SnpxWritableAssignableElements3[Position, int, PositionR
 		else:
 			self._instance = _internal
 	def write(self, index: int, cartesianPosition: CartesianPosition) -> None:
-		self._instance.Write(index, cartesianPosition._instance)
+		self._instance.Write(index, cartesianPosition._instance if cartesianPosition else None)
 	def create_batch_assignment(self, startIndex: int, count: int) -> PositionRegistersBatchAssignment:
 		return PositionRegistersBatchAssignment(self._instance.CreateBatchAssignment(startIndex, count))

underautomation/fanuc/snpx/internal/position_system_variables.py

@@ -17,4 +17,4 @@ class PositionSystemVariables(SnpxWritableAssignableElements3[Position, str, Pos
 		else:
 			self._instance = _internal
 	def write(self, variable: str, cartesianPosition: CartesianPosition) -> None:
-		self._instance.Write(variable, cartesianPosition._instance)
+		self._instance.Write(variable, cartesianPosition._instance if cartesianPosition else None)

underautomation/fanuc/snpx/internal/robot_alarm.py

@@ -16,7 +16,7 @@ class RobotAlarm:
 	def from_bytes(bytes: typing.List[int], start: int=0) -> 'RobotAlarm':
 		return RobotAlarm(robot_alarm.FromBytes(bytes, start))
 	def equals(self, other: 'RobotAlarm') -> bool:
-		return self._instance.Equals(other._instance)
+		return self._instance.Equals(other._instance if other else None)
 	def __repr__(self):
 		return self._instance.ToString()
 	@property

underautomation/fanuc/snpx/internal/robot_task_status.py

@@ -12,7 +12,7 @@ class RobotTaskStatus:
 		else:
 			self._instance = _internal
 	def equals(self, other: 'RobotTaskStatus') -> bool:
-		return self._instance.Equals(other._instance)
+		return self._instance.Equals(other._instance if other else None)
 	@staticmethod
 	def from_bytes(bytes: typing.List[int], start: int=0) -> 'RobotTaskStatus':
 		return RobotTaskStatus(robot_task_status.FromBytes(bytes, start))

underautomation/fanuc/snpx/internal/snpx_connect_parameters_base.py

@@ -16,9 +16,5 @@ class SnpxConnectParametersBase:
 	@port.setter
 	def port(self, value: int):
 		self._instance.Port = value
-	@property
-	def defaul_t__port(self) -> int:
-		return self._instance.DEFAULT_PORT
-	@defaul_t__port.setter
-	def defaul_t__port(self, value: int):
-		self._instance.DEFAULT_PORT = value
+
+SnpxConnectParametersBase.defaul_t__port = SnpxConnectParametersBase(snpx_connect_parameters_base.DEFAULT_PORT)

underautomation/fanuc/snpx/internal/snpx_writable_assignable_elements_3.py

@@ -16,5 +16,5 @@ class SnpxWritableAssignableElements3(SnpxAssignableElements2[TValue, TIndex], t
 			self._instance = _internal
 	def write(self, index: TIndex, value: TValue) -> None:
 		self._instance.Write(index, value)
-	def create_batch_assignment(self, indexes: typing.Any) -> TAssignment:
+	def create_batch_assignment(self, indexes: typing.List[TIndex]) -> TAssignment:
 		return self._instance.CreateBatchAssignment(indexes)

underautomation/fanuc/telnet/internal/telnet_client_base.py

@@ -28,7 +28,6 @@ import os
 clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
 from UnderAutomation.Fanuc.Telnet.Internal import TelnetClientBase as telnet_client_base
 
-뼁 = typing.TypeVar('뼁')
 T = typing.TypeVar('T')
 class TelnetClientBase:
 	def __init__(self, _internal = 0):
@@ -89,7 +88,7 @@ class TelnetClientBase:
 	def run(self, program: str="None") -> RunResult:
 		return RunResult(self._instance.Run(program))
 	def set_port(self, port: KCLPorts, index: int, value: int) -> SetPortResult:
-		return SetPortResult(self._instance.SetPort(port._instance, index, value))
+		return SetPortResult(self._instance.SetPort(port, index, value))
 	def set_variable(self, name: str, value: float, program: str="None") -> SetVariableResult:
 		return SetVariableResult(self._instance.SetVariable(name, value, program))
 	def get_current_pose(self) -> GetCurrentPoseResult:
@@ -97,11 +96,11 @@ class TelnetClientBase:
 	def get_variable(self, name: str, program: str="None") -> GetVariableResult:
 		return GetVariableResult(self._instance.GetVariable(name, program))
 	def simulate(self, port: KCLPorts, index: int, value: int) -> SimulateResult:
-		return SimulateResult(self._instance.Simulate(port._instance, index, value))
+		return SimulateResult(self._instance.Simulate(port, index, value))
 	def unsimulate_all(self) -> UnsimulateAllResult:
 		return UnsimulateAllResult(self._instance.UnsimulateAll())
 	def unsimulate(self, port: KCLPorts, index: int) -> UnsimulateResult:
-		return UnsimulateResult(self._instance.Unsimulate(port._instance, index))
+		return UnsimulateResult(self._instance.Unsimulate(port, index))
 	def send_custom_command(self, command: str) -> T:
 		return self._instance.SendCustomCommand(command)
 	def get_task_information(self, prog_name: str) -> TaskInformationResult:

{underautomation_fanuc-2.2.0.0.dist-info → underautomation_fanuc-3.0.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UnderAutomation.Fanuc
-Version: 2.2.0.0
+Version: 3.0.0.0
 Summary: Quickly create applications that communicate with your Fanuc robots
 Home-page: https://underautomation.com/fanuc
 Author: UnderAutomation