FreeOpcUa / python-opcua

    __repr__ = __str__

class CloseSessionRequest(FrozenClass):

    '''

    Closes a session with the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar DeleteSubscriptions:

    :vartype DeleteSubscriptions: Boolean

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

        ('DeleteSubscriptions', 'Boolean'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.CloseSessionRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.DeleteSubscriptions = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        packet.append(uabin.Primitives.Boolean.pack(self.DeleteSubscriptions))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = CloseSessionRequest()

        obj.TypeId = NodeId.from_binary(data)

        obj.RequestHeader = RequestHeader.from_binary(data)

        self.DeleteSubscriptions = uabin.Primitives.Boolean.unpack(data)

        return obj

    def __str__(self):

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

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

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

    __repr__ = __str__

class CloseSessionResponse(FrozenClass):

    __repr__ = __str__

class EnumValueType(FrozenClass):

    '''

    A mapping between a value of an enumerated type and a name and description.

    :ivar Value:

    :vartype Value: Int64

    :ivar DisplayName:

    :vartype DisplayName: LocalizedText

    :ivar Description:

    :vartype Description: LocalizedText

    '''

    ua_types = [

        ('Value', 'Int64'),

        ('DisplayName', 'LocalizedText'),

        ('Description', 'LocalizedText'),

               ]

    def __init__(self):

        self.Value = 0

        self.DisplayName = LocalizedText()

        self.Description = LocalizedText()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.Int64.pack(self.Value))

        packet.append(self.DisplayName.to_binary())

        packet.append(self.Description.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = EnumValueType()

        self.Value = uabin.Primitives.Int64.unpack(data)

        obj.DisplayName = LocalizedText.from_binary(data)

        obj.Description = LocalizedText.from_binary(data)

        return obj

    def __str__(self):

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

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

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

    __repr__ = __str__

class OptionSet(FrozenClass):

    __repr__ = __str__

class ModelChangeStructureDataType(FrozenClass):

    '''

    :ivar Affected:

    :vartype Affected: NodeId

    :ivar AffectedType:

    :vartype AffectedType: NodeId

    :ivar Verb:

    :vartype Verb: Byte

    '''

    ua_types = [

        ('Affected', 'NodeId'),

        ('AffectedType', 'NodeId'),

        ('Verb', 'Byte'),

               ]

    def __init__(self):

        self.Affected = NodeId()

        self.AffectedType = NodeId()

        self.Verb = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.Affected.to_binary())

        packet.append(self.AffectedType.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = ModelChangeStructureDataType()

        obj.Affected = NodeId.from_binary(data)

        obj.AffectedType = NodeId.from_binary(data)

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

        return obj

    def __str__(self):

        return 'ModelChangeStructureDataType(' + 'Affected:' + str(self.Affected) + ', ' + \

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

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

    __repr__ = __str__

class SemanticChangeStructureDataType(FrozenClass):

    __repr__ = __str__

class MonitoredItemCreateRequest(FrozenClass):

    '''

    :ivar ItemToMonitor:

    :vartype ItemToMonitor: ReadValueId

    :ivar MonitoringMode:

    :vartype MonitoringMode: MonitoringMode

    :ivar RequestedParameters:

    :vartype RequestedParameters: MonitoringParameters

    '''

    ua_types = [

        ('ItemToMonitor', 'ReadValueId'),

        ('MonitoringMode', 'MonitoringMode'),

        ('RequestedParameters', 'MonitoringParameters'),

               ]

    def __init__(self):

        self.ItemToMonitor = ReadValueId()

        self.MonitoringMode = MonitoringMode(0)

        self.RequestedParameters = MonitoringParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.ItemToMonitor.to_binary())

        packet.append(uabin.Primitives.UInt32.pack(self.MonitoringMode.value))

        packet.append(self.RequestedParameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = MonitoredItemCreateRequest()

        obj.ItemToMonitor = ReadValueId.from_binary(data)

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

        obj.RequestedParameters = MonitoringParameters.from_binary(data)

        return obj

    def __str__(self):

        return 'MonitoredItemCreateRequest(' + 'ItemToMonitor:' + str(self.ItemToMonitor) + ', ' + \

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

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

    __repr__ = __str__

class MonitoredItemCreateResult(FrozenClass):

    __repr__ = __str__

class HistoryReadResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    :ivar HistoryData:

    :vartype HistoryData: ExtensionObject

    '''

    ua_types = [

        ('StatusCode', 'StatusCode'),

        ('ContinuationPoint', 'ByteString'),

        ('HistoryData', 'ExtensionObject'),

               ]

    def __init__(self):

        self.StatusCode = StatusCode()

        self.ContinuationPoint = None

        self.HistoryData = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.StatusCode.to_binary())

        packet.append(uabin.Primitives.ByteString.pack(self.ContinuationPoint))

        packet.append(extensionobject_to_binary(self.HistoryData))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = HistoryReadResult()

        obj.StatusCode = StatusCode.from_binary(data)

        self.ContinuationPoint = uabin.Primitives.ByteString.unpack(data)

        obj.HistoryData = extensionobject_from_binary(data)

        return obj

    def __str__(self):

        return 'HistoryReadResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \

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

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

    __repr__ = __str__

class HistoryReadDetails(FrozenClass):

    __repr__ = __str__

class QueryDataDescription(FrozenClass):

    '''

    :ivar RelativePath:

    :vartype RelativePath: RelativePath

    :ivar AttributeId:

    :vartype AttributeId: UInt32

    :ivar IndexRange:

    :vartype IndexRange: String

    '''

    ua_types = [

        ('RelativePath', 'RelativePath'),

        ('AttributeId', 'UInt32'),

        ('IndexRange', 'String'),

               ]

    def __init__(self):

        self.RelativePath = RelativePath()

        self.AttributeId = 0

        self.IndexRange = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.RelativePath.to_binary())

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

        packet.append(uabin.Primitives.String.pack(self.IndexRange))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = QueryDataDescription()

        obj.RelativePath = RelativePath.from_binary(data)

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

        self.IndexRange = uabin.Primitives.String.unpack(data)

        return obj

    def __str__(self):

        return 'QueryDataDescription(' + 'RelativePath:' + str(self.RelativePath) + ', ' + \

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

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

    __repr__ = __str__

class NodeTypeDescription(FrozenClass):

    __repr__ = __str__

class OpenSecureChannelResult(FrozenClass):

    '''

    :ivar ServerProtocolVersion:

    :vartype ServerProtocolVersion: UInt32

    :ivar SecurityToken:

    :vartype SecurityToken: ChannelSecurityToken

    :ivar ServerNonce:

    :vartype ServerNonce: ByteString

    '''

    ua_types = [

        ('ServerProtocolVersion', 'UInt32'),

        ('SecurityToken', 'ChannelSecurityToken'),

        ('ServerNonce', 'ByteString'),

               ]

    def __init__(self):

        self.ServerProtocolVersion = 0

        self.SecurityToken = ChannelSecurityToken()

        self.ServerNonce = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.SecurityToken.to_binary())

        packet.append(uabin.Primitives.ByteString.pack(self.ServerNonce))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = OpenSecureChannelResult()

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

        obj.SecurityToken = ChannelSecurityToken.from_binary(data)

        self.ServerNonce = uabin.Primitives.ByteString.unpack(data)

        return obj

    def __str__(self):

        return 'OpenSecureChannelResult(' + 'ServerProtocolVersion:' + str(self.ServerProtocolVersion) + ', ' + \

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

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

    __repr__ = __str__

class OpenSecureChannelResponse(FrozenClass):