FreeOpcUa / python-opcua

    def __str__(self):

        return 'GetEndpointsRequest(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'RequestHeader:' + str(self.RequestHeader) + ', ' + \

               'Parameters:' + str(self.Parameters) + ')'

    __repr__ = __str__

class GetEndpointsResponse(FrozenClass):

    '''

    Gets the endpoints used by the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Endpoints:

    :vartype Endpoints: EndpointDescription

    '''

    ua_types = (

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

        ('Endpoints', 'ListOfEndpointDescription'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.GetEndpointsResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Endpoints = []

        self._freeze = True

class TrustListDataType(FrozenClass):

    '''

    :ivar SpecifiedLists:

    :vartype SpecifiedLists: UInt32

    :ivar TrustedCertificates:

    :vartype TrustedCertificates: ByteString

    :ivar TrustedCrls:

    :vartype TrustedCrls: ByteString

    :ivar IssuerCertificates:

    :vartype IssuerCertificates: ByteString

    :ivar IssuerCrls:

    :vartype IssuerCrls: ByteString

    '''

    ua_types = (

        ('SpecifiedLists', 'UInt32'),

        ('TrustedCertificates', 'ListOfByteString'),

        ('TrustedCrls', 'ListOfByteString'),

        ('IssuerCertificates', 'ListOfByteString'),

        ('IssuerCrls', 'ListOfByteString'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SpecifiedLists = 0

        self.TrustedCertificates = []

        self.TrustedCrls = []

        self.IssuerCertificates = []

        self.IssuerCrls = []

        self._freeze = True

    def to_binary(self):

        self.RequestedLifetimeCount = 0

        self.RequestedMaxKeepAliveCount = 0

        self.MaxNotificationsPerPublish = 0

        self.Priority = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.UInt32.pack(self.SubscriptionId))

        packet.append(uabin.Primitives.Double.pack(self.RequestedPublishingInterval))

        packet.append(uabin.Primitives.UInt32.pack(self.RequestedLifetimeCount))

        packet.append(uabin.Primitives.UInt32.pack(self.RequestedMaxKeepAliveCount))

        packet.append(uabin.Primitives.UInt32.pack(self.MaxNotificationsPerPublish))

        packet.append(uabin.Primitives.Byte.pack(self.Priority))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ModifySubscriptionParameters(data)

    def _binary_init(self, data):

        self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)

        self.RequestedPublishingInterval = uabin.Primitives.Double.unpack(data)

        self.RequestedLifetimeCount = uabin.Primitives.UInt32.unpack(data)

        self.RequestedMaxKeepAliveCount = uabin.Primitives.UInt32.unpack(data)

        self.MaxNotificationsPerPublish = uabin.Primitives.UInt32.unpack(data)

        self.Priority = uabin.Primitives.Byte.unpack(data)

    def __str__(self):

        return 'ModifySubscriptionParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \

               'RequestedPublishingInterval:' + str(self.RequestedPublishingInterval) + ', ' + \

               'RequestedLifetimeCount:' + str(self.RequestedLifetimeCount) + ', ' + \

               'RequestedMaxKeepAliveCount:' + str(self.RequestedMaxKeepAliveCount) + ', ' + \

               'MaxNotificationsPerPublish:' + str(self.MaxNotificationsPerPublish) + ', ' + \

               'Priority:' + str(self.Priority) + ')'

    ua_types = (

        ('MethodsToCall', 'ListOfCallMethodRequest'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MethodsToCall = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.Int32.pack(len(self.MethodsToCall)))

        for fieldname in self.MethodsToCall:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CallParameters(data)

    def _binary_init(self, data):

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(CallMethodRequest.from_binary(data))

        self.MethodsToCall = array

    def __str__(self):

        return 'CallParameters(' + 'MethodsToCall:' + str(self.MethodsToCall) + ')'

        ('Parameters', 'HistoryUpdateParameters'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.HistoryUpdateRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = HistoryUpdateParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.RequestHeader.to_binary())

        packet.append(self.Parameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryUpdateRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = HistoryUpdateParameters.from_binary(data)

    def __str__(self):

        return 'HistoryUpdateRequest(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'RequestHeader:' + str(self.RequestHeader) + ', ' + \

               'Parameters:' + str(self.Parameters) + ')'

    __repr__ = __str__

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.QueryNextResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = QueryNextResult()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        packet.append(self.Parameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return QueryNextResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = QueryNextResult.from_binary(data)

    def __str__(self):

        return 'QueryNextResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \

               'Parameters:' + str(self.Parameters) + ')'

    __repr__ = __str__

class ReadValueId(FrozenClass):

    '''