UnderAutomation.Fanuc 2.0.0.1__py3-none-any.whl

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,128 @@
+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.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 disconnect(self) -> None:
+		self._instance.Disconnect()
+	def clear_alarms(self) -> None:
+		self._instance.ClearAlarms()
+	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 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,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.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
+	@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

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.Any) -> 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

underautomation/fanuc/telnet/breakpoints_result.py

@@ -0,0 +1,17 @@
+import typing
+from underautomation.fanuc.telnet.breakpoint import Breakpoint
+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 BreakpointsResult as breakpoints_result
+
+class BreakpointsResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = breakpoints_result()
+		else:
+			self._instance = _internal
+	@property
+	def breakpoints(self) -> typing.List[Breakpoint]:
+		return [Breakpoint(x) for x in self._instance.Breakpoints]

underautomation/fanuc/telnet/command_sent_event_args.py

@@ -0,0 +1,18 @@
+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 CommandSentEventArgs as command_sent_event_args
+
+class CommandSentEventArgs:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = command_sent_event_args()
+		else:
+			self._instance = _internal
+	@property
+	def command(self) -> str:
+		return self._instance.Command
+	@command.setter
+	def command(self, value: str):
+		self._instance.Command = value

underautomation/fanuc/telnet/continue_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 ContinueResult as continue_result
+
+class ContinueResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = continue_result()
+		else:
+			self._instance = _internal

underautomation/fanuc/telnet/custom_command_result.py

@@ -0,0 +1,18 @@
+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 CustomCommandResult as custom_command_result
+
+class CustomCommandResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = custom_command_result()
+		else:
+			self._instance = _internal
+	def __repr__(self):
+		return self._instance.ToString()
+	@property
+	def data(self) -> str:
+		return self._instance.Data

underautomation/fanuc/telnet/get_current_pose_result.py

@@ -0,0 +1,22 @@
+import typing
+from underautomation.fanuc.common.cartesian_position import CartesianPosition
+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 GetCurrentPoseResult as get_current_pose_result
+
+class GetCurrentPoseResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = get_current_pose_result()
+		else:
+			self._instance = _internal
+	def __repr__(self):
+		return self._instance.ToString()
+	@property
+	def group(self) -> int:
+		return self._instance.Group
+	@property
+	def position(self) -> CartesianPosition:
+		return CartesianPosition(None, None, None, None, None, None, None, self._instance.Position)

underautomation/fanuc/telnet/get_variable_result.py

@@ -0,0 +1,18 @@
+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 GetVariableResult as get_variable_result
+
+class GetVariableResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = get_variable_result()
+		else:
+			self._instance = _internal
+	def __repr__(self):
+		return self._instance.ToString()
+	@property
+	def raw_value(self) -> str:
+		return self._instance.RawValue

underautomation/fanuc/telnet/internal/telnet_client_base.py

@@ -0,0 +1,128 @@
+import typing
+from underautomation.fanuc.telnet.tp_coordinates import TpCoordinates
+from underautomation.fanuc.telnet.program_command_result import ProgramCommandResult
+from underautomation.fanuc.telnet.run_result import RunResult
+from underautomation.fanuc.telnet.set_port_result import SetPortResult
+from underautomation.fanuc.telnet.kcl_ports import KCLPorts
+from underautomation.fanuc.telnet.set_variable_result import SetVariableResult
+from underautomation.fanuc.telnet.get_current_pose_result import GetCurrentPoseResult
+from underautomation.fanuc.telnet.get_variable_result import GetVariableResult
+from underautomation.fanuc.telnet.simulate_result import SimulateResult
+from underautomation.fanuc.telnet.unsimulate_all_result import UnsimulateAllResult
+from underautomation.fanuc.telnet.unsimulate_result import UnsimulateResult
+from underautomation.fanuc.telnet.custom_command_result import CustomCommandResult
+from underautomation.fanuc.telnet.task_information_result import TaskInformationResult
+from underautomation.fanuc.telnet.add_breakpoint_result import AddBreakpointResult
+from underautomation.fanuc.telnet.remove_breakpoint_result import RemoveBreakpointResult
+from underautomation.fanuc.telnet.breakpoints_result import BreakpointsResult
+from underautomation.fanuc.telnet.step_on_result import StepOnResult
+from underautomation.fanuc.telnet.step_off_result import StepOffResult
+from underautomation.fanuc.telnet.raw_data_received_event_args import RawDataReceivedEventArgs
+from underautomation.fanuc.telnet.tp_coordinates_received_event_args import TpCoordinatesReceivedEventArgs
+from underautomation.fanuc.telnet.message_received_event_args import MessageReceivedEventArgs
+from underautomation.fanuc.telnet.kcl_client_error_event_args import KclClientErrorEventArgs
+from underautomation.fanuc.telnet.command_sent_event_args import CommandSentEventArgs
+from underautomation.fanuc.telnet.kcl_command_received import KclCommandReceived
+import clr
+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
+
+T = typing.TypeVar('T')
+class TelnetClientBase:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = telnet_client_base()
+		else:
+			self._instance = _internal
+	def raw_data_received(self, handler):
+		class Wrapper :
+			def __init__(self, _internal):
+				self._instance = _internal
+		self._instance.RawDataReceived+= lambda sender, e : handler(Wrapper(sender), Wrapper(e))
+	def tp_coordinates_received(self, handler):
+		class Wrapper :
+			def __init__(self, _internal):
+				self._instance = _internal
+		self._instance.TpCoordinatesReceived+= lambda sender, e : handler(Wrapper(sender), Wrapper(e))
+	def message_received(self, handler):
+		class Wrapper :
+			def __init__(self, _internal):
+				self._instance = _internal
+		self._instance.MessageReceived+= lambda sender, e : handler(Wrapper(sender), Wrapper(e))
+	def error_occured(self, handler):
+		class Wrapper :
+			def __init__(self, _internal):
+				self._instance = _internal
+		self._instance.ErrorOccured+= lambda sender, e : handler(Wrapper(sender), Wrapper(e))
+	def command_sent(self, handler):
+		class Wrapper :
+			def __init__(self, _internal):
+				self._instance = _internal
+		self._instance.CommandSent+= lambda sender, e : handler(Wrapper(sender), Wrapper(e))
+	def command_received(self, handler):
+		class Wrapper :
+			def __init__(self, _internal):
+				self._instance = _internal
+		self._instance.CommandReceived+= lambda sender, e : handler(Wrapper(sender), Wrapper(e))
+	def disconnect(self) -> None:
+		self._instance.Disconnect()
+	def abort(self, program: str="None", force: bool=True) -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.Abort(program, force))
+	def abort_all(self, force: bool=True) -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.AbortAll(force))
+	def clear_all(self) -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.ClearAll())
+	def clear_program(self, program: str="None") -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.ClearProgram(program))
+	def clear_vars(self, program: str="None") -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.ClearVars(program))
+	def continue_(self, program: str="None") -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.Continue(program))
+	def hold(self, program: str="None") -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.Hold(program))
+	def pause(self, program: str="None", force: bool=False) -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.Pause(program, force))
+	def reset(self) -> ProgramCommandResult:
+		return ProgramCommandResult(self._instance.Reset())
+	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))
+	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:
+		return GetCurrentPoseResult(self._instance.GetCurrentPose())
+	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))
+	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))
+	def send_custom_command(self, command: str) -> T:
+		return self._instance.SendCustomCommand(command)
+	def get_task_information(self, prog_name: str) -> TaskInformationResult:
+		return TaskInformationResult(self._instance.GetTaskInformation(prog_name))
+	def add_breakpoint(self, taskName: str, line: int) -> AddBreakpointResult:
+		return AddBreakpointResult(self._instance.AddBreakpoint(taskName, line))
+	def remove_breakpoint(self, taskName: str, line: int) -> RemoveBreakpointResult:
+		return RemoveBreakpointResult(self._instance.RemoveBreakpoint(taskName, line))
+	def remove_all_breakpoints(self, taskName: str) -> RemoveBreakpointResult:
+		return RemoveBreakpointResult(self._instance.RemoveAllBreakpoints(taskName))
+	def get_breakpoints(self, taskName: str) -> BreakpointsResult:
+		return BreakpointsResult(self._instance.GetBreakpoints(taskName))
+	def step_on(self, taskName: str) -> StepOnResult:
+		return StepOnResult(self._instance.StepOn(taskName))
+	def step_off(self) -> StepOffResult:
+		return StepOffResult(self._instance.StepOff())
+	@property
+	def ip(self) -> str:
+		return self._instance.IP
+	@property
+	def tp_coordinates(self) -> TpCoordinates:
+		return TpCoordinates(self._instance.TpCoordinates)
+	@property
+	def connected(self) -> bool:
+		return self._instance.Connected

underautomation/fanuc/telnet/internal/telnet_client_internal.py

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

underautomation/fanuc/telnet/internal/telnet_connect_parameters_base.py

@@ -0,0 +1,18 @@
+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.Internal import TelnetConnectParametersBase as telnet_connect_parameters_base
+
+class TelnetConnectParametersBase:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = telnet_connect_parameters_base()
+		else:
+			self._instance = _internal
+	@property
+	def telnet_kcl_password(self) -> str:
+		return self._instance.TelnetKclPassword
+	@telnet_kcl_password.setter
+	def telnet_kcl_password(self, value: str):
+		self._instance.TelnetKclPassword = value

underautomation/fanuc/telnet/kcl_client_error_event_args.py

@@ -0,0 +1,18 @@
+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 KclClientErrorEventArgs as kcl_client_error_event_args
+
+class KclClientErrorEventArgs:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = kcl_client_error_event_args()
+		else:
+			self._instance = _internal
+	@property
+	def exception(self) -> typing.Any:
+		return self._instance.Exception
+	@exception.setter
+	def exception(self, value: typing.Any):
+		self._instance.Exception = value

underautomation/fanuc/telnet/kcl_command_received.py

@@ -0,0 +1,19 @@
+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 KclCommandReceived as kcl_command_received
+
+class KclCommandReceived:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = kcl_command_received()
+		else:
+			self._instance = _internal
+	@property
+	def result(self) -> Result:
+		return Result(self._instance.Result)
+	@result.setter
+	def result(self, value: Result):
+		self._instance.Result = value