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


    __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:
            self._binary_init(binary)
            self._freeze = True
            return
        self.StatusCode = StatusCode()
        self.Targets = []
        self._freeze = True

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

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

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

    def __str__(self):
        return 'BrowsePathResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \
               'Targets:' + str(self.Targets) + ')'

    __repr__ = __str__


class TranslateBrowsePathsToNodeIdsParameters(FrozenClass):

    __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:
            self._binary_init(binary)
            self._freeze = True
            return
        self.ServerUri = None
        self.NetworkPaths = []
        self._freeze = True

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

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

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

    def __str__(self):
        return 'NetworkGroupDataType(' + 'ServerUri:' + str(self.ServerUri) + ', ' + \
               'NetworkPaths:' + str(self.NetworkPaths) + ')'

    __repr__ = __str__


class SamplingIntervalDiagnosticsDataType(FrozenClass):

    __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:
            self._binary_init(binary)
            self._freeze = True
            return
        self.ClientHandle = 0
        self.EventFields = []
        self._freeze = True

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

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

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

    def __str__(self):
        return 'EventFieldList(' + 'ClientHandle:' + str(self.ClientHandle) + ', ' + \
               'EventFields:' + str(self.EventFields) + ')'

    __repr__ = __str__


class HistoryEventFieldList(FrozenClass):

    __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:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SelectClauses = []
        self.WhereClause = ContentFilter()
        self._freeze = True

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

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

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

    def __str__(self):
        return 'EventFilter(' + 'SelectClauses:' + str(self.SelectClauses) + ', ' + \
               'WhereClause:' + str(self.WhereClause) + ')'

    __repr__ = __str__


class AggregateConfiguration(FrozenClass):

    __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._binary_init(binary)
            self._freeze = True
            return
        self.QueryDataSets = []
        self.RevisedContinuationPoint = None
        self._freeze = True

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

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

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

    def __str__(self):
        return 'QueryNextResult(' + 'QueryDataSets:' + str(self.QueryDataSets) + ', ' + \
               'RevisedContinuationPoint:' + str(self.RevisedContinuationPoint) + ')'

    __repr__ = __str__


class QueryNextResponse(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.now()
        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):

    __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:
            self._binary_init(binary)
            self._freeze = True
            return
        self.FilterOperator = FilterOperator(0)
        self.FilterOperands = []
        self._freeze = True

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

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

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

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

    __repr__ = __str__


class ContentFilter(FrozenClass):

    __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):

		@@ 6757-6806 (lines=50) @@
6754		__repr__ = __str__
6755
6756
6757		class BrowsePathResult(FrozenClass):
6758		'''
6759		The result of a translate opearation.
6760
6761		:ivar StatusCode:
6762		:vartype StatusCode: StatusCode
6763		:ivar Targets:
6764		:vartype Targets: BrowsePathTarget
6765		'''
6766
6767		ua_types = {
6768		'StatusCode': 'StatusCode',
6769		'Targets': 'BrowsePathTarget',
6770		}
6771
6772		def __init__(self, binary=None):
6773		if binary is not None:
6774		self._binary_init(binary)
6775		self._freeze = True
6776		return
6777		self.StatusCode = StatusCode()
6778		self.Targets = []
6779		self._freeze = True
6780
6781		def to_binary(self):
6782		packet = []
6783		packet.append(self.StatusCode.to_binary())
6784		packet.append(uabin.Primitives.Int32.pack(len(self.Targets)))
6785		for fieldname in self.Targets:
6786		packet.append(fieldname.to_binary())
6787		return b''.join(packet)
6788
6789		@staticmethod
6790		def from_binary(data):
6791		return BrowsePathResult(data)
6792
6793		def _binary_init(self, data):
6794		self.StatusCode = StatusCode.from_binary(data)
6795		length = uabin.Primitives.Int32.unpack(data)
6796		array = []
6797		if length != -1:
6798		for _ in range(0, length):
6799		array.append(BrowsePathTarget.from_binary(data))
6800		self.Targets = array
6801
6802		def __str__(self):
6803		return 'BrowsePathResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \
6804		'Targets:' + str(self.Targets) + ')'
6805
6806		__repr__ = __str__
6807
6808
6809		class TranslateBrowsePathsToNodeIdsParameters(FrozenClass):
		@@ 14481-14528 (lines=48) @@
14478		__repr__ = __str__
14479
14480
14481		class NetworkGroupDataType(FrozenClass):
14482		'''
14483		:ivar ServerUri:
14484		:vartype ServerUri: String
14485		:ivar NetworkPaths:
14486		:vartype NetworkPaths: EndpointUrlListDataType
14487		'''
14488
14489		ua_types = {
14490		'ServerUri': 'String',
14491		'NetworkPaths': 'EndpointUrlListDataType',
14492		}
14493
14494		def __init__(self, binary=None):
14495		if binary is not None:
14496		self._binary_init(binary)
14497		self._freeze = True
14498		return
14499		self.ServerUri = None
14500		self.NetworkPaths = []
14501		self._freeze = True
14502
14503		def to_binary(self):
14504		packet = []
14505		packet.append(uabin.Primitives.String.pack(self.ServerUri))
14506		packet.append(uabin.Primitives.Int32.pack(len(self.NetworkPaths)))
14507		for fieldname in self.NetworkPaths:
14508		packet.append(fieldname.to_binary())
14509		return b''.join(packet)
14510
14511		@staticmethod
14512		def from_binary(data):
14513		return NetworkGroupDataType(data)
14514
14515		def _binary_init(self, data):
14516		self.ServerUri = uabin.Primitives.String.unpack(data)
14517		length = uabin.Primitives.Int32.unpack(data)
14518		array = []
14519		if length != -1:
14520		for _ in range(0, length):
14521		array.append(EndpointUrlListDataType.from_binary(data))
14522		self.NetworkPaths = array
14523
14524		def __str__(self):
14525		return 'NetworkGroupDataType(' + 'ServerUri:' + str(self.ServerUri) + ', ' + \
14526		'NetworkPaths:' + str(self.NetworkPaths) + ')'
14527
14528		__repr__ = __str__
14529
14530
14531		class SamplingIntervalDiagnosticsDataType(FrozenClass):
		@@ 13364-13411 (lines=48) @@
13361		__repr__ = __str__
13362
13363
13364		class EventFieldList(FrozenClass):
13365		'''
13366		:ivar ClientHandle:
13367		:vartype ClientHandle: UInt32
13368		:ivar EventFields:
13369		:vartype EventFields: Variant
13370		'''
13371
13372		ua_types = {
13373		'ClientHandle': 'UInt32',
13374		'EventFields': 'Variant',
13375		}
13376
13377		def __init__(self, binary=None):
13378		if binary is not None:
13379		self._binary_init(binary)
13380		self._freeze = True
13381		return
13382		self.ClientHandle = 0
13383		self.EventFields = []
13384		self._freeze = True
13385
13386		def to_binary(self):
13387		packet = []
13388		packet.append(uabin.Primitives.UInt32.pack(self.ClientHandle))
13389		packet.append(uabin.Primitives.Int32.pack(len(self.EventFields)))
13390		for fieldname in self.EventFields:
13391		packet.append(fieldname.to_binary())
13392		return b''.join(packet)
13393
13394		@staticmethod
13395		def from_binary(data):
13396		return EventFieldList(data)
13397
13398		def _binary_init(self, data):
13399		self.ClientHandle = uabin.Primitives.UInt32.unpack(data)
13400		length = uabin.Primitives.Int32.unpack(data)
13401		array = []
13402		if length != -1:
13403		for _ in range(0, length):
13404		array.append(Variant.from_binary(data))
13405		self.EventFields = array
13406
13407		def __str__(self):
13408		return 'EventFieldList(' + 'ClientHandle:' + str(self.ClientHandle) + ', ' + \
13409		'EventFields:' + str(self.EventFields) + ')'
13410
13411		__repr__ = __str__
13412
13413
13414		class HistoryEventFieldList(FrozenClass):
		@@ 10911-10958 (lines=48) @@
10908		__repr__ = __str__
10909
10910
10911		class EventFilter(FrozenClass):
10912		'''
10913		:ivar SelectClauses:
10914		:vartype SelectClauses: SimpleAttributeOperand
10915		:ivar WhereClause:
10916		:vartype WhereClause: ContentFilter
10917		'''
10918
10919		ua_types = {
10920		'SelectClauses': 'SimpleAttributeOperand',
10921		'WhereClause': 'ContentFilter',
10922		}
10923
10924		def __init__(self, binary=None):
10925		if binary is not None:
10926		self._binary_init(binary)
10927		self._freeze = True
10928		return
10929		self.SelectClauses = []
10930		self.WhereClause = ContentFilter()
10931		self._freeze = True
10932
10933		def to_binary(self):
10934		packet = []
10935		packet.append(uabin.Primitives.Int32.pack(len(self.SelectClauses)))
10936		for fieldname in self.SelectClauses:
10937		packet.append(fieldname.to_binary())
10938		packet.append(self.WhereClause.to_binary())
10939		return b''.join(packet)
10940
10941		@staticmethod
10942		def from_binary(data):
10943		return EventFilter(data)
10944
10945		def _binary_init(self, data):
10946		length = uabin.Primitives.Int32.unpack(data)
10947		array = []
10948		if length != -1:
10949		for _ in range(0, length):
10950		array.append(SimpleAttributeOperand.from_binary(data))
10951		self.SelectClauses = array
10952		self.WhereClause = ContentFilter.from_binary(data)
10953
10954		def __str__(self):
10955		return 'EventFilter(' + 'SelectClauses:' + str(self.SelectClauses) + ', ' + \
10956		'WhereClause:' + str(self.WhereClause) + ')'
10957
10958		__repr__ = __str__
10959
10960
10961		class AggregateConfiguration(FrozenClass):
		@@ 8633-8680 (lines=48) @@
8630		__repr__ = __str__
8631
8632
8633		class QueryNextResult(FrozenClass):
8634		'''
8635		:ivar QueryDataSets:
8636		:vartype QueryDataSets: QueryDataSet
8637		:ivar RevisedContinuationPoint:
8638		:vartype RevisedContinuationPoint: ByteString
8639		'''
8640
8641		ua_types = {
8642		'QueryDataSets': 'QueryDataSet',
8643		'RevisedContinuationPoint': 'ByteString',
8644		}
8645
8646		def __init__(self, binary=None):
8647		if binary is not None:
8648		self._binary_init(binary)
8649		self._freeze = True
8650		return
8651		self.QueryDataSets = []
8652		self.RevisedContinuationPoint = None
8653		self._freeze = True
8654
8655		def to_binary(self):
8656		packet = []
8657		packet.append(uabin.Primitives.Int32.pack(len(self.QueryDataSets)))
8658		for fieldname in self.QueryDataSets:
8659		packet.append(fieldname.to_binary())
8660		packet.append(uabin.Primitives.ByteString.pack(self.RevisedContinuationPoint))
8661		return b''.join(packet)
8662
8663		@staticmethod
8664		def from_binary(data):
8665		return QueryNextResult(data)
8666
8667		def _binary_init(self, data):
8668		length = uabin.Primitives.Int32.unpack(data)
8669		array = []
8670		if length != -1:
8671		for _ in range(0, length):
8672		array.append(QueryDataSet.from_binary(data))
8673		self.QueryDataSets = array
8674		self.RevisedContinuationPoint = uabin.Primitives.ByteString.unpack(data)
8675
8676		def __str__(self):
8677		return 'QueryNextResult(' + 'QueryDataSets:' + str(self.QueryDataSets) + ', ' + \
8678		'RevisedContinuationPoint:' + str(self.RevisedContinuationPoint) + ')'
8679
8680		__repr__ = __str__
8681
8682
8683		class QueryNextResponse(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.now()
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):
		@@ 7806-7853 (lines=48) @@
7803		__repr__ = __str__
7804
7805
7806		class ContentFilterElement(FrozenClass):
7807		'''
7808		:ivar FilterOperator:
7809		:vartype FilterOperator: FilterOperator
7810		:ivar FilterOperands:
7811		:vartype FilterOperands: ExtensionObject
7812		'''
7813
7814		ua_types = {
7815		'FilterOperator': 'FilterOperator',
7816		'FilterOperands': 'ExtensionObject',
7817		}
7818
7819		def __init__(self, binary=None):
7820		if binary is not None:
7821		self._binary_init(binary)
7822		self._freeze = True
7823		return
7824		self.FilterOperator = FilterOperator(0)
7825		self.FilterOperands = []
7826		self._freeze = True
7827
7828		def to_binary(self):
7829		packet = []
7830		packet.append(uabin.Primitives.UInt32.pack(self.FilterOperator.value))
7831		packet.append(uabin.Primitives.Int32.pack(len(self.FilterOperands)))
7832		for fieldname in self.FilterOperands:
7833		packet.append(extensionobject_to_binary(fieldname))
7834		return b''.join(packet)
7835
7836		@staticmethod
7837		def from_binary(data):
7838		return ContentFilterElement(data)
7839
7840		def _binary_init(self, data):
7841		self.FilterOperator = FilterOperator(uabin.Primitives.UInt32.unpack(data))
7842		length = uabin.Primitives.Int32.unpack(data)
7843		array = []
7844		if length != -1:
7845		for _ in range(0, length):
7846		array.append(extensionobject_from_binary(data))
7847		self.FilterOperands = array
7848
7849		def __str__(self):
7850		return 'ContentFilterElement(' + 'FilterOperator:' + str(self.FilterOperator) + ', ' + \
7851		'FilterOperands:' + str(self.FilterOperands) + ')'
7852
7853		__repr__ = __str__
7854
7855
7856		class ContentFilter(FrozenClass):
		@@ 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):

FreeOpcUa / python-opcua

Code Duplication Length = 48-50 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations