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

Code Duplication Length = 48-50 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations


    :ivar RemainingPathIndex:
    :vartype RemainingPathIndex: UInt32
    '''

    ua_types = {
        'TargetId': 'ExpandedNodeId',
        'RemainingPathIndex': 'UInt32',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.TargetId = ExpandedNodeId()
        self.RemainingPathIndex = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.TargetId.to_binary())
        packet.append(uabin.Primitives.UInt32.pack(self.RemainingPathIndex))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return BrowsePathTarget(data)

    def _binary_init(self, data):
        self.TargetId = ExpandedNodeId.from_binary(data)
        self.RemainingPathIndex = uabin.Primitives.UInt32.unpack(data)

    def __str__(self):
        return 'BrowsePathTarget(' + 'TargetId:' + str(self.TargetId) + ', ' + \
               'RemainingPathIndex:' + str(self.RemainingPathIndex) + ')'

    __repr__ = __str__


class BrowsePathResult(FrozenClass):
    '''
    The result of a translate opearation.

    :ivar StatusCode:
    :vartype StatusCode: StatusCode
    :ivar Targets:
    :vartype Targets: BrowsePathTarget
    '''

    ua_types = {
        'StatusCode': 'StatusCode',
        'Targets': 'BrowsePathTarget',
               }

    def __init__(self, binary=None):
        if binary is not None:


class EndpointUrlListDataType(FrozenClass):
    '''
    :ivar EndpointUrlList:
    :vartype EndpointUrlList: String
    '''

    ua_types = {
        'EndpointUrlList': 'String',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.EndpointUrlList = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Int32.pack(len(self.EndpointUrlList)))
        for fieldname in self.EndpointUrlList:
            packet.append(uabin.Primitives.String.pack(fieldname))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return EndpointUrlListDataType(data)

    def _binary_init(self, data):
        self.EndpointUrlList = uabin.Primitives.String.unpack_array(data)

    def __str__(self):
        return 'EndpointUrlListDataType(' + 'EndpointUrlList:' + str(self.EndpointUrlList) + ')'

    __repr__ = __str__


class NetworkGroupDataType(FrozenClass):
    '''
    :ivar ServerUri:
    :vartype ServerUri: String
    :ivar NetworkPaths:
    :vartype NetworkPaths: EndpointUrlListDataType
    '''

    ua_types = {
        'ServerUri': 'String',
        'NetworkPaths': 'EndpointUrlListDataType',
               }

    def __init__(self, binary=None):
        if binary is not None:

    '''

    ua_types = {
        'Events': 'EventFieldList',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Events = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Int32.pack(len(self.Events)))
        for fieldname in self.Events:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return EventNotificationList(data)

    def _binary_init(self, data):
        length = uabin.Primitives.Int32.unpack(data)
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(EventFieldList.from_binary(data))
        self.Events = array

    def __str__(self):
        return 'EventNotificationList(' + 'Events:' + str(self.Events) + ')'

    __repr__ = __str__


class EventFieldList(FrozenClass):
    '''
    :ivar ClientHandle:
    :vartype ClientHandle: UInt32
    :ivar EventFields:
    :vartype EventFields: Variant
    '''

    ua_types = {
        'ClientHandle': 'UInt32',
        'EventFields': 'Variant',
               }

    def __init__(self, binary=None):
        if binary is not None:

        'Trigger': 'DataChangeTrigger',
        'DeadbandType': 'UInt32',
        'DeadbandValue': 'Double',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Trigger = DataChangeTrigger(0)
        self.DeadbandType = 0
        self.DeadbandValue = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.Trigger.value))
        packet.append(uabin.Primitives.UInt32.pack(self.DeadbandType))
        packet.append(uabin.Primitives.Double.pack(self.DeadbandValue))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return DataChangeFilter(data)

    def _binary_init(self, data):
        self.Trigger = DataChangeTrigger(uabin.Primitives.UInt32.unpack(data))
        self.DeadbandType = uabin.Primitives.UInt32.unpack(data)
        self.DeadbandValue = uabin.Primitives.Double.unpack(data)

    def __str__(self):
        return 'DataChangeFilter(' + 'Trigger:' + str(self.Trigger) + ', ' + \
               'DeadbandType:' + str(self.DeadbandType) + ', ' + \
               'DeadbandValue:' + str(self.DeadbandValue) + ')'

    __repr__ = __str__


class EventFilter(FrozenClass):
    '''
    :ivar SelectClauses:
    :vartype SelectClauses: SimpleAttributeOperand
    :ivar WhereClause:
    :vartype WhereClause: ContentFilter
    '''

    ua_types = {
        'SelectClauses': 'SimpleAttributeOperand',
        'WhereClause': 'ContentFilter',
               }

    def __init__(self, binary=None):
        if binary is not None:

        'TypeId': 'NodeId',
        'RequestHeader': 'RequestHeader',
        'Parameters': 'QueryNextParameters',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.TypeId = FourByteNodeId(ObjectIds.QueryNextRequest_Encoding_DefaultBinary)
        self.RequestHeader = RequestHeader()
        self.Parameters = QueryNextParameters()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.TypeId.to_binary())
        packet.append(self.RequestHeader.to_binary())
        packet.append(self.Parameters.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return QueryNextRequest(data)

    def _binary_init(self, data):
        self.TypeId = NodeId.from_binary(data)
        self.RequestHeader = RequestHeader.from_binary(data)
        self.Parameters = QueryNextParameters.from_binary(data)

    def __str__(self):
        return 'QueryNextRequest(' + 'TypeId:' + str(self.TypeId) + ', ' + \
               'RequestHeader:' + str(self.RequestHeader) + ', ' + \
               'Parameters:' + str(self.Parameters) + ')'

    __repr__ = __str__


class QueryNextResult(FrozenClass):
    '''
    :ivar QueryDataSets:
    :vartype QueryDataSets: QueryDataSet
    :ivar RevisedContinuationPoint:
    :vartype RevisedContinuationPoint: ByteString
    '''

    ua_types = {
        'QueryDataSets': 'QueryDataSet',
        'RevisedContinuationPoint': 'ByteString',
               }

    def __init__(self, binary=None):
        if binary is not None:

        self.ReferenceTypeId = NodeId()
        self.IsForward = True
        self.ReferencedNodeIds = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.NodeId.to_binary())
        packet.append(self.ReferenceTypeId.to_binary())
        packet.append(uabin.Primitives.Boolean.pack(self.IsForward))
        packet.append(uabin.Primitives.Int32.pack(len(self.ReferencedNodeIds)))
        for fieldname in self.ReferencedNodeIds:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return NodeReference(data)

    def _binary_init(self, data):
        self.NodeId = NodeId.from_binary(data)
        self.ReferenceTypeId = NodeId.from_binary(data)
        self.IsForward = uabin.Primitives.Boolean.unpack(data)
        length = uabin.Primitives.Int32.unpack(data)
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(NodeId.from_binary(data))
        self.ReferencedNodeIds = array

    def __str__(self):
        return 'NodeReference(' + 'NodeId:' + str(self.NodeId) + ', ' + \
               'ReferenceTypeId:' + str(self.ReferenceTypeId) + ', ' + \
               'IsForward:' + str(self.IsForward) + ', ' + \
               'ReferencedNodeIds:' + str(self.ReferencedNodeIds) + ')'

    __repr__ = __str__


class ContentFilterElement(FrozenClass):
    '''
    :ivar FilterOperator:
    :vartype FilterOperator: FilterOperator
    :ivar FilterOperands:
    :vartype FilterOperands: ExtensionObject
    '''

    ua_types = {
        'FilterOperator': 'FilterOperator',
        'FilterOperands': 'ExtensionObject',
               }

    def __init__(self, binary=None):
        if binary is not None:

    __repr__ = __str__


class RegisterServer2Parameters(FrozenClass):
    '''
    :ivar Server:
    :vartype Server: RegisteredServer
    :ivar DiscoveryConfiguration:
    :vartype DiscoveryConfiguration: ExtensionObject
    '''

    ua_types = {
        'Server': 'RegisteredServer',
        'DiscoveryConfiguration': 'ExtensionObject',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Server = RegisteredServer()
        self.DiscoveryConfiguration = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.Server.to_binary())
        packet.append(uabin.Primitives.Int32.pack(len(self.DiscoveryConfiguration)))
        for fieldname in self.DiscoveryConfiguration:
            packet.append(extensionobject_to_binary(fieldname))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return RegisterServer2Parameters(data)

    def _binary_init(self, data):
        self.Server = RegisteredServer.from_binary(data)
        length = uabin.Primitives.Int32.unpack(data)
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(extensionobject_from_binary(data))
        self.DiscoveryConfiguration = array

    def __str__(self):
        return 'RegisterServer2Parameters(' + 'Server:' + str(self.Server) + ', ' + \
               'DiscoveryConfiguration:' + str(self.DiscoveryConfiguration) + ')'

    __repr__ = __str__


class RegisterServer2Request(FrozenClass):

    __repr__ = __str__


class FindServersOnNetworkResult(FrozenClass):
    '''
    :ivar LastCounterResetTime:
    :vartype LastCounterResetTime: DateTime
    :ivar Servers:
    :vartype Servers: ServerOnNetwork
    '''

    ua_types = {
        'LastCounterResetTime': 'DateTime',
        'Servers': 'ServerOnNetwork',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.LastCounterResetTime = datetime.utcnow()
        self.Servers = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.DateTime.pack(self.LastCounterResetTime))
        packet.append(uabin.Primitives.Int32.pack(len(self.Servers)))
        for fieldname in self.Servers:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return FindServersOnNetworkResult(data)

    def _binary_init(self, data):
        self.LastCounterResetTime = uabin.Primitives.DateTime.unpack(data)
        length = uabin.Primitives.Int32.unpack(data)
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(ServerOnNetwork.from_binary(data))
        self.Servers = array

    def __str__(self):
        return 'FindServersOnNetworkResult(' + 'LastCounterResetTime:' + str(self.LastCounterResetTime) + ', ' + \
               'Servers:' + str(self.Servers) + ')'

    __repr__ = __str__


class FindServersOnNetworkResponse(FrozenClass):

		@@ 6757-6806 (lines=50) @@
6754		:ivar RemainingPathIndex:
6755		:vartype RemainingPathIndex: UInt32
6756		'''
6757
6758		ua_types = {
6759		'TargetId': 'ExpandedNodeId',
6760		'RemainingPathIndex': 'UInt32',
6761		}
6762
6763		def __init__(self, binary=None):
6764		if binary is not None:
6765		self._binary_init(binary)
6766		self._freeze = True
6767		return
6768		self.TargetId = ExpandedNodeId()
6769		self.RemainingPathIndex = 0
6770		self._freeze = True
6771
6772		def to_binary(self):
6773		packet = []
6774		packet.append(self.TargetId.to_binary())
6775		packet.append(uabin.Primitives.UInt32.pack(self.RemainingPathIndex))
6776		return b''.join(packet)
6777
6778		@staticmethod
6779		def from_binary(data):
6780		return BrowsePathTarget(data)
6781
6782		def _binary_init(self, data):
6783		self.TargetId = ExpandedNodeId.from_binary(data)
6784		self.RemainingPathIndex = uabin.Primitives.UInt32.unpack(data)
6785
6786		def __str__(self):
6787		return 'BrowsePathTarget(' + 'TargetId:' + str(self.TargetId) + ', ' + \
6788		'RemainingPathIndex:' + str(self.RemainingPathIndex) + ')'
6789
6790		__repr__ = __str__
6791
6792
6793		class BrowsePathResult(FrozenClass):
6794		'''
6795		The result of a translate opearation.
6796
6797		:ivar StatusCode:
6798		:vartype StatusCode: StatusCode
6799		:ivar Targets:
6800		:vartype Targets: BrowsePathTarget
6801		'''
6802
6803		ua_types = {
6804		'StatusCode': 'StatusCode',
6805		'Targets': 'BrowsePathTarget',
6806		}
6807
6808		def __init__(self, binary=None):
6809		if binary is not None:
		@@ 14481-14528 (lines=48) @@
14478
14479		class EndpointUrlListDataType(FrozenClass):
14480		'''
14481		:ivar EndpointUrlList:
14482		:vartype EndpointUrlList: String
14483		'''
14484
14485		ua_types = {
14486		'EndpointUrlList': 'String',
14487		}
14488
14489		def __init__(self, binary=None):
14490		if binary is not None:
14491		self._binary_init(binary)
14492		self._freeze = True
14493		return
14494		self.EndpointUrlList = []
14495		self._freeze = True
14496
14497		def to_binary(self):
14498		packet = []
14499		packet.append(uabin.Primitives.Int32.pack(len(self.EndpointUrlList)))
14500		for fieldname in self.EndpointUrlList:
14501		packet.append(uabin.Primitives.String.pack(fieldname))
14502		return b''.join(packet)
14503
14504		@staticmethod
14505		def from_binary(data):
14506		return EndpointUrlListDataType(data)
14507
14508		def _binary_init(self, data):
14509		self.EndpointUrlList = uabin.Primitives.String.unpack_array(data)
14510
14511		def __str__(self):
14512		return 'EndpointUrlListDataType(' + 'EndpointUrlList:' + str(self.EndpointUrlList) + ')'
14513
14514		__repr__ = __str__
14515
14516
14517		class NetworkGroupDataType(FrozenClass):
14518		'''
14519		:ivar ServerUri:
14520		:vartype ServerUri: String
14521		:ivar NetworkPaths:
14522		:vartype NetworkPaths: EndpointUrlListDataType
14523		'''
14524
14525		ua_types = {
14526		'ServerUri': 'String',
14527		'NetworkPaths': 'EndpointUrlListDataType',
14528		}
14529
14530		def __init__(self, binary=None):
14531		if binary is not None:
		@@ 13364-13411 (lines=48) @@
13361		'''
13362
13363		ua_types = {
13364		'Events': 'EventFieldList',
13365		}
13366
13367		def __init__(self, binary=None):
13368		if binary is not None:
13369		self._binary_init(binary)
13370		self._freeze = True
13371		return
13372		self.Events = []
13373		self._freeze = True
13374
13375		def to_binary(self):
13376		packet = []
13377		packet.append(uabin.Primitives.Int32.pack(len(self.Events)))
13378		for fieldname in self.Events:
13379		packet.append(fieldname.to_binary())
13380		return b''.join(packet)
13381
13382		@staticmethod
13383		def from_binary(data):
13384		return EventNotificationList(data)
13385
13386		def _binary_init(self, data):
13387		length = uabin.Primitives.Int32.unpack(data)
13388		array = []
13389		if length != -1:
13390		for _ in range(0, length):
13391		array.append(EventFieldList.from_binary(data))
13392		self.Events = array
13393
13394		def __str__(self):
13395		return 'EventNotificationList(' + 'Events:' + str(self.Events) + ')'
13396
13397		__repr__ = __str__
13398
13399
13400		class EventFieldList(FrozenClass):
13401		'''
13402		:ivar ClientHandle:
13403		:vartype ClientHandle: UInt32
13404		:ivar EventFields:
13405		:vartype EventFields: Variant
13406		'''
13407
13408		ua_types = {
13409		'ClientHandle': 'UInt32',
13410		'EventFields': 'Variant',
13411		}
13412
13413		def __init__(self, binary=None):
13414		if binary is not None:
		@@ 10911-10958 (lines=48) @@
10908		'Trigger': 'DataChangeTrigger',
10909		'DeadbandType': 'UInt32',
10910		'DeadbandValue': 'Double',
10911		}
10912
10913		def __init__(self, binary=None):
10914		if binary is not None:
10915		self._binary_init(binary)
10916		self._freeze = True
10917		return
10918		self.Trigger = DataChangeTrigger(0)
10919		self.DeadbandType = 0
10920		self.DeadbandValue = 0
10921		self._freeze = True
10922
10923		def to_binary(self):
10924		packet = []
10925		packet.append(uabin.Primitives.UInt32.pack(self.Trigger.value))
10926		packet.append(uabin.Primitives.UInt32.pack(self.DeadbandType))
10927		packet.append(uabin.Primitives.Double.pack(self.DeadbandValue))
10928		return b''.join(packet)
10929
10930		@staticmethod
10931		def from_binary(data):
10932		return DataChangeFilter(data)
10933
10934		def _binary_init(self, data):
10935		self.Trigger = DataChangeTrigger(uabin.Primitives.UInt32.unpack(data))
10936		self.DeadbandType = uabin.Primitives.UInt32.unpack(data)
10937		self.DeadbandValue = uabin.Primitives.Double.unpack(data)
10938
10939		def __str__(self):
10940		return 'DataChangeFilter(' + 'Trigger:' + str(self.Trigger) + ', ' + \
10941		'DeadbandType:' + str(self.DeadbandType) + ', ' + \
10942		'DeadbandValue:' + str(self.DeadbandValue) + ')'
10943
10944		__repr__ = __str__
10945
10946
10947		class EventFilter(FrozenClass):
10948		'''
10949		:ivar SelectClauses:
10950		:vartype SelectClauses: SimpleAttributeOperand
10951		:ivar WhereClause:
10952		:vartype WhereClause: ContentFilter
10953		'''
10954
10955		ua_types = {
10956		'SelectClauses': 'SimpleAttributeOperand',
10957		'WhereClause': 'ContentFilter',
10958		}
10959
10960		def __init__(self, binary=None):
10961		if binary is not None:
		@@ 8633-8680 (lines=48) @@
8630		'TypeId': 'NodeId',
8631		'RequestHeader': 'RequestHeader',
8632		'Parameters': 'QueryNextParameters',
8633		}
8634
8635		def __init__(self, binary=None):
8636		if binary is not None:
8637		self._binary_init(binary)
8638		self._freeze = True
8639		return
8640		self.TypeId = FourByteNodeId(ObjectIds.QueryNextRequest_Encoding_DefaultBinary)
8641		self.RequestHeader = RequestHeader()
8642		self.Parameters = QueryNextParameters()
8643		self._freeze = True
8644
8645		def to_binary(self):
8646		packet = []
8647		packet.append(self.TypeId.to_binary())
8648		packet.append(self.RequestHeader.to_binary())
8649		packet.append(self.Parameters.to_binary())
8650		return b''.join(packet)
8651
8652		@staticmethod
8653		def from_binary(data):
8654		return QueryNextRequest(data)
8655
8656		def _binary_init(self, data):
8657		self.TypeId = NodeId.from_binary(data)
8658		self.RequestHeader = RequestHeader.from_binary(data)
8659		self.Parameters = QueryNextParameters.from_binary(data)
8660
8661		def __str__(self):
8662		return 'QueryNextRequest(' + 'TypeId:' + str(self.TypeId) + ', ' + \
8663		'RequestHeader:' + str(self.RequestHeader) + ', ' + \
8664		'Parameters:' + str(self.Parameters) + ')'
8665
8666		__repr__ = __str__
8667
8668
8669		class QueryNextResult(FrozenClass):
8670		'''
8671		:ivar QueryDataSets:
8672		:vartype QueryDataSets: QueryDataSet
8673		:ivar RevisedContinuationPoint:
8674		:vartype RevisedContinuationPoint: ByteString
8675		'''
8676
8677		ua_types = {
8678		'QueryDataSets': 'QueryDataSet',
8679		'RevisedContinuationPoint': 'ByteString',
8680		}
8681
8682		def __init__(self, binary=None):
8683		if binary is not None:
		@@ 7806-7853 (lines=48) @@
7803		self.ReferenceTypeId = NodeId()
7804		self.IsForward = True
7805		self.ReferencedNodeIds = []
7806		self._freeze = True
7807
7808		def to_binary(self):
7809		packet = []
7810		packet.append(self.NodeId.to_binary())
7811		packet.append(self.ReferenceTypeId.to_binary())
7812		packet.append(uabin.Primitives.Boolean.pack(self.IsForward))
7813		packet.append(uabin.Primitives.Int32.pack(len(self.ReferencedNodeIds)))
7814		for fieldname in self.ReferencedNodeIds:
7815		packet.append(fieldname.to_binary())
7816		return b''.join(packet)
7817
7818		@staticmethod
7819		def from_binary(data):
7820		return NodeReference(data)
7821
7822		def _binary_init(self, data):
7823		self.NodeId = NodeId.from_binary(data)
7824		self.ReferenceTypeId = NodeId.from_binary(data)
7825		self.IsForward = uabin.Primitives.Boolean.unpack(data)
7826		length = uabin.Primitives.Int32.unpack(data)
7827		array = []
7828		if length != -1:
7829		for _ in range(0, length):
7830		array.append(NodeId.from_binary(data))
7831		self.ReferencedNodeIds = array
7832
7833		def __str__(self):
7834		return 'NodeReference(' + 'NodeId:' + str(self.NodeId) + ', ' + \
7835		'ReferenceTypeId:' + str(self.ReferenceTypeId) + ', ' + \
7836		'IsForward:' + str(self.IsForward) + ', ' + \
7837		'ReferencedNodeIds:' + str(self.ReferencedNodeIds) + ')'
7838
7839		__repr__ = __str__
7840
7841
7842		class ContentFilterElement(FrozenClass):
7843		'''
7844		:ivar FilterOperator:
7845		:vartype FilterOperator: FilterOperator
7846		:ivar FilterOperands:
7847		:vartype FilterOperands: ExtensionObject
7848		'''
7849
7850		ua_types = {
7851		'FilterOperator': 'FilterOperator',
7852		'FilterOperands': 'ExtensionObject',
7853		}
7854
7855		def __init__(self, binary=None):
7856		if binary is not None:
		@@ 2459-2506 (lines=48) @@
2456		__repr__ = __str__
2457
2458
2459		class RegisterServer2Parameters(FrozenClass):
2460		'''
2461		:ivar Server:
2462		:vartype Server: RegisteredServer
2463		:ivar DiscoveryConfiguration:
2464		:vartype DiscoveryConfiguration: ExtensionObject
2465		'''
2466
2467		ua_types = {
2468		'Server': 'RegisteredServer',
2469		'DiscoveryConfiguration': 'ExtensionObject',
2470		}
2471
2472		def __init__(self, binary=None):
2473		if binary is not None:
2474		self._binary_init(binary)
2475		self._freeze = True
2476		return
2477		self.Server = RegisteredServer()
2478		self.DiscoveryConfiguration = []
2479		self._freeze = True
2480
2481		def to_binary(self):
2482		packet = []
2483		packet.append(self.Server.to_binary())
2484		packet.append(uabin.Primitives.Int32.pack(len(self.DiscoveryConfiguration)))
2485		for fieldname in self.DiscoveryConfiguration:
2486		packet.append(extensionobject_to_binary(fieldname))
2487		return b''.join(packet)
2488
2489		@staticmethod
2490		def from_binary(data):
2491		return RegisterServer2Parameters(data)
2492
2493		def _binary_init(self, data):
2494		self.Server = RegisteredServer.from_binary(data)
2495		length = uabin.Primitives.Int32.unpack(data)
2496		array = []
2497		if length != -1:
2498		for _ in range(0, length):
2499		array.append(extensionobject_from_binary(data))
2500		self.DiscoveryConfiguration = array
2501
2502		def __str__(self):
2503		return 'RegisterServer2Parameters(' + 'Server:' + str(self.Server) + ', ' + \
2504		'DiscoveryConfiguration:' + str(self.DiscoveryConfiguration) + ')'
2505
2506		__repr__ = __str__
2507
2508
2509		class RegisterServer2Request(FrozenClass):
		@@ 1761-1808 (lines=48) @@
1758		__repr__ = __str__
1759
1760
1761		class FindServersOnNetworkResult(FrozenClass):
1762		'''
1763		:ivar LastCounterResetTime:
1764		:vartype LastCounterResetTime: DateTime
1765		:ivar Servers:
1766		:vartype Servers: ServerOnNetwork
1767		'''
1768
1769		ua_types = {
1770		'LastCounterResetTime': 'DateTime',
1771		'Servers': 'ServerOnNetwork',
1772		}
1773
1774		def __init__(self, binary=None):
1775		if binary is not None:
1776		self._binary_init(binary)
1777		self._freeze = True
1778		return
1779		self.LastCounterResetTime = datetime.utcnow()
1780		self.Servers = []
1781		self._freeze = True
1782
1783		def to_binary(self):
1784		packet = []
1785		packet.append(uabin.Primitives.DateTime.pack(self.LastCounterResetTime))
1786		packet.append(uabin.Primitives.Int32.pack(len(self.Servers)))
1787		for fieldname in self.Servers:
1788		packet.append(fieldname.to_binary())
1789		return b''.join(packet)
1790
1791		@staticmethod
1792		def from_binary(data):
1793		return FindServersOnNetworkResult(data)
1794
1795		def _binary_init(self, data):
1796		self.LastCounterResetTime = uabin.Primitives.DateTime.unpack(data)
1797		length = uabin.Primitives.Int32.unpack(data)
1798		array = []
1799		if length != -1:
1800		for _ in range(0, length):
1801		array.append(ServerOnNetwork.from_binary(data))
1802		self.Servers = array
1803
1804		def __str__(self):
1805		return 'FindServersOnNetworkResult(' + 'LastCounterResetTime:' + str(self.LastCounterResetTime) + ', ' + \
1806		'Servers:' + str(self.Servers) + ')'
1807
1808		__repr__ = __str__
1809
1810
1811		class FindServersOnNetworkResponse(FrozenClass):

FreeOpcUa / python-opcua

Code Duplication Length = 48-50 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations