UnderAutomation.Fanuc 3.5.0.0__py3-none-any.whl

underautomation/fanuc/snpx/internal/numeric_io.py

@@ -0,0 +1,29 @@
+import typing
+from underautomation.fanuc.snpx.internal.segment_selector import SegmentSelector
+from underautomation.fanuc.snpx.internal.segment_offset import SegmentOffset
+from underautomation.fanuc.snpx.internal.segment_name import SegmentName
+from underautomation.fanuc.snpx.internal.snpx_elements_2 import SnpxElements2
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import NumericIO as numeric_io
+
+class NumericIO(SnpxElements2[int, int]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = numeric_io()
+		else:
+			self._instance = _internal
+	def read(self, firstIndex: int, count: int) -> typing.List[int]:
+		return self._instance.Read(firstIndex, count)
+	def write(self, firstIndex: int, values: typing.List[int]) -> None:
+		self._instance.Write(firstIndex, values)
+	@property
+	def segment_selector(self) -> SegmentSelector:
+		return SegmentSelector(self._instance.SegmentSelector)
+	@property
+	def segment_offset(self) -> SegmentOffset:
+		return SegmentOffset(self._instance.SegmentOffset)
+	@property
+	def segment_name(self) -> SegmentName:
+		return SegmentName(self._instance.SegmentName)

underautomation/fanuc/snpx/internal/numeric_registers.py

@@ -0,0 +1,16 @@
+import typing
+from underautomation.fanuc.snpx.assignment.numeric_registers_batch_assignment import NumericRegistersBatchAssignment
+from underautomation.fanuc.snpx.internal.snpx_writable_assignable_elements_3 import SnpxWritableAssignableElements3
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import NumericRegisters as numeric_registers
+
+class NumericRegisters(SnpxWritableAssignableElements3[float, int, NumericRegistersBatchAssignment]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = numeric_registers()
+		else:
+			self._instance = _internal
+	def create_batch_assignment(self, startIndex: int, count: int) -> NumericRegistersBatchAssignment:
+		return NumericRegistersBatchAssignment(self._instance.CreateBatchAssignment(startIndex, count))

underautomation/fanuc/snpx/internal/position_registers.py

@@ -0,0 +1,22 @@
+import typing
+from underautomation.fanuc.common.joints_position import JointsPosition
+from underautomation.fanuc.common.extended_cartesian_position import ExtendedCartesianPosition
+from underautomation.fanuc.common.cartesian_position import CartesianPosition
+from underautomation.fanuc.snpx.assignment.position_registers_batch_assignment import PositionRegistersBatchAssignment
+from underautomation.fanuc.snpx.internal.snpx_writable_assignable_elements_3 import SnpxWritableAssignableElements3
+from underautomation.fanuc.common.position import Position
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import PositionRegisters as position_registers
+
+class PositionRegisters(SnpxWritableAssignableElements3[Position, int, PositionRegistersBatchAssignment]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = position_registers()
+		else:
+			self._instance = _internal
+	def write(self, index: int, cartesianPosition: CartesianPosition) -> None:
+		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

@@ -0,0 +1,20 @@
+import typing
+from underautomation.fanuc.common.joints_position import JointsPosition
+from underautomation.fanuc.common.extended_cartesian_position import ExtendedCartesianPosition
+from underautomation.fanuc.common.cartesian_position import CartesianPosition
+from underautomation.fanuc.snpx.internal.snpx_writable_assignable_elements_3 import SnpxWritableAssignableElements3
+from underautomation.fanuc.common.position import Position
+from underautomation.fanuc.snpx.assignment.position_system_variables_batch_assignment import PositionSystemVariablesBatchAssignment
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import PositionSystemVariables as position_system_variables
+
+class PositionSystemVariables(SnpxWritableAssignableElements3[Position, str, PositionSystemVariablesBatchAssignment]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = position_system_variables()
+		else:
+			self._instance = _internal
+	def write(self, variable: str, cartesianPosition: CartesianPosition) -> None:
+		self._instance.Write(variable, cartesianPosition._instance if cartesianPosition else None)

underautomation/fanuc/snpx/internal/real_system_variables.py

@@ -0,0 +1,14 @@
+import typing
+from underautomation.fanuc.snpx.internal.snpx_writable_assignable_elements_3 import SnpxWritableAssignableElements3
+from underautomation.fanuc.snpx.assignment.real_system_variables_batch_assignment import RealSystemVariablesBatchAssignment
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import RealSystemVariables as real_system_variables
+
+class RealSystemVariables(SnpxWritableAssignableElements3[float, str, RealSystemVariablesBatchAssignment]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = real_system_variables()
+		else:
+			self._instance = _internal

underautomation/fanuc/snpx/internal/robot_alarm.py

@@ -0,0 +1,76 @@
+import typing
+from underautomation.fanuc.snpx.internal.alarm_id import AlarmId
+from underautomation.fanuc.snpx.internal.alarm_severity import AlarmSeverity
+from underautomation.fanuc.common.languages import Languages
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import RobotAlarm as robot_alarm
+
+class RobotAlarm:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = robot_alarm()
+		else:
+			self._instance = _internal
+	@staticmethod
+	def from_bytes(bytes: typing.List[int], language: Languages, start: int=0) -> 'RobotAlarm':
+		return RobotAlarm(robot_alarm.FromBytes(bytes, language, start))
+	def equals(self, other: 'RobotAlarm') -> bool:
+		return self._instance.Equals(other._instance if other else None)
+	def __repr__(self):
+		return self._instance.ToString()
+	@property
+	def id(self) -> AlarmId:
+		return AlarmId(self._instance.Id)
+	@id.setter
+	def id(self, value: AlarmId):
+		self._instance.Id = value
+	@property
+	def number(self) -> int:
+		return self._instance.Number
+	@number.setter
+	def number(self, value: int):
+		self._instance.Number = value
+	@property
+	def cause_id(self) -> AlarmId:
+		return AlarmId(self._instance.CauseId)
+	@cause_id.setter
+	def cause_id(self, value: AlarmId):
+		self._instance.CauseId = value
+	@property
+	def cause_number(self) -> int:
+		return self._instance.CauseNumber
+	@cause_number.setter
+	def cause_number(self, value: int):
+		self._instance.CauseNumber = value
+	@property
+	def severity(self) -> AlarmSeverity:
+		return AlarmSeverity(self._instance.Severity)
+	@severity.setter
+	def severity(self, value: AlarmSeverity):
+		self._instance.Severity = value
+	@property
+	def time(self) -> typing.Any:
+		return self._instance.Time
+	@time.setter
+	def time(self, value: typing.Any):
+		self._instance.Time = value
+	@property
+	def message(self) -> str:
+		return self._instance.Message
+	@message.setter
+	def message(self, value: str):
+		self._instance.Message = value
+	@property
+	def cause_message(self) -> str:
+		return self._instance.CauseMessage
+	@cause_message.setter
+	def cause_message(self, value: str):
+		self._instance.CauseMessage = value
+	@property
+	def severity_message(self) -> str:
+		return self._instance.SeverityMessage
+	@severity_message.setter
+	def severity_message(self, value: str):
+		self._instance.SeverityMessage = value

underautomation/fanuc/snpx/internal/robot_task_state.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.Snpx.Internal import RobotTaskState as robot_task_state
+
+class RobotTaskState(int):
+	Stopped = robot_task_state.Stopped
+	Paused = robot_task_state.Paused
+	Running = robot_task_state.Running

underautomation/fanuc/snpx/internal/robot_task_status.py

@@ -0,0 +1,43 @@
+import typing
+from underautomation.fanuc.snpx.internal.robot_task_state import RobotTaskState
+from underautomation.fanuc.common.languages import Languages
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import RobotTaskStatus as robot_task_status
+
+class RobotTaskStatus:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = robot_task_status()
+		else:
+			self._instance = _internal
+	def equals(self, other: 'RobotTaskStatus') -> bool:
+		return self._instance.Equals(other._instance if other else None)
+	@staticmethod
+	def from_bytes(bytes: typing.List[int], language: Languages, start: int=0) -> 'RobotTaskStatus':
+		return RobotTaskStatus(robot_task_status.FromBytes(bytes, language, start))
+	@property
+	def program_name(self) -> str:
+		return self._instance.ProgramName
+	@program_name.setter
+	def program_name(self, value: str):
+		self._instance.ProgramName = value
+	@property
+	def line_number(self) -> int:
+		return self._instance.LineNumber
+	@line_number.setter
+	def line_number(self, value: int):
+		self._instance.LineNumber = value
+	@property
+	def state(self) -> RobotTaskState:
+		return RobotTaskState(self._instance.State)
+	@state.setter
+	def state(self, value: RobotTaskState):
+		self._instance.State = value
+	@property
+	def caller(self) -> str:
+		return self._instance.Caller
+	@caller.setter
+	def caller(self, value: str):
+		self._instance.Caller = value

underautomation/fanuc/snpx/internal/segment_name.py

@@ -0,0 +1,24 @@
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import SegmentName as segment_name
+
+class SegmentName(int):
+	SDI = segment_name.SDI
+	SDO = segment_name.SDO
+	RDI = segment_name.RDI
+	RDO = segment_name.RDO
+	UI = segment_name.UI
+	UO = segment_name.UO
+	SI = segment_name.SI
+	SO = segment_name.SO
+	WI = segment_name.WI
+	WO = segment_name.WO
+	WSI = segment_name.WSI
+	PMC_K = segment_name.PMC_K
+	PMC_R = segment_name.PMC_R
+	AI = segment_name.AI
+	AO = segment_name.AO
+	GI = segment_name.GI
+	GO = segment_name.GO
+	PMC_D = segment_name.PMC_D

underautomation/fanuc/snpx/internal/segment_offset.py

@@ -0,0 +1,17 @@
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import SegmentOffset as segment_offset
+
+class SegmentOffset(int):
+	SDIO = segment_offset.SDIO
+	RDIO = segment_offset.RDIO
+	UOP = segment_offset.UOP
+	SOP = segment_offset.SOP
+	WIO = segment_offset.WIO
+	WSI = segment_offset.WSI
+	PMC_K = segment_offset.PMC_K
+	PMC_R = segment_offset.PMC_R
+	GIO = segment_offset.GIO
+	AIO = segment_offset.AIO
+	PMC_D = segment_offset.PMC_D

underautomation/fanuc/snpx/internal/segment_selector.py

@@ -0,0 +1,27 @@
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import SegmentSelector as segment_selector
+
+class SegmentSelector(int):
+	BIT_I = segment_selector.BIT_I
+	BIT_Q = segment_selector.BIT_Q
+	BIT_T = segment_selector.BIT_T
+	BIT_M = segment_selector.BIT_M
+	BIT_SA = segment_selector.BIT_SA
+	BIT_SB = segment_selector.BIT_SB
+	BIT_SC = segment_selector.BIT_SC
+	BIT_S = segment_selector.BIT_S
+	BIT_G = segment_selector.BIT_G
+	BYTE_I = segment_selector.BYTE_I
+	BYTE_Q = segment_selector.BYTE_Q
+	BYTE_T = segment_selector.BYTE_T
+	BYTE_M = segment_selector.BYTE_M
+	BYTE_SA = segment_selector.BYTE_SA
+	BYTE_SB = segment_selector.BYTE_SB
+	BYTE_SC = segment_selector.BYTE_SC
+	BYTE_G = segment_selector.BYTE_G
+	WORD_R = segment_selector.WORD_R
+	WORD_AI = segment_selector.WORD_AI
+	WORD_AQ = segment_selector.WORD_AQ
+	INIT = segment_selector.INIT

underautomation/fanuc/snpx/internal/snpx_assignable_elements_2.py

@@ -0,0 +1,20 @@
+import typing
+from underautomation.fanuc.snpx.internal.assignment_1 import Assignment1
+from underautomation.fanuc.snpx.internal.snpx_elements_2 import SnpxElements2
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import SnpxAssignableElements as snpx_assignable_elements_2
+
+TValue = typing.TypeVar('TValue')
+TIndex = typing.TypeVar('TIndex')
+class SnpxAssignableElements2(SnpxElements2[TValue, TIndex], typing.Generic[TValue, TIndex]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = snpx_assignable_elements_2()
+		else:
+			self._instance = _internal
+	def read(self, index: TIndex) -> TValue:
+		return self._instance.Read(index)
+	def get_or_create_assignment(self, index: TIndex) -> Assignment1[TIndex]:
+		return Assignment1[TIndex](self._instance.GetOrCreateAssignment(index))

underautomation/fanuc/snpx/internal/snpx_client_base.py

@@ -0,0 +1,139 @@
+import typing
+from underautomation.fanuc.snpx.internal.numeric_registers import NumericRegisters
+from underautomation.fanuc.snpx.internal.position_registers import PositionRegisters
+from underautomation.fanuc.snpx.internal.string_registers import StringRegisters
+from underautomation.fanuc.snpx.internal.integer_system_variables import IntegerSystemVariables
+from underautomation.fanuc.snpx.internal.real_system_variables import RealSystemVariables
+from underautomation.fanuc.snpx.internal.position_system_variables import PositionSystemVariables
+from underautomation.fanuc.snpx.internal.string_system_variables import StringSystemVariables
+from underautomation.fanuc.snpx.internal.digital_signals import DigitalSignals
+from underautomation.fanuc.snpx.internal.numeric_io import NumericIO
+from underautomation.fanuc.snpx.internal.current_position import CurrentPosition
+from underautomation.fanuc.snpx.internal.alarm_access import AlarmAccess
+from underautomation.fanuc.common.languages import Languages
+from underautomation.fanuc.snpx.internal.assignment import Assignment
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import SnpxClientBase as snpx_client_base
+
+class SnpxClientBase:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = snpx_client_base()
+		else:
+			self._instance = _internal
+	def poll_and_get_updated_connected_state(self) -> bool:
+		return self._instance.PollAndGetUpdatedConnectedState()
+	def disconnect(self) -> None:
+		self._instance.Disconnect()
+	def clear_alarms(self) -> None:
+		self._instance.ClearAlarms()
+	def set_variable(self, name: str, value: float) -> None:
+		self._instance.SetVariable(name, value)
+	def clear_assignments(self) -> None:
+		self._instance.ClearAssignments()
+	def get_assignments(self) -> typing.List[Assignment]:
+		return [Assignment(x) for x in self._instance.GetAssignments()]
+	@property
+	def ip(self) -> str:
+		return self._instance.Ip
+	@property
+	def numeric_registers(self) -> NumericRegisters:
+		return NumericRegisters(self._instance.NumericRegisters)
+	@property
+	def position_registers(self) -> PositionRegisters:
+		return PositionRegisters(self._instance.PositionRegisters)
+	@property
+	def string_registers(self) -> StringRegisters:
+		return StringRegisters(self._instance.StringRegisters)
+	@property
+	def integer_system_variables(self) -> IntegerSystemVariables:
+		return IntegerSystemVariables(self._instance.IntegerSystemVariables)
+	@property
+	def real_system_variables(self) -> RealSystemVariables:
+		return RealSystemVariables(self._instance.RealSystemVariables)
+	@property
+	def position_system_variables(self) -> PositionSystemVariables:
+		return PositionSystemVariables(self._instance.PositionSystemVariables)
+	@property
+	def string_system_variables(self) -> StringSystemVariables:
+		return StringSystemVariables(self._instance.StringSystemVariables)
+	@property
+	def digital_signals(self) -> typing.List[DigitalSignals]:
+		return [DigitalSignals(x) for x in self._instance.DigitalSignals]
+	@property
+	def sdi(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.SDI)
+	@property
+	def sdo(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.SDO)
+	@property
+	def rdi(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.RDI)
+	@property
+	def rdo(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.RDO)
+	@property
+	def ui(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.UI)
+	@property
+	def uo(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.UO)
+	@property
+	def si(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.SI)
+	@property
+	def so(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.SO)
+	@property
+	def wi(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.WI)
+	@property
+	def wo(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.WO)
+	@property
+	def wsi(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.WSI)
+	@property
+	def pm_c__k(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.PMC_K)
+	@property
+	def pm_c__r(self) -> DigitalSignals:
+		return DigitalSignals(self._instance.PMC_R)
+	@property
+	def numeric_i_os(self) -> typing.List[NumericIO]:
+		return [NumericIO(x) for x in self._instance.NumericIOs]
+	@property
+	def gi(self) -> NumericIO:
+		return NumericIO(self._instance.GI)
+	@property
+	def go(self) -> NumericIO:
+		return NumericIO(self._instance.GO)
+	@property
+	def ai(self) -> NumericIO:
+		return NumericIO(self._instance.AI)
+	@property
+	def ao(self) -> NumericIO:
+		return NumericIO(self._instance.AO)
+	@property
+	def pm_c__d(self) -> NumericIO:
+		return NumericIO(self._instance.PMC_D)
+	@property
+	def current_position(self) -> CurrentPosition:
+		return CurrentPosition(self._instance.CurrentPosition)
+	@property
+	def active_alarm(self) -> AlarmAccess:
+		return AlarmAccess(self._instance.ActiveAlarm)
+	@property
+	def alarm_history(self) -> AlarmAccess:
+		return AlarmAccess(self._instance.AlarmHistory)
+	@property
+	def language(self) -> Languages:
+		return Languages(self._instance.Language)
+	@language.setter
+	def language(self, value: Languages):
+		self._instance.Language = value
+	@property
+	def connected(self) -> bool:
+		return self._instance.Connected

underautomation/fanuc/snpx/internal/snpx_client_internal.py

@@ -0,0 +1,13 @@
+import typing
+from underautomation.fanuc.snpx.internal.snpx_client_base import SnpxClientBase
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import SnpxClientInternal as snpx_client_internal
+
+class SnpxClientInternal(SnpxClientBase):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = snpx_client_internal()
+		else:
+			self._instance = _internal

underautomation/fanuc/snpx/internal/snpx_connect_parameters_base.py

@@ -0,0 +1,20 @@
+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.Snpx.Internal import SnpxConnectParametersBase as snpx_connect_parameters_base
+
+class SnpxConnectParametersBase:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = snpx_connect_parameters_base()
+		else:
+			self._instance = _internal
+	@property
+	def port(self) -> int:
+		return self._instance.Port
+	@port.setter
+	def port(self, value: int):
+		self._instance.Port = value
+
+SnpxConnectParametersBase.defaul_t__port = SnpxConnectParametersBase(snpx_connect_parameters_base.DEFAULT_PORT)

underautomation/fanuc/snpx/internal/snpx_elements_2.py

@@ -0,0 +1,16 @@
+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.Snpx.Internal import SnpxElements as snpx_elements_2
+
+TValue = typing.TypeVar('TValue')
+TIndex = typing.TypeVar('TIndex')
+class SnpxElements2(typing.Generic[TValue, TIndex]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = snpx_elements_2()
+		else:
+			self._instance = _internal
+	def read(self, index: TIndex) -> TValue:
+		return self._instance.Read(index)

underautomation/fanuc/snpx/internal/snpx_writable_assignable_elements_3.py

@@ -0,0 +1,20 @@
+import typing
+from underautomation.fanuc.snpx.internal.snpx_assignable_elements_2 import SnpxAssignableElements2
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import SnpxWritableAssignableElements as snpx_writable_assignable_elements_3
+
+TValue = typing.TypeVar('TValue')
+TIndex = typing.TypeVar('TIndex')
+TAssignment = typing.TypeVar('TAssignment')
+class SnpxWritableAssignableElements3(SnpxAssignableElements2[TValue, TIndex], typing.Generic[TValue, TIndex, TAssignment]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = snpx_writable_assignable_elements_3()
+		else:
+			self._instance = _internal
+	def write(self, index: TIndex, value: TValue) -> None:
+		self._instance.Write(index, value)
+	def create_batch_assignment(self, indexes: typing.List[TIndex]) -> TAssignment:
+		return self._instance.CreateBatchAssignment(indexes)

underautomation/fanuc/snpx/internal/string_registers.py

@@ -0,0 +1,16 @@
+import typing
+from underautomation.fanuc.snpx.assignment.string_registers_batch_assignment import StringRegistersBatchAssignment
+from underautomation.fanuc.snpx.internal.snpx_writable_assignable_elements_3 import SnpxWritableAssignableElements3
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import StringRegisters as string_registers
+
+class StringRegisters(SnpxWritableAssignableElements3[str, int, StringRegistersBatchAssignment]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = string_registers()
+		else:
+			self._instance = _internal
+	def create_batch_assignment(self, startIndex: int, count: int) -> StringRegistersBatchAssignment:
+		return StringRegistersBatchAssignment(self._instance.CreateBatchAssignment(startIndex, count))

underautomation/fanuc/snpx/internal/string_system_variables.py

@@ -0,0 +1,14 @@
+import typing
+from underautomation.fanuc.snpx.internal.snpx_writable_assignable_elements_3 import SnpxWritableAssignableElements3
+from underautomation.fanuc.snpx.assignment.string_system_variables_batch_assignment import StringSystemVariablesBatchAssignment
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx.Internal import StringSystemVariables as string_system_variables
+
+class StringSystemVariables(SnpxWritableAssignableElements3[str, str, StringSystemVariablesBatchAssignment]):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = string_system_variables()
+		else:
+			self._instance = _internal

underautomation/fanuc/snpx/snpx_client.py

@@ -0,0 +1,15 @@
+import typing
+from underautomation.fanuc.snpx.internal.snpx_client_base import SnpxClientBase
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Snpx import SnpxClient as snpx_client
+
+class SnpxClient(SnpxClientBase):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = snpx_client()
+		else:
+			self._instance = _internal
+	def connect(self, ip: str, port: int=60008) -> None:
+		self._instance.Connect(ip, port)

underautomation/fanuc/telnet/abort_result.py

@@ -0,0 +1,13 @@
+import typing
+from underautomation.fanuc.telnet.result import Result
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Telnet import AbortResult as abort_result
+
+class AbortResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = abort_result()
+		else:
+			self._instance = _internal

underautomation/fanuc/telnet/add_breakpoint_result.py

@@ -0,0 +1,13 @@
+import typing
+from underautomation.fanuc.telnet.result import Result
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Telnet import AddBreakpointResult as add_breakpoint_result
+
+class AddBreakpointResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = add_breakpoint_result()
+		else:
+			self._instance = _internal

underautomation/fanuc/telnet/base_result.py

@@ -0,0 +1,13 @@
+import typing
+from underautomation.fanuc.telnet.result import Result
+import clr
+import os
+clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Fanuc.dll')))
+from UnderAutomation.Fanuc.Telnet import BaseResult as base_result
+
+class BaseResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = base_result()
+		else:
+			self._instance = _internal

underautomation/fanuc/telnet/breakpoint.py

@@ -0,0 +1,15 @@
+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.Telnet import Breakpoint as breakpoint
+
+class Breakpoint:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = breakpoint()
+		else:
+			self._instance = _internal
+	@property
+	def line(self) -> int:
+		return self._instance.Line