FreeOpcUa / python-opcua

    __repr__ = __str__

class UserNameIdentityToken(FrozenClass):

    '''

    A token representing a user identified by a user name and password.

    :ivar PolicyId:

    :vartype PolicyId: String

    :ivar UserName:

    :vartype UserName: String

    :ivar Password:

    :vartype Password: ByteString

    :ivar EncryptionAlgorithm:

    :vartype EncryptionAlgorithm: String

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.PolicyId = None

        self.UserName = None

        self.Password = None

        self.EncryptionAlgorithm = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.PolicyId))

        packet.append(pack_string(self.UserName))

        packet.append(pack_bytes(self.Password))

        packet.append(pack_string(self.EncryptionAlgorithm))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UserNameIdentityToken(data)

    def _binary_init(self, data):

        self.PolicyId = unpack_string(data)

        self.UserName = unpack_string(data)

        self.Password = unpack_bytes(data)

        self.EncryptionAlgorithm = unpack_string(data)

    def __str__(self):

        return 'UserNameIdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \

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

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

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

    __repr__ = __str__

    __repr__ = __str__

class HistoryReadValueId(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar IndexRange:

    :vartype IndexRange: String

    :ivar DataEncoding:

    :vartype DataEncoding: QualifiedName

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.IndexRange = None

        self.DataEncoding = QualifiedName()

        self.ContinuationPoint = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.NodeId.to_binary())

        packet.append(pack_string(self.IndexRange))

        packet.append(self.DataEncoding.to_binary())

        packet.append(pack_bytes(self.ContinuationPoint))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryReadValueId(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.IndexRange = unpack_string(data)

        self.DataEncoding = QualifiedName.from_binary(data)

        self.ContinuationPoint = unpack_bytes(data)

    def __str__(self):

        return 'HistoryReadValueId(' + 'NodeId:' + str(self.NodeId) + ', ' + \

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

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

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

    __repr__ = __str__