# Copyright 2011-2020 Wason Technology, LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import absolute_import, print_function from . import RobotRaconteurPython from .RobotRaconteurPythonDataTypes import * from . import RobotRaconteurPythonError import operator import traceback import threading import functools import sys import warnings import weakref import codecs import numbers import os from RobotRaconteur.RobotRaconteurPython import DataTypes_ContainerTypes_generator import numpy import itertools if (sys.version_info > (3, 0)): from builtins import property from functools import reduce else: from __builtin__ import property import numpy if (sys.version_info > (3, 5)): import asyncio # cSpell: ignore subdtype, ascontiguousarray, odef, outerm, innerep, rrmultidim, rrinnerstub # cSpell: ignore destrrarray, innerw, outerw, tdims _traceback_requested = str(os.environ.get('ROBOTRACONTEUR_PYTHON_TRACEBACK_PRINT_EXC', "0") ).lower() in ("1", "true", "yes", "on") def _print_exc_traceback(exc): if _traceback_requested: print("RobotRaconteurPython async caught exception:", file=sys.stderr) traceback.print_exception(exc, file=sys.stderr) def SplitQualifiedName(name): pos = name.rfind('.') if (pos == -1): raise Exception("Name is not qualified") return (name[0:pos], name[pos + 1:]) def FindStructureByName(l, name): for i in l: if (i.Name == name): return i raise RobotRaconteurPythonError.ServiceException( "Structure " + name + " not found") def FindMemberByName(l, name): for i in l: if (i.Name == name): return i raise RobotRaconteurPythonError.MemberNotFoundException( "Member " + name + " not found") def FindMessageElementByName(l, name): return RobotRaconteurPython.MessageElement.FindElement(l, name) def PackMessageElement(data, type1, obj=None, node=None): if (hasattr(obj, 'rrinnerstub')): obj = obj.rrinnerstub if (isinstance(type1, str)): if (len(type1.split()) == 1): type1 = type1 + " value" type2 = RobotRaconteurPython.TypeDefinition() type2.FromString(type1) type1 = type2 return RobotRaconteurPython._PackMessageElement(data, type1, obj, node) def UnpackMessageElement(element, type1=None, obj=None, node=None): if (hasattr(obj, 'rrinnerstub')): obj = obj.rrinnerstub if (not type1 is None): if (isinstance(type1, str)): if (len(type1.split()) == 1): type1 = type1 + " value" type2 = RobotRaconteurPython.TypeDefinition() type2.FromString(type1) type1 = type2 return RobotRaconteurPython._UnpackMessageElement(element, type1, obj, node) def PackToRRArray(array, type1, destrrarray=None): return RobotRaconteurPython._PackToRRArray(array, type1, destrrarray) def UnpackFromRRArray(rrarray, type1=None): if (rrarray is None): return None return RobotRaconteurPython._UnpackFromRRArray(rrarray, type1) def CreateStructureType(name, dict_): def struct_init(s): for k, v in dict_.items(): init_type, init_args = v if init_type is None: setattr(s, k, None) else: setattr(s, k, init_type(*init_args)) slots = list(dict_.keys()) return type(name, (RobotRaconteurStructure,), {'__init__': struct_init, "__slots__": slots}) def CreateZeroArray(dtype, dims): if dims is None: return numpy.zeros((0,), dtype) else: return numpy.zeros(dims, dtype) def NewStructure(StructType, obj=None, node=None): if (hasattr(obj, 'rrinnerstub')): obj = obj.rrinnerstub return RobotRaconteurPython._NewStructure(StructType, obj, node) def GetStructureType(StructType, obj=None, node=None): if (hasattr(obj, 'rrinnerstub')): obj = obj.rrinnerstub return RobotRaconteurPython._GetStructureType(StructType, obj, node) def GetPodDType(pod_type, obj=None, node=None): if (hasattr(obj, 'rrinnerstub')): obj = obj.rrinnerstub return RobotRaconteurPython._GetNumPyDescrForType(pod_type, obj, node) def GetNamedArrayDType(namedarray_type, obj=None, node=None): if (hasattr(obj, 'rrinnerstub')): obj = obj.rrinnerstub return RobotRaconteurPython._GetNumPyDescrForType(namedarray_type, obj, node) def GetPrimitiveDTypeFromNamedArrayDType(dt): prim_dt = None count = 0 for dt_i in dt.fields.values(): if len(dt_i[0].shape) == 0: prim_dt_i = dt_i[0].type dt_i_2 = dt_i[0] count_i = 1 else: prim_dt_i = dt_i[0].subdtype[0].type dt_i_2 = dt_i[0].subdtype[0] count_i = dt_i[0].shape[0] if (prim_dt_i == numpy.void): prim_dt_i, n = GetPrimitiveDTypeFromNamedArrayDType(dt_i_2) count_i *= n if prim_dt is None: prim_dt = prim_dt_i else: assert prim_dt == prim_dt_i count += count_i return prim_dt, count def NamedArrayToArray(named_array): prim_dt, _ = GetPrimitiveDTypeFromNamedArrayDType(named_array.dtype) a = numpy.ascontiguousarray(named_array.reshape(named_array.shape + (1,))) return a.view(prim_dt) def ArrayToNamedArray(a, named_array_dt): prim_dt, elem_count = GetPrimitiveDTypeFromNamedArrayDType(named_array_dt) a = numpy.ascontiguousarray(a) assert a.dtype == prim_dt, "Array type must match named array element type" assert a.shape[-1] == elem_count, "Last dimension must match named array size" b = a.view(named_array_dt) if len(b.shape) > 1 and b.shape[-1] == 1: return b.reshape(a.shape[0:-1], order="C") return b _init_stub_lock = threading.Lock() def InitStub(stub): with _init_stub_lock: old_stub = stub.GetPyStub() if (old_stub is not None): return old_stub odef = stub.RR_objecttype mdict = {} for i in range(len(odef.Members)): m = odef.Members[i] if (isinstance(m, RobotRaconteurPython.PropertyDefinition)): def inner_prop(m1): def fget(self): return stub_getproperty(stub, m1.Name, m1) def fset(self, value): return stub_setproperty( stub, m1.Name, m1, value) return property(fget, fset) p1 = inner_prop(m) mdict[m.Name] = p1 def inner_async_prop(m1): def fget(self, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): return stub_async_getproperty( stub, m1.Name, m1, handler, timeout) def fset(self, value, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): return stub_async_setproperty( stub, m1.Name, m1, value, handler, timeout) return fget, fset p1_async = inner_async_prop(m) mdict['async_get_' + m.Name] = p1_async[0] mdict['async_set_' + m.Name] = p1_async[1] if (isinstance(m, RobotRaconteurPython.FunctionDefinition)): def inner_func(m1): if (not m1.IsGenerator()): if (m1.ReturnType.Type == RobotRaconteurPython.DataTypes_void_t): f = lambda self, * \ args: stub_functioncallvoid( stub, m1.Name, m1, *args) else: f = lambda self, * \ args: stub_functioncall(stub, m1.Name, m1, *args) return f else: return lambda self, *args: stub_functioncallgenerator(stub, m1.Name, m1, *args) f1 = inner_func(m) mdict[m.Name] = f1 def inner_async_func(m1): if not m1.IsGenerator(): if (m1.ReturnType.Type == RobotRaconteurPython.DataTypes_void_t): f = lambda self, * \ args: stub_async_functioncallvoid( stub, m1.Name, m1, *args) else: f = lambda self, * \ args: stub_async_functioncall( stub, m1.Name, m1, *args) return f else: return lambda self, *args: stub_async_functioncallgenerator(stub, m1.Name, m1, *args) f1_async = inner_async_func(m) mdict['async_' + m.Name] = f1_async if (isinstance(m, RobotRaconteurPython.EventDefinition)): def new_evt_hook(): evt = EventHook() def fget(self): return evt def fset(self, value): if (value is not evt): raise RuntimeError("Invalid operation") return property(fget, fset) mdict[m.Name] = new_evt_hook() if (isinstance(m, RobotRaconteurPython.ObjRefDefinition)): def inner_objref(m1): if (m1.ArrayType != RobotRaconteurPython.DataTypes_ArrayTypes_none or m1.ContainerType != RobotRaconteurPython.DataTypes_ContainerTypes_none): def f(self, index): return stub_objref( stub, m1.Name, index) else: def f(self): return stub_objref(stub, m1.Name) return f f1 = inner_objref(m) mdict['get_%s' % m.Name] = f1 def inner_async_objref(m1): if (m1.ArrayType != RobotRaconteurPython.DataTypes_ArrayTypes_none or m1.ContainerType != RobotRaconteurPython.DataTypes_ContainerTypes_none): def f(self, index, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): return stub_async_objref( stub, m1.Name, index, handler, timeout) else: def f(self, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): return stub_async_objref( stub, m1.Name, None, handler, timeout) return f f1 = inner_async_objref(m) mdict['async_get_%s' % m.Name] = f1 if (isinstance(m, RobotRaconteurPython.PipeDefinition)): def inner_pipe(m1): innerp = stub.GetPipe(m1.Name) outerp = Pipe(innerp) def fget(self): return outerp return property(fget) p2 = inner_pipe(m) mdict[m.Name] = p2 if (isinstance(m, RobotRaconteurPython.CallbackDefinition)): def new_cb_client(): cb = CallbackClient() def fget(self): return cb return property(fget) mdict[m.Name] = new_cb_client() if (isinstance(m, RobotRaconteurPython.WireDefinition)): def inner_wire(m1): innerw = stub.GetWire(m1.Name) outerw = Wire(innerw) def fget(self): return outerw return property(fget) w = inner_wire(m) mdict[m.Name] = w if (isinstance(m, RobotRaconteurPython.MemoryDefinition)): if (RobotRaconteurPython.IsTypeNumeric(m.Type.Type)): def inner_memory(m1): if (m.Type.ArrayType == RobotRaconteurPython.DataTypes_ArrayTypes_array): outerm = ArrayMemoryClient( stub.GetArrayMemory(m1.Name)) else: outerm = MultiDimArrayMemoryClient( stub.GetMultiDimArrayMemory(m1.Name)) def fget(self): return outerm return property(fget) mem = inner_memory(m) mdict[m.Name] = mem else: memory_rr_type = RobotRaconteurPython._GetNamedTypeEntryType( m.Type, stub, stub.RRGetNode()) if (memory_rr_type == RobotRaconteurPython.DataTypes_pod_t): def inner_memory(m1): if (m.Type.ArrayType == RobotRaconteurPython.DataTypes_ArrayTypes_array): pass outerm = PodArrayMemoryClient(stub.GetPodArrayMemory( m1.Name), m.Type, stub, stub.RRGetNode()) else: outerm = PodMultiDimArrayMemoryClient( stub.GetPodMultiDimArrayMemory(m1.Name), m.Type, stub, stub.RRGetNode()) pass def fget(self): return outerm return property(fget) mem = inner_memory(m) mdict[m.Name] = mem elif (memory_rr_type == RobotRaconteurPython.DataTypes_namedarray_t): def inner_memory(m1): if (m.Type.ArrayType == RobotRaconteurPython.DataTypes_ArrayTypes_array): pass outerm = NamedArrayMemoryClient(stub.GetNamedArrayMemory( m1.Name), m.Type, stub, stub.RRGetNode()) else: outerm = NamedMultiDimArrayMemoryClient( stub.GetNamedMultiDimArrayMemory(m1.Name), m.Type, stub, stub.RRGetNode()) pass def fget(self): return outerm return property(fget) mem = inner_memory(m) mdict[m.Name] = mem else: assert False mdict["__slots__"] = ["rrinnerstub", "rrlock"] outerstub_type = type(str(odef.Name), (ServiceStub,), mdict) outerstub = outerstub_type() for i in range(len(odef.Members)): m = odef.Members[i] if (isinstance(m, RobotRaconteurPython.PipeDefinition)): p = getattr(outerstub, m.Name) p._obj = outerstub if (isinstance(m, RobotRaconteurPython.WireDefinition)): w = getattr(outerstub, m.Name) w._obj = outerstub director = WrappedServiceStubDirectorPython(outerstub, stub) stub.SetRRDirector(director, 0) director_lock = stub.GetRRDirectorLock() try: if director_lock.valid(): director.__disown__() finally: del director_lock stub.SetPyStub(outerstub) outerstub.rrinnerstub = stub outerstub.rrlock = threading.RLock() return outerstub def check_member_args(name, param_types, args, isasync=False): expected_args_len = len(param_types) if isasync: expected_args_len += 1 if len(param_types) > 0 and param_types[-1].ContainerType == RobotRaconteurPython.DataTypes_ContainerTypes_generator: expected_args_len -= 1 if (expected_args_len != len(args)) and not (isasync and expected_args_len + 1 == len(args)): raise TypeError("%s() expects exactly %d arguments (%d given)" % ( name, expected_args_len, len(args))) def stub_getproperty(stub, name, type1): return UnpackMessageElement(stub.PropertyGet(name), type1.Type, stub, stub.RRGetNode()) def stub_setproperty(stub, name, type1, value): pvalue = PackMessageElement(value, type1.Type, stub, stub.RRGetNode()) stub.PropertySet(name, pvalue) def stub_functioncall(stub, name, type1, *args): check_member_args(name, type1.Parameters, args) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 for p in type1.Parameters: a = PackMessageElement(args[i], p, stub, stub.RRGetNode()) a.ElementName = p.Name m.append(a) i += 1 ret = stub.FunctionCall(name, m) return UnpackMessageElement(ret, type1.ReturnType, stub, stub.RRGetNode()) def stub_functioncallvoid(stub, name, type1, *args): check_member_args(name, type1.Parameters, args) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 for p in type1.Parameters: a = PackMessageElement(args[i], p, stub) a.ElementName = p.Name m.append(a) i += 1 stub.FunctionCall(name, m) def stub_functioncallgenerator(stub, name, type1, *args): check_member_args(name, type1.Parameters, args) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 param_type = None for p in type1.Parameters: if (p.ContainerType != RobotRaconteurPython.DataTypes_ContainerTypes_generator): a = PackMessageElement(args[i], p, stub) a.ElementName = p.Name m.append(a) i += 1 else: param_type = p return GeneratorClient(stub.GeneratorFunctionCall(name, m), type1.ReturnType, param_type, stub, stub.RRGetNode()) class AsyncRequestDirectorImpl(RobotRaconteurPython.AsyncRequestDirector): def __init__(self, handler, isvoid, Type, stub, node): super(AsyncRequestDirectorImpl, self).__init__() self._handler = handler self._isvoid = isvoid self._Type = Type self._node = node self._stub = stub def handler(self, m, error_info): if (self._isvoid): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(err) return else: self._handler(None) else: if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(None, err) return else: try: a = UnpackMessageElement( m, self._Type, self._stub, self._node) except Exception as err: self._handler(None, err) return self._handler(a, None) return def stub_async_getproperty(stub, name, type1, handler, timeout=-1): return async_call(stub.async_PropertyGet, (name, adjust_timeout(timeout)), AsyncRequestDirectorImpl, handler, directorargs=(False, type1.Type, stub, stub.RRGetNode())) def stub_async_setproperty(stub, name, type1, value, handler, timeout=-1): pvalue = PackMessageElement(value, type1.Type, stub) return async_call(stub.async_PropertySet, (name, pvalue, adjust_timeout(timeout)), AsyncRequestDirectorImpl, handler, directorargs=(True, type1.Type, stub, stub.RRGetNode())) def stub_async_functioncall(stub, name, type1, *args): check_member_args(name, type1.Parameters, args, True) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 for p in type1.Parameters: a = PackMessageElement(args[i], p, stub) a.ElementName = p.Name m.append(a) i += 1 handler = args[i] if (len(args) > i + 1): timeout = args[i + 1] else: timeout = RobotRaconteurPython.RR_TIMEOUT_INFINITE return async_call(stub.async_FunctionCall, (name, m, adjust_timeout(timeout)), AsyncRequestDirectorImpl, handler, directorargs=(False, type1.ReturnType, stub, stub.RRGetNode())) def stub_async_functioncallvoid(stub, name, type1, *args): check_member_args(name, type1.Parameters, args, True) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 for p in type1.Parameters: a = PackMessageElement(args[i], p, stub) a.ElementName = p.Name m.append(a) i += 1 handler = args[i] if (len(args) > i + 1): timeout = args[i + 1] else: timeout = -1 return async_call(stub.async_FunctionCall, (name, m, adjust_timeout(timeout)), AsyncRequestDirectorImpl, handler, directorargs=(True, type1.ReturnType, stub, stub.RRGetNode())) def stub_async_functioncallgenerator(stub, name, type1, *args): check_member_args(name, type1.Parameters, args, True) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 param_type = None for p in type1.Parameters: if (p.ContainerType != RobotRaconteurPython.DataTypes_ContainerTypes_generator): a = PackMessageElement(args[i], p, stub) a.ElementName = p.Name m.append(a) i += 1 else: param_type = p handler = args[i] if (len(args) > i + 1): timeout = args[i + 1] else: timeout = RobotRaconteurPython.RR_TIMEOUT_INFINITE return async_call(stub.async_GeneratorFunctionCall, (name, m, adjust_timeout(timeout)), AsyncGeneratorClientReturnDirectorImpl, handler, directorargs=(type1.ReturnType, param_type, stub, stub.RRGetNode())) _stub_objref_lock = threading.Lock() def stub_objref(stub, name, index=None): if (index is None): s = stub.FindObjRef(name) with _stub_objref_lock: s2 = s.GetPyStub() if (s2 is not None): return s2 return InitStub(s) return else: s = stub.FindObjRef(name, str(index)) with _stub_objref_lock: s2 = s.GetPyStub() if (s2 is not None): return s2 return InitStub(s) def stub_async_objref(stub, name, index, handler, timeout=-1): if (index is None): return async_call(stub.async_FindObjRef, (name, adjust_timeout(timeout)), AsyncStubReturnDirectorImpl, handler) else: return async_call(stub.async_FindObjRef, (name, str(index), adjust_timeout(timeout)), AsyncStubReturnDirectorImpl, handler) class WrappedServiceStubDirectorPython(RobotRaconteurPython.WrappedServiceStubDirector): def __init__(self, stub, innerstub): self.stub = stub self.innerstub = innerstub super(WrappedServiceStubDirectorPython, self).__init__() def DispatchEvent(self, name, args1): try: type1 = FindMemberByName( self.innerstub.RR_objecttype.Members, name) # type1=[e for e in self.innerstub.RR_objecttype.Members if e.Name == name][0] args = [] type2 = RobotRaconteurPython.MemberDefinitionUtil.ToEvent(type1) for p in type2.Parameters: m = FindMessageElementByName(args1, p.Name) a = UnpackMessageElement( m, p, self.stub, node=self.innerstub.RRGetNode()) args.append(a) getattr(self.stub, name).fire(*args) except: traceback.print_exc() def CallbackCall(self, name, args1): try: type1 = FindMemberByName( self.innerstub.RR_objecttype.Members, name) # type1=[e for e in self.innerstub.RR_objecttype.Members if e.Name == name][0] args = [] type2 = RobotRaconteurPython.MemberDefinitionUtil.ToCallback(type1) for p in type2.Parameters: m = FindMessageElementByName(args1, p.Name) a = UnpackMessageElement( m, p, self.stub, self.innerstub.RRGetNode()) args.append(a) ret = getattr(self.stub, name).Function(*args) if (ret is None): m = RobotRaconteurPython.MessageElement() m.ElementName = "return" m.ElementType = RobotRaconteurPython.DataTypes_void_t return m return PackMessageElement(ret, type2.ReturnType, self.stub, self.innerstub.RRGetNode()) except: traceback.print_exc() class ServiceStub(object): __slots__ = ["rrinnerstub", "rrlock", "__weakref__"] def RRGetNode(self): return self.rrinnerstub.RRGetNode() class CallbackClient(object): __slots__ = ["Function", "__weakref__"] def __init__(self): self.Function = None class PipeEndpoint(object): """ PipeEndpoint() Pipe endpoint used to transmit reliable or unreliable data streams Pipe endpoints are used to communicate data between connected pipe members. See Pipe for more information on pipe members. Pipe endpoints are created by clients using the Pipe.Connect() or Pipe.AsyncConnect() functions. Services receive incoming pipe endpoint connection requests through a callback function specified using the Pipe.PipeConnectCallback property. Services may also use the PipeBroadcaster class to automate managing pipe endpoint lifecycles and sending packets to all connected client endpoints. Pipe endpoints are *indexed*, meaning that more than one pipe endpoint pair can be created using the same member. This means that multiple data streams can be created independent of each other between the client and service using the same member. Pipes send reliable packet streams between connected client/service endpoint pairs. Packets are sent using the SendPacket() or AsyncSendPacket() functions. Packets are read from the receive queue using the ReceivePacket(), ReceivePacketWait(), TryReceivePacketWait(), TryReceivePacketWait(), or PeekNextPacket(). The endpoint is closed using the Close() or AsyncClose() function. This class is instantiated by the Pipe class. It should not be instantiated by the user. """ __slots__ = ["__innerpipe", "__type", "PipeEndpointClosedCallback", "_PacketReceivedEvent", "_PacketAckReceivedEvent", "__obj", "__weakref__"] def __init__(self, innerpipe, type, obj=None): self.__innerpipe = innerpipe self.__type = type self.PipeEndpointClosedCallback = None """ (Callable[[RobotRaconteur.PipeEndpoint],None]) The function to invoke when the pipe endpoint has been closed. """ self._PacketReceivedEvent = EventHook() self._PacketAckReceivedEvent = EventHook() self.__obj = obj @property def Index(self): """ The pipe endpoint index used when endpoint connected :rtype: int """ return self.__innerpipe.GetIndex() @property def Endpoint(self): """ the endpoint associated with the ClientContext or ServerEndpoint associated with the pipe endpoint. :rtype: int """ return self.__innerpipe.GetEndpoint() @property def Available(self): """ Return number of packets in the receive queue Invalid for *writeonly* pipes. :rtype: int """ return self.__innerpipe.Available() @property def IsUnreliable(self): """ Get if pipe endpoint is unreliable Pipe members may be declared as *unreliable* using member modifiers in the service definition. Pipes confirm unreliable operation when pipe endpoints are connected. :rtype: bool """ return self.__innerpipe.IsUnreliable() @property def Direction(self): """ The direction of the pipe Pipes may be declared "readonly" or "writeonly" in the service definition file. (If neither is specified, the pipe is assumed to be full duplex.) "readonly" pipes may only send packets from service to client. "writeonly" pipes may only send packets from client to service. See ``MemberDefinition_Direction`` constants for possible return values. :rtype: int """ return self.__innerpipe.Direction() @property def RequestPacketAck(self): """ Get if pipe endpoint should request packet acks Packet acks are generated by receiving endpoints to inform the sender that a packet has been received. The ack contains the packet index, the sequence number of the packet. Packet acks are used for flow control by PipeBroadcaster. :rtype: bool """ return self.__innerpipe.GetRequestPacketAck() @RequestPacketAck.setter def RequestPacketAck(self, value): self.__innerpipe.SetRequestPacketAck(value) @property def IgnoreReceived(self): """ Set if pipe endpoint is ignoring incoming packets If true, pipe endpoint is ignoring incoming packets and is not adding incoming packets to the receive queue. :rtype: bool """ return self.__innerpipe.GetIgnoreReceived() @IgnoreReceived.setter def IgnoreReceived(self, value): self.__innerpipe.SetIgnoreReceived(value) def Close(self): """ Close the pipe endpoint Close the pipe endpoint. Blocks until close complete. The peer endpoint is destroyed automatically. """ return self.__innerpipe.Close() def AsyncClose(self, handler, timeout=2): """ Asynchronously close the pipe endpoint Same as Close() but returns asynchronously If ``handler`` is None, returns an awaitable future. :param handler: A handler function to call on completion, possibly with an exception :type handler: Callable[[Exception],None] :param timeout: Timeout in seconds, or -1 for no timeout :type timeout: float """ return async_call(self.__innerpipe.AsyncClose, (adjust_timeout(timeout),), AsyncVoidReturnDirectorImpl, handler) def SendPacket(self, packet): """ Sends a packet to the peer endpoint Sends a packet to the peer endpoint. If the pipe is reliable, the packetsare guaranteed to arrive in order. If the pipe is set to unreliable, "best effort" is made to deliver packets, and they are not guaranteed to arrive in order. This function will block until the packet has been transmitted by the transport. It will return before the peer endpoint has received the packet. :param packet: The packet to send :return: The packet number of the sent packet :rtype: int """ m = PackMessageElement(packet, self.__type, self.__obj, self.__innerpipe.GetNode()) return self.__innerpipe.SendPacket(m) def AsyncSendPacket(self, packet, handler): """ Send a packet to the peer endpoint asynchronously Same as SendPacket(), but returns asynchronously. If ``handler`` is None, returns an awaitable future. :param packet: The packet to send :param handler: A handler function to receive the sent packet number or an exception :type handler: Callable[[Exception],None] """ m = PackMessageElement(packet, self.__type, self.__obj, self.__innerpipe.GetNode()) return async_call(self.__innerpipe.AsyncSendPacket, (m,), AsyncUInt32ReturnDirectorImpl, handler) def ReceivePacket(self): """ Receive the next packet in the receive queue Receive the next packet from the receive queue. This function will throw an InvalidOperationException if there are no packets in the receive queue. Use ReceivePacketWait() to block until a packet has been received. :return: The received packet """ m = self.__innerpipe.ReceivePacket() return UnpackMessageElement(m, self.__type, self.__obj, self.__innerpipe.GetNode()) def PeekNextPacket(self): """ Peeks the next packet in the receive queue Returns the first packet in the receive queue, but does not remove it from the queue. Throws an InvalidOperationException if there are no packets in the receive queue. :return: The next packet in the receive queue """ m = self.__innerpipe.PeekNextPacket() return UnpackMessageElement(m, self.__type, self.__obj, self.__innerpipe.GetNode()) def ReceivePacketWait(self, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): """ Receive the next packet in the receive queue, block if queue is empty Same as ReceivePacket(), but blocks if queue is empty :param timeout: Timeout in seconds to wait for a packet, or -1 for infinite :type timeout: float :return: The received packet """ m = self.__innerpipe.ReceivePacketWait(adjust_timeout(timeout)) return UnpackMessageElement(m, self.__type, self.__obj, self.__innerpipe.GetNode()) def PeekNextPacketWait(self, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): """ Peek the next packet in the receive queue, block if queue is empty Same as PeekPacket(), but blocks if queue is empty :param timeout: Timeout in seconds to wait for a packet, or -1 for infinite :return: The received packet """ m = self.__innerpipe.PeekNextPacketWait(adjust_timeout(timeout)) return UnpackMessageElement(m, self.__type, self.__obj, self.__innerpipe.GetNode()) def TryReceivePacketWait(self, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE, peek=False): """ Try receiving a packet, optionally blocking if the queue is empty Try receiving a packet with various options. Returns True if a packet has been received, or False if no packet is available instead of throwing an exception on failure. The timeout and peek parameters can be used to modify behavior to provide functionality similar to the various Receive and Peek functions. :param timeout: The timeout in seconds. Set to zero for non-blocking operation, an arbitrary value in seconds for a finite duration timeout, or -1 for infinite :type timeout: float :param peek: If true, the packet is not removed from the receive queue :type peek: bool :return: Tuple of success and received packet :rtype: Tuple[bool,T] """ m = RobotRaconteurPython.MessageElement() r = self.__innerpipe.TryReceivePacketWait( m, adjust_timeout(timeout), peek) return (r, UnpackMessageElement(m, self.__type, self.__obj, self.__innerpipe.GetNode())) @property def PacketReceivedEvent(self): """ Event hook for received packets. Use to add handlers to be called when packets are received by the endpoint. .. code-block:: python def my_handler(ep): # Receive packets while ep.Available > 0: packet = ep.ReceivePacket() # Do something with packet my_endpoint.PacketReceivedEvent += my_handler Handler must have signature ``Callable[[RobotRaconteur.PipeEndpoint],None]`` """ return self._PacketReceivedEvent @PacketReceivedEvent.setter def PacketReceivedEvent(self, evt): if (evt is not self._PacketReceivedEvent): raise RuntimeError("Invalid operation") @property def PacketAckReceivedEvent(self): """ Event hook for received packets. Use to add handlers to be called when packets are received by the endpoint. .. code-block:: python def my_ack_handler(ep, packet_num): # Do something with packet_num info pass my_endpoint.PacketAckReceivedEvent += my_ack_handler Handler must have signature ``Callable[[RobotRaconteur.PipeEndpoint,T],None]`` """ return self._PacketAckReceivedEvent @PacketAckReceivedEvent.setter def PacketAckReceivedEvent(self, evt): if (evt is not self._PacketAckReceivedEvent): raise RuntimeError("Invalid operation") def GetNode(self): return self.__innerpipe.GetNode() class PipeEndpointDirector(RobotRaconteurPython.WrappedPipeEndpointDirector): def __init__(self, endpoint): self.__endpoint = endpoint super(PipeEndpointDirector, self).__init__() def PipeEndpointClosedCallback(self): if (not self.__endpoint.PipeEndpointClosedCallback is None): self.__endpoint.PipeEndpointClosedCallback(self.__endpoint) def PacketReceivedEvent(self): self.__endpoint.PacketReceivedEvent.fire(self.__endpoint) def PacketAckReceivedEvent(self, packetnum): self.__endpoint.PacketAckReceivedEvent.fire(self.__endpoint, packetnum) class PipeAsyncConnectHandlerImpl(RobotRaconteurPython.AsyncPipeEndpointReturnDirector): def __init__(self, handler, innerpipe, obj): super(PipeAsyncConnectHandlerImpl, self).__init__() self._handler = handler self.__innerpipe = innerpipe self.__obj = obj def handler(self, innerendpoint, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(None, err) return try: outerendpoint = PipeEndpoint( innerendpoint, self.__innerpipe.Type, self.__obj) director = PipeEndpointDirector(outerendpoint) innerendpoint.SetRRDirector(director, 0) director.__disown__() except Exception as err2: self._handler(None, err2) return self._handler(outerendpoint, None) class Pipe(object): """ Pipe() "pipe" member type interface The Pipe class implements the "pipe" member type. Pipes are declared in service definition files using the "pipe" keyword within object declarations. Pipes provide reliable packet streaming between clients and services. They work by creating pipe endpoint pairs (peers), with one endpoint in the client, and one in the service. Packets are transmitted between endpoint pairs. Packets sent by one endpoint are received by the other, where they are placed in a receive queue. Received packets can then be retrieved from the receive queue. Pipe endpoints are created by the client using the Connect() or AsyncConnect() functions. Services receive incoming connection requests through a callback function. This callback is configured using the PipeConnectCallback property. Services may also use the PipeBroadcaster class to automate managing pipe endpoint lifecycles and sending packets to all connected client endpoints. If the PipeConnectCallback function is used, the service is responsible for keeping track of endpoints as the connect and disconnect. See PipeEndpoint for details on sending and receiving packets. Pipe endpoints are *indexed*, meaning that more than one endpoint pair can be created between the client and the service. Pipes may be *unreliable*, meaning that packets may arrive out of order or be dropped. Use IsUnreliable to check for unreliable pipes. The member modifier `unreliable` is used to specify that a pipe should be unreliable. Pipes may be declared *readonly* or *writeonly*. If neither is specified, the pipe is assumed to be full duplex. *readonly* pipes may only send packets from service to client. *writeonly* pipes may only send packets from client to service. Use Direction to determine the direction of the pipe. The PipeBroadcaster is often used to simplify the use of Pipes. See PipeBroadcaster for more information. This class is instantiated by the node. It should not be instantiated by the user. """ __slots__ = ["_innerpipe", "_obj", "__weakref__"] def __init__(self, innerpipe, obj=None): self._innerpipe = innerpipe self._obj = obj def Connect(self, index): """ Connect a pipe endpoint Creates a connected pipe endpoint pair, and returns the local endpoint. Use to create the streaming data connection to the service. Pipe endpoints are indexed, meaning that Connect() may be called multiple times for the same client connection to create multple pipe endpoint pairs. For most cases Pipe.ANY_INDEX (-1) can be used to automatically select an available index. Only valid on clients. Will throw InvalidOperationException on the service side. :param index: The index of the pipe endpoint, or -1 to automatically select an index :type index: int :return: The connected pipe endpoint :rtype: RobotRaconteur.PipeEndpoint """ innerendpoint = self._innerpipe.Connect(index) outerendpoint = PipeEndpoint( innerendpoint, self._innerpipe.Type, self._obj) director = PipeEndpointDirector(outerendpoint) innerendpoint.SetRRDirector(director, 0) director.__disown__() return outerendpoint def AsyncConnect(self, *args): """ AsyncConnect(index,handler,timeout=-1) Asynchronously connect a pipe endpoint. Same as Connect(), but returns asynchronously. Only valid on clients. Will throw InvalidOperationException on the service side. If ``handler`` is None, returns an awaitable future. :param index: The index of the pipe endpoint, or -1 to automatically select an index :type index: int :param handler: A handler function to receive the connected endpoint, or an exception :type handler: Callable[[PipeEndpoint,Exception],None] :param timeout: Timeout in seconds, or -1 for no timeout """ if (isinstance(args[0], numbers.Number)): index = args[0] handler = args[1] if (len(args) >= 3): timeout = args[2] else: timeout = RobotRaconteurPython.RR_TIMEOUT_INFINITE else: index = -1 handler = args[0] if (len(args) >= 2): timeout = args[1] else: timeout = RobotRaconteurPython.RR_TIMEOUT_INFINITE return async_call(self._innerpipe.AsyncConnect, (index, adjust_timeout(timeout)), PipeAsyncConnectHandlerImpl, handler, directorargs=(self._innerpipe, self._obj)) @property def MemberName(self): """ Get the member name of the pipe :rtype: str """ return self._innerpipe.GetMemberName() @property def Direction(self): """ The direction of the pipe Pipes may be declared "readonly" or "writeonly" in the service definition file. (If neither is specified, the pipe is assumed to be full duplex.) "readonly" pipes may only send packets from service to client. "writeonly" pipes may only send packets from client to service. See ``MemberDefinition_Direction`` constants for possible return values. :rtype: int """ return self._innerpipe.Direction() @property def PipeConnectCallback(self): """ Set the pipe endpoint connected callback function Callback function invoked when a client attempts to connect a pipe endpoint. The callback will receive the incoming pipe endpoint as a parameter. The service must maintain a reference to the pipe endpoint, but the pipe will retain ownership of the endpoint until it is closed. The callback may throw an exception to reject incoming connect request. Note: Connect callback is configured automatically by PipeBroadcaster Only valid for services. Will throw InvalidOperationException on the client side. :rtype: Callable[[PipeEndpoint],None] """ raise Exception("Read only property") @PipeConnectCallback.setter def PipeConnectCallback(self, c): wrappedp = WrappedPipeServerConnectDirectorPython( self, self._innerpipe.Type, c) self._innerpipe.SetWrappedPipeConnectCallback(wrappedp, 0) wrappedp.__disown__() def GetNode(self): return self._innerpipe.GetNode() class WrappedPipeServerConnectDirectorPython(RobotRaconteurPython.WrappedPipeServerConnectDirector): def __init__(self, pipe, type, callback): self.pipe = pipe self.type = type self.callback = callback super(WrappedPipeServerConnectDirectorPython, self).__init__() def PipeConnectCallback(self, innerendpoint): outerendpoint = PipeEndpoint(innerendpoint, self.type) director = PipeEndpointDirector(outerendpoint) innerendpoint.SetRRDirector(director, 0) director.__disown__() self.callback(outerendpoint) class WireConnection(object): """ WireConnection() Wire connection used to transmit "most recent" values Wire connections are used to transmit "most recent" values between connected wire members. See Wire for more information on wire members. Wire connections are created by clients using the Wire.Connect() or Wire.AsyncConnect() functions. Services receive incoming wire connection requests through a callback function specified using the Wire.WireConnectCallback property. Services may also use the WireBroadcaster class to automate managing wire connection lifecycles and sending values to all connected clients, or use WireUnicastReceiver to receive an incoming value from the most recently connected client. Wire connections are used to transmit "most recent" values between clients and services. Connection the wire creates a connection pair, one in the client, and one in the service. Each wire connection object has an InValue and an OutValue. Setting the OutValue of one will cause the specified value to be transmitted to the InValue of the peer. See Wire for more information. Values can optionally be specified to have a finite lifespan using InValueLifespan and OutValueLifespan. Lifespans can be used to prevent using old values that have not been recently updated. This class is instantiated by the Wire class. It should not be instantiated by the user. """ __slots__ = ["__innerwire", "__type", "WireConnectionClosedCallback", "_WireValueChanged", "__obj", "__weakref__"] def __init__(self, innerwire, type, obj=None): self.__innerwire = innerwire self.__type = type self.WireConnectionClosedCallback = None self._WireValueChanged = EventHook() self.__obj = obj @property def Endpoint(self): """ Get the Robot Raconteur node Endpoint ID Gets the endpoint associated with the ClientContext or ServerEndpoint associated with the wire connection. :rtype: int """ return self.__innerwire.GetEndpoint() @property def Direction(self): """ The direction of the wire Wires may be declared "readonly" or "writeonly" in the service definition file. (If neither is specified, the wire is assumed to be full duplex.) "readonly" wires may only send packets from service to client. "writeonly" wires may only send packets from client to service. See ``MemberDefinition_Direction`` constants for possible return values. :rtype: int """ return self.__innerwire.Direction() def Close(self): """ Close the wire connection Close the wire connection. Blocks until close complete. The peer wire connection is destroyed automatically. """ return self.__innerwire.Close() def AsyncClose(self, handler, timeout=2): """ Asynchronously close the wire connection Same as Close() but returns asynchronously :param handler: A handler function to call on completion, possibly with an exception :type handler: Callable[[Exception],None] :param timeout: Timeout in seconds, or -1 for infinite :type timeout: float """ return async_call(self.__innerwire.AsyncClose, (adjust_timeout(timeout),), AsyncVoidReturnDirectorImpl, handler) @property def InValue(self): """ Get the current InValue Gets the current InValue that was transmitted from the peer. Throws ValueNotSetException if no value has been received, or the most recent value lifespan has expired. """ m = self.__innerwire.GetInValue() return UnpackMessageElement(m, self.__type, self.__obj, self.__innerwire.GetNode()) @property def OutValue(self): """ Set the OutValue and transmit to the peer connection Sets the OutValue for the wire connection. The specified value will be transmitted to the peer, and will become the peers InValue. The transmission is unreliable, meaning that values may be dropped if newer values arrive. The most recent OutValue may also be read through this property. """ m = self.__innerwire.GetOutValue() return UnpackMessageElement(m, self.__type, self.__obj, self.__innerwire.GetNode()) @OutValue.setter def OutValue(self, value): m = PackMessageElement( value, self.__type, self.__obj, self.__innerwire.GetNode()) return self.__innerwire.SetOutValue(m) @property def LastValueReceivedTime(self): """ Get the timestamp of the last received value Returns the timestamp of the value in the *senders* clock :rtype: RobotRaconteur.TimeSpec """ return self.__innerwire.GetLastValueReceivedTime() @property def LastValueSentTime(self): """ Get the timestamp of the last sent value Returns the timestamp of the last sent value in the *local* clock :rtype: RobotRaconteur.TimeSpec """ return self.__innerwire.GetLastValueSentTime() @property def InValueValid(self): """ Get if the InValue is valid The InValue is valid if a value has been received and the value has not expired :rtype: bool """ return self.__innerwire.GetInValueValid() @property def OutValueValid(self): """ Get if the OutValue is valid The OutValue is valid if a value has been set using the OutValue property :rtype: bool """ return self.__innerwire.GetOutValueValid() @property def IgnoreInValue(self): """ Set whether wire connection should ignore incoming values Wire connections may optionally desire to ignore incoming values. This is useful if the connection is only being used to send out values, and received values may create a potential memory . If ignore is true, incoming values will be discarded. :rtype: bool """ return self.__innerwire.GetIgnoreInValue() @IgnoreInValue.setter def IgnoreInValue(self, value): self.__innerwire.SetIgnoreInValue(value) def TryGetInValue(self): """ Try getting the InValue, returning true on success or false on failure Get the current InValue and InValue timestamp. Return true or false on success or failure instead of throwing exception. :return: Tuple of success, in value, and timespec :rtype: Tuple[bool,T,RobotRaconteur.TimeSpec] """ res = self.__innerwire.TryGetInValue() if not res.res: return (False, None, None) return (True, UnpackMessageElement(res.value, self.__type, self.__obj, self.__innerwire.GetNode()), res.ts) def TryGetOutValue(self): """ Try getting the OutValue, returning true on success or false on failure Get the current OutValue and OutValue timestamp. Return true or false on success and failure instead of throwing exception. :return: Tuple of success, out value, and timespec :rtype: Tuple[bool,T,RobotRaconteur.TimeSpec] """ res = self.__innerwire.TryGetOutValue() if not res.res: return (False, None, None) return (True, UnpackMessageElement(res.value, self.__type, self.__obj, self.__innerwire.GetNode()), res.ts) def WaitInValueValid(self, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): """ Waits for InValue to be valid Blocks the current thread until InValue is valid, with an optional timeout. Returns true if InValue is valid, or false if timeout occurred. :param timeout: Timeout in seconds, or -1 for infinite :return: Value is valid :rtype: bool """ return self.__innerwire.WaitInValueValid(adjust_timeout(timeout)) def WaitOutValueValid(self, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): """ Waits for OutValue to be valid Blocks the current thread until OutValue is valid, with an optional timeout. Returns true if OutValue is valid, or false if timeout occurred. :param timeout: Timeout in seconds, or -1 for infinite :return: Value is valid :rtype: bool """ return self.__innerwire.WaitOutValueValid(adjust_timeout(timeout)) @property def WireValueChanged(self): """ Event hook for wire value change. Use to add handlers to be called when the InValue changes. .. code-block:: python def my_handler(con, value, ts): # Handle new value pass my_wire_connection.WireValueChanged += my_handler Handler must have signature ``Callable[[RobotRaconteur.WireConnection,T,RobotRaconteur.TimeSpec],None]`` :rtype: RobotRaconteur.EventHook """ return self._WireValueChanged @WireValueChanged.setter def WireValueChanged(self, evt): if (evt is not self._WireValueChanged): raise RuntimeError("Invalid operation") @property def InValueLifespan(self): """ Set the lifespan of InValue InValue may optionally have a finite lifespan specified in seconds. Once the lifespan after reception has expired, the InValue is cleared and becomes invalid. Attempts to access InValue will result in ValueNotSetException. InValue lifespans may be used to avoid using a stale value received by the wire. If the lifespan is not set, the wire will continue to return the last received value, even if the value is old. Specify -1 for infinite lifespan. :rtype: float """ t = self.__innerwire.GetInValueLifespan() if t < 0: return t return float(t) / 1000.0 @InValueLifespan.setter def InValueLifespan(self, secs): if secs < 0: self.__innerwire.SetInValueLifespan(-1) else: self.__innerwire.SetInValueLifespan(int(secs * 1000.0)) @property def OutValueLifespan(self): """ Set the lifespan of OutValue OutValue may optionally have a finite lifespan specified in seconds. Once the lifespan after sending has expired, the OutValue is cleared and becomes invalid. Attempts to access OutValue will result in ValueNotSetException. OutValue lifespans may be used to avoid using a stale value sent by the wire. If the lifespan is not set, the wire will continue to return the last sent value, even if the value is old. Specify -1 for infinite lifespan. :rtype: float """ t = self.__innerwire.GetOutValueLifespan() if t < 0: return t return float(t) / 1000.0 @OutValueLifespan.setter def OutValueLifespan(self, secs): if secs < 0: self.__innerwire.SetOutValueLifespan(-1) else: self.__innerwire.SetOutValueLifespan(int(secs * 1000.0)) def GetNode(self): return self.__innerwire.GetNode() class WireConnectionDirector(RobotRaconteurPython.WrappedWireConnectionDirector): def __init__(self, endpoint, type, obj=None, innerep=None): self.__endpoint = endpoint self.__type = type self.__obj = obj self.__innerep = innerep super(WireConnectionDirector, self).__init__() def WireValueChanged(self, value, time): value2 = UnpackMessageElement( value, self.__type, self.__obj, self.__innerep.GetNode()) self.__endpoint.WireValueChanged.fire(self.__endpoint, value2, time) def WireConnectionClosedCallback(self): if (not self.__endpoint.WireConnectionClosedCallback is None): self.__endpoint.WireConnectionClosedCallback(self.__endpoint) class WireAsyncConnectHandlerImpl(RobotRaconteurPython.AsyncWireConnectionReturnDirector): def __init__(self, handler, innerpipe, obj): super(WireAsyncConnectHandlerImpl, self).__init__() self._handler = handler self.__innerpipe = innerpipe self.__obj = obj def handler(self, innerendpoint, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(None, err) return try: outerendpoint = WireConnection( innerendpoint, self.__innerpipe.Type, self.__obj) director = WireConnectionDirector( outerendpoint, self.__innerpipe.Type, self.__obj, innerendpoint) innerendpoint.SetRRDirector(director, 0) director.__disown__() except Exception as err2: self._handler(None, err2) return self._handler(outerendpoint, None) class WireAsyncPeekReturnDirectorImpl(RobotRaconteurPython.AsyncWirePeekReturnDirector): def __init__(self, handler, innerpipe, obj): super(WireAsyncPeekReturnDirectorImpl, self).__init__() self._handler = handler self.__innerpipe = innerpipe self.__obj = obj def handler(self, m, ts, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler((None, None), err) return value = UnpackMessageElement( m, self.__innerpipe.Type, self.__obj, self.__innerpipe.GetNode()) self._handler((value, ts), None) class WrappedWireServerPeekValueDirectorImpl(RobotRaconteurPython.WrappedWireServerPeekValueDirector): def __init__(self, cb, innerpipe, obj): super(WrappedWireServerPeekValueDirectorImpl, self).__init__() self._cb = cb self.__innerpipe = innerpipe self.__obj = obj def PeekValue(self, ep): value = self._cb(ep) m = PackMessageElement(value, self.__innerpipe.Type, self.__obj, self.__innerpipe.GetNode()) return m class WrappedWireServerPokeValueDirectorImpl(RobotRaconteurPython.WrappedWireServerPokeValueDirector): def __init__(self, cb, innerpipe, obj): super(WrappedWireServerPokeValueDirectorImpl, self).__init__() self._cb = cb self.__innerpipe = innerpipe self.__obj = obj def PokeValue(self, m, ts, ep): value = UnpackMessageElement( m, self.__innerpipe.Type, self.__obj, self.__innerpipe.GetNode()) self._cb(value, ts, ep) class Wire(object): """ Wire() \"wire\" member type interface The Wire class implements the \"wire\" member type. Wires are declared in service definition files using the \"wire\" keyword within object declarations. Wires provide "most recent" value streaming between clients and services. They work by creating "connection" pairs between the client and service. The wire streams the current value between the wire connection pairs using packets. Wires are unreliable; only the most recent value is of interest, and any older values will be dropped. Wire connections have an InValue and an OutValue. Users set the OutValue on the connection. The new OutValue is transmitted to the peer wire connection, and becomes the peer's InValue. The peer can then read the InValue. The client and service have their own InValue and OutValue, meaning that each direction, client to service or service to client, has its own value. Wire connections are created using the Connect() or AsyncConnect() functions. Services receive incoming connection requests through a callback function. Thes callback is configured using the SetWireConnectCallback() function. Services may also use the WireBroadcaster class or WireUnicastReceiver class to automate managing wire connection lifecycles. WireBroadcaster is used to send values to all connected clients. WireUnicastReceiver is used to receive the value from the most recent wire connection. See WireConnection for details on sending and receiving streaming values. Wire clients may also optionally "peek" and "poke" the wire without forming a streaming connection. This is useful if the client needs to read the InValue or set the OutValue instantaniously, but does not need continuous updating. PeekInValue() or AsyncPeekInValue() will retrieve the client's current InValue. PokeOutValue() or AsyncPokeOutValue() will send a new client OutValue to the service. PeekOutValue() or AsyncPeekOutValue() will retrieve the last client OutValue received by the service. "Peek" and "poke" operations initiated by the client are received on the service using callbacks. Use PeekInValueCallback, PeekOutValueCallback, and PokeOutValueCallback to configure the callbacks to handle these requests. WireBroadcaster and WireUnicastReceiver configure these callbacks automatically, so the user does not need to configure the callbacks when these classes are used. Wires can be declared *readonly* or *writeonly*. If neither is specified, the wire is assumed to be full duplex. *readonly* pipes may only send values from service to client, ie OutValue on service side and InValue on client side. *writeonly* pipes may only send values from client to service, ie OutValue on client side and InValue on service side. Use Direction() to determine the direction of the wire. Unlike pipes, wire connections are not indexed, so only one connection pair can be created per client connection. WireBroadcaster or WireUnicastReceiver are typically used to simplify using wires. See WireBroadcaster and WireUnicastReceiver for more information. This class is instantiated by the node. It should not be instantiated by the user. """ __slots__ = ["_innerpipe", "_obj", "__weakref__"] def __init__(self, innerpipe, obj=None): self._innerpipe = innerpipe self._obj = obj def Connect(self): """ Connect the wire Creates a connection between the wire, returning the client connection. Used to create a "most recent" value streaming connection to the service. Only valid on clients. Will throw InvalidOperationException on the service side. Note: If a streaming connection is not required, use PeekInValue(), PeekOutValue(), or PokeOutValue() instead of creating a connection. :return: The wire connection :rtype: RobotRaconteur.WireConnection """ innerendpoint = self._innerpipe.Connect() outerendpoint = WireConnection( innerendpoint, self._innerpipe.Type, self._obj) director = WireConnectionDirector( outerendpoint, self._innerpipe.Type, self._obj, innerendpoint) innerendpoint.SetRRDirector(director, 0) director.__disown__() return outerendpoint def AsyncConnect(self, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): """ Asynchronously connect the wire Same as Connect(), but returns asynchronously Only valid on clients. Will throw InvalidOperationException on the service side. If ``handler`` is None, returns an awaitable future. :param handler: A handler function to receive the wire connection, or an exception :type handler: Callable[[RobotRaconteur.WireConnection,Exception],None] :param timeout: Timeout in seconds, or -1 for infinite """ return async_call(self._innerpipe.AsyncConnect, (adjust_timeout(timeout),), WireAsyncConnectHandlerImpl, handler, directorargs=(self._innerpipe, self._obj)) @property def MemberName(self): """ Get the member name of the wire :rtype: str """ return self._innerpipe.GetMemberName() @property def Direction(self): """ The direction of the wire Wires may be declared "readonly" or "writeonly" in the service definition file. (If neither is specified, the wire is assumed to be full duplex.) "readonly" wires may only send packets from service to client. "writeonly" wires may only send packets from client to service. See ``MemberDefinition_Direction`` constants for possible return values. :rtype: int """ return self._innerpipe.Direction() @property def WireConnectCallback(self): """ Set wire connected callback function Callback function invoked when a client attempts to connect a the wire. The callback will receive the incoming wire connection as a parameter. The service must maintain a reference to the wire connection, but the wire will retain ownership of the wire connection until it is closed. Using boost::weak_ptr to store the reference to the connection is recommended. The callback may throw an exception to reject incoming connect request. Note: Connect callback is configured automatically by WireBroadcaster or WireUnicastReceiver Only valid for services. Will throw InvalidOperationException on the client side. :rtype: Callable[[RobotRaconteur.WireConnection],None] """ raise Exception("Read only property") @WireConnectCallback.setter def WireConnectCallback(self, c): wrappedp = WrappedWireServerConnectDirectorPython( self, self._innerpipe.Type, c) self._innerpipe.SetWrappedWireConnectCallback(wrappedp, 0) wrappedp.__disown__() def PeekInValue(self): """ Peek the current InValue Peeks the current InValue using a "request" instead of a streaming value. Use if only the instantanouse value is required. Peek and poke are similar to "property" members. Unlike streaming, peek and poke are reliable operations. Throws ValueNotSetException if InValue is not valid. Only valid on clients. Will throw InvalidOperationException on the service side. :rtype: Tuple[T,RobotRaconteur.TimeSpec] """ ts = RobotRaconteurPython.TimeSpec() m = self._innerpipe.PeekInValue(ts) return (UnpackMessageElement(m, self._innerpipe.Type, self._obj, self._innerpipe.GetNode()), ts) def PeekOutValue(self): """ Peek the current OutValue Peeks the current OutValue using a "request" instead of a streaming value. Use if only the instantanouse value is required. Peek and poke are similar to "property" members. Unlike streaming, peek and poke are reliable operations. Throws ValueNotSetException if OutValue is not valid. Only valid on clients. Will throw InvalidOperationException on the service side. :rtype: Tuple[T,RobotRaconteur.TimeSpec] """ ts = RobotRaconteurPython.TimeSpec() m = self._innerpipe.PeekOutValue(ts) return (UnpackMessageElement(m, self._innerpipe.Type, self._obj, self._innerpipe.GetNode()), ts) def PokeOutValue(self, value): """ Poke the OutValue Pokes the OutValue using a "request" instead of a streaming value. Use to update the OutValue if the value is updated infrequently. Peek and poke are similar to `property` members. Unlike streaming, peek and poke are reliable operations. Only valid on clients. Will throw InvalidOperationException on the service side. :param value: The new OutValue """ m = PackMessageElement(value, self._innerpipe.Type, self._obj, self._innerpipe.GetNode()) self._innerpipe.PokeOutValue(m) def AsyncPeekInValue(self, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): """ Asynchronously peek the current InValue Same as PeekInValue(), but returns asynchronously. Only valid on clients. Will throw InvalidOperationException on the service side. :param handler: A handler function to receive the InValue and timestamp, or an exception :type handler: Callable[[T,RobotRaconteur.TimeSpec,Exception],None] :param timeout: Timeout in seconds, or -1 for infinite :type timeout: float """ return async_call(self._innerpipe.AsyncPeekInValue, (adjust_timeout(timeout),), WireAsyncPeekReturnDirectorImpl, handler, directorargs=(self._innerpipe, self._obj)) def AsyncPeekOutValue(self, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): """ Asynchronously peek the current OutValue Same as PeekOutValue(), but returns asynchronously. Only valid on clients. Will throw InvalidOperationException on the service side. :param handler: A handler function to receive the OutValue and timestamp, or an exception :type handler: Callable[[T,RobotRaconteur.TimeSpec,Exception],None] :param timeout: Timeout in seconds, or -1 for infinite :type timeout: float """ return async_call(self._innerpipe.AsyncPeekOutValue, (adjust_timeout(timeout),), WireAsyncPeekReturnDirectorImpl, handler, directorargs=(self._innerpipe, self._obj)) def AsyncPokeOutValue(self, value, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): """ Asynchronously poke the OutValue Same as PokeOutValue(), but returns asynchronously Only valid on clients. Will throw InvalidOperationException on the service side. :param handler: A handler function to invoke on completion, with possible exception :type handler: Callable[[Exception],None] :param value: The new OutValue :param timeout: Timeout in seconds, or -1 for no timeout :type timeout: float """ m = PackMessageElement(value, self._innerpipe.Type, self._obj, self._innerpipe.GetNode()) return async_call(self._innerpipe.AsyncPokeOutValue, (m, adjust_timeout(timeout)), AsyncVoidReturnDirectorImpl, handler) @property def PeekInValueCallback(self): """ Set the PeekInValue callback function Peek and poke operations are used when a streaming connection of the most recent value is not required. Clients initiate peek and poke operations using PeekInValue(), PeekOutValue(), PokeOutValue(), or their asynchronous equivalents. Services receive the peek and poke requests through callbacks. PeekInValueCallback configures the service callback for PeekInValue() requests. The function receives the client endpoint ID, and returns the current InValue. Note: Callback is configured automatically by WireBroadcaster or WireUnicastReceiver Only valid for services. Will throw InvalidOperationException on the client side. :rtype: Callable[[int],T] """ raise Exception("Read only property") @PeekInValueCallback.setter def PeekInValueCallback(self, c): cb = WrappedWireServerPeekValueDirectorImpl( c, self._innerpipe, self._obj) self._innerpipe.SetPeekInValueCallback(cb, 0) cb.__disown__() @property def PeekOutValueCallback(self): """ Set the PeekOutValue callback function Peek and poke operations are used when a streaming connection of the most recent value is not required. Clients initiate peek and poke operations using PeekInValue(), PeekOutValue(), PokeOutValue(), or their asynchronous equivalents. Services receive the peek and poke requests through callbacks. PeekOutValueCallback configures the service callback for PeekOutValue() requests. The function receives the client endpoint ID, and returns the current OutValue. Note: Callback is configured automatically by WireBroadcaster or WireUnicastReceiver Only valid for services. Will throw InvalidOperationException on the client side. :rtype: Callable[[int],T] """ raise Exception("Read only property") @PeekOutValueCallback.setter def PeekOutValueCallback(self, c): cb = WrappedWireServerPeekValueDirectorImpl( c, self._innerpipe, self._obj) self._innerpipe.SetPeekOutValueCallback(cb, 0) cb.__disown__() @property def PokeOutValueCallback(self): """ Set the PokeOutValue callback function Peek and poke operations are used when a streaming connection of the most recent value is not required. Clients initiate peek and poke operations using PeekInValue(), PeekOutValue(), PokeOutValue(), or their asynchronous equivalents. Services receive the peek and poke requests through callbacks. PokeOutValueCallback configures the service callback for PokeOutValue() requests. The function receives the new out value, the new out value timestamp in the client's clock, and the client endpoint ID. Note: Callback is configured automatically by WireBroadcaster or WireUnicastReceiver Only valid for services. Will throw InvalidOperationException on the client side. :rtype: Callable[[T,RobotRaconteur.TimeSpec,int],None] """ raise Exception("Read only property") @PokeOutValueCallback.setter def PokeOutValueCallback(self, c): cb = WrappedWireServerPokeValueDirectorImpl( c, self._innerpipe, self._obj) self._innerpipe.SetPokeOutValueCallback(cb, 0) cb.__disown__() def GetNode(self): return self._innerpipe.GetNode() class WrappedWireServerConnectDirectorPython(RobotRaconteurPython.WrappedWireServerConnectDirector): def __init__(self, wire, type, callback): self.wire = wire self.type = type self.callback = callback super(WrappedWireServerConnectDirectorPython, self).__init__() def WireConnectCallback(self, innerendpoint): outerendpoint = WireConnection(innerendpoint, self.type) director = WireConnectionDirector( outerendpoint, self.type, innerep=innerendpoint) innerendpoint.SetRRDirector(director, 0) director.__disown__() self.callback(outerendpoint) class ArrayMemoryClient(object): __slots__ = ["__innermemory", "__weakref__"] def __init__(self, innermemory): self.__innermemory = innermemory @property def Length(self): return self.__innermemory.Length() def Read(self, memorypos, buffer, bufferpos, count): dat = RobotRaconteurPython.WrappedArrayMemoryClientUtil.Read( self.__innermemory, memorypos, count) t = RobotRaconteurPython.TypeDefinition() t.Type = self.__innermemory.ElementTypeID() t.ArrayType = RobotRaconteurPython.DataTypes_ArrayTypes_array t.ArrayVarLength = True t.ArrayLength = RobotRaconteurPython.vectorint32([0]) buffer[bufferpos:(bufferpos + count)] = UnpackFromRRArray(dat, t) def Write(self, memorypos, buffer, bufferpos, count): t = RobotRaconteurPython.TypeDefinition() t.Type = self.__innermemory.ElementTypeID() t.ArrayType = RobotRaconteurPython.DataTypes_ArrayTypes_array t.ArrayVarLength = True t.ArrayLength = RobotRaconteurPython.vectorint32([0]) dat = PackToRRArray(buffer[bufferpos:(bufferpos + count)], t) RobotRaconteurPython.WrappedArrayMemoryClientUtil.Write( self.__innermemory, memorypos, dat, 0, count) class MultiDimArrayMemoryClient(object): __slots__ = ["__innermemory", "__weakref__"] def __init__(self, innermemory): self.__innermemory = innermemory import RobotRaconteur @property def DimCount(self): return self.__innermemory.DimCount() @property def Dimensions(self): return list(self.__innermemory.Dimensions()) def Read(self, memorypos, buffer, bufferpos, count): dat = RobotRaconteurPython.WrappedMultiDimArrayMemoryClientUtil.Read( self.__innermemory, memorypos, count) tdims = RobotRaconteurPython.TypeDefinition() tdims.Type = RobotRaconteurPython.DataTypes_uint32_t tdims.ArrayType = RobotRaconteurPython.DataTypes_ArrayTypes_array tdims.ArrayVarLength = True tdims.ArrayLength = RobotRaconteurPython.vectorint32([0]) dims = UnpackFromRRArray(dat.Dims, tdims) t = RobotRaconteurPython.TypeDefinition() t.Type = self.__innermemory.ElementTypeID() t.ArrayType = RobotRaconteurPython.DataTypes_ArrayTypes_array t.ArrayVarLength = True t.ArrayLength = RobotRaconteurPython.vectorint32([0]) array = UnpackFromRRArray(dat.Array, t) memind = [(slice(memorypos[i], (memorypos[i] + count[i]))) for i in range(len(count))] bufind = [(slice(bufferpos[i], (bufferpos[i] + count[i]))) for i in range(len(count))] buffer2 = array.reshape(dims, order="F") buffer[tuple(bufind)] = buffer2 def Write(self, memorypos, buffer, bufferpos, count): tdims = RobotRaconteurPython.TypeDefinition() tdims.Type = RobotRaconteurPython.DataTypes_uint32_t tdims.ArrayType = RobotRaconteurPython.DataTypes_ArrayTypes_array tdims.ArrayVarLength = True tdims.ArrayLength = RobotRaconteurPython.vectorint32([0]) t = RobotRaconteurPython.TypeDefinition() t.Type = self.__innermemory.ElementTypeID() t.ArrayType = RobotRaconteurPython.DataTypes_ArrayTypes_array t.ArrayVarLength = True t.ArrayLength = RobotRaconteurPython.vectorint32([0]) elementcount = reduce(operator.mul, count, 1) dims = count memind = [slice(memorypos[i], (memorypos[i] + count[i])) for i in range(len(count))] bufind = [slice(bufferpos[i], (bufferpos[i] + count[i])) for i in range(len(count))] array = buffer[tuple(bufind)].flatten(order="F") dims2 = PackToRRArray(count, tdims) array2 = PackToRRArray(array, t) writedat2 = RobotRaconteurPython.RRMultiDimArrayUntyped() writedat2.Dims = dims2 writedat2.Array = array2 RobotRaconteurPython.WrappedMultiDimArrayMemoryClientUtil.Write( self.__innermemory, memorypos, writedat2, [0] * len(count), count) class PodArrayMemoryClient_bufferdirector(RobotRaconteurPython.WrappedPodArrayMemoryClientBuffer): def __init__(self, buf, type1, obj, node): super(PodArrayMemoryClient_bufferdirector, self).__init__() self._buffer = buf self._obj = obj self._node = node self._type = type1 def UnpackReadResult(self, res, bufferpos, count): res1 = RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList( res) m = RobotRaconteurPython.MessageElement() m.SetData(res) m.ElementTypeName = res1.TypeName m.DataCount = len(res1.Elements) res1 = UnpackMessageElement(m, self._type, self._obj, self._node) self._buffer[bufferpos:(bufferpos + count)] = res1 def PackWriteRequest(self, bufferpos, count): buf1 = self._buffer[bufferpos:(bufferpos + count)] m_data = PackMessageElement( buf1, self._type, self._obj, self._node).GetData() return RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList(m_data) class PodArrayMemoryClient(object): __slots__ = ["__innermemory", "_type", "_obj", "_node", "__weakref__"] def __init__(self, innermemory, type1, obj, node): self.__innermemory = innermemory self._type = type1 self._obj = obj self._node = node @property def Length(self): return self.__innermemory.Length() def Read(self, memorypos, buf, bufferpos, count): b = PodArrayMemoryClient_bufferdirector( buf, self._type, self._obj, self._node) self.__innermemory.Read(memorypos, b, bufferpos, count) def Write(self, memorypos, buf, bufferpos, count): b = PodArrayMemoryClient_bufferdirector( buf, self._type, self._obj, self._node) self.__innermemory.Write(memorypos, b, bufferpos, count) class PodMultiDimArrayMemoryClient_bufferdirector(RobotRaconteurPython.WrappedPodMultiDimArrayMemoryClientBuffer): def __init__(self, buf, type1, obj, node): super(PodMultiDimArrayMemoryClient_bufferdirector, self).__init__() self._buffer = buf self._obj = obj self._node = node self._type = type1 def UnpackReadResult(self, res, bufferpos, count): res1 = RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList( res) m = RobotRaconteurPython.MessageElement() m.SetData(res) m.ElementTypeName = res1.TypeName m.DataCount = len(res1.Elements) res2 = UnpackMessageElement(m, self._type, self._obj, self._node) bufind = [(slice(bufferpos[i], (bufferpos[i] + count[i]))) for i in range(len(count))] self._buffer[tuple(bufind)] = res2 def PackWriteRequest(self, bufferpos, count): bufind = [(slice(bufferpos[i], (bufferpos[i] + count[i]))) for i in range(len(count))] buf1 = self._buffer[tuple(bufind)] m_data = PackMessageElement( buf1, self._type, self._obj, self._node).GetData() return RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList(m_data) class PodMultiDimArrayMemoryClient(object): __slots__ = ["__innermemory", "_type", "_obj", "_node", "__weakref__"] def __init__(self, innermemory, type1, obj, node): self.__innermemory = innermemory self._type = type1 self._obj = obj self._node = node @property def DimCount(self): return self.__innermemory.DimCount() @property def Dimensions(self): return list(self.__innermemory.Dimensions()) def Read(self, memorypos, buf, bufferpos, count): b = PodMultiDimArrayMemoryClient_bufferdirector( buf, self._type, self._obj, self._node) self.__innermemory.Read(memorypos, b, bufferpos, count) def Write(self, memorypos, buf, bufferpos, count): b = PodMultiDimArrayMemoryClient_bufferdirector( buf, self._type, self._obj, self._node) self.__innermemory.Write(memorypos, b, bufferpos, count) class NamedArrayMemoryClient_bufferdirector(RobotRaconteurPython.WrappedNamedArrayMemoryClientBuffer): def __init__(self, buf, type1, obj, node): super(NamedArrayMemoryClient_bufferdirector, self).__init__() self._buffer = buf self._obj = obj self._node = node self._type = type1 def UnpackReadResult(self, res, bufferpos, count): res1 = RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList( res) m = RobotRaconteurPython.MessageElement() m.SetData(res) m.ElementTypeName = res1.TypeName m.DataCount = len(res1.Elements) res1 = UnpackMessageElement(m, self._type, self._obj, self._node) self._buffer[bufferpos:(bufferpos + count)] = res1 def PackWriteRequest(self, bufferpos, count): buf1 = self._buffer[bufferpos:(bufferpos + count)] m_data = PackMessageElement( buf1, self._type, self._obj, self._node).GetData() return RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList(m_data) class NamedArrayMemoryClient(object): __slots__ = ["__innermemory", "_type", "_obj", "_node", "__weakref__"] def __init__(self, innermemory, type1, obj, node): self.__innermemory = innermemory self._type = type1 self._obj = obj self._node = node @property def Length(self): return self.__innermemory.Length() def Read(self, memorypos, buf, bufferpos, count): b = NamedArrayMemoryClient_bufferdirector( buf, self._type, self._obj, self._node) self.__innermemory.Read(memorypos, b, bufferpos, count) def Write(self, memorypos, buf, bufferpos, count): b = NamedArrayMemoryClient_bufferdirector( buf, self._type, self._obj, self._node) self.__innermemory.Write(memorypos, b, bufferpos, count) class NamedMultiDimArrayMemoryClient_bufferdirector(RobotRaconteurPython.WrappedNamedMultiDimArrayMemoryClientBuffer): def __init__(self, buf, type1, obj, node): super(NamedMultiDimArrayMemoryClient_bufferdirector, self).__init__() self._buffer = buf self._obj = obj self._node = node self._type = type1 def UnpackReadResult(self, res, bufferpos, count): res1 = RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList( res) m = RobotRaconteurPython.MessageElement() m.SetData(res) m.ElementTypeName = res1.TypeName m.DataCount = len(res1.Elements) res2 = UnpackMessageElement(m, self._type, self._obj, self._node) bufind = [(slice(bufferpos[i], (bufferpos[i] + count[i]))) for i in range(len(count))] self._buffer[tuple(bufind)] = res2 def PackWriteRequest(self, bufferpos, count): bufind = [(slice(bufferpos[i], (bufferpos[i] + count[i]))) for i in range(len(count))] buf1 = self._buffer[tuple(bufind)] m_data = PackMessageElement( buf1, self._type, self._obj, self._node).GetData() return RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList(m_data) class NamedMultiDimArrayMemoryClient(object): __slots__ = ["__innermemory", "_type", "_obj", "_node", "__weakref__"] def __init__(self, innermemory, type1, obj, node): self.__innermemory = innermemory self._type = type1 self._obj = obj self._node = node @property def DimCount(self): return self.__innermemory.DimCount() @property def Dimensions(self): return list(self.__innermemory.Dimensions()) def Read(self, memorypos, buf, bufferpos, count): b = NamedMultiDimArrayMemoryClient_bufferdirector( buf, self._type, self._obj, self._node) self.__innermemory.Read(memorypos, b, bufferpos, count) def Write(self, memorypos, buf, bufferpos, count): b = NamedMultiDimArrayMemoryClient_bufferdirector( buf, self._type, self._obj, self._node) self.__innermemory.Write(memorypos, b, bufferpos, count) class ServiceInfo2(object): """ ServiceInfo2() Contains information about a service found using discovery ServiceInfo2 contains information about a service required to connect to the service, metadata, and the service attributes ServiceInfo2 structures are returned by RobotRaconteurNode.FindServiceByType() and ServiceInfo2Subscription """ __slots__ = ["Name", "RootObjectType", "RootObjectImplements", "ConnectionURL", "NodeID", "NodeName", "Attributes"] def __init__(self, info): self.Name = info.Name """(str) The name of the service""" self.RootObjectType = info.RootObjectType """(str) The fully qualified types the root object implements""" self.RootObjectImplements = list(info.RootObjectImplements) """(str) The fully qualified types the root object implements""" self.ConnectionURL = list(info.ConnectionURL) """(List[str]) Candidate URLs to connect to the service""" self.NodeID = RobotRaconteurPython.NodeID(str(info.NodeID)) """(RobotRaconteur.NodeID) The NodeID of the node that owns the service""" self.NodeName = info.NodeName """(str) The NodeName of the node that owns the service""" self.Attributes = UnpackMessageElement( info.Attributes, "varvalue{string} value") """(Dict[str,Any]) Service attributes""" class NodeInfo2(object): """ NodeInfo2() Contains information about a node detected using discovery NodeInfo2 contains information about a node detected using discovery. Node information is typically not verified, and is used as a first step to detect available services. NodeInfo2 structures are returned by RobotRaconteurNode.FindNodeByName() and RobotRaconteurNode.FindNodeByID() """ __slots__ = ["NodeID", "NodeName", "ConnectionURL"] def __init__(self, info): self.NodeID = RobotRaconteurPython.NodeID(str(info.NodeID)) """(RobotRaconteur.NodeID) The NodeID of the detected node""" self.NodeName = info.NodeName """(str) The NodeName of the detected node""" self.ConnectionURL = list(info.ConnectionURL) """(List[str]) Candidate URLs to connect to the node The URLs for the node typically contain the node transport endpoint and the nodeid. A URL service parameter must be appended to connect to a service. """ class WrappedServiceSkelDirectorPython(RobotRaconteurPython.WrappedServiceSkelDirector): def __init__(self, obj): self.obj = obj super(WrappedServiceSkelDirectorPython, self).__init__() def Init(self, skel): self.skel = skel odef = skel.Type for i in range(len(odef.Members)): m = odef.Members[i] if (isinstance(m, RobotRaconteurPython.EventDefinition)): if (not m.Name in dir(self.obj)): setattr(self.obj, m.Name, EventHook()) def inner_event(m1): f = lambda *args: skel_dispatchevent( skel, m1.Name, m1, *args) return f f1 = inner_event(m) evt = getattr(self.obj, m.Name) evt += f1 if (isinstance(m, RobotRaconteurPython.CallbackDefinition)): def inner_callback(m1): if (m1.ReturnType.Type == RobotRaconteurPython.DataTypes_void_t): f = lambda endpoint, * \ args: skel_callbackcallvoid( skel, m1.Name, m1, endpoint, *args) else: f = lambda endpoint, * \ args: skel_callbackcall( skel, m1.Name, m1, endpoint, *args) return f f1 = inner_callback(m) cs = CallbackServer(f1) setattr(self.obj, m.Name, cs) if (isinstance(m, RobotRaconteurPython.PipeDefinition)): p = skel.GetPipe(m.Name) outerp = Pipe(p) if (not m.Name in dir(self.obj)): if ("readonly" in m.Modifiers): setattr(self.obj, m.Name, PipeBroadcaster(outerp)) else: setattr(self.obj, m.Name, outerp) else: setattr(self.obj, m.Name, outerp) if (isinstance(m, RobotRaconteurPython.WireDefinition)): w = skel.GetWire(m.Name) outerw = Wire(w) if (not m.Name in dir(self.obj)): if ("readonly" in m.Modifiers): setattr(self.obj, m.Name, WireBroadcaster(outerw)) elif ("writeonly" in m.Modifiers): setattr(self.obj, m.Name, WireUnicastReceiver(outerw)) else: setattr(self.obj, m.Name, outerw) else: setattr(self.obj, m.Name, outerw) if hasattr(self.obj, "RRServiceObjectInit"): self.obj.RRServiceObjectInit( skel.GetContext(), skel.GetServicePath()) def _CallGetProperty(self, name, async_adapter): type1 = FindMemberByName(self.skel.Type.Members, name) # type1=[e for e in self.skel.Type.Members if e.Name == name][0] type2 = RobotRaconteurPython.MemberDefinitionUtil.ToProperty(type1) try: async_getter = getattr(self.obj, "async_get_" + name) except AttributeError: pass else: def async_getter_handler(ret, err): if err is not None: async_adapter.End( RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ExceptionToErrorInfo(err)) _print_exc_traceback(err) return if (ret is None): m = RobotRaconteurPython.MessageElement() m.ElementName = "value" m.ElementType = RobotRaconteurPython.DataTypes_void_t else: m = PackMessageElement( ret, type2.Type, node=self.skel.RRGetNode()) async_adapter.End(m, RobotRaconteurPython.HandlerErrorInfo()) return async_adapter.MakeAsync() async_getter(async_getter_handler) return ret = getattr(self.obj, name) if (ret is None): m = RobotRaconteurPython.MessageElement() m.ElementName = "value" m.ElementType = RobotRaconteurPython.DataTypes_void_t return m return PackMessageElement(ret, type2.Type, node=self.skel.RRGetNode()) def _CallSetProperty(self, name, value, async_adapter): type1 = FindMemberByName(self.skel.Type.Members, name) # type1=[e for e in self.skel.Type.Members if e.Name == name][0] type2 = RobotRaconteurPython.MemberDefinitionUtil.ToProperty(type1) a = UnpackMessageElement(value, type2.Type, node=self.skel.RRGetNode()) try: async_setter = getattr(self.obj, "async_set_" + name) except AttributeError: pass else: def async_setter_handler(err): if err is not None: async_adapter.End( RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ExceptionToErrorInfo(err)) _print_exc_traceback(err) return async_adapter.End(RobotRaconteurPython.HandlerErrorInfo()) return async_adapter.MakeAsync() async_setter(a, async_setter_handler) return setattr(self.obj, name, a) def _CallFunction(self, name, args1, async_adapter): type1 = FindMemberByName(self.skel.Type.Members, name) type2 = RobotRaconteurPython.MemberDefinitionUtil.ToFunction(type1) args = [] for p in type2.Parameters: if p.ContainerType == RobotRaconteurPython.DataTypes_ContainerTypes_generator: continue m = FindMessageElementByName(args1, p.Name) a = UnpackMessageElement(m, p, node=self.skel.RRGetNode()) args.append(a) is_generator = type2.IsGenerator() if not is_generator: try: async_func = getattr(self.obj, "async_" + name) except AttributeError: pass else: if type2.ReturnType.Type == RobotRaconteurPython.DataTypes_void_t: def async_function_handler(err): if err is not None: async_adapter.End( RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ExceptionToErrorInfo(err)) _print_exc_traceback(err) return async_adapter.End( None, RobotRaconteurPython.HandlerErrorInfo()) return else: def async_function_handler(ret, err): if err is not None: async_adapter.End( RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ExceptionToErrorInfo(err)) _print_exc_traceback(err) return if (ret is None): m = RobotRaconteurPython.MessageElement() m.ElementName = "return" m.ElementType = RobotRaconteurPython.DataTypes_void_t else: m = PackMessageElement( ret, type2.ReturnType, node=self.skel.RRGetNode()) async_adapter.End( m, RobotRaconteurPython.HandlerErrorInfo()) return async_adapter.MakeAsync() async_func(*args + [async_function_handler]) return ret = getattr(self.obj, name)(*args) if is_generator: gen_return_type = None if type2.ReturnType.Type != RobotRaconteurPython.DataTypes_void_t: gen_return_type = type2.ReturnType.Clone() gen_return_type.RemoveContainers() gen_param_type = None if len(type2.Parameters) > 0 and type2.Parameters[-1].ContainerType == RobotRaconteurPython.DataTypes_ContainerTypes_generator: gen_param_type = type2.Parameters[-1] gen = WrappedGeneratorServerDirectorPython( ret, gen_return_type, gen_param_type, self.skel.RRGetNode()) ind = self.skel.RegisterGeneratorServer(type2.Name, gen) gen.__disown__() return PackMessageElement(ind, "int32 index", node=self.skel.RRGetNode()) if (ret is None): m = RobotRaconteurPython.MessageElement() m.ElementName = "return" m.ElementType = RobotRaconteurPython.DataTypes_void_t return m return PackMessageElement(ret, type2.ReturnType, node=self.skel.RRGetNode()) def _GetSubObj(self, name, index): type1 = FindMemberByName(self.skel.Type.Members, name) # type1=[e for e in self.skel.Type.Members if e.Name == name][0] type2 = RobotRaconteurPython.MemberDefinitionUtil.ToObjRef(type1) if (type2.ArrayType == RobotRaconteurPython.DataTypes_ArrayTypes_array or (type2.ContainerType == RobotRaconteurPython.DataTypes_ContainerTypes_map_int32)): obj, objecttype = getattr(self.obj, 'get_' + name)(str(index)) elif (type2.ContainerType == RobotRaconteurPython.DataTypes_ContainerTypes_map_string): obj, objecttype = getattr(self.obj, 'get_' + name)(index) else: obj, objecttype = getattr(self.obj, 'get_' + name)() director = WrappedServiceSkelDirectorPython(obj) rrobj = RobotRaconteurPython.WrappedRRObject(objecttype, director, 0) director.__disown__() return rrobj def _GetArrayMemory(self, name): m = getattr(self.obj, name) d = WrappedArrayMemoryDirectorPython(m) d.__disown__() return d def _GetMultiDimArrayMemory(self, name): m = getattr(self.obj, name) d = WrappedMultiDimArrayMemoryDirectorPython(m) d.__disown__() return d def _GetPodArrayMemory(self, name): type1 = FindMemberByName(self.skel.Type.Members, name) type2 = RobotRaconteurPython.MemberDefinitionUtil.ToMemory(type1) m = getattr(self.obj, name) d = WrappedPodArrayMemoryDirectorPython( m, type2.Type, self.skel.RRGetNode()) d.__disown__() return d def _GetPodMultiDimArrayMemory(self, name): type1 = FindMemberByName(self.skel.Type.Members, name) type2 = RobotRaconteurPython.MemberDefinitionUtil.ToMemory(type1) m = getattr(self.obj, name) d = WrappedPodMultiDimArrayMemoryDirectorPython( m, type2.Type, self.skel.RRGetNode()) d.__disown__() return d def _GetNamedArrayMemory(self, name): type1 = FindMemberByName(self.skel.Type.Members, name) type2 = RobotRaconteurPython.MemberDefinitionUtil.ToMemory(type1) m = getattr(self.obj, name) d = WrappedNamedArrayMemoryDirectorPython( m, type2.Type, self.skel.RRGetNode()) d.__disown__() return d def _GetNamedMultiDimArrayMemory(self, name): type1 = FindMemberByName(self.skel.Type.Members, name) type2 = RobotRaconteurPython.MemberDefinitionUtil.ToMemory(type1) m = getattr(self.obj, name) d = WrappedNamedMultiDimArrayMemoryDirectorPython( m, type2.Type, self.skel.RRGetNode()) d.__disown__() return d def MonitorEnter(self, timeout): self.obj.RobotRaconteurMonitorEnter(timeout) def MonitorExit(self): self.obj.RobotRaconteurMonitorExit() def ReleaseCastObject(self): self.obj = None self.skel = None def skel_dispatchevent(skel, name, type1, *args): check_member_args(name, type1.Parameters, args) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 node = skel.RRGetNode() for p in type1.Parameters: a = PackMessageElement(args[i], p, node=node) a.ElementName = p.Name m.append(a) i += 1 skel.WrappedDispatchEvent(name, m) def skel_callbackcall(skel, name, type1, endpoint, *args): check_member_args(name, type1.Parameters, args) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 node = skel.RRGetNode() for p in type1.Parameters: a = PackMessageElement(args[i], p, node=node) a.ElementName = p.Name m.append(a) i += 1 ret = skel.WrappedCallbackCall(name, endpoint, m) return UnpackMessageElement(ret, type1.ReturnType, node=node) def skel_callbackcallvoid(skel, name, type1, endpoint, *args): check_member_args(name, type1.Parameters, args) m = RobotRaconteurPython.vectorptr_messageelement() i = 0 node = skel.RRGetNode() for p in type1.Parameters: a = PackMessageElement(args[i], p, node=node) a.ElementName = p.Name m.append(a) i += 1 skel.WrappedCallbackCall(name, endpoint, m) class CallbackServer(object): __slots__ = ["func", "__weakref__"] def __init__(self, func): self.func = func def GetClientFunction(self, endpoint): func = self.func return lambda *args: func(endpoint, *args) class WrappedArrayMemoryDirectorPython(RobotRaconteurPython.WrappedArrayMemoryDirector): def __init__(self, memory): self.memory = memory super(WrappedArrayMemoryDirectorPython, self).__init__() def Length(self): return self.memory.Length def Read(self, memorypos, buffer, bufferpos, count): buffer3 = numpy.zeros( (count,), dtype=RobotRaconteurPython._RRTypeIdToNumPyDataType(buffer.GetTypeID())) self.memory.Read(memorypos, buffer3, bufferpos, count) type1 = RobotRaconteurPython.TypeDefinition() type1.ArrayType = RobotRaconteurPython.DataTypes_ArrayTypes_array type1.ArrayVarLength = True type1.ArrayLength = RobotRaconteurPython.vectorint32([0]) type1.Type = buffer.GetTypeID() PackToRRArray(buffer3, type1, buffer) def Write(self, memorypos, buffer, bufferpos, count): buffer3 = UnpackFromRRArray(buffer, None) self.memory.Write(memorypos, buffer3, bufferpos, count) class WrappedMultiDimArrayMemoryDirectorPython(RobotRaconteurPython.WrappedMultiDimArrayMemoryDirector): def __init__(self, memory): self.memory = memory super(WrappedMultiDimArrayMemoryDirectorPython, self).__init__() import RobotRaconteur def Dimensions(self): d = self.memory.Dimensions d2 = RobotRaconteurPython.vector_uint64_t() for d_i in d: d2.push_back(d_i) return d2 def DimCount(self): return self.memory.DimCount def Read(self, p): rrmultidim = p.buffer rrt = RobotRaconteurPython.TypeDefinition() rrt.Type = rrmultidim.Array.GetTypeID() rrt.ArrayType = RobotRaconteurPython.DataTypes_ArrayTypes_array rrt.ArrayVarLength = True rrt.ArrayLength = RobotRaconteurPython.vectorint32([0]) dims = list(p.count) elementcount = reduce(operator.mul, dims, 1) readdat1 = numpy.zeros(dims, dtype=RobotRaconteurPython._RRTypeIdToNumPyDataType( rrmultidim.Array.GetTypeID())) self.memory.Read(list(p.memorypos), readdat1, list(p.bufferpos), dims) PackToRRArray(readdat1.flatten(order="F"), rrt, rrmultidim.Array) def Write(self, p): memorypos = list(p.memorypos) bufferpos = list(p.bufferpos) count = list(p.count) rrmultidim = p.buffer md_dims = UnpackFromRRArray(rrmultidim.Dims) md_array = UnpackFromRRArray(rrmultidim.Array) buffer = md_array.reshape(count, order="F") self.memory.Write(memorypos, buffer, bufferpos, count) class WrappedPodArrayMemoryDirectorPython(RobotRaconteurPython.WrappedPodArrayMemoryDirector): def __init__(self, memory, type1, node): self.memory = memory self.node = node self.type = type1 super(WrappedPodArrayMemoryDirectorPython, self).__init__() def Length(self): return self.memory.Length def Read(self, memorypos, bufferpos, count): dt = GetPodDType(self.type) buffer3 = numpy.zeros((count,), dtype=dt) self.memory.Read(memorypos, buffer3, bufferpos, count) m = PackMessageElement(buffer3, self.type, node=self.node) return RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList(m.GetData()) def Write(self, memorypos, buffer_, bufferpos, count): m = RobotRaconteurPython.MessageElement() m.SetData(buffer_) m.ElementTypeName = buffer_.TypeName m.DataCount = len(buffer_.Elements) buffer3 = UnpackMessageElement(m, self.type, node=self.node) self.memory.Write(memorypos, buffer3, bufferpos, count) class WrappedPodMultiDimArrayMemoryDirectorPython(RobotRaconteurPython.WrappedPodMultiDimArrayMemoryDirector): def __init__(self, memory, type1, node): super(WrappedPodMultiDimArrayMemoryDirectorPython, self).__init__() self.memory = memory self.type = type1 self.node = node def Dimensions(self): d = self.memory.Dimensions d2 = RobotRaconteurPython.vector_uint64_t() for d_i in d: d2.push_back(d_i) return d2 def DimCount(self): return self.memory.DimCount def Read(self, memorypos, bufferpos, count): dims = list(count) dt = GetPodDType(self.type) readdat1 = numpy.zeros(dims, dtype=dt) self.memory.Read(list(memorypos), readdat1, list(bufferpos), dims) m = PackMessageElement(readdat1, self.type, node=self.node) return RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList(m.GetData()) def Write(self, memorypos_, buffer_, bufferpos_, count_): try: memorypos = list(memorypos_) bufferpos = list(bufferpos_) count = list(count_) buffer1 = RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList( buffer_) m = RobotRaconteurPython.MessageElement() m.SetData(buffer_) m.ElementTypeName = buffer1.TypeName m.DataCount = len(buffer1.Elements) buffer2 = UnpackMessageElement(m, self.type, node=self.node) self.memory.Write(memorypos, buffer2, bufferpos, count) except: traceback.print_exc() raise class WrappedNamedArrayMemoryDirectorPython(RobotRaconteurPython.WrappedNamedArrayMemoryDirector): def __init__(self, memory, type1, node): self.memory = memory self.node = node self.type = type1 super(WrappedNamedArrayMemoryDirectorPython, self).__init__() def Length(self): return self.memory.Length def Read(self, memorypos, bufferpos, count): dt = GetNamedArrayDType(self.type) buffer3 = numpy.zeros((count,), dtype=dt) self.memory.Read(memorypos, buffer3, bufferpos, count) m = PackMessageElement(buffer3, self.type, node=self.node) return RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList(m.GetData()) def Write(self, memorypos, buffer_, bufferpos, count): m = RobotRaconteurPython.MessageElement() m.SetData(buffer_) m.ElementTypeName = buffer_.TypeName m.DataCount = len(buffer_.Elements) buffer3 = UnpackMessageElement(m, self.type, node=self.node) self.memory.Write(memorypos, buffer3, bufferpos, count) class WrappedNamedMultiDimArrayMemoryDirectorPython(RobotRaconteurPython.WrappedNamedMultiDimArrayMemoryDirector): def __init__(self, memory, type1, node): super(WrappedNamedMultiDimArrayMemoryDirectorPython, self).__init__() self.memory = memory self.type = type1 self.node = node def Dimensions(self): d = self.memory.Dimensions d2 = RobotRaconteurPython.vector_uint64_t() for d_i in d: d2.push_back(d_i) return d2 def DimCount(self): return self.memory.DimCount def Read(self, memorypos, bufferpos, count): dims = list(count) dt = GetNamedArrayDType(self.type) readdat1 = numpy.zeros(dims, dtype=dt) self.memory.Read(list(memorypos), readdat1, list(bufferpos), dims) m = PackMessageElement(readdat1, self.type, node=self.node) return RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList(m.GetData()) def Write(self, memorypos_, buffer_, bufferpos_, count_): try: memorypos = list(memorypos_) bufferpos = list(bufferpos_) count = list(count_) buffer1 = RobotRaconteurPython.MessageElementDataUtil.ToMessageElementNestedElementList( buffer_) m = RobotRaconteurPython.MessageElement() m.SetData(buffer_) m.ElementTypeName = buffer1.TypeName m.DataCount = len(buffer1.Elements) buffer2 = UnpackMessageElement(m, self.type, node=self.node) self.memory.Write(memorypos, buffer2, bufferpos, count) except: traceback.print_exc() raise class WrappedClientServiceListenerDirector(RobotRaconteurPython.ClientServiceListenerDirector): def __init__(self, callback): self.callback = callback super(WrappedClientServiceListenerDirector, self).__init__() def Callback(self, code): self.callback(self.stub, code, None) def Callback2(self, code, p): self.callback(self.stub, code, p) class WrappedServerServiceListenerDirector(RobotRaconteurPython.ServerServiceListenerDirector): def __init__(self, callback, context): self.callback = callback self.context = context super(WrappedServerServiceListenerDirector, self).__init__() def Callback(self, code, endpoint): self.callback(self.context, code, endpoint) class RRConstants(object): pass def convert_constant(const): if not const.VerifyValue(): raise Exception("Invalid constant " + const.Name) t = const.Type if (t.Type == RobotRaconteurPython.DataTypes_string_t): return const.Name, const.ValueToString() if RobotRaconteurPython.IsTypeNumeric(t.Type): if (t.Type == RobotRaconteurPython.DataTypes_double_t or t.Type == RobotRaconteurPython.DataTypes_single_t): if (t.ArrayType == RobotRaconteurPython.DataTypes_ArrayTypes_array): s3 = const.Value.strip().lstrip('{').rstrip('}') return const.Name, [float(i) for i in s3.split(',')] else: return const.Name, float(const.Value) else: if (t.ArrayType == RobotRaconteurPython.DataTypes_ArrayTypes_array): s3 = const.Value.strip().lstrip('{').rstrip('}') return const.Name, [int(i, 0) for i in s3.split(',')] else: return const.Name, const.Value if t.Type == RobotRaconteurPython.DataTypes_namedtype_t: struct_fields = const.ValueToStructFields() f = dict() for struct_field in struct_fields: f[struct_field.Name] = struct_field.ConstantRefName return const.Name, f raise Exception("Unknown constant type") def ServiceDefinitionConstants(servicedef, node, obj): o = dict() for s in servicedef.Options: s2 = s.split(None, 1) if (s2[0] == "constant"): c = RobotRaconteurPython.ConstantDefinition(servicedef) c.FromString(s) name, val = convert_constant(c) o[name] = val for c in servicedef.Constants: name, val = convert_constant(c) o[name] = val elem_o = dict() for e in itertools.chain(servicedef.NamedArrays, servicedef.Pods, servicedef.Structures, servicedef.Objects): o2 = dict() for s in e.Options: s2 = s.split(None, 1) if (s2[0] == "constant"): c = RobotRaconteurPython.ConstantDefinition(servicedef) c.FromString(s) name, val = convert_constant(c) o2[name] = val for c in e.Constants: name, val = convert_constant(c) o2[name] = val if (len(o2) > 0): elem_o[e.Name] = o2 for _, c_value in o.items(): if isinstance(c_value, dict): for f_name, f_value in c_value.items(): if not f_value in o: raise Exception( "Invalid struct reference type: " + f_value) c_value[f_name] = o[f_value] for n, v in elem_o.items(): o[n] = v for e in servicedef.Enums: o_enum = dict() for v in e.Values: o_enum[v.Name] = v.Value o[e.Name] = o_enum return o def adjust_timeout(t): if (t < 0): return -1 else: return int(t * 1000) class AsyncStubReturnDirectorImpl(RobotRaconteurPython.AsyncStubReturnDirector): def __init__(self, handler): super(AsyncStubReturnDirectorImpl, self).__init__() self._handler = handler def handler(self, innerstub2, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(None, err) return try: stub = innerstub2.GetPyStub() if (stub is None): stub = InitStub(innerstub2) innerstub2.SetPyStub(stub) except Exception as err2: self._handler(None, err2) return self._handler(stub, None) class AsyncVoidReturnDirectorImpl(RobotRaconteurPython.AsyncVoidReturnDirector): def __init__(self, handler): super(AsyncVoidReturnDirectorImpl, self).__init__() self._handler = handler def handler(self, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(err) return self._handler(None) class AsyncVoidNoErrReturnDirectorImpl(RobotRaconteurPython.AsyncVoidNoErrReturnDirector): def __init__(self, handler): super(AsyncVoidNoErrReturnDirectorImpl, self).__init__() self._handler = handler def handler(self): self._handler() class AsyncStringReturnDirectorImpl(RobotRaconteurPython.AsyncStringReturnDirector): def __init__(self, handler): super(AsyncStringReturnDirectorImpl, self).__init__() self._handler = handler def handler(self, istr, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(None, err) return self._handler(istr, None) class AsyncUInt32ReturnDirectorImpl(RobotRaconteurPython.AsyncUInt32ReturnDirector): def __init__(self, handler): super(AsyncUInt32ReturnDirectorImpl, self).__init__() self._handler = handler def handler(self, e, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(None, err) return self._handler(e, None) class AsyncTimerEventReturnDirectorImpl(RobotRaconteurPython.AsyncTimerEventReturnDirector): def __init__(self, handler): super(AsyncTimerEventReturnDirectorImpl, self).__init__() self._handler = handler def handler(self, ev, error_info): self._handler(ev) def async_call(func, args, directorclass, handler, noerror=False, directorargs=()): d = None if (handler is None): if (sys.version_info > (3, 5)): loop = asyncio.get_event_loop() d = asyncio.Future() def handler3(*args): if noerror: if len(args) == 0: loop.call_soon_threadsafe(d.set_result, None) else: loop.call_soon_threadsafe(d.set_result, args[0]) else: ret = None if len(args) == 2: ret = args[0] if args[-1] is None: loop.call_soon_threadsafe(d.set_result, ret) else: loop.call_soon_threadsafe(d.set_exception, args[-1]) handler = lambda *args1: handler3(*args1) else: raise Exception("handler must not be None") handler2 = directorclass(handler, *directorargs) args2 = list(args) args2.extend([handler2, 0]) handler2.__disown__() func(*args2) return d class ExceptionHandlerDirectorImpl(RobotRaconteurPython.AsyncVoidReturnDirector): def __init__(self, handler): super(ExceptionHandlerDirectorImpl, self).__init__() self._handler = handler def handler(self, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(err) return class WrappedPipeBroadcasterPredicateDirectorPython(RobotRaconteurPython.WrappedPipeBroadcasterPredicateDirector): def __init__(self, f): super(WrappedPipeBroadcasterPredicateDirectorPython, self).__init__() self.f = f def Predicate(self, client_endpoint, index_): try: return self.f(client_endpoint, index_) except: traceback.print_exc() return True class PipeBroadcaster(object): """ Broadcaster to send packets to all connected clients PipeBroadcaster is used by services to send packets to all connected client endpoints. It attaches to the pipe on the service side, and manages the lifecycle of connected endpoints. PipeBroadcaster should only be used with pipes that are declared *readonly*, since it has no provisions for receiving incoming packets from the client. PipeBroadcaster is initialized by the user, or by default if the service object has no attribute for *readonly* pipes. If default an attribute is specified for the pipe not used, the broadcaster must be instantiated manually. It is recommended this be done using the RRServiceObjectInit() function. If present in the service object, function is called after the pipes have been instantiated by the service. Use SendPacket() or AsyncSendPacket() to broadcast packets to all connected clients. PipeBroadcaster provides flow control by optionally tracking how many packets are in flight to each client pipe endpoint. (This is accomplished using packet acks.) If a maximum backlog is specified, pipe endpoints exceeding this count will stop sending packets. Specify the maximum backlog on construction or the MaxBacklog property. The rate that packets are sent can be regulated using a callback function configured with the SetPredicate() function, or using the BroadcastDownsampler class. :param pipe: The pipe to use for broadcasting. Must be a pipe from a service object. Specifying a client pipe will result in an exception. :type pipe: RobotRaconteur.Pipe :param maximum_backlog: The maximum number of packets in flight, or -1 for unlimited :type maximum_backlog: int """ __slots__ = ["pipe", "_innerpipe", "_obj", "_type", "__weakref__"] def __init__(self, pipe, maximum_backlog=-1): self.pipe = pipe self._innerpipe = RobotRaconteurPython.WrappedPipeBroadcaster() self._innerpipe.Init(pipe._innerpipe, maximum_backlog) self._obj = pipe._obj self._type = pipe._innerpipe.Type def AsyncSendPacket(self, packet, handler): """ Asynchronously send packet to all connected pipe endpoint clients Asynchronous version of SendPacket() :param packet: The packet to send :param handler: A handler function for when packet has been sent by all endpoints :type handler: Callable[[],None] """ m = PackMessageElement(packet, self._type, self._obj) return async_call(self._innerpipe.AsyncSendPacket, (m,), AsyncVoidNoErrReturnDirectorImpl, handler) def SendPacket(self, packet): """ Send a packet to all connected pipe endpoint clients Blocks until packet has been sent by all endpoints :param packet: The packet to send """ m = PackMessageElement(packet, self._type, self._obj) self._innerpipe.SendPacket(m) @property def ActivePipeEndpointCount(self): """Get the number of active pipe endpoints""" return self._innerpipe.GetActivePipeEndpointCount() def SetPredicate(self, f): """ Set the predicate callback function A predicate is optionally used to regulate when packets are sent to clients. This is used by the BroadcastDownsampler to regulate update rates of packets sent to clients. The predicate callback is invoked before the broadcaster sends a packet to an endpoint. If the predicate returns true, the packet will be sent. If it is false, the packet will not be sent to that endpoint. The predicate receives the broadcaster, the client endpoint ID, and the pipe endpoint index. It returns true to send the packet, or false to not send the packet. :param f: The predicate :type f: Callable[[RobotRaconteur.PipeBroadcaster,int,int],bool] """ p = WrappedPipeBroadcasterPredicateDirectorPython(f) self._innerpipe.SetPredicateDirector(p, 0) p.__disown__() @property def MaxBacklog(self): """ Set the maximum backlog PipeBroadcaster provides flow control by optionally tracking how many packets are in flight to each client pipe endpoint. (This is accomplished using packet acks.) If a maximum backlog is specified, pipe endpoints exceeding this count will stop sending packets. Set -1 for no flow control. :rtype: int """ return self._innerpipe.GetMaxBacklog() @MaxBacklog.setter def MaxBacklog(self, maximum_backlog): self._innerpipe.SetMaxBacklog(maximum_backlog) class WrappedWireBroadcasterPredicateDirectorPython(RobotRaconteurPython.WrappedWireBroadcasterPredicateDirector): def __init__(self, f): super(WrappedWireBroadcasterPredicateDirectorPython, self).__init__() self.f = f def Predicate(self, client_endpoint): try: return self.f(client_endpoint) except: traceback.print_exc() return True class WrappedWireBroadcasterPeekValueDirectorImpl(RobotRaconteurPython.WrappedWireServerPeekValueDirector): def __init__(self, cb, value_type, node, obj): super(WrappedWireBroadcasterPeekValueDirectorImpl, self).__init__() self._cb = cb self.__node = node self.__obj = obj self.__value_type = value_type def PeekValue(self, ep): value = self._cb(ep) m = PackMessageElement(value, self.__value_type, self.__obj, self.__node) return m class WireBroadcaster(object): """ Broadcaster to send values to all connected clients WireBroadcaster is used by services to send values to all connected client endpoints. It attaches to the wire on the service side, and manages the lifecycle of connections. WireBroadcaster should only we used with wires that are declared *readonly*, since it has no provisions for receiving incoming values from clients. WireBroadcaster is initialized by the user, or by default if the service object does not contain an attribute for the wire member. The default will automatically instantiate unicast receivers for wires marked *readonly*. If default the implementation is not not used, the broadcaster must be instantiated manually. It is recommended this be done using an RRServiceObjectInit() function in the service object. This function is called after the wires have been instantiated by the service. Use OutValue property to broadcast values to all connected clients. The rate that packets are sent can be regulated using a callback function configured with the SetPredicate() function, or using the BroadcastDownsampler class. :param wire: The wire to use for broadcasting. Must be a wire from a service object. Specifying a client wire will result in an exception. :type wire: RobotRaconteur.Wire """ __slots__ = ["_wire", "_innerpipe", "_obj", "_type", "__weakref__", "_node"] def __init__(self, wire): self._wire = wire self._innerpipe = RobotRaconteurPython.WrappedWireBroadcaster() self._innerpipe.Init(wire._innerpipe) self._obj = wire._obj self._type = wire._innerpipe.Type self._node = wire._innerpipe.GetNode() @property def OutValue(self): """ Set the OutValue for all connections Sets the OutValue for all connections. This will transmit the value to all connected clients using packets. The value will become the clients' InValue. The value will be returned when clients call Wire.PeekInValue() or Wire.AsyncPeekInValue() """ raise Exception("Write only property") @OutValue.setter def OutValue(self, value): m = PackMessageElement(value, self._type, self._obj) self._innerpipe.SetOutValue(m) @property def ActiveWireConnectionCount(self): """Get the number of active wire connections""" return self._innerpipe.GetActiveWireConnectionCount() def SetPredicate(self, f): """ Set the predicate callback function A predicate is optionally used to regulate when values are sent to clients. This is used by the BroadcastDownsampler to regulate update rates of values sent to clients. The predicate callback is invoked before the broadcaster sends a value to an endpoint. If the predicate returns true, the value will be sent. If it is false, the value will not be sent to that endpoint. The predicate receives the broadcaster and the client endpoint ID. It returns true to send the value, or false to not send the value. :param f: The predicate :type f: Callable[[RobotRaconteur.WireBroadcaster,int],bool] """ p = WrappedWireBroadcasterPredicateDirectorPython(f) self._innerpipe.SetPredicateDirector(p, 0) p.__disown__() @property def OutValueLifespan(self): """ Set the lifespan of OutValue OutValue may optionally have a finite lifespan specified in seconds. Once the lifespan after sending has expired, the OutValue is cleared and becomes invalid. Attempts to access OutValue will result in ValueNotSetException. OutValue lifespans may be used to avoid using a stale value sent by the wire. If the lifespan is not set, the wire will continue to return the last sent value, even if the value is old. Specify -1 for no expiration. """ t = self._innerpipe.GetOutValueLifespan() if t < 0: return t return float(t) / 1000.0 @OutValueLifespan.setter def OutValueLifespan(self, secs): if secs < 0: self._innerpipe.SetOutValueLifespan(-1) else: self._innerpipe.SetOutValueLifespan(int(secs * 1000.0)) @property def PeekInValueCallback(self): """ Set the PeekInValue callback function for the WireBroadcaster. Overrides the default callback that returns the last set OutValue. :rtype: Callable[[int],T] """ raise Exception("Write only property") @PeekInValueCallback.setter def PeekInValueCallback(self, c): cb = WrappedWireBroadcasterPeekValueDirectorImpl( c, self._type, self._node, self._obj) self._innerpipe.SetPeekInValueCallback(cb, 0) cb.__disown__() class WrappedWireUnicastReceiverInValueChangedImpl(RobotRaconteurPython.WrappedWireServerPokeValueDirector): def __init__(self, rec): super(WrappedWireUnicastReceiverInValueChangedImpl, self).__init__() self._rec = weakref.ref(rec) def PokeValue(self, m, ts, ep): rec = self._rec() if (rec is None): return value = UnpackMessageElement( m, rec._wire._innerpipe.Type, None, rec._wire._innerpipe.GetNode()) rec.InValueChanged.fire(value, ts, ep) class WireUnicastReceiver(object): """ Receive the InValue from the most recent connection WireUnicastReceiver is used by services to receive a value from a single client. When a client sets its OutValue, this value is transmitted to the service using packets, and becomes the service's InValue for that connection. Service wires can have multiple active clients, so the service needs to choose which connection is "active". The WireUnicastReceiver selects the "most recent" connection, and returns that connection's InValue. Any existing connections are closed. WireUnicastReceiver should only be used with wires that are declared *writeonly*. It is recommended that object locks be used to protect from concurrent access when unicast receivers are used. WireUnicastReceiver is initialized by the user, or by default if the service object does not contain an attribute for the wire member. The default will automatically instantiate unicast receivers for wires marked *writeonly*. If default the implementation is not not used, the unicast receiver must be instantiated manually. It is recommended this be done using an RRServiceObjectInit() function in the service object. This function is called after the wires have been instantiated by the service. The current InValue is received using the InValue property or TryGetInValue(). The InValueChanged event hook can be used to monitor for changes to the InValue. Clients may also use PokeOutValue() or AsyncPokeOutValue() to update the unicast receiver's value. :param wire: The wire to use for receiving. Must be a wire from a service object. Specifying a client wire will result in an exception. :type wire: RobotRaconteur.Wire """ __slots__ = ["_wire", "_innerpipe", "_obj", "_type", "_InValueChanged", "__weakref__"] def __init__(self, wire): self._wire = wire self._innerpipe = RobotRaconteurPython.WrappedWireUnicastReceiver() self._innerpipe.Init(wire._innerpipe) self._obj = wire._obj self._type = wire._innerpipe.Type self._InValueChanged = EventHook() cb = WrappedWireUnicastReceiverInValueChangedImpl(self) self._innerpipe.AddInValueChangedListener(cb, 0) cb.__disown__() @property def InValue(self): """ Get the current InValue Gets the current InValue that was received from the active connection. Throws ValueNotSetException if no value has been received, or the most recent value lifespan has expired. :rtype: Tuple[T,RobotRaconteur.TimeStamp] """ ts = RobotRaconteurPython.TimeSpec() (m, ep) = self._innerpipe.GetInValue(ts) return (UnpackMessageElement(m, self._type, self._obj, self._wire._innerpipe.GetNode()), ts) def TryGetInValue(self): """ Try getting the current InValue, returning true on success or false on failure Gets the current InValue, its timestamp, and the client that owns the connection. Returns True if value is valid, or False if value is invalid. Value will be invalid if no value has been received, or the value lifespan has expired. :rtype: Tuple[bool,T,RobotRaconteur.TimeSpec,object] """ val = RobotRaconteurPython.WrappedService_typed_packet() ts = RobotRaconteurPython.TimeSpec() res = self._innerpipe.TryGetInValue(val, ts) if not res: return False, None, None, None return (True, UnpackMessageElement(val.packet, self._type, self._obj, self._wire._innerpipe.GetNode()), ts, val.client) @property def InValueChanged(self): """ Event hook for wire value change. Use to add handlers to be called when the InValue changes. .. code-block:: python def my_handler(con, value, ts): # Handle new value pass my_wire_connection.WireValueChanged += my_handler Handler must have signature ``Callable[[T,RobotRaconteur.TimeSpec,int],None]`` """ return self._InValueChanged @InValueChanged.setter def InValueChanged(self, evt): if (evt is not self._InValueChanged): raise RuntimeError("Invalid operation") @property def InValueLifespan(self): """ Set the lifespan of InValue InValue may optionally have a finite lifespan specified in seconds, or -1 for infinite. Once the lifespan after reception has expired, the InValue is cleared, and becomes invalid. Attempts to access InValue will result in a ValueNotSetException. :rtype: float """ t = self._innerpipe.GetInValueLifespan() if t < 0: return t return float(t) / 1000.0 @InValueLifespan.setter def InValueLifespan(self, secs): if secs < 0: self._innerpipe.SetInValueLifespan(-1) else: self._innerpipe.SetInValueLifespan(int(secs * 1000.0)) class BroadcastDownsamplerStep(object): """ Class for automatic broadcast downsampler stepping Helper class to automate BroadcastDownsampler stepping. Calls BroadcastDownsampler.BeginStep() on construction, and BroadcastDownsampler.EndStep() on destruction. Use with a "with" block """ __slots__ = ["downsampler"] def __init__(self, downsampler): self.downsampler = downsampler def __enter__(self): self.downsampler.BeginStep() def __exit__(self, etype, value, traceback): self.downsampler.EndStep() class GeneratorClient(object): __slots__ = ["_inner_gen", "_obj", "_node", "_return_type", "_param_type", "__weakref__"] def __init__(self, inner_gen, return_type, param_type, obj, node): self._inner_gen = inner_gen self._obj = obj self._node = node self._return_type = return_type self._param_type = param_type def _pack_param(self, param): param_type1 = RobotRaconteurPython.TypeDefinition() self._param_type.CopyTo(param_type1) param_type1.RemoveContainers() param1 = PackMessageElement(param, param_type1, self._obj, self._node) return param1 def _unpack_return(self, ret): return_type1 = RobotRaconteurPython.TypeDefinition() self._return_type.CopyTo(return_type1) return_type1.RemoveContainers() return UnpackMessageElement(ret, return_type1, self._obj, self._node) def Next(self, param=None): if (self._param_type is not None and self._param_type.ContainerType == DataTypes_ContainerTypes_generator): param1 = self._pack_param(param) else: assert param is None param1 = None ret1 = self._inner_gen.Next(param1) return self._unpack_return(ret1) def TryNext(self, param=None): if (self._param_type is not None and self._param_type.ContainerType == DataTypes_ContainerTypes_generator): param1 = self._pack_param(param) else: assert param is None param1 = None gen_res = self._inner_gen.TryNext(param1) if not gen_res.res: return False, None return True, self._unpack_return(gen_res.value) def AsyncNext(self, param, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): if (self._param_type is not None and self._param_type.ContainerType == DataTypes_ContainerTypes_generator): param1 = self._pack_param(param) else: assert param is None param1 = None return_type1 = RobotRaconteurPython.TypeDefinition() self._return_type.CopyTo(return_type1) return_type1.RemoveContainers() if (self._return_type.Type != RobotRaconteurPython.DataTypes_void_t): return async_call(self._inner_gen.AsyncNext, (param1, adjust_timeout(timeout)), AsyncRequestDirectorImpl, handler, directorargs=(False, return_type1, self._obj, self._node)) else: return async_call(self._inner_gen.AsyncNext, (param1, adjust_timeout(timeout)), AsyncRequestDirectorImpl, handler, directorargs=(True, return_type1, self._obj, self._node)) def Abort(self): self._inner_gen.Abort() def AsyncAbort(self, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): return async_call(self._inner_gen.AsyncAbort, (adjust_timeout(timeout),), AsyncVoidReturnDirectorImpl, handler) def Close(self): self._inner_gen.Close() def AsyncClose(self, handler, timeout=RobotRaconteurPython.RR_TIMEOUT_INFINITE): return async_call(self._inner_gen.AsyncClose, (adjust_timeout(timeout),), AsyncVoidReturnDirectorImpl, handler) def NextAll(self): ret = [] try: while True: ret.append(self.Next()) except RobotRaconteurPythonError.StopIterationException: pass return ret # Add compatibility for iterator protocols def __iter__(self): if self._return_type is None or self._param_type is not None: raise TypeError('Generator must be type 1 for iterable') return self def __next__(self): return self.send(None) def next(self): return self.send(None) def send(self, param): try: return self.Next(param) except RobotRaconteurPythonError.StopIterationException: raise StopIteration() class AsyncGeneratorClientReturnDirectorImpl(RobotRaconteurPython.AsyncGeneratorClientReturnDirector): def __init__(self, handler, return_type, param_type, obj, node): super(AsyncGeneratorClientReturnDirectorImpl, self).__init__() self._handler = handler self._return_type = return_type self._param_type = param_type self._obj = obj self._node = node def handler(self, gen, error_info): if (error_info.error_code != 0): err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) self._handler(None, err) return gen2 = GeneratorClient(gen, self._return_type, self._param_type, self._obj, self._node) self._handler(gen2, None) class IteratorGenerator(object): """ A generator that proxies Next() to Python iterators """ __slots__ = ["_iter", "_lock", "_closed", "_aborted"] def __init__(self, obj): self._iter = iter(obj) self._lock = threading.Lock() self._closed = False self._aborted = False def Next(self): with self._lock: if self._aborted: raise RobotRaconteurPythonError.OperationAbortedException() if self._closed: raise RobotRaconteurPythonError.StopIterationException() try: return next(self._iter) except StopIteration: raise RobotRaconteurPythonError.StopIterationException() def Close(self): with self._lock: self._closed = True if hasattr(self._iter, "close"): self._iter.close() def Abort(self): with self._lock: self._aborted = True if hasattr(self._iter, "close"): self._iter.close() class WrappedGeneratorServerDirectorPython(RobotRaconteurPython.WrappedGeneratorServerDirector): def __init__(self, gen, return_type, param_type, node): super(WrappedGeneratorServerDirectorPython, self).__init__() self._return_type = return_type self._param_type = param_type self._node = node if hasattr(gen, "Next") or hasattr(gen, "AsyncNext"): self._gen = gen else: if not hasattr(gen, "__iter__"): raise TypeError("Invalid generator") self._gen = IteratorGenerator(gen) def Next(self, m, async_adapter): try: async_next_func = getattr(self._gen, "AsyncNext") except AttributeError: pass else: if self._return_type is None: def async_next_handler(err): if err is not None: async_adapter.End( RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ExceptionToErrorInfo(err)) _print_exc_traceback(err) return async_adapter.End( None, RobotRaconteurPython.HandlerErrorInfo()) return else: def async_next_handler(ret, err): if err is not None: async_adapter.End( RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ExceptionToErrorInfo(err)) _print_exc_traceback(err) return if (ret is None): m = RobotRaconteurPython.MessageElement() m.ElementName = "return" m.ElementType = RobotRaconteurPython.DataTypes_void_t else: m = PackMessageElement( ret, self._return_type, node=self._node) async_adapter.End( m, RobotRaconteurPython.HandlerErrorInfo()) return async_adapter.MakeAsync() if self._param_type is None: async_next_func(async_next_handler) else: param = UnpackMessageElement( m, self._param_type, node=self._node) async_next_func(param, async_next_handler) return if self._param_type is None: ret = self._gen.Next() else: param = UnpackMessageElement(m, self._param_type, node=self._node) ret = self._gen.Next(param) if ret is None: mret = RobotRaconteurPython.MessageElement() mret.ElementName = "return" mret.ElementType = RobotRaconteurPython.DataTypes_void_t return mret return PackMessageElement(ret, self._return_type, node=self._node) def Abort(self, async_adapter): try: async_abort_func = getattr(self._gen, "AsyncAbort") except AttributeError: pass else: def async_abort_handler(err): if err is not None: async_adapter.End( RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ExceptionToErrorInfo(err)) _print_exc_traceback(err) return async_adapter.End(RobotRaconteurPython.HandlerErrorInfo()) return async_adapter.MakeAsync() async_abort_func(async_abort_handler) return self._gen.Abort() def Close(self, async_adapter): try: async_close_func = getattr(self._gen, "AsyncClose") except AttributeError: pass else: def async_close_handler(err): if err is not None: async_adapter.End( RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ExceptionToErrorInfo(err)) _print_exc_traceback(err) return async_adapter.End(RobotRaconteurPython.HandlerErrorInfo()) return async_adapter.MakeAsync() async_close_func(async_close_handler) return self._gen.Close() _trace_hook = sys.gettrace() class ServiceSubscriptionClientID(object): """ ServiceSubscriptionClientID() ClientID for use with ServiceSubscription The ServiceSubscriptionClientID stores the NodeID and ServiceName of a connected service. """ __slots__ = ["NodeID", "ServiceName"] def __init__(self, *args): self.NodeID = None """(RobotRaconteur.NodeID) The NodeID of the connected service""" self.ServiceName = None """(str) The ServiceName of the connected service""" if (len(args) == 1): self.NodeID = RobotRaconteurPython.NodeID(args[0].NodeID) self.ServiceName = args[0].ServiceName elif (len(args) == 2): self.NodeID = args[0] self.ServiceName = args[1] def __eq__(self, other): if (not hasattr(other, 'NodeID') or not hasattr(other, 'ServiceName')): return False return (self.NodeID == other.NodeID) and (self.ServiceName == other.ServiceName) def __neq__(self, other): return not self == other def __hash__(self): return hash((str(self.NodeID), self.ServiceName)) def __str__(self): return str(self.NodeID) + "," + self.ServiceName class ServiceSubscriptionFilterNode(object): """ Subscription filter node information Specify a node by NodeID and/or NodeName. Also allows specifying username and password. When using username and credentials, secure transports and specified NodeID should be used. Using username and credentials without a transport that verifies the NodeID could result in credentials being leaked. """ __slots__ = ["NodeID", "NodeName", "Username", "Credentials"] def __init__(self): self.NodeID = None """(RobotRaconteur.NodeID) The NodeID to match. All zero NodeID will match any NodeID.""" self.NodeName = None """(str) The NodeName to match. Emtpy NodeName will match any NodeName.""" self.Username = None """(str) The username to use for authentication. Should only be used with secure transports and verified NodeID""" self.Credentials = None """(Dict[str,Any]) The credentials to use for authentication. Should only be used with secure transports and verified NodeID""" class ServiceSubscriptionFilter(object): """ Subscription filter The subscription filter is used with RobotRaconteurNode.SubscribeServiceByType() and RobotRaconteurNode.SubscribeServiceInfo2() to decide which services should be connected. Detected services that match the service type are checked against the filter before connecting. """ __slots__ = ["Nodes", "ServiceNames", "TransportSchemes", "Predicate", "Attributes", "AttributesMatchOperation", "MaxConnections"] def __init__(self): self.Nodes = [] """(List[RobotRaconteurServiceSubscriptionFilterNode]) List of nodes that should be connected. Empty means match any node.""" self.ServiceNames = [] """(List[str]) List of service names that should be connected. Empty means match any service name.""" self.TransportSchemes = [] """(List[str]) List of transport schemes. Empty means match any transport scheme.""" self.Attributes = dict() """(Dict[str,RobotRaconteur.ServiceSubscriptionFilterAttributeGroup] Attributes to match)""" self.AttributesMatchOperation = RobotRaconteurPython.ServiceSubscriptionFilterAttributeGroupOperation_AND """(RobotRaconteur.ServiceSubscriptionFilterAttributeGroupOperation) The operation to use when matching attributes. Default is AND. Can be OR, AND, NOR, and NAND.""" self.Predicate = None """(Callable[[RobotRaconteur.ServiceInfo2],bool]) A user specified predicate function. If nullptr, the predicate is not checked.""" self.MaxConnections = 1000000 """(int) The maximum number of connections the subscription will create. Zero means unlimited connections.""" class WrappedServiceInfo2SubscriptionDirectorPython(RobotRaconteurPython.WrappedServiceInfo2SubscriptionDirector): def __init__(self, subscription): super(WrappedServiceInfo2SubscriptionDirectorPython, self).__init__() self._subscription = weakref.ref(subscription) def ServiceDetected(self, subscription, id, info): s = self._subscription() if (s is None): return try: s.ServiceDetected.fire( s, ServiceSubscriptionClientID(id), ServiceInfo2(info)) except: pass def ServiceLost(self, subscription, id, info): s = self._subscription() if (s is None): return try: s.ServiceLost.fire( s, ServiceSubscriptionClientID(id), ServiceInfo2(info)) except: pass class ServiceInfo2Subscription(object): """ ServiceInfo2Subscription() Subscription for information about detected services Created using RobotRaconteurNode.SubscribeServiceInfo2() The ServiceInfo2Subscription class is used to track services with a specific service type as they are detected on the local network and when they are lost. The currently detected services can also be retrieved. The service information is returned using the ServiceInfo2 structure. """ __slots__ = ["_subscription", "_ServiceDetected", "_ServiceLost", "__weakref__"] def __init__(self, subscription): self._subscription = subscription self._ServiceDetected = EventHook() self._ServiceLost = EventHook() director = WrappedServiceInfo2SubscriptionDirectorPython(self) subscription.SetRRDirector(director, 0) director.__disown__() def GetDetectedServiceInfo2(self): """ Returns a dict of detected services. The returned dict contains the detected nodes as ServiceInfo2. The dict is keyed with ServiceSubscriptionClientID. This function does not block. :return: The detected services. :rtype: Dict[RobotRaconteur.ServiceSubscriptionClientID,ServiceInfo2] """ o = dict() c1 = self._subscription.GetDetectedServiceInfo2() for c2 in c1.items(): id1 = ServiceSubscriptionClientID(c2[0]) stub = ServiceInfo2(c2[1]) o[id1] = stub return o def Close(self): """ Close the subscription Closes the subscription. Subscriptions are automatically closed when the node is shut down. """ self._subscription.Close() @property def ServiceDetected(self): """ Event hook for service detected events. Use to add handlers to be called when a service is detected. .. code-block:: python def my_handler(sub, subscription_id, service_info2): # Process detected service pass my_serviceinfo2_sub.ServiceDetected += my_handler Handler must have signature ``Callable[[RobotRaconteur.ServiceInfo2Subscription,RobotRaconteur.ServiceSubscriptionClientID,RobotRaconteur.ServiceInfo2],None]`` :rtype: RobotRaconteur.EventHook """ return self._ServiceDetected @ServiceDetected.setter def ServiceDetected(self, evt): if (evt is not self._ServiceDetected): raise RuntimeError("Invalid operation") @property def ServiceLost(self): """ Event hook for service lost events. Use to add handlers to be called when a service is lost. .. code-block:: python def my_handler(sub, subscription_id, service_info2): # Process lost service pass my_serviceinfo2_sub.ServiceLost += my_handler Handler must have signature ``Callable[[RobotRaconteur.ServiceInfo2Subscription,RobotRaconteur.ServiceSubscriptionClientID,RobotRaconteur.ServiceInfo2],None]`` :rtype: RobotRaconteur.EventHook """ return self._ServiceLost @ServiceLost.setter def ServiceLost(self, evt): if (evt is not self._ServiceLost): raise RuntimeError("Invalid operation") def GetNode(self): return self._subscription.GetNode() class WrappedServiceSubscriptionDirectorPython(RobotRaconteurPython.WrappedServiceSubscriptionDirector): def __init__(self, subscription): super(WrappedServiceSubscriptionDirectorPython, self).__init__() self._subscription = weakref.ref(subscription) def ClientConnected(self, subscription, id, client): s = self._subscription() if (s is None): return client2 = s._GetClientStub(client) try: s.ClientConnected.fire(s, ServiceSubscriptionClientID(id), client2) except: traceback.print_exc() def ClientDisconnected(self, subscription, id, client): s = self._subscription() if (s is None): return client2 = s._GetClientStub(client) try: s.ClientDisconnected.fire( s, ServiceSubscriptionClientID(id), client2) except: traceback.print_exc() def ClientConnectFailed(self, subscription, id, url, error_info): s = self._subscription() if (s is None): return err = RobotRaconteurPythonError.RobotRaconteurExceptionUtil.ErrorInfoToException( error_info) try: s.ClientConnectFailed.fire( s, ServiceSubscriptionClientID(id), list(url), err) except: traceback.print_exc() class ServiceSubscription(object): """ ServiceSubscription() Subscription that automatically connects services and manages lifecycle of connected services Created using RobotRaconteurNode.SubscribeService() or RobotRaconteurNode.SubscribeServiceByType(). The ServiceSubscription class is used to automatically create and manage connections based on connection criteria. RobotRaconteur.SubscribeService() is used to create a robust connection to a service with a specific URL. RobotRaconteurNode.SubscribeServiceByType() is used to connect to services with a specified type, filtered with a ServiceSubscriptionFilter. Subscriptions will create connections to matching services, and will retry the connection if it fails or the connection is lost. This behavior allows subscriptions to be used to create robust connections. The retry delay for connections can be modified using the ConnectRetryDelay property. The currently connected clients can be retrieved using the GetConnectedClients() function. A single "default client" can be retrieved using the GetDefaultClient() function or TryGetDefaultClient() functions. Listeners for client connect and disconnect events can be added using the ClientConnectListener and ClientDisconnectListener properties. If the user wants to claim a client, the ClaimClient() and ReleaseClient() functions will be used. Claimed clients will no longer have their lifecycle managed by the subscription. Subscriptions can be used to create \"pipe\" and \"wire\" subscriptions. These member subscriptions aggregate the packets and values being received from all services. They can also act as a "reverse broadcaster" to send packets and values to all services that are actively connected. See PipeSubscription and WireSubscription. """ def __init__(self, subscription): self._subscription = subscription self._ClientConnected = EventHook() self._ClientDisconnected = EventHook() self._ClientConnectFailed = EventHook() director = WrappedServiceSubscriptionDirectorPython(self) subscription.SetRRDirector(director, 0) director.__disown__() def _GetClientStub(self, innerstub): if (innerstub is None): return None s2 = innerstub.GetPyStub() if (s2 is not None): return s2 return InitStub(innerstub) def GetConnectedClients(self): """ Returns a dict of connected clients The returned dict contains the connect clients. The dict is keyed with ServiceSubscriptionClientID. Clients must be cast to a type, similar to the client returned by RobotRaconteurNode.ConnectService(). Clients can be "claimed" using ClaimClient(). Once claimed, the subscription will stop managing the lifecycle of the client. This function does not block. :rtype: Dict[RobotRaconteur.ServiceSubscriptionClientID,Any] """ o = dict() c1 = self._subscription.GetConnectedClients() for c2 in c1.items(): id1 = ServiceSubscriptionClientID(c2[0]) stub = self._GetClientStub(c2[1]) o[id1] = stub return o def Close(self): """ Close the subscription Closes the subscription. Subscriptions are automatically closed when the node is shut down. """ self._subscription.Close() @property def ConnectRetryDelay(self): """ Set the connect retry delay in seconds Default is 2.5 seconds :rtype: float """ return self._subscription.GetConnectRetryDelay() / 1000.0 @ConnectRetryDelay.setter def ConnectRetryDelay(self, value): if (value < 1): raise Exception("Invalid ConnectRetryDelay value") self._subscription.SetConnectRetryDelay(int(value * 1000.0)) def SubscribeWire(self, wire_name, service_path=None): """ Creates a wire subscription Wire subscriptions aggregate the value received from the connected services. It can also act as a "reverse broadcaster" to send values to clients. See WireSubscription. The optional service path may be an empty string to use the root object in the service. The first level of the service path may be "*" to match any service name. For instance, the service path "*.sub_obj" will match any service name, and use the "sub_obj" objref. :param membername: The member name of the wire :type membername: str :param servicepath: The service path of the object owning the wire member :type servicepath: str :return: The wire subscription :rtype: RobotRaconteur.WireSubscription """ if service_path is None: service_path = "" s = self._subscription.SubscribeWire(wire_name, service_path) return WireSubscription(s) def SubscribePipe(self, pipe_name, service_path=None): """ Creates a pipe subscription Pipe subscriptions aggregate the packets received from the connected services. It can also act as a "reverse broadcaster" to send packets to clients. See PipeSubscription. The optional service path may be an empty string to use the root object in the service. The first level of the service path may be "*" to match any service name. For instance, the service path "*.sub_obj" will match any service name, and use the "sub_obj" objref. :param membername: The member name of the pipe :type membername: str :param servicepath: The service path of the object owning the pipe member :type servicepath: str :return: The pipe subscription :rtype: RobotRaconteur.PipeSubscription """ if service_path is None: service_path = "" s = self._subscription.SubscribePipe(pipe_name, service_path) return PipeSubscription(s) def SubscribeSubObject(self, service_path): """ Creates a sub object subscription. Sub objects are objects within a service that are not the root object. Sub objects are typically referenced using objref members, however they can also be referenced using a service path. The SubObjectSubscription class is used to automatically access sub objects of the default client. The service path is broken up into segments using periods. See the Robot Raconter documentation for more information. The BuildServicePath() function can be used to assist building service paths. The first level of the* service path may be "*" to match any service name. For instance, the service path "*.sub_obj" will match any service name, and use the "sub_obj" objref :param service_path: The service path of the object :type service_path: str :return: The sub object subscription :rtype: SubObjectSubscription """ s = self._subscription.SubscribeSubObject(service_path) return SubObjectSubscription(self, s) @property def ClientConnected(self): """ Event hook for client connected events. Use to add handlers to be called when a client is connected. .. code-block:: python def my_handler(sub, subscription_id, connected_service): # Process lost service pass my_service_sub.ClientConnected += my_handler Handler must have signature ``Callable[[RobotRaconteur.ServiceInfo2Subscription,RobotRaconteur.ServiceSubscriptionClientID,T],None]`` :rtype: RobotRaconteur.EventHook """ return self._ClientConnected @ClientConnected.setter def ClientConnected(self, evt): if (evt is not self._ClientConnected): raise RuntimeError("Invalid operation") @property def ClientDisconnected(self): """ Event hook for client disconnected events. Use to add handlers to be called when a client is disconnected. .. code-block:: python def my_handler(sub, subscription_id, connected_service): # Process lost service pass my_service_sub.ClientDisconnected += my_handler Handler must have signature ``Callable[[RobotRaconteur.ServiceInfo2Subscription,RobotRaconteur.ServiceSubscriptionClientID,T],None]`` :rtype: RobotRaconteur.EventHook """ return self._ClientDisconnected @ClientDisconnected.setter def ClientDisconnected(self, evt): if (evt is not self._ClientDisconnected): raise RuntimeError("Invalid operation") @property def ClientConnectFailed(self): """ Event hook for client client connect failed events. Used to receive notification of when a client connection was not successful, including the urls and resulting exceptions. .. code-block:: python def my_handler(sub, subscription_id, candidate_urls, exceptions): # Process lost service pass my_service_sub.ClientDisconnected += my_handler Handler must have signature ``Callable[[RobotRaconteur.ServiceInfo2Subscription,RobotRaconteur.ServiceSubscriptionClientID,List[str],List[Exception]],None]`` :rtype: RobotRaconteur.EventHook """ return self._ClientConnectFailed @ClientConnectFailed.setter def ClientConnectFailed(self, evt): if (evt is not self._ClientConnectFailed): raise RuntimeError("Invalid operation") def GetDefaultClient(self): """ Get the "default client" connection The "default client" is the "first" client returned from the connected clients map. This is effectively default, and is only useful if only a single client connection is expected. This is normally true for RobotRaconteurNode.SubscribeService() Clients using GetDefaultClient() should not store a reference to the client. It should instead call GetDefaultClient() right before using the client to make sure the most recenty connection is being used. If possible, SubscribePipe() or SubscribeWire() should be used so the lifecycle of pipes and wires can be managed automatically. :return: The client connection """ return self._GetClientStub(self._subscription.GetDefaultClient()) def TryGetDefaultClient(self): """ Try getting the "default client" connection Same as GetDefaultClient(), but returns a bool success instead of throwing exceptions on failure. :return: Success and client (if successful) as a tuple :rtype: Tuple[bool,T] """ res = self._subscription.TryGetDefaultClient() if not res.res: return False, None return True, self._GetClientStub(res.client) def GetDefaultClientWait(self, timeout=-1): """ Get the "default client" connection, waiting with timeout if not connected The "default client" is the "first" client returned from the connected clients map. This is effectively default, and is only useful if only a single client connection is expected. This is normally true for RobotRaconteurNode.SubscribeService() Clients using GetDefaultClient() should not store a reference to the client. It should instead call GetDefaultClient() right before using the client to make sure the most recenty connection is being used. If possible, SubscribePipe() or SubscribeWire() should be used so the lifecycle of pipes and wires can be managed automatically. :param timeout: Timeout in seconds, or -1 for infinite :type timeout: float :return: The client connection """ return self._GetClientStub(self._subscription.GetDefaultClientWait(adjust_timeout(timeout))) def TryGetDefaultClientWait(self, timeout=-1): """ Try getting the "default client" connection, waiting with timeout if not connected Same as GetDefaultClientWait(), but returns a bool success instead of throwing exceptions on failure. :return: Success and client (if successful) as a tuple :rtype: Tuple[bool,T] """ res = self._subscription.TryGetDefaultClientWait( adjust_timeout(timeout)) if not res.res: return False, None return True, self._GetClientStub(res.client) def AsyncGetDefaultClient(self, handler, timeout=-1): """ Asynchronously get the default client, with optional timeout Same as GetDefaultClientWait(), but returns asynchronously. If ``handler`` is None, returns an awaitable future. :param handler: The handler to call when default client is available, or times out :type handler: Callable[[bool,object],None] :param timeout: Timeout in seconds, or -1 for infinite :type timeout: float """ return async_call(self._subscription.AsyncGetDefaultClient, (adjust_timeout(timeout),), AsyncStubReturnDirectorImpl, handler) def GetNode(self): return self._subscription.GetNode() @property def ServiceURL(self): """ Get the service connection URL Returns the service connection URL. Only valid when subscription was created using RobotRaconteurNode.SubscribeService(). Will throw an exception if subscription was opened using RobotRaconteurNode.SubscribeServiceByType() """ return list(self._subscription.GetServiceURL()) def UpdateServiceURL(self, url, username=None, credentials=None, close_connected=False): """ Update the service connection URL Updates the URL used to connect to the service. If close_connected is True, existing connections will be closed. If False, existing connections will not be closed. :param url: The new URL to use to connect to service :type url: Union[str,List[str]] :param username: An optional username for authentication :type username: str :param credentials: Optional credentials for authentication :type credentials: Dict[str,Any] :param close_connected: Optional, (default False) Close existing connections """ if username is None: username = "" if credentials is not None: credentials = PackMessageElement( credentials, "varvalue{string}", None, self._subscription.GetNode()).GetData() self._subscription.UpdateServiceURL( url, username, credentials, "", close_connected) def UpdateServiceByType(self, service_types, filter_=None): """ Update the service types and filter :param service_types: The new service types to use to connect to service :type service_types: Union[str,List[str]] :param filter_: Optional filter to use to connect to service :type filter_: Union[str,RobotRaconteurPython.ServiceSubscriptionFilter] """ node = self._subscription.GetNode() filter2 = _SubscribeService_LoadFilter(node, filter_) service_types2 = RobotRaconteurPython.vectorstring() if (sys.version_info > (3, 0)): if (isinstance(service_types, str)): service_types2.append(service_types) else: for s in service_types: service_types2.append(s) else: if (isinstance(service_types, (str, unicode))): service_types2.append(service_types) else: for s in service_types: service_types2.append(s) self._subscription.UpdateServiceByType(service_types2, filter2) class WrappedWireSubscriptionDirectorPython(RobotRaconteurPython.WrappedWireSubscriptionDirector): def __init__(self, subscription): super(WrappedWireSubscriptionDirectorPython, self).__init__() self._subscription = weakref.ref(subscription) def WireValueChanged(self, subscription, value, time): s = self._subscription() if (s is None): return try: v = RobotRaconteurPython._UnpackMessageElement( value.packet, value.type, value.stub, None) s.WireValueChanged.fire(s, v, time) except: traceback.print_exc() class WireSubscription(object): """ WireSubscription() Subscription for wire members that aggregates the values from client wire connections Wire subscriptions are created using the ServiceSubscription.SubscribeWire() function. This function takes the type of the wire value, the name of the wire member, and an optional service path of the service object that owns the wire member. Wire subscriptions aggregate the InValue from all active wire connections. When a client connects, the wire subscriptions will automatically create wire connections to the wire member specified when the WireSubscription was created using ServiceSubscription.SubscribeWire(). The InValue of all the active wire connections are collected, and the most recent one is used as the current InValue of the wire subscription. The current value, the timespec, and the wire connection can be accessed using GetInValue() or TryGetInValue(). The lifespan of the InValue can be configured using the InValueLifeSpan property. It is recommended that the lifespan be configured, so that the value will expire if the subscription stops receiving fresh in values. The wire subscription can also be used to set the OutValue of all active wire connections. This behaves similar to a "reverse broadcaster", sending the same value to all connected services. """ __slots__ = ["_subscription", "_WireValueChanged", "__weakref__"] def __init__(self, subscription): self._subscription = subscription director = WrappedWireSubscriptionDirectorPython(self) subscription.SetRRDirector(director, 0) director.__disown__() self._WireValueChanged = EventHook() def _UnpackValue(self, m): return RobotRaconteurPython._UnpackMessageElement(m.packet, m.type, m.stub, None) @property def InValue(self): """ Get the current InValue Throws ValueNotSetException if no valid value is available :return: The current InValue """ return self._UnpackValue(self._subscription.GetInValue()) @property def InValueWithTimeSpec(self): """ Get the current InValue and TimeSpec Throws ValueNotSetException if no valid value is available :return: The current InValue and TimeSpec :rtype: Tuple[T,RobotRaconteur.TimeSpec] """ t = RobotRaconteurPython.TimeSpec() m = self._subscription.GetInValue(t) return (self._UnpackValue(m), t) def WaitInValueValid(self, timeout=-1): """ Wait for a valid InValue to be received from a client Blocks the current thread until value is received or timeout :param timeout: The timeout in seconds :type timeout: float :return: True if value was received, otherwise False :rtype: bool """ return self._subscription.WaitInValueValid(adjust_timeout(timeout)) def TryGetInValue(self): """ Try getting the current InValue and metadata Same as GetInValue(), but returns a bool for success or failure instead of throwing an exception. :return: Success and value (if successful) :rtype: Tuple[bool,T,RobotRaconteur.TimeSpec] """ val = RobotRaconteurPython.WrappedService_typed_packet() t = RobotRaconteurPython.TimeSpec() res = self._subscription.TryGetInValue(val, t) if not res: return False, None, None return (True, self._UnpackValue(val), t) @property def ActiveWireConnectionCount(self): """ Get the number of wire connections currently connected :rtype: int """ return self._subscription.GetActiveWireConnectionCount() @property def IgnoreInValue(self): """ Set if InValue should be ignored See WireConnection.IgnoreInValue If true, InValue will be ignored for all wire connections :rtype: bool """ return self._subscription.GetIgnoreInValue() @IgnoreInValue.setter def IgnoreInValue(self, ignore): self._subscription.SetIgnoreInValue(ignore) @property def InValueLifespan(self): """ Set the InValue lifespan in seconds Set the lifespan of InValue in seconds. The value will expire after the specified lifespan, becoming invalid. Use -1 for infinite lifespan. See also WireConnection.InValueLifespan :rtype: float """ t = self._subscription.GetInValueLifespan() if t < 0: return t return float(t) / 1000.0 @InValueLifespan.setter def InValueLifespan(self, secs): if secs < 0: self._subscription.SetInValueLifespan(-1) else: self._subscription.SetInValueLifespan(int(secs * 1000.0)) def SetOutValueAll(self, value): """ Set the OutValue for all active wire connections Behaves like a "reverse broadcaster". Calls WireConnection.OutValue for all connected wire connections. :param value: The value to send """ iter = RobotRaconteurPython.WrappedWireSubscription_send_iterator( self._subscription) try: while iter.Next() is not None: m = PackMessageElement(value, iter.GetType(), iter.GetStub()) iter.SetOutValue(m) finally: del iter def Close(self): """ Closes the wire subscription Wire subscriptions are automatically closed when the parent ServiceSubscription is closed or when the node is shut down. """ self._subscription.Close() @property def WireValueChanged(self): """ Event hook for wire value change. Use to add handlers to be called when the InValue changes. .. code-block:: python def my_handler(sub, value, ts): # Handle new value pass my_wire_csub.WireValueChanged += my_handler Handler must have signature ``Callable[[RobotRaconteur.WireSubscription,T,RobotRaconteur.TimeSpec],None]`` :rtype: RobotRaconteur.EventHook """ return self._WireValueChanged @WireValueChanged.setter def WireValueChanged(self, evt): if (evt is not self._WireValueChanged): raise RuntimeError("Invalid operation") def GetNode(self): return self._subscription.GetNode() class WrappedPipeSubscriptionDirectorPython(RobotRaconteurPython.WrappedPipeSubscriptionDirector): def __init__(self, subscription): super(WrappedPipeSubscriptionDirectorPython, self).__init__() self._subscription = weakref.ref(subscription) def PipePacketReceived(self, subscription): s = self._subscription() if (s is None): return try: s.PipePacketReceived.fire(s) except: traceback.print_exc() class PipeSubscription(object): """ PipeSubscription() Subscription for pipe members that aggregates incoming packets from client pipe endpoints Pipe subscriptions are created using the ServiceSubscription.SubscribePipe() function. This function takes the the type of the pipe packets, the name of the pipe member, and an optional service path of the service object that owns the pipe member. Pipe subscriptions collect all incoming packets from connect pipe endpoints. When a client connects, the pipe subscription will automatically connect a pipe endpoint the pipe endpoint specified when the PipeSubscription was created using ServiceSubscription.SubscribePipe(). The packets received from each of the collected pipes are collected and placed into a common receive queue. This queue is read using ReceivePacket(), TryReceivePacket(), or TryReceivePacketWait(). The number of packets available to receive can be checked using Available(). Pipe subscriptions can also be used to send packets to all connected pipe endpoints. This is done with the AsyncSendPacketAll() function. This function behaves somewhat like a "reverse broadcaster", sending the packets to all connected services. If the pipe subscription is being used to send packets but not receive them, IgnoreInValue should be set to true to prevent packets from queueing. """ __slots__ = ["_subscription", "_PipePacketReceived", "__weakref__"] def __init__(self, subscription): self._subscription = subscription director = WrappedPipeSubscriptionDirectorPython(self) subscription.SetRRDirector(director, 0) director.__disown__() self._PipePacketReceived = EventHook() def _UnpackValue(self, m): return RobotRaconteurPython._UnpackMessageElement(m.packet, m.type, m.stub, None) def ReceivePacket(self): """ Dequeue a packet from the receive queue If the receive queue is empty, an InvalidOperationException() is thrown :return: The dequeued packet """ return self._UnpackValue(self._subscription.ReceivePacket()) def TryReceivePacket(self): """ Try dequeuing a packet from the receive queue Same as ReceivePacket(), but returns a bool for success or failure instead of throwing an exception :return: Success and packet (if successful) :rtype: Tuple[bool,T] """ return self.TryReceivePacketWait(0) def TryReceivePacketWait(self, timeout=-1, peek=False): """ Try dequeuing a packet from the receive queue, optionally waiting or peeking the packet :param timeout: The time to wait for a packet to be received in seconds if the queue is empty, or -1 to wait forever :type timeout: float :param peek: If True, the packet is returned, but not dequeued. If False, the packet is dequeued :type peek: bool :return: Success and packet (if successful) :rtype: Tuple[bool,T] """ val = RobotRaconteurPython.WrappedService_typed_packet() res = self._subscription.TryReceivePacketWait( val, adjust_timeout(timeout), peek) if (not res): return (False, None) else: return (True, self._UnpackValue(val)) @property def Available(self): """ Get the number of packets available to receive Use ReceivePacket(), TryReceivePacket(), or TryReceivePacketWait() to receive the packet :rtype: int """ return self._subscription.Available() def AsyncSendPacketAll(self, packet): """ Sends a packet to all connected pipe endpoints Calls AsyncSendPacket() on all connected pipe endpoints with the specified value. Returns immediately, not waiting for transmission to complete. :param packet: The packet to send """ iter = RobotRaconteurPython.WrappedPipeSubscription_send_iterator( self._subscription) try: while iter.Next() is not None: m = PackMessageElement(packet, iter.GetType(), iter.GetStub()) iter.AsyncSendPacket(m) finally: del iter @property def ActivePipeEndpointCount(self): """ Get the number of pipe endpoints currently connected :rtype: int """ return self._subscription.GetActivePipeEndpointCount() def Close(self): """ Closes the pipe subscription Pipe subscriptions are automatically closed when the parent ServiceSubscription is closed or when the node is shut down. """ return self._subscription.Close() @property def PipePacketReceived(self): """ Event hook for packet received. Use to add handlers to be called when the subscription receives a new packet. .. code-block:: python def my_handler(pipe_sub): while pipe_sub.Available > 0: packet = pipe_sub.ReceivePacket() # Handle new packet pass my_pipe_sub.PipePacketReceived+= my_handler Handler must have signature ``Callable[[RobotRaconteur.PipeSubscription],None]`` :rtype: RobotRaconteur.EventHook """ return self._PipePacketReceived @PipePacketReceived.setter def PipePacketReceived(self, evt): if (evt is not self._PipePacketReceived): raise RuntimeError("Invalid operation") def GetNode(self): return self._subscription.GetNode() class SubObjectSubscription(object): """ Subscription for sub objects of the default client. SubObjectSubscription is used to access sub objects of the default client. Sub objects are objects within a service that are not the root object. Sub objects are typically referenced using objref members, however they can also be referenced using a service path. The SubObjectSubscription class is used to automatically access sub objects of the default client. Use ServiceSubscription.SubscribeSubObject() to create a SubObjectSubscription. This class should not be used to access Pipe or Wire members. Use the ServiceSubscription.SubscribePipe() and ServiceSubscription.SubscribeWire() functions to access Pipe and Wire members. """ def __init__(self, parent, subscription): self._parent = parent self._subscription = subscription def GetDefaultClient(self): """ Get the "default client" sub object. The sub object is retrieved from the default client. The default client is the first client that connected to the service. If no clients are currently connected, an exception is thrown. Clients using GetDefaultClient() should not store a reference to the client. Call GetDefaultClient() each time the client is needed. :return: The sub object :rtype: T """ return self._parent._GetClientStub(self._subscription.GetDefaultClient()) def TryGetDefaultClient(self): """ Try getting the "default client" sub object. Same as GetDefaultClient(), but returns a bool success instead of throwing exceptions on failure. :return: Success and client (if successful) as a tuple :rtype: Tuple[bool,T] """ res = self._subscription.TryGetDefaultClient() if not res.res: return False, None return True, self._parent._GetClientStub(res.client) def GetDefaultClientWait(self, timeout=-1): """ Get the "default client" sub object, waiting with timeout if not connected The sub object is retrieved from the default client. The default client is the first client that connected to the service. If no clients are currently connected, an exception is thrown. Clients using GetDefaultClient() should not store a reference to the client. Call GetDefaultClient() each time the client is needed. :param timeout: Timeout in seconds, or -1 for infinite :type timeout: float :return: The sub object """ return self._parent._GetClientStub(self._subscription.GetDefaultClientWait(adjust_timeout(timeout))) def TryGetDefaultClientWait(self, timeout=-1): """ Try getting the "default client" sub object, waiting with timeout if not connected Same as GetDefaultClientWait(), but returns a bool success instead of throwing exceptions on failure. :return: Success and client (if successful) as a tuple :rtype: Tuple[bool,T] """ res = self._subscription.TryGetDefaultClientWait(adjust_timeout(timeout)) if not res.res: return False, None return True, self._parent._GetClientStub(res.client) def AsyncGetDefaultClient(self, handler, timeout=-1): """ Asynchronously get the default client, with optional timeout Same as GetDefaultClientWait(), but returns asynchronously. If ``handler`` is None, returns an awaitable future. :param handler: The handler to call when default client is available, or times out :type handler: Callable[[bool,object],None] :param timeout: Timeout in seconds, or -1 for infinite :type timeout: float """ return async_call(self._subscription.AsyncGetDefaultClient, (adjust_timeout(timeout),), AsyncStubReturnDirectorImpl, handler) def GetNode(self): return self._subscription.GetNode() class WrappedServiceSubscriptionFilterPredicateDirectorPython(RobotRaconteurPython.WrappedServiceSubscriptionFilterPredicateDirector): def __init__(self, f): super(WrappedServiceSubscriptionFilterPredicateDirectorPython, self).__init__() self._f = f def Predicate(self, info): info2 = ServiceInfo2(info) return self._f(info2) def _SubscribeService_LoadFilter(node, filter_): filter2 = None if (filter_ is not None): filter2 = RobotRaconteurPython.WrappedServiceSubscriptionFilter() if (filter_.ServiceNames is not None): for s in filter_.ServiceNames: filter2.ServiceNames.append(s) if (filter_.TransportSchemes is not None): for s in filter_.TransportSchemes: filter2.TransportSchemes.append(s) filter2.MaxConnections = filter_.MaxConnections if (filter_.Attributes is not None): for n, v in filter_.Attributes.items(): filter2.Attributes[n] = v filter2.AttributesMatchOperation = filter_.AttributesMatchOperation if (filter_.Nodes is not None): nodes2 = RobotRaconteurPython.vectorptr_wrappedservicesubscriptionnode() for n1 in filter_.Nodes: if (n1 is None): continue n2 = RobotRaconteurPython.WrappedServiceSubscriptionFilterNode() if (n1.NodeID is not None): n2.NodeID = n1.NodeID if (n1.NodeName is not None): n2.NodeName = n1.NodeName if (n1.Username is not None): n2.Username = n1.Username if (n1.Credentials is not None): n2.Credentials = PackMessageElement( n1.Credentials, "varvalue{string}", None, node).GetData() nodes2.append(n2) filter2.Nodes = nodes2 if (filter_.Predicate is not None): director = WrappedServiceSubscriptionFilterPredicateDirectorPython( filter_.Predicate) filter2.SetRRPredicateDirector(director, 0) director.__disown__() return filter2 def SubscribeServiceInfo2(node, service_types, filter_=None): filter2 = _SubscribeService_LoadFilter(node, filter_) service_types2 = RobotRaconteurPython.vectorstring() if (sys.version_info > (3, 0)): if (isinstance(service_types, str)): service_types2.append(service_types) else: for s in service_types: service_types2.append(s) else: if (isinstance(service_types, (str, unicode))): service_types2.append(service_types) else: for s in service_types: service_types2.append(s) sub1 = RobotRaconteurPython.WrappedSubscribeServiceInfo2( node, service_types2, filter2) return ServiceInfo2Subscription(sub1) def SubscribeServiceByType(node, service_types, filter_=None): filter2 = _SubscribeService_LoadFilter(node, filter_) service_types2 = RobotRaconteurPython.vectorstring() if (sys.version_info > (3, 0)): if (isinstance(service_types, str)): service_types2.append(service_types) else: for s in service_types: service_types2.append(s) else: if (isinstance(service_types, (str, unicode))): service_types2.append(service_types) else: for s in service_types: service_types2.append(s) sub1 = RobotRaconteurPython.WrappedSubscribeServiceByType( node, service_types2, filter2) return ServiceSubscription(sub1) def SubscribeService(node, *args): args2 = list(args) if (len(args) >= 3): if (args[1] == None): args2[1] = "" args2[2] = PackMessageElement( args[2], "varvalue{string}", None, node).GetData() sub1 = RobotRaconteurPython.WrappedSubscribeService(node, *args2) return ServiceSubscription(sub1) class ServiceSubscriptionManagerDetails(object): """ ServiceSubscriptionManager subscription connection information Contains the connection information for a ServiceSubscriptionManager subscription and the local name of the subscription """ __slots__ = ["Name", "ConnectionMethod", "Urls", "UrlUsername", "UrlCredentials", "ServiceTypes", "Filter", "Enabled"] def __init__(self, Name=None, ConnectionMethod=None, Urls=None, UrlUsername=None, UrlCredentials=None, ServiceTypes=None, Filter=None, Enabled=True ): self.Name = Name """(str) The local name of the subscription""" self.ConnectionMethod = ConnectionMethod """(ServiceSubscriptionManager_CONNECTION_METHOD) The connection method used to connect to the service""" self.Urls = Urls """(List[str]) The URLs used to connect to the service""" self.UrlUsername = UrlUsername """(str) The username used to connect to the service""" self.UrlCredentials = UrlCredentials """(Dict[str,Any]) The credentials used to connect to the service""" self.ServiceTypes = ServiceTypes """(List[str]) The service types used to connect to the service""" self.Filter = Filter """(ServiceSubscriptionFilter) The filter used to connect to the service""" self.Enabled = Enabled """(bool) True if the subscription is enabled""" def _ServiceSubscriptionManager_LoadDetails(node, details): if details is None: return None details2 = RobotRaconteurPython.WrappedServiceSubscriptionManagerDetails() if details.Name is not None: details2.Name = details.Name if details.ConnectionMethod is not None: details2.ConnectionMethod = details.ConnectionMethod if details.Urls is not None: for s in details.Urls: details2.Urls.append(s) if details.UrlUsername is not None: details2.UrlUsername = details.UrlUsername if details.UrlCredentials is not None: details2.UrlCredentials = PackMessageElement( details.UrlCredentials, "varvalue{string}", None, node).GetData() if details.ServiceTypes is not None: if isinstance(details.ServiceTypes, str): details2.ServiceTypes.append(details.ServiceTypes) else: for s in details.ServiceTypes: details2.ServiceTypes.append(s) if details.Filter is not None: details2.Filter = _SubscribeService_LoadFilter(node, details.Filter) details2.Enabled = details.Enabled return details2 class ServiceSubscriptionManager(object): """ Class to manage multiple subscriptions to services ServiceSubscriptionManager is used to manage multiple subscriptions to services. Subscriptions are created using information contained in ServiceSubscriptionManagerDetails structures. The subscriptions can connect using URLs or service types. The subscriptions can be enabled or disabled, and can be closed. :param details: (optional) A list of ServiceSubscriptionManagerDetails structures :type details: List[ServiceSubscriptionManagerDetails] :param node: (optional) The RobotRaconteurNode to use :type node: RobotRaconteur.RobotRaconteurNode """ def __init__(self, details=None, node=None): if node is None: node = RobotRaconteurPython.RobotRaconteurNode.s details2 = RobotRaconteurPython.vector_wrappedservicesubscriptionmanagerdetails() if details is not None: for d in details: details2.append(_ServiceSubscriptionManager_LoadDetails(node, d)) self._subscription_manager = RobotRaconteurPython.WrappedServiceSubscriptionManager(details2, node) self._subscriptions = {} self._lock = threading.Lock() def AddSubscription(self, details): """ Add a subscription to the manager :param details: The subscription to add :type details: ServiceSubscriptionManagerDetails """ details2 = _ServiceSubscriptionManager_LoadDetails(self._subscription_manager.GetNode(), details) self._subscription_manager.AddSubscription(details2) def RemoveSubscription(self, name, close=True): """ Remove a subscription from the manager :param name: The name of the subscription to remove :type name: str :param close: (default True) Close the subscription :type close: bool """ with self._lock: self._subscription_manager.RemoveSubscription(name) if close: del self._subscriptions[name] def EnableSubscription(self, name): """ Enable a subscription :param name: The name of the subscription to enable :type name: str """ self._subscription_manager.EnableSubscription(name) def DisableSubscription(self, name, close=True): """ Disable a subscription :param name: The name of the subscription to disable :type name: str """ self._subscription_manager.DisableSubscription(name, close) def GetSubscription(self, name, force_create=False): """ Get a subscription by name :param name: The name of the subscription to get :type name: str :param force_create: (default False) Create the subscription if it does not exist :type force_create: bool :return: The subscription :rtype: ServiceSubscription """ with self._lock: sub = self._subscriptions.get(name, None) if sub is None: sub1 = self._subscription_manager.GetSubscription(name, force_create) if sub1 is None: return None sub = ServiceSubscription(sub1) self._subscriptions[name] = sub return sub def IsConnected(self, name): """ Check if a subscription is connected :param name: The name of the subscription to check :type name: str :return: True if the subscription is connected :rtype: bool """ return self._subscription_manager.IsConnected(name) def IsEnabled(self, name): """ Get if a subscription is enabled :param name: The name of the subscription to check :type name: str :return: True if the subscription is enabled :rtype: bool """ return self._subscription_manager.IsEnabled(name) def Close(self, close_subscriptions=True): """ Close the subscription manager :param close_subscriptions: (default True) Close all subscriptions :type close_subscriptions: bool """ self._subscription_manager.Close(close_subscriptions) with self._lock: self._subscriptions.clear() @property def SubscriptionNames(self): """ Get the names of all subscriptions :rtype: List[str] """ return list(self._subscription_manager.GetSubscriptionNames()) @property def SubscriptionDetails(self): """ Get the details of all subscriptions :rtype: List[ServiceSubscriptionManagerDetails] """ details = [] for d in self._subscription_manager.GetSubscriptionDetails(): d2 = ServiceSubscriptionManagerDetails() d2.Name = d.Name d2.ConnectionMethod = d.ConnectionMethod d2.Urls = list(d.Urls) d2.ServiceTypes = list(d.ServiceTypes) d2.Enabled = d.Enabled details.append(d2) return details class WrappedUserAuthenticatorDirectorPython(RobotRaconteurPython.WrappedUserAuthenticatorDirector): def __init__(self, target): super(WrappedUserAuthenticatorDirectorPython, self).__init__() self.target = target def AuthenticateUser(self, username, credentials, context): c2 = UnpackMessageElement(credentials, "varvalue{string}") ret = self.target.AuthenticateUser(username, c2, context) return ret def _UserAuthenticator_PackCredentials(credentials): return PackMessageElement(credentials, "varvalue{string}") def ReadServiceDefinitionFile(servicedef_name): f_name = None if (os.path.isfile(servicedef_name)): f_name = servicedef_name elif (os.path.isfile(servicedef_name + '.robdef')): f_name = servicedef_name + '.robdef' elif not os.path.isabs(servicedef_name): p = os.getenv("ROBOTRACONTEUR_ROBDEF_PATH", None) if p is not None: p1 = p.split(os.pathsep) for p2 in p1: p3 = p2.strip() if (os.path.isfile(os.path.join(p3, servicedef_name))): f_name = os.path.join(p3, servicedef_name) if (os.path.isfile(os.path.join(p3, servicedef_name + '.robdef'))): f_name = os.path.join(p3, servicedef_name + '.robdef') if f_name is None: raise IOError("Service definition file %s not found" % servicedef_name) with codecs.open(f_name, 'r', 'utf-8-sig') as f: return f.read() def ReadServiceDefinitionFiles(servicedef_names, auto_import=False): d = [] for servicedef_name in servicedef_names: d1 = RobotRaconteurPython.ServiceDefinition() d1.FromString(str(ReadServiceDefinitionFile(servicedef_name))) d.append(d1) if auto_import: missing_imports = set() d2 = {d3.Name: d3 for d3 in d} for k, v in d2.items(): for imported in v.Imports: if imported not in d2: missing_imports.add(imported) attempted_imports = set() while len(missing_imports) != 0: e = missing_imports.pop() d1 = RobotRaconteurPython.ServiceDefinition() d1.FromString(str(ReadServiceDefinitionFile(e))) d.append(d1) d2[d1.Name] = d1 for imported in d1.Imports: if imported not in d2: missing_imports.add(imported) return d class RobotRaconteurNodeSetup(object): """ Setup a node using specified options and manage node lifecycle RobotRaconteurNodeSetup and its subclasses ClientNodeSetup, ServerNodeSetup, and SecureServerNodeSetup are designed to help configure nodes and manage node lifecycles. The node setup classes use the "with" statement to configure the node on construction, and call RobotRaconteurNode.Shutdown() when the instance is destroyed. The node setup classes execute the following operations to configure the node: 1. Set log level and tap options from flags, command line options, or environmental variables 2. Register specified service factory types 3. Initialize transports using flags specified in flags or from command line options 4. Configure timeouts See Command Line Options for more information on available command line options. Logging level is configured using the environmental variable ``ROBOTRACONTEUR_LOG_LEVEL`` or the command line option ``--robotraconteur-log-level``. See Logging for more information. See Taps for more information on using taps. The node setup classes optionally initialize LocalTransport, TcpTransport, HardwareTransport, and/or IntraTransport. Transports for more information. The LocalTransport.StartServerAsNodeName() or LocalTransport.StartClientAsNodeName() are used to load the NodeID. See LocalTransport for more information on this procedure. :param node_name: (optional) The NodeName :type node_name: str :param tcp_port: (optional) The port to listen for incoming TCP clients :type tcp_port: int :param flags: (optional) The configuration flags :type flags: int :param allowed_overrides: (optional) The allowed override flags :type allowed_overrides: int :param node: (optional) The node to configure and manage lifecycle :type node: RobotRaconteur.RobotRaconteurNode :param argv: (optional) The command line argument vector. Default is ``sys.argv`` """ __slots__ = ["__setup", "__node"] def __init__(self, node_name=None, tcp_port=None, flags=None, allowed_overrides=None, node=None, argv=None, config=None): if (config is not None): assert node_name is None and tcp_port is None and flags is None and allowed_overrides is None and argv is None self.__setup = RobotRaconteurPython.WrappedRobotRaconteurNodeSetup( config) else: if node_name is None: node_name = "" if tcp_port is None: tcp_port = 0 if flags is None: flags = 0 if node is None: node = RobotRaconteurPython.RobotRaconteurNode.s if allowed_overrides is None: allowed_overrides = 0 if argv is None: argv = sys.argv self.__setup = RobotRaconteurPython.WrappedRobotRaconteurNodeSetup(node, node_name, tcp_port, flags, allowed_overrides, RobotRaconteurPython.vectorstring(argv)) self.__node = node @property def tcp_transport(self): """The TcpTransport, will be None if TcpTransport is not specified in flags""" return self.__setup.GetTcpTransport() @property def local_transport(self): """The LocalTransport, will be None if LocalTransport is not specified in flags""" return self.__setup.GetLocalTransport() @property def hardware_transport(self): """The HardwareTransport, will be None if HardwareTransport is not specified in flags, Note: Hardware transport is not enabled by default""" return self.__setup.GetHardwareTransport() @property def intra_transport(self): """The IntraTransport, will be None if IntraTransport is not specified in flags""" return self.__setup.GetIntraTransport() @property def command_line_config(self): """The command line config parser object used to configure node""" return self.__setup.GetCommandLineConfig() def __enter__(self): return self def __exit__(self, etype, value, traceback): self.close() def close(self): """Shutdown the node and release the node from lifecycle management""" if self.__node is not None: self.__node.Shutdown() self.__node = None if self.__setup is not None: self.__setup.ReleaseNode() self.__setup = None def ReleaseNode(self): """ Release the node from lifecycle management If called, RobotRaconteurNode.Shutdown() will not be called when the node setup instance is destroyed """ if self.__setup is None: return self.__node = None self.__setup.ReleaseNode() class ClientNodeSetup(RobotRaconteurNodeSetup): """ Initializes a RobotRaconteurNode instance to default configuration for a client only node ClientNodeSetup is a subclass of RobotRaconteurNodeSetup providing default configuration for a RobotRaconteurNode instance that is used only to create outgoing client connections. See CommandLineOptions for more information on available command line options. Note: String table and HardwareTransport are disabled by default. They can be enabled using command line options. By default, the configuration will do the following: 1. Configure logging level from environmental variable or command line options. Defaults to `INFO` if not specified 2. Configure tap if specified in command line options 3. Register service types passed to service_types 4. Start LocalTransport (default enabled) 1. If `RobotRaconteurNodeSetupFlags_LOCAL_TRANSPORT_START_CLIENT` flag is specified, call LocalTransport.StartServerAsNodeName() with the specified node_name 2. Start LocalTransport discovery listening if specified in flags or on command line (default enabled) 3. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified on command line 5. Start TcpTransport (default enabled) 1. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 2. Start TcpTranport discovery listening (default enabled) 3. Load TLS certificate and set if TLS is specified on command line (default disabled) 4. Process WebSocket origin command line options 6. Start HardwareTransport (default disabled) 1. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 7. Start IntraTransport (default enabled) 1. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 8. Disable timeouts if specified in flags or command line (default timeouts normal) Most users will not need to be concerned with these details, and can simply use the default configuration. :param node_name: (optional) The NodeName :type node_name: str :param node: (optional) The node to configure and manage lifecycle :type node: RobotRaconteur.RobotRaconteurNode :param argv: (optional) The command line argument vector. Default is ``sys.argv`` """ def __init__(self, node_name=None, node=None, argv=None): super(ClientNodeSetup, self).__init__(node_name, 0, RobotRaconteurPython.RobotRaconteurNodeSetupFlags_CLIENT_DEFAULT, RobotRaconteurPython.RobotRaconteurNodeSetupFlags_CLIENT_DEFAULT_ALLOWED_OVERRIDE, node, argv) class ServerNodeSetup(RobotRaconteurNodeSetup): """ Initializes a RobotRaconteurNode instance to default configuration for a server and client node ServerNodeSetup is a subclass of RobotRaconteurNodeSetup providing default configuration for a RobotRaconteurNode instance that is used as a server to accept incoming client connections and to initiate client connections. ServerNodeSetup requires a NodeName, and a TCP port if LocalTransport and TcpTransport are enabled (default behavior). See Command Line Options for more information on available command line options. Note: String table and HardwareTransport are disabled by default. They can be enabled using command line options. By default, the configuration will do the following: 1. Configure logging level from environmental variable or command line options. Defaults to `INFO` if not specified 2. Configure tap if specified in command line options 3. Register service types passed to service_types 4. Start LocalTransport (default enabled) 1. Configure the node to use the specified NodeName, and load the NodeID from the filesystem based based on the NodeName. NodeID will be automatically generated if not previously used. 1. If "public" option is set, the transport will listen for all local users (default disabled) 2. Start the LocalTransport server to listen for incoming connections with the specified NodeName and NodeID 3. Start LocalTransport discovery announce and listening (default enabled) 4. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified on command line 5. Start TcpTransport (default enabled) 1. Start the TcpTransport server to listen for incoming connections on specified port or using the port sharer (default enabled using specified port) 2. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 3. Start TcpTranport discovery announce and listening (default enabled) 4. Load TLS certificate and set if TLS is specified on command line (default disabled) 5. Process WebSocket origin command line options 6. Start HardwareTransport (default disabled) 1. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 7. Start IntraTransport (default enabled) 1. Enable IntraTransport server to listen for incoming clients (default enabled) 2. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 8. Disable timeouts if specified in flags or command line (default timeouts normal) Most users will not need to be concerned with these details, and can simply use the default configuration. :param node_name: The NodeName :type node_name: str :param tcp_port: The port to listen for incoming TCP clients :type tcp_port: int :param node: (optional) The node to configure and manage lifecycle :type node: RobotRaconteur.RobotRaconteurNode :param argv: (optional) The command line argument vector. Default is ``sys.argv`` """ def __init__(self, node_name, tcp_port, node=None, argv=None): super(ServerNodeSetup, self).__init__(node_name, tcp_port, RobotRaconteurPython.RobotRaconteurNodeSetupFlags_SERVER_DEFAULT, RobotRaconteurPython.RobotRaconteurNodeSetupFlags_SERVER_DEFAULT_ALLOWED_OVERRIDE, node, argv) class SecureServerNodeSetup(RobotRaconteurNodeSetup): """ Initializes a RobotRaconteurNode instance to default configuration for a secure server and client node SecureServerNodeSetup is a subclass of RobotRaconteurNodeSetup providing default configuration for a secure RobotRaconteurNode instance that is used as a server to accept incoming client connections and to initiate client connections. SecureServerNodeSetup is identical to ServerNodeSetup, except that it requires TLS for all network communication. ServerNodeSetup requires a NodeName, and a TCP port if LocalTransport and TcpTransport are enabled (default behavior). See Command Line Options for more information on available command line options. Note: String table and HardwareTransport are disabled by default. They can be enabled using command line options. By default, the configuration will do the following: 1. Configure logging level from environmental variable or command line options. Defaults to `INFO` if not specified 2. Configure tap if specified in command line options 3. Register service types passed to service_types 4. Start LocalTransport (default enabled) 1. Configure the node to use the specified NodeName, and load the NodeID from the filesystem based based on the NodeName. NodeID will be automatically generated if not previously used. 1. If "public" option is set, the transport will listen for all local users (default disabled) 2. Start the LocalTransport server to listen for incoming connections with the specified NodeName and NodeID 3. Start LocalTransport discovery announce and listening (default enabled) 4. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified on command line 5. Start TcpTransport (default enabled) 1. Start the TcpTransport server to listen for incoming connections on specified port or using the port sharer (default enabled using specified port) 2. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 3. Start TcpTranport discovery announce and listening (default enabled) 4. Load TLS certificate and set if TLS is specified on command line (default enabled, required) 5. Process WebSocket origin command line options 6. Start HardwareTransport (default disabled) 1. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 7. Start IntraTransport (default enabled) 1. Enable IntraTransport server to listen for incoming clients (default enabled) 2. Disable Message Format Version 4 (default enabled) and/or String Table (default disabled) if specified in flags or command line 8. Disable timeouts if specified in flags or command line (default timeouts normal) Most users will not need to be concerned with these details, and can simply use the default configuration. :param node_name: The NodeName :type node_name: str :param tcp_port: The port to listen for incoming TCP clients :type tcp_port: int :param node: (optional) The node to configure and manage lifecycle :type node: RobotRaconteur.RobotRaconteurNode :param argv: (optional) The command line argument vector. Default is ``sys.argv`` """ def __init__(self, node_name, tcp_port, node=None, argv=None): super(SecureServerNodeSetup, self).__init__(node_name, tcp_port, RobotRaconteurPython.RobotRaconteurNodeSetupFlags_SECURE_SERVER_DEFAULT, RobotRaconteurPython.RobotRaconteurNodeSetupFlags_SECURE_SERVER_DEFAULT_ALLOWED_OVERRIDE, node, argv) class UserLogRecordHandlerDirectorPython(RobotRaconteurPython.UserLogRecordHandlerDirector): def __init__(self, handler): super(UserLogRecordHandlerDirectorPython, self).__init__() self.handler = handler def HandleLogRecord(self, record): if self.handler is not None: self.handler(record) class UserLogRecordHandler(RobotRaconteurPython.UserLogRecordHandlerBase): def __init__(self, handler): super(UserLogRecordHandler, self).__init__() director = UserLogRecordHandlerDirectorPython(handler) self._SetHandler(director, 0) director.__disown__() class TapFileReader(object): __slots__ = ["_fileobj"] def __init__(self, fileobj): self._fileobj = fileobj def ReadNextMessage(self): len_bytes = self._fileobj.read(8) if (len(len_bytes) < 8): return None message_len = RobotRaconteurPython.MessageLengthFromBytes(len_bytes) message_bytes = len_bytes + self._fileobj.read(message_len - 8) if (len(message_bytes) < message_len): return None m = RobotRaconteurPython.MessageFromBytes(message_bytes) return m def UnpackMessageElement(self, el, node=None): if node is None: node = RobotRaconteurPython.RobotRaconteurNode.s return UnpackMessageElement(el, "varvalue value", None, node) def settrace(): enable_debugpy = os.environ.get( "ROBOTRACONTEUR_PYTHON_ENABLE_DEBUGPY", None) if enable_debugpy is not None: enable_debugpy = enable_debugpy.strip().lower() if enable_debugpy == "1" or enable_debugpy == "true": import debugpy debugpy.debug_this_thread() return enable_pydevd = os.environ.get("ROBOTRACONTEUR_PYTHON_ENABLE_PYDEVD", None) if enable_pydevd is not None: enable_pydevd = enable_pydevd.strip().lower() if enable_pydevd == "1" or enable_pydevd == "true": import pydevd pydevd.settrace(suspend=False)