Code Duplication - FreeOpcUa/python-opcua - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 28-30 lines in 20 locations

opcua/ua/uaprotocol_auto.py 20 locations


    def __init__(self):
        self.ClientDescription = ApplicationDescription()
        self.ServerUri = None
        self.EndpointUrl = None
        self.SessionName = None
        self.ClientNonce = None
        self.ClientCertificate = None
        self.RequestedSessionTimeout = 0
        self.MaxResponseMessageSize = 0
        self._freeze = True

    def __str__(self):
        return 'CreateSessionParameters(' + 'ClientDescription:' + str(self.ClientDescription) + ', ' + \
               'ServerUri:' + str(self.ServerUri) + ', ' + \
               'EndpointUrl:' + str(self.EndpointUrl) + ', ' + \
               'SessionName:' + str(self.SessionName) + ', ' + \
               'ClientNonce:' + str(self.ClientNonce) + ', ' + \
               'ClientCertificate:' + str(self.ClientCertificate) + ', ' + \
               'RequestedSessionTimeout:' + str(self.RequestedSessionTimeout) + ', ' + \
               'MaxResponseMessageSize:' + str(self.MaxResponseMessageSize) + ')'

    __repr__ = __str__


class CreateSessionRequest(FrozenClass):
    '''
    Creates a new session with the server.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar RequestHeader:
    :vartype RequestHeader: RequestHeader
    :ivar Parameters:
    :vartype Parameters: CreateSessionParameters
    '''


    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('ConfigurationResults', 'ListOfStatusCode'),
        ('DiagnosticInfos', 'ListOfDiagnosticInfo'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.RegisterServer2Response_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.ConfigurationResults = []
        self.DiagnosticInfos = []
        self._freeze = True

    def __str__(self):
        return 'RegisterServer2Response(' + 'TypeId:' + str(self.TypeId) + ', ' + \
               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
               'ConfigurationResults:' + str(self.ConfigurationResults) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__


class ChannelSecurityToken(FrozenClass):
    '''
    The token that identifies a set of keys for an active secure channel.

    :ivar ChannelId:
    :vartype ChannelId: UInt32
    :ivar TokenId:
    :vartype TokenId: UInt32
    :ivar CreatedAt:
    :vartype CreatedAt: DateTime
    :ivar RevisedLifetime:
    :vartype RevisedLifetime: UInt32
    '''


    :ivar EndpointUrl:
    :vartype EndpointUrl: String
    :ivar Server:
    :vartype Server: ApplicationDescription
    :ivar ServerCertificate:
    :vartype ServerCertificate: ByteString
    :ivar SecurityMode:
    :vartype SecurityMode: MessageSecurityMode
    :ivar SecurityPolicyUri:
    :vartype SecurityPolicyUri: String
    :ivar UserIdentityTokens:
    :vartype UserIdentityTokens: UserTokenPolicy
    :ivar TransportProfileUri:
    :vartype TransportProfileUri: String
    :ivar SecurityLevel:
    :vartype SecurityLevel: Byte
    '''

    ua_types = [
        ('EndpointUrl', 'String'),
        ('Server', 'ApplicationDescription'),
        ('ServerCertificate', 'ByteString'),
        ('SecurityMode', 'MessageSecurityMode'),
        ('SecurityPolicyUri', 'String'),
        ('UserIdentityTokens', 'ListOfUserTokenPolicy'),
        ('TransportProfileUri', 'String'),
        ('SecurityLevel', 'Byte'),
               ]

    def __init__(self):
        self.EndpointUrl = None
        self.Server = ApplicationDescription()
        self.ServerCertificate = None
        self.SecurityMode = MessageSecurityMode(0)
        self.SecurityPolicyUri = None

        self._freeze = True

    def __str__(self):
        return 'JsonDataSetWriterMessageDataType(' + 'DataSetMessageContentMask:' + str(self.DataSetMessageContentMask) + ')'

    __repr__ = __str__


class JsonDataSetReaderMessageDataType(FrozenClass):
    '''
    :ivar NetworkMessageContentMask:
    :vartype NetworkMessageContentMask: JsonNetworkMessageContentMask
    :ivar DataSetMessageContentMask:
    :vartype DataSetMessageContentMask: JsonDataSetMessageContentMask
    '''

    ua_types = [
        ('NetworkMessageContentMask', 'JsonNetworkMessageContentMask'),
        ('DataSetMessageContentMask', 'JsonDataSetMessageContentMask'),
               ]

    def __init__(self):
        self.NetworkMessageContentMask = JsonNetworkMessageContentMask(0)
        self.DataSetMessageContentMask = JsonDataSetMessageContentMask(0)
        self._freeze = True

    def __str__(self):
        return 'JsonDataSetReaderMessageDataType(' + 'NetworkMessageContentMask:' + str(self.NetworkMessageContentMask) + ', ' + \
               'DataSetMessageContentMask:' + str(self.DataSetMessageContentMask) + ')'

    __repr__ = __str__


class DatagramConnectionTransportDataType(FrozenClass):
    '''
    :ivar DiscoveryAddress:

    :ivar DataSetOrdering:
    :vartype DataSetOrdering: DataSetOrderingType
    :ivar NetworkMessageContentMask:
    :vartype NetworkMessageContentMask: UadpNetworkMessageContentMask
    :ivar SamplingOffset:
    :vartype SamplingOffset: Double
    :ivar PublishingOffset:
    :vartype PublishingOffset: Double
    '''

    ua_types = [
        ('GroupVersion', 'UInt32'),
        ('DataSetOrdering', 'DataSetOrderingType'),
        ('NetworkMessageContentMask', 'UadpNetworkMessageContentMask'),
        ('SamplingOffset', 'Double'),
        ('PublishingOffset', 'ListOfDouble'),
               ]

    def __init__(self):
        self.GroupVersion = 0
        self.DataSetOrdering = DataSetOrderingType(0)
        self.NetworkMessageContentMask = UadpNetworkMessageContentMask(0)
        self.SamplingOffset = 0
        self.PublishingOffset = []
        self._freeze = True

    def __str__(self):
        return 'UadpWriterGroupMessageDataType(' + 'GroupVersion:' + str(self.GroupVersion) + ', ' + \
               'DataSetOrdering:' + str(self.DataSetOrdering) + ', ' + \
               'NetworkMessageContentMask:' + str(self.NetworkMessageContentMask) + ', ' + \
               'SamplingOffset:' + str(self.SamplingOffset) + ', ' + \
               'PublishingOffset:' + str(self.PublishingOffset) + ')'

    __repr__ = __str__



class ReaderGroupTransportDataType(FrozenClass):
    '''
    '''

    ua_types = [
               ]

    def __init__(self):
        self._freeze = True

    def __str__(self):
        return 'ReaderGroupTransportDataType(' +  + ')'

    __repr__ = __str__


class ReaderGroupMessageDataType(FrozenClass):
    '''
    '''

    ua_types = [
               ]

    def __init__(self):
        self._freeze = True

    def __str__(self):
        return 'ReaderGroupMessageDataType(' +  + ')'

    __repr__ = __str__


class DataSetReaderDataType(FrozenClass):
    '''
    :ivar Name:
    :vartype Name: String

    :vartype KeepAliveTime: Double
    :ivar Priority:
    :vartype Priority: Byte
    :ivar LocaleIds:
    :vartype LocaleIds: String
    :ivar TransportSettings:
    :vartype TransportSettings: ExtensionObject
    :ivar MessageSettings:
    :vartype MessageSettings: ExtensionObject
    :ivar DataSetWriters:
    :vartype DataSetWriters: DataSetWriterDataType
    '''

    ua_types = [
        ('Name', 'String'),
        ('Enabled', 'Boolean'),
        ('SecurityMode', 'MessageSecurityMode'),
        ('SecurityGroupId', 'String'),
        ('SecurityKeyServices', 'ListOfEndpointDescription'),
        ('MaxNetworkMessageSize', 'UInt32'),
        ('GroupProperties', 'ListOfKeyValuePair'),
        ('WriterGroupId', 'UInt16'),
        ('PublishingInterval', 'Double'),
        ('KeepAliveTime', 'Double'),
        ('Priority', 'Byte'),
        ('LocaleIds', 'ListOfString'),
        ('TransportSettings', 'ExtensionObject'),
        ('MessageSettings', 'ExtensionObject'),
        ('DataSetWriters', 'ListOfDataSetWriterDataType'),
               ]

    def __init__(self):
        self.Name = None
        self.Enabled = True
        self.SecurityMode = MessageSecurityMode(0)
        self.SecurityGroupId = None

               'Description:' + str(self.Description) + ', ' + \
               'Fields:' + str(self.Fields) + ', ' + \
               'DataSetClassId:' + str(self.DataSetClassId) + ', ' + \
               'ConfigurationVersion:' + str(self.ConfigurationVersion) + ')'

    __repr__ = __str__


class FieldMetaData(FrozenClass):
    '''
    :ivar Name:
    :vartype Name: String
    :ivar Description:
    :vartype Description: LocalizedText
    :ivar FieldFlags:
    :vartype FieldFlags: DataSetFieldFlags
    :ivar BuiltInType:
    :vartype BuiltInType: Byte
    :ivar DataType:
    :vartype DataType: NodeId
    :ivar ValueRank:
    :vartype ValueRank: Int32
    :ivar ArrayDimensions:
    :vartype ArrayDimensions: UInt32
    :ivar MaxStringLength:
    :vartype MaxStringLength: UInt32
    :ivar DataSetFieldId:
    :vartype DataSetFieldId: Guid
    :ivar Properties:
    :vartype Properties: KeyValuePair
    '''

    ua_types = [
        ('Name', 'String'),
        ('Description', 'LocalizedText'),
        ('FieldFlags', 'DataSetFieldFlags'),

        ('CriteriaType', 'IdentityCriteriaType'),
        ('Criteria', 'String'),
               ]

    def __init__(self):
        self.CriteriaType = IdentityCriteriaType(0)
        self.Criteria = None
        self._freeze = True

    def __str__(self):
        return 'IdentityMappingRuleType(' + 'CriteriaType:' + str(self.CriteriaType) + ', ' + \
               'Criteria:' + str(self.Criteria) + ')'

    __repr__ = __str__


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'),

        ('NodeId', 'NodeId'),
               ]

    def __init__(self):
        self.NodeId = NodeId()
        self._freeze = True

    def __str__(self):
        return 'HistoryUpdateDetails(' + 'NodeId:' + str(self.NodeId) + ')'

    __repr__ = __str__


class UpdateDataDetails(FrozenClass):
    '''
    :ivar NodeId:
    :vartype NodeId: NodeId
    :ivar PerformInsertReplace:
    :vartype PerformInsertReplace: PerformUpdateType
    :ivar UpdateValues:
    :vartype UpdateValues: DataValue
    '''

    ua_types = [
        ('NodeId', 'NodeId'),
        ('PerformInsertReplace', 'PerformUpdateType'),
        ('UpdateValues', 'ListOfDataValue'),
               ]

    def __init__(self):
        self.NodeId = NodeId()
        self.PerformInsertReplace = PerformUpdateType(0)
        self.UpdateValues = []
        self._freeze = True

        return 'HistoryReadResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
               'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__


class WriteValue(FrozenClass):
    '''
    :ivar NodeId:
    :vartype NodeId: NodeId
    :ivar AttributeId:
    :vartype AttributeId: UInt32
    :ivar IndexRange:
    :vartype IndexRange: String
    :ivar Value:
    :vartype Value: DataValue
    '''

    ua_types = [
        ('NodeId', 'NodeId'),
        ('AttributeId', 'UInt32'),
        ('IndexRange', 'String'),
        ('Value', 'DataValue'),
               ]

    def __init__(self):
        self.NodeId = NodeId()
        self.AttributeId = 0
        self.IndexRange = None
        self.Value = DataValue()
        self._freeze = True


    :vartype ReleaseContinuationPoints: Boolean
    :ivar NodesToRead:
    :vartype NodesToRead: HistoryReadValueId
    '''

    ua_types = [
        ('HistoryReadDetails', 'ExtensionObject'),
        ('TimestampsToReturn', 'TimestampsToReturn'),
        ('ReleaseContinuationPoints', 'Boolean'),
        ('NodesToRead', 'ListOfHistoryReadValueId'),
               ]

    def __init__(self):
        self.HistoryReadDetails = ExtensionObject()
        self.TimestampsToReturn = TimestampsToReturn(0)
        self.ReleaseContinuationPoints = True
        self.NodesToRead = []
        self._freeze = True

    def __str__(self):
        return 'HistoryReadParameters(' + 'HistoryReadDetails:' + str(self.HistoryReadDetails) + ', ' + \
               'TimestampsToReturn:' + str(self.TimestampsToReturn) + ', ' + \
               'ReleaseContinuationPoints:' + str(self.ReleaseContinuationPoints) + ', ' + \
               'NodesToRead:' + str(self.NodesToRead) + ')'

    __repr__ = __str__


class HistoryReadRequest(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar RequestHeader:
    :vartype RequestHeader: RequestHeader

        self.Results = []
        self.DiagnosticInfos = []
        self._freeze = True

    def __str__(self):
        return 'ReadResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
               'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __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
    '''

    ua_types = [
        ('NodeId', 'NodeId'),
        ('IndexRange', 'String'),
        ('DataEncoding', 'QualifiedName'),
        ('ContinuationPoint', 'ByteString'),
               ]

    def __init__(self):
        self.NodeId = NodeId()

    :vartype IndexRange: String
    :ivar DataEncoding:
    :vartype DataEncoding: QualifiedName
    '''

    ua_types = [
        ('NodeId', 'NodeId'),
        ('AttributeId', 'UInt32'),
        ('IndexRange', 'String'),
        ('DataEncoding', 'QualifiedName'),
               ]

    def __init__(self):
        self.NodeId = NodeId()
        self.AttributeId = 0
        self.IndexRange = None
        self.DataEncoding = QualifiedName()
        self._freeze = True

    def __str__(self):
        return 'ReadValueId(' + 'NodeId:' + str(self.NodeId) + ', ' + \
               'AttributeId:' + str(self.AttributeId) + ', ' + \
               'IndexRange:' + str(self.IndexRange) + ', ' + \
               'DataEncoding:' + str(self.DataEncoding) + ')'

    __repr__ = __str__


class ReadParameters(FrozenClass):
    '''
    :ivar MaxAge:
    :vartype MaxAge: Double
    :ivar TimestampsToReturn:
    :vartype TimestampsToReturn: TimestampsToReturn

        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'QueryFirstResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.QueryFirstResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = QueryFirstResult()
        self._freeze = True

    def __str__(self):
        return 'QueryFirstResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
               'Parameters:' + str(self.Parameters) + ')'

    __repr__ = __str__


class QueryNextParameters(FrozenClass):
    '''
    :ivar ReleaseContinuationPoint:
    :vartype ReleaseContinuationPoint: Boolean
    :ivar ContinuationPoint:
    :vartype ContinuationPoint: ByteString
    '''

    ua_types = [
        ('ReleaseContinuationPoint', 'Boolean'),
        ('ContinuationPoint', 'ByteString'),
               ]

    def __init__(self):
        self.ReleaseContinuationPoint = True
        self.ContinuationPoint = None

    ua_types = [
        ('TypeDefinitionId', 'NodeId'),
        ('BrowsePath', 'ListOfQualifiedName'),
        ('AttributeId', 'UInt32'),
        ('IndexRange', 'String'),
               ]

    def __init__(self):
        self.TypeDefinitionId = NodeId()
        self.BrowsePath = []
        self.AttributeId = 0
        self.IndexRange = None
        self._freeze = True

    def __str__(self):
        return 'SimpleAttributeOperand(' + 'TypeDefinitionId:' + str(self.TypeDefinitionId) + ', ' + \
               'BrowsePath:' + str(self.BrowsePath) + ', ' + \
               'AttributeId:' + str(self.AttributeId) + ', ' + \
               'IndexRange:' + str(self.IndexRange) + ')'

    __repr__ = __str__


class ContentFilterElementResult(FrozenClass):
    '''
    :ivar StatusCode:
    :vartype StatusCode: StatusCode
    :ivar OperandStatusCodes:
    :vartype OperandStatusCodes: StatusCode
    :ivar OperandDiagnosticInfos:
    :vartype OperandDiagnosticInfos: DiagnosticInfo
    '''

    ua_types = [


    ua_types = [
        ('FilterOperator', 'FilterOperator'),
        ('FilterOperands', 'ListOfExtensionObject'),
               ]

    def __init__(self):
        self.FilterOperator = FilterOperator(0)
        self.FilterOperands = []
        self._freeze = True

    def __str__(self):
        return 'ContentFilterElement(' + 'FilterOperator:' + str(self.FilterOperator) + ', ' + \
               'FilterOperands:' + str(self.FilterOperands) + ')'

    __repr__ = __str__


class ContentFilter(FrozenClass):
    '''
    :ivar Elements:
    :vartype Elements: ContentFilterElement
    '''

    ua_types = [
        ('Elements', 'ListOfContentFilterElement'),
               ]

    def __init__(self):
        self.Elements = []
        self._freeze = True

    def __str__(self):
        return 'ContentFilter(' + 'Elements:' + str(self.Elements) + ')'

    :ivar DataType:
    :vartype DataType: NodeId
    :ivar ValueRank:
    :vartype ValueRank: Int32
    :ivar ArrayDimensions:
    :vartype ArrayDimensions: UInt32
    :ivar IsAbstract:
    :vartype IsAbstract: Boolean
    '''

    ua_types = [
        ('SpecifiedAttributes', 'UInt32'),
        ('DisplayName', 'LocalizedText'),
        ('Description', 'LocalizedText'),
        ('WriteMask', 'UInt32'),
        ('UserWriteMask', 'UInt32'),
        ('Value', 'Variant'),
        ('DataType', 'NodeId'),
        ('ValueRank', 'Int32'),
        ('ArrayDimensions', 'ListOfUInt32'),
        ('IsAbstract', 'Boolean'),
               ]

    def __init__(self):
        self.SpecifiedAttributes = 0
        self.DisplayName = LocalizedText()
        self.Description = LocalizedText()
        self.WriteMask = 0
        self.UserWriteMask = 0
        self.Value = Variant()
        self.DataType = NodeId()
        self.ValueRank = 0
        self.ArrayDimensions = []
        self.IsAbstract = True

    :vartype SpecifiedAttributes: UInt32
    :ivar DisplayName:
    :vartype DisplayName: LocalizedText
    :ivar Description:
    :vartype Description: LocalizedText
    :ivar WriteMask:
    :vartype WriteMask: UInt32
    :ivar UserWriteMask:
    :vartype UserWriteMask: UInt32
    :ivar Executable:
    :vartype Executable: Boolean
    :ivar UserExecutable:
    :vartype UserExecutable: Boolean
    '''

    ua_types = [
        ('SpecifiedAttributes', 'UInt32'),
        ('DisplayName', 'LocalizedText'),
        ('Description', 'LocalizedText'),
        ('WriteMask', 'UInt32'),
        ('UserWriteMask', 'UInt32'),
        ('Executable', 'Boolean'),
        ('UserExecutable', 'Boolean'),
               ]

    def __init__(self):
        self.SpecifiedAttributes = 0
        self.DisplayName = LocalizedText()
        self.Description = LocalizedText()
        self.WriteMask = 0
        self.UserWriteMask = 0
        self.Executable = True
        self.UserExecutable = True
        self._freeze = True

        ('DataTypeId', 'NodeId'),
        ('Name', 'QualifiedName'),
        ('StructureDefinition', 'StructureDefinition'),
               ]

    def __init__(self):
        self.DataTypeId = NodeId()
        self.Name = QualifiedName()
        self.StructureDefinition = StructureDefinition()
        self._freeze = True

    def __str__(self):
        return 'StructureDescription(' + 'DataTypeId:' + str(self.DataTypeId) + ', ' + \
               'Name:' + str(self.Name) + ', ' + \
               'StructureDefinition:' + str(self.StructureDefinition) + ')'

    __repr__ = __str__


class EnumDescription(FrozenClass):
    '''
    :ivar DataTypeId:
    :vartype DataTypeId: NodeId
    :ivar Name:
    :vartype Name: QualifiedName
    :ivar EnumDefinition:
    :vartype EnumDefinition: EnumDefinition
    :ivar BuiltInType:
    :vartype BuiltInType: Byte
    '''

    ua_types = [
        ('DataTypeId', 'NodeId'),
        ('Name', 'QualifiedName'),

		@@ 4493-4522 (lines=30) @@
4490		def __init__(self):
4491		self.ClientDescription = ApplicationDescription()
4492		self.ServerUri = None
4493		self.EndpointUrl = None
4494		self.SessionName = None
4495		self.ClientNonce = None
4496		self.ClientCertificate = None
4497		self.RequestedSessionTimeout = 0
4498		self.MaxResponseMessageSize = 0
4499		self._freeze = True
4500
4501		def __str__(self):
4502		return 'CreateSessionParameters(' + 'ClientDescription:' + str(self.ClientDescription) + ', ' + \
4503		'ServerUri:' + str(self.ServerUri) + ', ' + \
4504		'EndpointUrl:' + str(self.EndpointUrl) + ', ' + \
4505		'SessionName:' + str(self.SessionName) + ', ' + \
4506		'ClientNonce:' + str(self.ClientNonce) + ', ' + \
4507		'ClientCertificate:' + str(self.ClientCertificate) + ', ' + \
4508		'RequestedSessionTimeout:' + str(self.RequestedSessionTimeout) + ', ' + \
4509		'MaxResponseMessageSize:' + str(self.MaxResponseMessageSize) + ')'
4510
4511		__repr__ = __str__
4512
4513
4514		class CreateSessionRequest(FrozenClass):
4515		'''
4516		Creates a new session with the server.
4517
4518		:ivar TypeId:
4519		:vartype TypeId: NodeId
4520		:ivar RequestHeader:
4521		:vartype RequestHeader: RequestHeader
4522		:ivar Parameters:
4523		:vartype Parameters: CreateSessionParameters
4524		'''
4525
		@@ 4160-4189 (lines=30) @@
4157		ua_types = [
4158		('TypeId', 'NodeId'),
4159		('ResponseHeader', 'ResponseHeader'),
4160		('ConfigurationResults', 'ListOfStatusCode'),
4161		('DiagnosticInfos', 'ListOfDiagnosticInfo'),
4162		]
4163
4164		def __init__(self):
4165		self.TypeId = FourByteNodeId(ObjectIds.RegisterServer2Response_Encoding_DefaultBinary)
4166		self.ResponseHeader = ResponseHeader()
4167		self.ConfigurationResults = []
4168		self.DiagnosticInfos = []
4169		self._freeze = True
4170
4171		def __str__(self):
4172		return 'RegisterServer2Response(' + 'TypeId:' + str(self.TypeId) + ', ' + \
4173		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
4174		'ConfigurationResults:' + str(self.ConfigurationResults) + ', ' + \
4175		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
4176
4177		__repr__ = __str__
4178
4179
4180		class ChannelSecurityToken(FrozenClass):
4181		'''
4182		The token that identifies a set of keys for an active secure channel.
4183
4184		:ivar ChannelId:
4185		:vartype ChannelId: UInt32
4186		:ivar TokenId:
4187		:vartype TokenId: UInt32
4188		:ivar CreatedAt:
4189		:vartype CreatedAt: DateTime
4190		:ivar RevisedLifetime:
4191		:vartype RevisedLifetime: UInt32
4192		'''
		@@ 3784-3813 (lines=30) @@
3781
3782		:ivar EndpointUrl:
3783		:vartype EndpointUrl: String
3784		:ivar Server:
3785		:vartype Server: ApplicationDescription
3786		:ivar ServerCertificate:
3787		:vartype ServerCertificate: ByteString
3788		:ivar SecurityMode:
3789		:vartype SecurityMode: MessageSecurityMode
3790		:ivar SecurityPolicyUri:
3791		:vartype SecurityPolicyUri: String
3792		:ivar UserIdentityTokens:
3793		:vartype UserIdentityTokens: UserTokenPolicy
3794		:ivar TransportProfileUri:
3795		:vartype TransportProfileUri: String
3796		:ivar SecurityLevel:
3797		:vartype SecurityLevel: Byte
3798		'''
3799
3800		ua_types = [
3801		('EndpointUrl', 'String'),
3802		('Server', 'ApplicationDescription'),
3803		('ServerCertificate', 'ByteString'),
3804		('SecurityMode', 'MessageSecurityMode'),
3805		('SecurityPolicyUri', 'String'),
3806		('UserIdentityTokens', 'ListOfUserTokenPolicy'),
3807		('TransportProfileUri', 'String'),
3808		('SecurityLevel', 'Byte'),
3809		]
3810
3811		def __init__(self):
3812		self.EndpointUrl = None
3813		self.Server = ApplicationDescription()
3814		self.ServerCertificate = None
3815		self.SecurityMode = MessageSecurityMode(0)
3816		self.SecurityPolicyUri = None
		@@ 2720-2749 (lines=30) @@
2717		self._freeze = True
2718
2719		def __str__(self):
2720		return 'JsonDataSetWriterMessageDataType(' + 'DataSetMessageContentMask:' + str(self.DataSetMessageContentMask) + ')'
2721
2722		__repr__ = __str__
2723
2724
2725		class JsonDataSetReaderMessageDataType(FrozenClass):
2726		'''
2727		:ivar NetworkMessageContentMask:
2728		:vartype NetworkMessageContentMask: JsonNetworkMessageContentMask
2729		:ivar DataSetMessageContentMask:
2730		:vartype DataSetMessageContentMask: JsonDataSetMessageContentMask
2731		'''
2732
2733		ua_types = [
2734		('NetworkMessageContentMask', 'JsonNetworkMessageContentMask'),
2735		('DataSetMessageContentMask', 'JsonDataSetMessageContentMask'),
2736		]
2737
2738		def __init__(self):
2739		self.NetworkMessageContentMask = JsonNetworkMessageContentMask(0)
2740		self.DataSetMessageContentMask = JsonDataSetMessageContentMask(0)
2741		self._freeze = True
2742
2743		def __str__(self):
2744		return 'JsonDataSetReaderMessageDataType(' + 'NetworkMessageContentMask:' + str(self.NetworkMessageContentMask) + ', ' + \
2745		'DataSetMessageContentMask:' + str(self.DataSetMessageContentMask) + ')'
2746
2747		__repr__ = __str__
2748
2749
2750		class DatagramConnectionTransportDataType(FrozenClass):
2751		'''
2752		:ivar DiscoveryAddress:
		@@ 2557-2586 (lines=30) @@
2554		:ivar DataSetOrdering:
2555		:vartype DataSetOrdering: DataSetOrderingType
2556		:ivar NetworkMessageContentMask:
2557		:vartype NetworkMessageContentMask: UadpNetworkMessageContentMask
2558		:ivar SamplingOffset:
2559		:vartype SamplingOffset: Double
2560		:ivar PublishingOffset:
2561		:vartype PublishingOffset: Double
2562		'''
2563
2564		ua_types = [
2565		('GroupVersion', 'UInt32'),
2566		('DataSetOrdering', 'DataSetOrderingType'),
2567		('NetworkMessageContentMask', 'UadpNetworkMessageContentMask'),
2568		('SamplingOffset', 'Double'),
2569		('PublishingOffset', 'ListOfDouble'),
2570		]
2571
2572		def __init__(self):
2573		self.GroupVersion = 0
2574		self.DataSetOrdering = DataSetOrderingType(0)
2575		self.NetworkMessageContentMask = UadpNetworkMessageContentMask(0)
2576		self.SamplingOffset = 0
2577		self.PublishingOffset = []
2578		self._freeze = True
2579
2580		def __str__(self):
2581		return 'UadpWriterGroupMessageDataType(' + 'GroupVersion:' + str(self.GroupVersion) + ', ' + \
2582		'DataSetOrdering:' + str(self.DataSetOrdering) + ', ' + \
2583		'NetworkMessageContentMask:' + str(self.NetworkMessageContentMask) + ', ' + \
2584		'SamplingOffset:' + str(self.SamplingOffset) + ', ' + \
2585		'PublishingOffset:' + str(self.PublishingOffset) + ')'
2586
2587		__repr__ = __str__
2588
2589
		@@ 2258-2287 (lines=30) @@
2255		class ReaderGroupTransportDataType(FrozenClass):
2256		'''
2257		'''
2258
2259		ua_types = [
2260		]
2261
2262		def __init__(self):
2263		self._freeze = True
2264
2265		def __str__(self):
2266		return 'ReaderGroupTransportDataType(' + + ')'
2267
2268		__repr__ = __str__
2269
2270
2271		class ReaderGroupMessageDataType(FrozenClass):
2272		'''
2273		'''
2274
2275		ua_types = [
2276		]
2277
2278		def __init__(self):
2279		self._freeze = True
2280
2281		def __str__(self):
2282		return 'ReaderGroupMessageDataType(' + + ')'
2283
2284		__repr__ = __str__
2285
2286
2287		class DataSetReaderDataType(FrozenClass):
2288		'''
2289		:ivar Name:
2290		:vartype Name: String
		@@ 1971-2000 (lines=30) @@
1968		:vartype KeepAliveTime: Double
1969		:ivar Priority:
1970		:vartype Priority: Byte
1971		:ivar LocaleIds:
1972		:vartype LocaleIds: String
1973		:ivar TransportSettings:
1974		:vartype TransportSettings: ExtensionObject
1975		:ivar MessageSettings:
1976		:vartype MessageSettings: ExtensionObject
1977		:ivar DataSetWriters:
1978		:vartype DataSetWriters: DataSetWriterDataType
1979		'''
1980
1981		ua_types = [
1982		('Name', 'String'),
1983		('Enabled', 'Boolean'),
1984		('SecurityMode', 'MessageSecurityMode'),
1985		('SecurityGroupId', 'String'),
1986		('SecurityKeyServices', 'ListOfEndpointDescription'),
1987		('MaxNetworkMessageSize', 'UInt32'),
1988		('GroupProperties', 'ListOfKeyValuePair'),
1989		('WriterGroupId', 'UInt16'),
1990		('PublishingInterval', 'Double'),
1991		('KeepAliveTime', 'Double'),
1992		('Priority', 'Byte'),
1993		('LocaleIds', 'ListOfString'),
1994		('TransportSettings', 'ExtensionObject'),
1995		('MessageSettings', 'ExtensionObject'),
1996		('DataSetWriters', 'ListOfDataSetWriterDataType'),
1997		]
1998
1999		def __init__(self):
2000		self.Name = None
2001		self.Enabled = True
2002		self.SecurityMode = MessageSecurityMode(0)
2003		self.SecurityGroupId = None
		@@ 1549-1578 (lines=30) @@
1546		'Description:' + str(self.Description) + ', ' + \
1547		'Fields:' + str(self.Fields) + ', ' + \
1548		'DataSetClassId:' + str(self.DataSetClassId) + ', ' + \
1549		'ConfigurationVersion:' + str(self.ConfigurationVersion) + ')'
1550
1551		__repr__ = __str__
1552
1553
1554		class FieldMetaData(FrozenClass):
1555		'''
1556		:ivar Name:
1557		:vartype Name: String
1558		:ivar Description:
1559		:vartype Description: LocalizedText
1560		:ivar FieldFlags:
1561		:vartype FieldFlags: DataSetFieldFlags
1562		:ivar BuiltInType:
1563		:vartype BuiltInType: Byte
1564		:ivar DataType:
1565		:vartype DataType: NodeId
1566		:ivar ValueRank:
1567		:vartype ValueRank: Int32
1568		:ivar ArrayDimensions:
1569		:vartype ArrayDimensions: UInt32
1570		:ivar MaxStringLength:
1571		:vartype MaxStringLength: UInt32
1572		:ivar DataSetFieldId:
1573		:vartype DataSetFieldId: Guid
1574		:ivar Properties:
1575		:vartype Properties: KeyValuePair
1576		'''
1577
1578		ua_types = [
1579		('Name', 'String'),
1580		('Description', 'LocalizedText'),
1581		('FieldFlags', 'DataSetFieldFlags'),
		@@ 1206-1235 (lines=30) @@
1203		('CriteriaType', 'IdentityCriteriaType'),
1204		('Criteria', 'String'),
1205		]
1206
1207		def __init__(self):
1208		self.CriteriaType = IdentityCriteriaType(0)
1209		self.Criteria = None
1210		self._freeze = True
1211
1212		def __str__(self):
1213		return 'IdentityMappingRuleType(' + 'CriteriaType:' + str(self.CriteriaType) + ', ' + \
1214		'Criteria:' + str(self.Criteria) + ')'
1215
1216		__repr__ = __str__
1217
1218
1219		class TrustListDataType(FrozenClass):
1220		'''
1221		:ivar SpecifiedLists:
1222		:vartype SpecifiedLists: UInt32
1223		:ivar TrustedCertificates:
1224		:vartype TrustedCertificates: ByteString
1225		:ivar TrustedCrls:
1226		:vartype TrustedCrls: ByteString
1227		:ivar IssuerCertificates:
1228		:vartype IssuerCertificates: ByteString
1229		:ivar IssuerCrls:
1230		:vartype IssuerCrls: ByteString
1231		'''
1232
1233		ua_types = [
1234		('SpecifiedLists', 'UInt32'),
1235		('TrustedCertificates', 'ListOfByteString'),
1236		('TrustedCrls', 'ListOfByteString'),
1237		('IssuerCertificates', 'ListOfByteString'),
1238		('IssuerCrls', 'ListOfByteString'),
		@@ 8353-8380 (lines=28) @@
8350		('NodeId', 'NodeId'),
8351		]
8352
8353		def __init__(self):
8354		self.NodeId = NodeId()
8355		self._freeze = True
8356
8357		def __str__(self):
8358		return 'HistoryUpdateDetails(' + 'NodeId:' + str(self.NodeId) + ')'
8359
8360		__repr__ = __str__
8361
8362
8363		class UpdateDataDetails(FrozenClass):
8364		'''
8365		:ivar NodeId:
8366		:vartype NodeId: NodeId
8367		:ivar PerformInsertReplace:
8368		:vartype PerformInsertReplace: PerformUpdateType
8369		:ivar UpdateValues:
8370		:vartype UpdateValues: DataValue
8371		'''
8372
8373		ua_types = [
8374		('NodeId', 'NodeId'),
8375		('PerformInsertReplace', 'PerformUpdateType'),
8376		('UpdateValues', 'ListOfDataValue'),
8377		]
8378
8379		def __init__(self):
8380		self.NodeId = NodeId()
8381		self.PerformInsertReplace = PerformUpdateType(0)
8382		self.UpdateValues = []
8383		self._freeze = True
		@@ 8218-8245 (lines=28) @@
8215		return 'HistoryReadResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
8216		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
8217		'Results:' + str(self.Results) + ', ' + \
8218		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
8219
8220		__repr__ = __str__
8221
8222
8223		class WriteValue(FrozenClass):
8224		'''
8225		:ivar NodeId:
8226		:vartype NodeId: NodeId
8227		:ivar AttributeId:
8228		:vartype AttributeId: UInt32
8229		:ivar IndexRange:
8230		:vartype IndexRange: String
8231		:ivar Value:
8232		:vartype Value: DataValue
8233		'''
8234
8235		ua_types = [
8236		('NodeId', 'NodeId'),
8237		('AttributeId', 'UInt32'),
8238		('IndexRange', 'String'),
8239		('Value', 'DataValue'),
8240		]
8241
8242		def __init__(self):
8243		self.NodeId = NodeId()
8244		self.AttributeId = 0
8245		self.IndexRange = None
8246		self.Value = DataValue()
8247		self._freeze = True
8248
		@@ 8133-8160 (lines=28) @@
8130		:vartype ReleaseContinuationPoints: Boolean
8131		:ivar NodesToRead:
8132		:vartype NodesToRead: HistoryReadValueId
8133		'''
8134
8135		ua_types = [
8136		('HistoryReadDetails', 'ExtensionObject'),
8137		('TimestampsToReturn', 'TimestampsToReturn'),
8138		('ReleaseContinuationPoints', 'Boolean'),
8139		('NodesToRead', 'ListOfHistoryReadValueId'),
8140		]
8141
8142		def __init__(self):
8143		self.HistoryReadDetails = ExtensionObject()
8144		self.TimestampsToReturn = TimestampsToReturn(0)
8145		self.ReleaseContinuationPoints = True
8146		self.NodesToRead = []
8147		self._freeze = True
8148
8149		def __str__(self):
8150		return 'HistoryReadParameters(' + 'HistoryReadDetails:' + str(self.HistoryReadDetails) + ', ' + \
8151		'TimestampsToReturn:' + str(self.TimestampsToReturn) + ', ' + \
8152		'ReleaseContinuationPoints:' + str(self.ReleaseContinuationPoints) + ', ' + \
8153		'NodesToRead:' + str(self.NodesToRead) + ')'
8154
8155		__repr__ = __str__
8156
8157
8158		class HistoryReadRequest(FrozenClass):
8159		'''
8160		:ivar TypeId:
8161		:vartype TypeId: NodeId
8162		:ivar RequestHeader:
8163		:vartype RequestHeader: RequestHeader
		@@ 7797-7824 (lines=28) @@
7794		self.Results = []
7795		self.DiagnosticInfos = []
7796		self._freeze = True
7797
7798		def __str__(self):
7799		return 'ReadResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7800		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7801		'Results:' + str(self.Results) + ', ' + \
7802		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
7803
7804		__repr__ = __str__
7805
7806
7807		class HistoryReadValueId(FrozenClass):
7808		'''
7809		:ivar NodeId:
7810		:vartype NodeId: NodeId
7811		:ivar IndexRange:
7812		:vartype IndexRange: String
7813		:ivar DataEncoding:
7814		:vartype DataEncoding: QualifiedName
7815		:ivar ContinuationPoint:
7816		:vartype ContinuationPoint: ByteString
7817		'''
7818
7819		ua_types = [
7820		('NodeId', 'NodeId'),
7821		('IndexRange', 'String'),
7822		('DataEncoding', 'QualifiedName'),
7823		('ContinuationPoint', 'ByteString'),
7824		]
7825
7826		def __init__(self):
7827		self.NodeId = NodeId()
		@@ 7687-7714 (lines=28) @@
7684		:vartype IndexRange: String
7685		:ivar DataEncoding:
7686		:vartype DataEncoding: QualifiedName
7687		'''
7688
7689		ua_types = [
7690		('NodeId', 'NodeId'),
7691		('AttributeId', 'UInt32'),
7692		('IndexRange', 'String'),
7693		('DataEncoding', 'QualifiedName'),
7694		]
7695
7696		def __init__(self):
7697		self.NodeId = NodeId()
7698		self.AttributeId = 0
7699		self.IndexRange = None
7700		self.DataEncoding = QualifiedName()
7701		self._freeze = True
7702
7703		def __str__(self):
7704		return 'ReadValueId(' + 'NodeId:' + str(self.NodeId) + ', ' + \
7705		'AttributeId:' + str(self.AttributeId) + ', ' + \
7706		'IndexRange:' + str(self.IndexRange) + ', ' + \
7707		'DataEncoding:' + str(self.DataEncoding) + ')'
7708
7709		__repr__ = __str__
7710
7711
7712		class ReadParameters(FrozenClass):
7713		'''
7714		:ivar MaxAge:
7715		:vartype MaxAge: Double
7716		:ivar TimestampsToReturn:
7717		:vartype TimestampsToReturn: TimestampsToReturn
		@@ 7552-7579 (lines=28) @@
7549		('ResponseHeader', 'ResponseHeader'),
7550		('Parameters', 'QueryFirstResult'),
7551		]
7552
7553		def __init__(self):
7554		self.TypeId = FourByteNodeId(ObjectIds.QueryFirstResponse_Encoding_DefaultBinary)
7555		self.ResponseHeader = ResponseHeader()
7556		self.Parameters = QueryFirstResult()
7557		self._freeze = True
7558
7559		def __str__(self):
7560		return 'QueryFirstResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7561		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7562		'Parameters:' + str(self.Parameters) + ')'
7563
7564		__repr__ = __str__
7565
7566
7567		class QueryNextParameters(FrozenClass):
7568		'''
7569		:ivar ReleaseContinuationPoint:
7570		:vartype ReleaseContinuationPoint: Boolean
7571		:ivar ContinuationPoint:
7572		:vartype ContinuationPoint: ByteString
7573		'''
7574
7575		ua_types = [
7576		('ReleaseContinuationPoint', 'Boolean'),
7577		('ContinuationPoint', 'ByteString'),
7578		]
7579
7580		def __init__(self):
7581		self.ReleaseContinuationPoint = True
7582		self.ContinuationPoint = None
		@@ 7322-7349 (lines=28) @@
7319		ua_types = [
7320		('TypeDefinitionId', 'NodeId'),
7321		('BrowsePath', 'ListOfQualifiedName'),
7322		('AttributeId', 'UInt32'),
7323		('IndexRange', 'String'),
7324		]
7325
7326		def __init__(self):
7327		self.TypeDefinitionId = NodeId()
7328		self.BrowsePath = []
7329		self.AttributeId = 0
7330		self.IndexRange = None
7331		self._freeze = True
7332
7333		def __str__(self):
7334		return 'SimpleAttributeOperand(' + 'TypeDefinitionId:' + str(self.TypeDefinitionId) + ', ' + \
7335		'BrowsePath:' + str(self.BrowsePath) + ', ' + \
7336		'AttributeId:' + str(self.AttributeId) + ', ' + \
7337		'IndexRange:' + str(self.IndexRange) + ')'
7338
7339		__repr__ = __str__
7340
7341
7342		class ContentFilterElementResult(FrozenClass):
7343		'''
7344		:ivar StatusCode:
7345		:vartype StatusCode: StatusCode
7346		:ivar OperandStatusCodes:
7347		:vartype OperandStatusCodes: StatusCode
7348		:ivar OperandDiagnosticInfos:
7349		:vartype OperandDiagnosticInfos: DiagnosticInfo
7350		'''
7351
7352		ua_types = [
		@@ 7192-7219 (lines=28) @@
7189
7190		ua_types = [
7191		('FilterOperator', 'FilterOperator'),
7192		('FilterOperands', 'ListOfExtensionObject'),
7193		]
7194
7195		def __init__(self):
7196		self.FilterOperator = FilterOperator(0)
7197		self.FilterOperands = []
7198		self._freeze = True
7199
7200		def __str__(self):
7201		return 'ContentFilterElement(' + 'FilterOperator:' + str(self.FilterOperator) + ', ' + \
7202		'FilterOperands:' + str(self.FilterOperands) + ')'
7203
7204		__repr__ = __str__
7205
7206
7207		class ContentFilter(FrozenClass):
7208		'''
7209		:ivar Elements:
7210		:vartype Elements: ContentFilterElement
7211		'''
7212
7213		ua_types = [
7214		('Elements', 'ListOfContentFilterElement'),
7215		]
7216
7217		def __init__(self):
7218		self.Elements = []
7219		self._freeze = True
7220
7221		def __str__(self):
7222		return 'ContentFilter(' + 'Elements:' + str(self.Elements) + ')'
		@@ 5364-5391 (lines=28) @@
5361		:ivar DataType:
5362		:vartype DataType: NodeId
5363		:ivar ValueRank:
5364		:vartype ValueRank: Int32
5365		:ivar ArrayDimensions:
5366		:vartype ArrayDimensions: UInt32
5367		:ivar IsAbstract:
5368		:vartype IsAbstract: Boolean
5369		'''
5370
5371		ua_types = [
5372		('SpecifiedAttributes', 'UInt32'),
5373		('DisplayName', 'LocalizedText'),
5374		('Description', 'LocalizedText'),
5375		('WriteMask', 'UInt32'),
5376		('UserWriteMask', 'UInt32'),
5377		('Value', 'Variant'),
5378		('DataType', 'NodeId'),
5379		('ValueRank', 'Int32'),
5380		('ArrayDimensions', 'ListOfUInt32'),
5381		('IsAbstract', 'Boolean'),
5382		]
5383
5384		def __init__(self):
5385		self.SpecifiedAttributes = 0
5386		self.DisplayName = LocalizedText()
5387		self.Description = LocalizedText()
5388		self.WriteMask = 0
5389		self.UserWriteMask = 0
5390		self.Value = Variant()
5391		self.DataType = NodeId()
5392		self.ValueRank = 0
5393		self.ArrayDimensions = []
5394		self.IsAbstract = True
		@@ 5254-5281 (lines=28) @@
5251		:vartype SpecifiedAttributes: UInt32
5252		:ivar DisplayName:
5253		:vartype DisplayName: LocalizedText
5254		:ivar Description:
5255		:vartype Description: LocalizedText
5256		:ivar WriteMask:
5257		:vartype WriteMask: UInt32
5258		:ivar UserWriteMask:
5259		:vartype UserWriteMask: UInt32
5260		:ivar Executable:
5261		:vartype Executable: Boolean
5262		:ivar UserExecutable:
5263		:vartype UserExecutable: Boolean
5264		'''
5265
5266		ua_types = [
5267		('SpecifiedAttributes', 'UInt32'),
5268		('DisplayName', 'LocalizedText'),
5269		('Description', 'LocalizedText'),
5270		('WriteMask', 'UInt32'),
5271		('UserWriteMask', 'UInt32'),
5272		('Executable', 'Boolean'),
5273		('UserExecutable', 'Boolean'),
5274		]
5275
5276		def __init__(self):
5277		self.SpecifiedAttributes = 0
5278		self.DisplayName = LocalizedText()
5279		self.Description = LocalizedText()
5280		self.WriteMask = 0
5281		self.UserWriteMask = 0
5282		self.Executable = True
5283		self.UserExecutable = True
5284		self._freeze = True
		@@ 1358-1385 (lines=28) @@
1355		('DataTypeId', 'NodeId'),
1356		('Name', 'QualifiedName'),
1357		('StructureDefinition', 'StructureDefinition'),
1358		]
1359
1360		def __init__(self):
1361		self.DataTypeId = NodeId()
1362		self.Name = QualifiedName()
1363		self.StructureDefinition = StructureDefinition()
1364		self._freeze = True
1365
1366		def __str__(self):
1367		return 'StructureDescription(' + 'DataTypeId:' + str(self.DataTypeId) + ', ' + \
1368		'Name:' + str(self.Name) + ', ' + \
1369		'StructureDefinition:' + str(self.StructureDefinition) + ')'
1370
1371		__repr__ = __str__
1372
1373
1374		class EnumDescription(FrozenClass):
1375		'''
1376		:ivar DataTypeId:
1377		:vartype DataTypeId: NodeId
1378		:ivar Name:
1379		:vartype Name: QualifiedName
1380		:ivar EnumDefinition:
1381		:vartype EnumDefinition: EnumDefinition
1382		:ivar BuiltInType:
1383		:vartype BuiltInType: Byte
1384		'''
1385
1386		ua_types = [
1387		('DataTypeId', 'NodeId'),
1388		('Name', 'QualifiedName'),

FreeOpcUa / python-opcua

Code Duplication Length = 28-30 lines in 20 locations

opcua/ua/uaprotocol_auto.py 20 locations