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

Code Duplication Length = 55-55 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations


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

    __repr__ = __str__


class TransferSubscriptionsResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: TransferResult
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''

    ua_types = {
        'Results': 'TransferResult',
        'DiagnosticInfos': 'DiagnosticInfo',
               }

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

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

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

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

    def __str__(self):
        return 'TransferSubscriptionsResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__


        return 'NotificationData(' +  + ')'

    __repr__ = __str__


class DataChangeNotification(FrozenClass):
    '''
    :ivar MonitoredItems:
    :vartype MonitoredItems: MonitoredItemNotification
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''

    ua_types = {
        'MonitoredItems': 'MonitoredItemNotification',
        'DiagnosticInfos': 'DiagnosticInfo',
               }

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

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

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

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

    def __str__(self):
        return 'DataChangeNotification(' + 'MonitoredItems:' + str(self.MonitoredItems) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__


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

    __repr__ = __str__


class SetPublishingModeResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: StatusCode
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''

    ua_types = {
        'Results': 'StatusCode',
        'DiagnosticInfos': 'DiagnosticInfo',
               }

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

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

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

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

    def __str__(self):
        return 'SetPublishingModeResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__


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

    __repr__ = __str__


class SetMonitoringModeResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: StatusCode
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''

    ua_types = {
        'Results': 'StatusCode',
        'DiagnosticInfos': 'DiagnosticInfo',
               }

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

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

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

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

    def __str__(self):
        return 'SetMonitoringModeResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__


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

    __repr__ = __str__


class HistoryModifiedData(FrozenClass):
    '''
    :ivar DataValues:
    :vartype DataValues: DataValue
    :ivar ModificationInfos:
    :vartype ModificationInfos: ModificationInfo
    '''

    ua_types = {
        'DataValues': 'DataValue',
        'ModificationInfos': 'ModificationInfo',
               }

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

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

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

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

    def __str__(self):
        return 'HistoryModifiedData(' + 'DataValues:' + str(self.DataValues) + ', ' + \
               'ModificationInfos:' + str(self.ModificationInfos) + ')'

    __repr__ = __str__


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

    __repr__ = __str__


class ContentFilterResult(FrozenClass):
    '''
    :ivar ElementResults:
    :vartype ElementResults: ContentFilterElementResult
    :ivar ElementDiagnosticInfos:
    :vartype ElementDiagnosticInfos: DiagnosticInfo
    '''

    ua_types = {
        'ElementResults': 'ContentFilterElementResult',
        'ElementDiagnosticInfos': 'DiagnosticInfo',
               }

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

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

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

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

    def __str__(self):
        return 'ContentFilterResult(' + 'ElementResults:' + str(self.ElementResults) + ', ' + \
               'ElementDiagnosticInfos:' + str(self.ElementDiagnosticInfos) + ')'

    __repr__ = __str__


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

    __repr__ = __str__


class BrowseNextResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: BrowseResult
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''

    ua_types = {
        'Results': 'BrowseResult',
        'DiagnosticInfos': 'DiagnosticInfo',
               }

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

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

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

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

    def __str__(self):
        return 'BrowseNextResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__


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

    __repr__ = __str__


class DeleteReferencesResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: StatusCode
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''

    ua_types = {
        'Results': 'StatusCode',
        'DiagnosticInfos': 'DiagnosticInfo',
               }

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

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

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

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

    def __str__(self):
        return 'DeleteReferencesResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__


		@@ 14090-14144 (lines=55) @@
14087		'Parameters:' + str(self.Parameters) + ')'
14088
14089		__repr__ = __str__
14090
14091
14092		class TransferSubscriptionsResult(FrozenClass):
14093		'''
14094		:ivar Results:
14095		:vartype Results: TransferResult
14096		:ivar DiagnosticInfos:
14097		:vartype DiagnosticInfos: DiagnosticInfo
14098		'''
14099
14100		ua_types = {
14101		'Results': 'TransferResult',
14102		'DiagnosticInfos': 'DiagnosticInfo',
14103		}
14104
14105		def __init__(self, binary=None):
14106		if binary is not None:
14107		self._binary_init(binary)
14108		self._freeze = True
14109		return
14110		self.Results = []
14111		self.DiagnosticInfos = []
14112		self._freeze = True
14113
14114		def to_binary(self):
14115		packet = []
14116		packet.append(uabin.Primitives.Int32.pack(len(self.Results)))
14117		for fieldname in self.Results:
14118		packet.append(fieldname.to_binary())
14119		packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))
14120		for fieldname in self.DiagnosticInfos:
14121		packet.append(fieldname.to_binary())
14122		return b''.join(packet)
14123
14124		@staticmethod
14125		def from_binary(data):
14126		return TransferSubscriptionsResult(data)
14127
14128		def _binary_init(self, data):
14129		length = uabin.Primitives.Int32.unpack(data)
14130		array = []
14131		if length != -1:
14132		for _ in range(0, length):
14133		array.append(TransferResult.from_binary(data))
14134		self.Results = array
14135		length = uabin.Primitives.Int32.unpack(data)
14136		array = []
14137		if length != -1:
14138		for _ in range(0, length):
14139		array.append(DiagnosticInfo.from_binary(data))
14140		self.DiagnosticInfos = array
14141
14142		def __str__(self):
14143		return 'TransferSubscriptionsResult(' + 'Results:' + str(self.Results) + ', ' + \
14144		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
14145
14146		__repr__ = __str__
14147
		@@ 13255-13309 (lines=55) @@
13252		return 'NotificationData(' + + ')'
13253
13254		__repr__ = __str__
13255
13256
13257		class DataChangeNotification(FrozenClass):
13258		'''
13259		:ivar MonitoredItems:
13260		:vartype MonitoredItems: MonitoredItemNotification
13261		:ivar DiagnosticInfos:
13262		:vartype DiagnosticInfos: DiagnosticInfo
13263		'''
13264
13265		ua_types = {
13266		'MonitoredItems': 'MonitoredItemNotification',
13267		'DiagnosticInfos': 'DiagnosticInfo',
13268		}
13269
13270		def __init__(self, binary=None):
13271		if binary is not None:
13272		self._binary_init(binary)
13273		self._freeze = True
13274		return
13275		self.MonitoredItems = []
13276		self.DiagnosticInfos = []
13277		self._freeze = True
13278
13279		def to_binary(self):
13280		packet = []
13281		packet.append(uabin.Primitives.Int32.pack(len(self.MonitoredItems)))
13282		for fieldname in self.MonitoredItems:
13283		packet.append(fieldname.to_binary())
13284		packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))
13285		for fieldname in self.DiagnosticInfos:
13286		packet.append(fieldname.to_binary())
13287		return b''.join(packet)
13288
13289		@staticmethod
13290		def from_binary(data):
13291		return DataChangeNotification(data)
13292
13293		def _binary_init(self, data):
13294		length = uabin.Primitives.Int32.unpack(data)
13295		array = []
13296		if length != -1:
13297		for _ in range(0, length):
13298		array.append(MonitoredItemNotification.from_binary(data))
13299		self.MonitoredItems = array
13300		length = uabin.Primitives.Int32.unpack(data)
13301		array = []
13302		if length != -1:
13303		for _ in range(0, length):
13304		array.append(DiagnosticInfo.from_binary(data))
13305		self.DiagnosticInfos = array
13306
13307		def __str__(self):
13308		return 'DataChangeNotification(' + 'MonitoredItems:' + str(self.MonitoredItems) + ', ' + \
13309		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
13310
13311		__repr__ = __str__
13312
		@@ 13060-13114 (lines=55) @@
13057		'Parameters:' + str(self.Parameters) + ')'
13058
13059		__repr__ = __str__
13060
13061
13062		class SetPublishingModeResult(FrozenClass):
13063		'''
13064		:ivar Results:
13065		:vartype Results: StatusCode
13066		:ivar DiagnosticInfos:
13067		:vartype DiagnosticInfos: DiagnosticInfo
13068		'''
13069
13070		ua_types = {
13071		'Results': 'StatusCode',
13072		'DiagnosticInfos': 'DiagnosticInfo',
13073		}
13074
13075		def __init__(self, binary=None):
13076		if binary is not None:
13077		self._binary_init(binary)
13078		self._freeze = True
13079		return
13080		self.Results = []
13081		self.DiagnosticInfos = []
13082		self._freeze = True
13083
13084		def to_binary(self):
13085		packet = []
13086		packet.append(uabin.Primitives.Int32.pack(len(self.Results)))
13087		for fieldname in self.Results:
13088		packet.append(fieldname.to_binary())
13089		packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))
13090		for fieldname in self.DiagnosticInfos:
13091		packet.append(fieldname.to_binary())
13092		return b''.join(packet)
13093
13094		@staticmethod
13095		def from_binary(data):
13096		return SetPublishingModeResult(data)
13097
13098		def _binary_init(self, data):
13099		length = uabin.Primitives.Int32.unpack(data)
13100		array = []
13101		if length != -1:
13102		for _ in range(0, length):
13103		array.append(StatusCode.from_binary(data))
13104		self.Results = array
13105		length = uabin.Primitives.Int32.unpack(data)
13106		array = []
13107		if length != -1:
13108		for _ in range(0, length):
13109		array.append(DiagnosticInfo.from_binary(data))
13110		self.DiagnosticInfos = array
13111
13112		def __str__(self):
13113		return 'SetPublishingModeResult(' + 'Results:' + str(self.Results) + ', ' + \
13114		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
13115
13116		__repr__ = __str__
13117
		@@ 11997-12051 (lines=55) @@
11994		'Parameters:' + str(self.Parameters) + ')'
11995
11996		__repr__ = __str__
11997
11998
11999		class SetMonitoringModeResult(FrozenClass):
12000		'''
12001		:ivar Results:
12002		:vartype Results: StatusCode
12003		:ivar DiagnosticInfos:
12004		:vartype DiagnosticInfos: DiagnosticInfo
12005		'''
12006
12007		ua_types = {
12008		'Results': 'StatusCode',
12009		'DiagnosticInfos': 'DiagnosticInfo',
12010		}
12011
12012		def __init__(self, binary=None):
12013		if binary is not None:
12014		self._binary_init(binary)
12015		self._freeze = True
12016		return
12017		self.Results = []
12018		self.DiagnosticInfos = []
12019		self._freeze = True
12020
12021		def to_binary(self):
12022		packet = []
12023		packet.append(uabin.Primitives.Int32.pack(len(self.Results)))
12024		for fieldname in self.Results:
12025		packet.append(fieldname.to_binary())
12026		packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))
12027		for fieldname in self.DiagnosticInfos:
12028		packet.append(fieldname.to_binary())
12029		return b''.join(packet)
12030
12031		@staticmethod
12032		def from_binary(data):
12033		return SetMonitoringModeResult(data)
12034
12035		def _binary_init(self, data):
12036		length = uabin.Primitives.Int32.unpack(data)
12037		array = []
12038		if length != -1:
12039		for _ in range(0, length):
12040		array.append(StatusCode.from_binary(data))
12041		self.Results = array
12042		length = uabin.Primitives.Int32.unpack(data)
12043		array = []
12044		if length != -1:
12045		for _ in range(0, length):
12046		array.append(DiagnosticInfo.from_binary(data))
12047		self.DiagnosticInfos = array
12048
12049		def __str__(self):
12050		return 'SetMonitoringModeResult(' + 'Results:' + str(self.Results) + ', ' + \
12051		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
12052
12053		__repr__ = __str__
12054
		@@ 9470-9524 (lines=55) @@
9467		'UserName:' + str(self.UserName) + ')'
9468
9469		__repr__ = __str__
9470
9471
9472		class HistoryModifiedData(FrozenClass):
9473		'''
9474		:ivar DataValues:
9475		:vartype DataValues: DataValue
9476		:ivar ModificationInfos:
9477		:vartype ModificationInfos: ModificationInfo
9478		'''
9479
9480		ua_types = {
9481		'DataValues': 'DataValue',
9482		'ModificationInfos': 'ModificationInfo',
9483		}
9484
9485		def __init__(self, binary=None):
9486		if binary is not None:
9487		self._binary_init(binary)
9488		self._freeze = True
9489		return
9490		self.DataValues = []
9491		self.ModificationInfos = []
9492		self._freeze = True
9493
9494		def to_binary(self):
9495		packet = []
9496		packet.append(uabin.Primitives.Int32.pack(len(self.DataValues)))
9497		for fieldname in self.DataValues:
9498		packet.append(fieldname.to_binary())
9499		packet.append(uabin.Primitives.Int32.pack(len(self.ModificationInfos)))
9500		for fieldname in self.ModificationInfos:
9501		packet.append(fieldname.to_binary())
9502		return b''.join(packet)
9503
9504		@staticmethod
9505		def from_binary(data):
9506		return HistoryModifiedData(data)
9507
9508		def _binary_init(self, data):
9509		length = uabin.Primitives.Int32.unpack(data)
9510		array = []
9511		if length != -1:
9512		for _ in range(0, length):
9513		array.append(DataValue.from_binary(data))
9514		self.DataValues = array
9515		length = uabin.Primitives.Int32.unpack(data)
9516		array = []
9517		if length != -1:
9518		for _ in range(0, length):
9519		array.append(ModificationInfo.from_binary(data))
9520		self.ModificationInfos = array
9521
9522		def __str__(self):
9523		return 'HistoryModifiedData(' + 'DataValues:' + str(self.DataValues) + ', ' + \
9524		'ModificationInfos:' + str(self.ModificationInfos) + ')'
9525
9526		__repr__ = __str__
9527
		@@ 8197-8251 (lines=55) @@
8194		'OperandDiagnosticInfos:' + str(self.OperandDiagnosticInfos) + ')'
8195
8196		__repr__ = __str__
8197
8198
8199		class ContentFilterResult(FrozenClass):
8200		'''
8201		:ivar ElementResults:
8202		:vartype ElementResults: ContentFilterElementResult
8203		:ivar ElementDiagnosticInfos:
8204		:vartype ElementDiagnosticInfos: DiagnosticInfo
8205		'''
8206
8207		ua_types = {
8208		'ElementResults': 'ContentFilterElementResult',
8209		'ElementDiagnosticInfos': 'DiagnosticInfo',
8210		}
8211
8212		def __init__(self, binary=None):
8213		if binary is not None:
8214		self._binary_init(binary)
8215		self._freeze = True
8216		return
8217		self.ElementResults = []
8218		self.ElementDiagnosticInfos = []
8219		self._freeze = True
8220
8221		def to_binary(self):
8222		packet = []
8223		packet.append(uabin.Primitives.Int32.pack(len(self.ElementResults)))
8224		for fieldname in self.ElementResults:
8225		packet.append(fieldname.to_binary())
8226		packet.append(uabin.Primitives.Int32.pack(len(self.ElementDiagnosticInfos)))
8227		for fieldname in self.ElementDiagnosticInfos:
8228		packet.append(fieldname.to_binary())
8229		return b''.join(packet)
8230
8231		@staticmethod
8232		def from_binary(data):
8233		return ContentFilterResult(data)
8234
8235		def _binary_init(self, data):
8236		length = uabin.Primitives.Int32.unpack(data)
8237		array = []
8238		if length != -1:
8239		for _ in range(0, length):
8240		array.append(ContentFilterElementResult.from_binary(data))
8241		self.ElementResults = array
8242		length = uabin.Primitives.Int32.unpack(data)
8243		array = []
8244		if length != -1:
8245		for _ in range(0, length):
8246		array.append(DiagnosticInfo.from_binary(data))
8247		self.ElementDiagnosticInfos = array
8248
8249		def __str__(self):
8250		return 'ContentFilterResult(' + 'ElementResults:' + str(self.ElementResults) + ', ' + \
8251		'ElementDiagnosticInfos:' + str(self.ElementDiagnosticInfos) + ')'
8252
8253		__repr__ = __str__
8254
		@@ 6488-6542 (lines=55) @@
6485		'Parameters:' + str(self.Parameters) + ')'
6486
6487		__repr__ = __str__
6488
6489
6490		class BrowseNextResult(FrozenClass):
6491		'''
6492		:ivar Results:
6493		:vartype Results: BrowseResult
6494		:ivar DiagnosticInfos:
6495		:vartype DiagnosticInfos: DiagnosticInfo
6496		'''
6497
6498		ua_types = {
6499		'Results': 'BrowseResult',
6500		'DiagnosticInfos': 'DiagnosticInfo',
6501		}
6502
6503		def __init__(self, binary=None):
6504		if binary is not None:
6505		self._binary_init(binary)
6506		self._freeze = True
6507		return
6508		self.Results = []
6509		self.DiagnosticInfos = []
6510		self._freeze = True
6511
6512		def to_binary(self):
6513		packet = []
6514		packet.append(uabin.Primitives.Int32.pack(len(self.Results)))
6515		for fieldname in self.Results:
6516		packet.append(fieldname.to_binary())
6517		packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))
6518		for fieldname in self.DiagnosticInfos:
6519		packet.append(fieldname.to_binary())
6520		return b''.join(packet)
6521
6522		@staticmethod
6523		def from_binary(data):
6524		return BrowseNextResult(data)
6525
6526		def _binary_init(self, data):
6527		length = uabin.Primitives.Int32.unpack(data)
6528		array = []
6529		if length != -1:
6530		for _ in range(0, length):
6531		array.append(BrowseResult.from_binary(data))
6532		self.Results = array
6533		length = uabin.Primitives.Int32.unpack(data)
6534		array = []
6535		if length != -1:
6536		for _ in range(0, length):
6537		array.append(DiagnosticInfo.from_binary(data))
6538		self.DiagnosticInfos = array
6539
6540		def __str__(self):
6541		return 'BrowseNextResult(' + 'Results:' + str(self.Results) + ', ' + \
6542		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
6543
6544		__repr__ = __str__
6545
		@@ 5836-5890 (lines=55) @@
5833		'Parameters:' + str(self.Parameters) + ')'
5834
5835		__repr__ = __str__
5836
5837
5838		class DeleteReferencesResult(FrozenClass):
5839		'''
5840		:ivar Results:
5841		:vartype Results: StatusCode
5842		:ivar DiagnosticInfos:
5843		:vartype DiagnosticInfos: DiagnosticInfo
5844		'''
5845
5846		ua_types = {
5847		'Results': 'StatusCode',
5848		'DiagnosticInfos': 'DiagnosticInfo',
5849		}
5850
5851		def __init__(self, binary=None):
5852		if binary is not None:
5853		self._binary_init(binary)
5854		self._freeze = True
5855		return
5856		self.Results = []
5857		self.DiagnosticInfos = []
5858		self._freeze = True
5859
5860		def to_binary(self):
5861		packet = []
5862		packet.append(uabin.Primitives.Int32.pack(len(self.Results)))
5863		for fieldname in self.Results:
5864		packet.append(fieldname.to_binary())
5865		packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))
5866		for fieldname in self.DiagnosticInfos:
5867		packet.append(fieldname.to_binary())
5868		return b''.join(packet)
5869
5870		@staticmethod
5871		def from_binary(data):
5872		return DeleteReferencesResult(data)
5873
5874		def _binary_init(self, data):
5875		length = uabin.Primitives.Int32.unpack(data)
5876		array = []
5877		if length != -1:
5878		for _ in range(0, length):
5879		array.append(StatusCode.from_binary(data))
5880		self.Results = array
5881		length = uabin.Primitives.Int32.unpack(data)
5882		array = []
5883		if length != -1:
5884		for _ in range(0, length):
5885		array.append(DiagnosticInfo.from_binary(data))
5886		self.DiagnosticInfos = array
5887
5888		def __str__(self):
5889		return 'DeleteReferencesResult(' + 'Results:' + str(self.Results) + ', ' + \
5890		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
5891
5892		__repr__ = __str__
5893

FreeOpcUa / python-opcua

Code Duplication Length = 55-55 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations