UnderAutomation.Fanuc 3.5.0.0__py3-none-any.whl

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,137 @@
+import typing
+from underautomation.fanuc.common.languages import Languages
+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 poll_and_get_updated_connected_state(self) -> bool:
+		return self._instance.PollAndGetUpdatedConnectedState()
+	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, 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, 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, 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 language(self) -> Languages:
+		return Languages(self._instance.Language)
+	@language.setter
+	def language(self, value: Languages):
+		self._instance.Language = value
+	@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

underautomation/fanuc/telnet/kcl_ports.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.Telnet import KCLPorts as kcl_ports
+
+class KCLPorts(int):
+	DIN = kcl_ports.DIN
+	DOUT = kcl_ports.DOUT
+	RDO = kcl_ports.RDO
+	OPOUT = kcl_ports.OPOUT
+	TPOUT = kcl_ports.TPOUT
+	WDI = kcl_ports.WDI
+	WDO = kcl_ports.WDO
+	AIN = kcl_ports.AIN
+	AOUT = kcl_ports.AOUT
+	GIN = kcl_ports.GIN
+	GOUT = kcl_ports.GOUT

underautomation/fanuc/telnet/message_received_event_args.py

@@ -0,0 +1,21 @@
+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 MessageReceivedEventArgs as message_received_event_args
+
+class MessageReceivedEventArgs:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = message_received_event_args()
+		else:
+			self._instance = _internal
+	@property
+	def is_reset(self) -> bool:
+		return self._instance.IsReset
+	@property
+	def message(self) -> str:
+		return self._instance.Message
+	@message.setter
+	def message(self, value: str):
+		self._instance.Message = value

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

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

underautomation/fanuc/telnet/raw_data_received_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 RawDataReceivedEventArgs as raw_data_received_event_args
+
+class RawDataReceivedEventArgs:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = raw_data_received_event_args()
+		else:
+			self._instance = _internal
+	@property
+	def data(self) -> str:
+		return self._instance.Data
+	@data.setter
+	def data(self, value: str):
+		self._instance.Data = value

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

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

underautomation/fanuc/telnet/result.py

@@ -0,0 +1,23 @@
+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 Result as result
+
+class Result:
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = result()
+		else:
+			self._instance = _internal
+	def __repr__(self):
+		return self._instance.ToString()
+	@property
+	def error_text(self) -> str:
+		return self._instance.ErrorText
+	@property
+	def succeed(self) -> bool:
+		return self._instance.Succeed
+	@property
+	def kcl_command(self) -> str:
+		return self._instance.KclCommand

underautomation/fanuc/telnet/run_result.py

@@ -0,0 +1,13 @@
+import typing
+from underautomation.fanuc.telnet.program_command_result import ProgramCommandResult
+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 RunResult as run_result
+
+class RunResult(ProgramCommandResult):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = run_result()
+		else:
+			self._instance = _internal

underautomation/fanuc/telnet/set_port_result.py

@@ -0,0 +1,13 @@
+import typing
+from underautomation.fanuc.telnet.set_value_result import SetValueResult
+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 SetPortResult as set_port_result
+
+class SetPortResult(SetValueResult):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = set_port_result()
+		else:
+			self._instance = _internal

underautomation/fanuc/telnet/set_value_result.py

@@ -0,0 +1,21 @@
+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 SetValueResult as set_value_result
+
+class SetValueResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = set_value_result()
+		else:
+			self._instance = _internal
+	def __repr__(self):
+		return self._instance.ToString()
+	@property
+	def former_value(self) -> str:
+		return self._instance.FormerValue
+	@property
+	def new_value(self) -> str:
+		return self._instance.NewValue

underautomation/fanuc/telnet/set_variable_result.py

@@ -0,0 +1,13 @@
+import typing
+from underautomation.fanuc.telnet.set_value_result import SetValueResult
+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 SetVariableResult as set_variable_result
+
+class SetVariableResult(SetValueResult):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = set_variable_result()
+		else:
+			self._instance = _internal

underautomation/fanuc/telnet/simulate_result.py

@@ -0,0 +1,13 @@
+import typing
+from underautomation.fanuc.telnet.base_result import BaseResult
+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 SimulateResult as simulate_result
+
+class SimulateResult(BaseResult):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = simulate_result()
+		else:
+			self._instance = _internal

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

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

underautomation/fanuc/telnet/task_information_result.py

@@ -0,0 +1,47 @@
+import typing
+from underautomation.fanuc.common.task_status import TaskStatus
+from underautomation.fanuc.common.program_type import ProgramType
+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 TaskInformationResult as task_information_result
+
+class TaskInformationResult(Result):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = task_information_result()
+		else:
+			self._instance = _internal
+	def __repr__(self):
+		return self._instance.ToString()
+	@property
+	def task_name(self) -> str:
+		return self._instance.TaskName
+	@property
+	def task_number(self) -> int:
+		return self._instance.TaskNumber
+	@property
+	def task_status_str(self) -> str:
+		return self._instance.TaskStatusStr
+	@property
+	def task_status(self) -> TaskStatus:
+		return TaskStatus(self._instance.TaskStatus)
+	@property
+	def routine_name(self) -> str:
+		return self._instance.RoutineName
+	@property
+	def current_line(self) -> int:
+		return self._instance.CurrentLine
+	@property
+	def program_type(self) -> ProgramType:
+		return ProgramType(self._instance.ProgramType)
+	@property
+	def hold_conditions(self) -> str:
+		return self._instance.HoldConditions
+	@property
+	def invisible_task(self) -> bool:
+		return self._instance.InvisibleTask
+	@property
+	def system_task(self) -> bool:
+		return self._instance.SystemTask

underautomation/fanuc/telnet/telnet_client.py

@@ -0,0 +1,15 @@
+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 import TelnetClient as telnet_client
+
+class TelnetClient(TelnetClientBase):
+	def __init__(self, _internal = 0):
+		if(_internal == 0):
+			self._instance = telnet_client()
+		else:
+			self._instance = _internal
+	def connect(self, ip: str, telnetKclPassword: str) -> None:
+		self._instance.Connect(ip, telnetKclPassword)

underautomation/fanuc/telnet/tp_coordinates.py

@@ -0,0 +1,12 @@
+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 TpCoordinates as tp_coordinates
+
+class TpCoordinates(int):
+	Unknown = tp_coordinates.Unknown
+	Tool = tp_coordinates.Tool
+	User = tp_coordinates.User
+	Joint = tp_coordinates.Joint
+	JogFrame = tp_coordinates.JogFrame
+	World = tp_coordinates.World