FreeOpcUa / python-opcua

    __repr__ = __str__

class IssuedIdentityToken(FrozenClass):

    '''

    A token representing a user identified by a WS-Security XML token.

    :ivar PolicyId:

    :vartype PolicyId: String

    :ivar TokenData:

    :vartype TokenData: 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 = ''

        self.TokenData = b''

        self.EncryptionAlgorithm = ''

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.PolicyId))

        packet.append(pack_bytes(self.TokenData))

        packet.append(pack_string(self.EncryptionAlgorithm))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return IssuedIdentityToken(data)

    def _binary_init(self, data):

        self.PolicyId = unpack_string(data)

        self.TokenData = unpack_bytes(data)

        self.EncryptionAlgorithm = unpack_string(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class ActivateSessionParameters(FrozenClass):

    __repr__ = __str__

class Annotation(FrozenClass):

    '''

    :ivar Message:

    :vartype Message: String

    :ivar UserName:

    :vartype UserName: String

    :ivar AnnotationTime:

    :vartype AnnotationTime: DateTime

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Message = ''

        self.UserName = ''

        self.AnnotationTime = datetime.now()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.Message))

        packet.append(pack_string(self.UserName))

        packet.append(pack_datetime(self.AnnotationTime))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return Annotation(data)

    def _binary_init(self, data):

        self.Message = unpack_string(data)

        self.UserName = unpack_string(data)

        self.AnnotationTime = unpack_datetime(data)

    def __str__(self):

        return 'Annotation(' + 'Message:' + str(self.Message) + ', ' + \

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

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

    __repr__ = __str__

ExtensionClasses = {

    __repr__ = __str__

class ModificationInfo(FrozenClass):

    '''

    :ivar ModificationTime:

    :vartype ModificationTime: DateTime

    :ivar UpdateType:

    :vartype UpdateType: HistoryUpdateType

    :ivar UserName:

    :vartype UserName: String

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ModificationTime = datetime.now()

        self.UpdateType = HistoryUpdateType(0)

        self.UserName = ''

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_datetime(self.ModificationTime))

        packet.append(uatype_UInt32.pack(self.UpdateType.value))

        packet.append(pack_string(self.UserName))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ModificationInfo(data)

    def _binary_init(self, data):

        self.ModificationTime = unpack_datetime(data)

        self.UpdateType = HistoryUpdateType(uatype_UInt32.unpack(data.read(4))[0])

        self.UserName = unpack_string(data)

    def __str__(self):

        return 'ModificationInfo(' + 'ModificationTime:' + str(self.ModificationTime) + ', ' + \

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

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

    __repr__ = __str__

class HistoryModifiedData(FrozenClass):

    __repr__ = __str__

class MdnsDiscoveryConfiguration(FrozenClass):

    '''

    The discovery information needed for mDNS registration.

    :ivar MdnsServerName:

    :vartype MdnsServerName: String

    :ivar ServerCapabilities:

    :vartype ServerCapabilities: String

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MdnsServerName = ''

        self.ServerCapabilities = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.MdnsServerName))

        packet.append(uatype_Int32.pack(len(self.ServerCapabilities)))

        for fieldname in self.ServerCapabilities:

            packet.append(pack_string(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MdnsDiscoveryConfiguration(data)

    def _binary_init(self, data):

        self.MdnsServerName = unpack_string(data)

        self.ServerCapabilities = unpack_uatype_array('String', data)

    def __str__(self):

        return 'MdnsDiscoveryConfiguration(' + 'MdnsServerName:' + str(self.MdnsServerName) + ', ' + \

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

    __repr__ = __str__

class RegisterServer2Parameters(FrozenClass):