FreeOpcUa / python-opcua

    __repr__ = __str__

class X509IdentityToken(FrozenClass):

    '''

    A token representing a user identified by an X509 certificate.

    :ivar PolicyId:

    :vartype PolicyId: String

    :ivar CertificateData:

    :vartype CertificateData: ByteString

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.PolicyId = None

        self.CertificateData = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.PolicyId))

        packet.append(pack_bytes(self.CertificateData))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return X509IdentityToken(data)

    def _binary_init(self, data):

        self.PolicyId = unpack_string(data)

        self.CertificateData = unpack_bytes(data)

    def __str__(self):

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

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

    __repr__ = __str__

class KerberosIdentityToken(FrozenClass):

    __repr__ = __str__

class SignatureData(FrozenClass):

    '''

    A digital signature.

    :ivar Algorithm:

    :vartype Algorithm: String

    :ivar Signature:

    :vartype Signature: ByteString

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Algorithm = None

        self.Signature = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.Algorithm))

        packet.append(pack_bytes(self.Signature))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SignatureData(data)

    def _binary_init(self, data):

        self.Algorithm = unpack_string(data)

        self.Signature = unpack_bytes(data)

    def __str__(self):

        return 'SignatureData(' + 'Algorithm:' + str(self.Algorithm) + ', ' + \

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

    __repr__ = __str__

class CreateSessionParameters(FrozenClass):

    __repr__ = __str__

class SignedSoftwareCertificate(FrozenClass):

    '''

    A software certificate with a digital signature.

    :ivar CertificateData:

    :vartype CertificateData: ByteString

    :ivar Signature:

    :vartype Signature: ByteString

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.CertificateData = None

        self.Signature = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_bytes(self.CertificateData))

        packet.append(pack_bytes(self.Signature))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SignedSoftwareCertificate(data)

    def _binary_init(self, data):

        self.CertificateData = unpack_bytes(data)

        self.Signature = unpack_bytes(data)

    def __str__(self):

        return 'SignedSoftwareCertificate(' + 'CertificateData:' + str(self.CertificateData) + ', ' + \

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

    __repr__ = __str__

class SignatureData(FrozenClass):

    __repr__ = __str__

class OptionSet(FrozenClass):

    '''

    This abstract Structured DataType is the base DataType for all DataTypes representing a bit mask.

    :ivar Value:

    :vartype Value: ByteString

    :ivar ValidBits:

    :vartype ValidBits: ByteString

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Value = None

        self.ValidBits = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_bytes(self.Value))

        packet.append(pack_bytes(self.ValidBits))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return OptionSet(data)

    def _binary_init(self, data):

        self.Value = unpack_bytes(data)

        self.ValidBits = unpack_bytes(data)

    def __str__(self):

        return 'OptionSet(' + 'Value:' + str(self.Value) + ', ' + \

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

    __repr__ = __str__

class Union(FrozenClass):

    __repr__ = __str__

class QueryNextParameters(FrozenClass):

    '''

    :ivar ReleaseContinuationPoint:

    :vartype ReleaseContinuationPoint: Boolean

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ReleaseContinuationPoint = True

        self.ContinuationPoint = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Boolean.pack(self.ReleaseContinuationPoint))

        packet.append(pack_bytes(self.ContinuationPoint))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return QueryNextParameters(data)

    def _binary_init(self, data):

        self.ReleaseContinuationPoint = uatype_Boolean.unpack(data.read(1))[0]

        self.ContinuationPoint = unpack_bytes(data)

    def __str__(self):

        return 'QueryNextParameters(' + 'ReleaseContinuationPoint:' + str(self.ReleaseContinuationPoint) + ', ' + \

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

    __repr__ = __str__

class QueryNextRequest(FrozenClass):

    __repr__ = __str__

class KerberosIdentityToken(FrozenClass):

    '''

    :ivar PolicyId:

    :vartype PolicyId: String

    :ivar TicketData:

    :vartype TicketData: ByteString

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.PolicyId = None

        self.TicketData = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.PolicyId))

        packet.append(pack_bytes(self.TicketData))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return KerberosIdentityToken(data)

    def _binary_init(self, data):

        self.PolicyId = unpack_string(data)

        self.TicketData = unpack_bytes(data)

    def __str__(self):

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

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

    __repr__ = __str__

class IssuedIdentityToken(FrozenClass):