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

Code Duplication Length = 37-39 lines in 11 locations

opcua/ua/uaprotocol_auto.py 11 locations


    __repr__ = __str__


class UnregisterNodesResponse(FrozenClass):
    '''
    Unregisters one or more previously registered nodes.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    '''

    ua_types = [

        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.UnregisterNodesResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = UnregisterNodesResponse()
        obj.TypeId = NodeId.from_binary(data)
        obj.ResponseHeader = ResponseHeader.from_binary(data)
        return obj

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

    __repr__ = __str__


class EndpointConfiguration(FrozenClass):

    __repr__ = __str__


class BrowsePath(FrozenClass):
    '''
    A request to translate a path into a node id.

    :ivar StartingNode:
    :vartype StartingNode: NodeId
    :ivar RelativePath:
    :vartype RelativePath: RelativePath
    '''

    ua_types = [

        ('StartingNode', 'NodeId'),
        ('RelativePath', 'RelativePath'),
               ]

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

    def to_binary(self):
        packet = []
        packet.append(self.StartingNode.to_binary())
        packet.append(self.RelativePath.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = BrowsePath()
        obj.StartingNode = NodeId.from_binary(data)
        obj.RelativePath = RelativePath.from_binary(data)
        return obj

    def __str__(self):
        return 'BrowsePath(' + 'StartingNode:' + str(self.StartingNode) + ', ' + \
               'RelativePath:' + str(self.RelativePath) + ')'

    __repr__ = __str__


class BrowsePathTarget(FrozenClass):

    __repr__ = __str__


class AddNodesResult(FrozenClass):
    '''
    A result of an add node operation.

    :ivar StatusCode:
    :vartype StatusCode: StatusCode
    :ivar AddedNodeId:
    :vartype AddedNodeId: NodeId
    '''

    ua_types = [

        ('StatusCode', 'StatusCode'),
        ('AddedNodeId', 'NodeId'),
               ]

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

    def to_binary(self):
        packet = []
        packet.append(self.StatusCode.to_binary())
        packet.append(self.AddedNodeId.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = AddNodesResult()
        obj.StatusCode = StatusCode.from_binary(data)
        obj.AddedNodeId = NodeId.from_binary(data)
        return obj

    def __str__(self):
        return 'AddNodesResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \
               'AddedNodeId:' + str(self.AddedNodeId) + ')'

    __repr__ = __str__


class AddNodesParameters(FrozenClass):

    __repr__ = __str__


class CloseSessionResponse(FrozenClass):
    '''
    Closes a session with the server.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    '''

    ua_types = [

        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.CloseSessionResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = CloseSessionResponse()
        obj.TypeId = NodeId.from_binary(data)
        obj.ResponseHeader = ResponseHeader.from_binary(data)
        return obj

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

    __repr__ = __str__


class CancelParameters(FrozenClass):

    __repr__ = __str__


class CloseSecureChannelResponse(FrozenClass):
    '''
    Closes a secure channel.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    '''

    ua_types = [

        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.CloseSecureChannelResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = CloseSecureChannelResponse()
        obj.TypeId = NodeId.from_binary(data)
        obj.ResponseHeader = ResponseHeader.from_binary(data)
        return obj

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

    __repr__ = __str__


class SignedSoftwareCertificate(FrozenClass):

    __repr__ = __str__


class CloseSecureChannelRequest(FrozenClass):
    '''
    Closes a secure channel.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar RequestHeader:
    :vartype RequestHeader: RequestHeader
    '''

    ua_types = [

        ('TypeId', 'NodeId'),
        ('RequestHeader', 'RequestHeader'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.CloseSecureChannelRequest_Encoding_DefaultBinary)
        self.RequestHeader = RequestHeader()
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = CloseSecureChannelRequest()
        obj.TypeId = NodeId.from_binary(data)
        obj.RequestHeader = RequestHeader.from_binary(data)
        return obj

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

    __repr__ = __str__


class CloseSecureChannelResponse(FrozenClass):

    __repr__ = __str__


class RegisterServerResponse(FrozenClass):
    '''
    Registers a server with the discovery server.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    '''

    ua_types = [

        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.RegisterServerResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = RegisterServerResponse()
        obj.TypeId = NodeId.from_binary(data)
        obj.ResponseHeader = ResponseHeader.from_binary(data)
        return obj

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

    __repr__ = __str__


class DiscoveryConfiguration(FrozenClass):

    __repr__ = __str__


class ServiceFault(FrozenClass):
    '''
    The response returned by all services when there is a service level error.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    '''

    ua_types = [

        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.ServiceFault_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = ServiceFault()
        obj.TypeId = NodeId.from_binary(data)
        obj.ResponseHeader = ResponseHeader.from_binary(data)
        return obj

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

    __repr__ = __str__


class FindServersParameters(FrozenClass):

    __repr__ = __str__


class SemanticChangeStructureDataType(FrozenClass):
    '''
    :ivar Affected:
    :vartype Affected: NodeId
    :ivar AffectedType:
    :vartype AffectedType: NodeId
    '''

    ua_types = [

        ('Affected', 'NodeId'),
        ('AffectedType', 'NodeId'),
               ]

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

    def to_binary(self):
        packet = []
        packet.append(self.Affected.to_binary())
        packet.append(self.AffectedType.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = SemanticChangeStructureDataType()
        obj.Affected = NodeId.from_binary(data)
        obj.AffectedType = NodeId.from_binary(data)
        return obj

    def __str__(self):
        return 'SemanticChangeStructureDataType(' + 'Affected:' + str(self.Affected) + ', ' + \
               'AffectedType:' + str(self.AffectedType) + ')'

    __repr__ = __str__


class Range(FrozenClass):

    __repr__ = __str__


class StatusResult(FrozenClass):
    '''
    :ivar StatusCode:
    :vartype StatusCode: StatusCode
    :ivar DiagnosticInfo:
    :vartype DiagnosticInfo: DiagnosticInfo
    '''

    ua_types = [

        ('StatusCode', 'StatusCode'),
        ('DiagnosticInfo', 'DiagnosticInfo'),
               ]

    def __init__(self):
        self.StatusCode = StatusCode()
        self.DiagnosticInfo = DiagnosticInfo()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.StatusCode.to_binary())
        packet.append(self.DiagnosticInfo.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = StatusResult()
        obj.StatusCode = StatusCode.from_binary(data)
        obj.DiagnosticInfo = DiagnosticInfo.from_binary(data)
        return obj

    def __str__(self):
        return 'StatusResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \
               'DiagnosticInfo:' + str(self.DiagnosticInfo) + ')'

    __repr__ = __str__


class SubscriptionDiagnosticsDataType(FrozenClass):

    __repr__ = __str__


class StatusChangeNotification(FrozenClass):
    '''
    :ivar Status:
    :vartype Status: StatusCode
    :ivar DiagnosticInfo:
    :vartype DiagnosticInfo: DiagnosticInfo
    '''

    ua_types = [

        ('Status', 'StatusCode'),
        ('DiagnosticInfo', 'DiagnosticInfo'),
               ]

    def __init__(self):
        self.Status = StatusCode()
        self.DiagnosticInfo = DiagnosticInfo()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.Status.to_binary())
        packet.append(self.DiagnosticInfo.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = StatusChangeNotification()
        obj.Status = StatusCode.from_binary(data)
        obj.DiagnosticInfo = DiagnosticInfo.from_binary(data)
        return obj

    def __str__(self):
        return 'StatusChangeNotification(' + 'Status:' + str(self.Status) + ', ' + \
               'DiagnosticInfo:' + str(self.DiagnosticInfo) + ')'

    __repr__ = __str__


class SubscriptionAcknowledgement(FrozenClass):

		@@ 7070-7108 (lines=39) @@
7067		__repr__ = __str__
7068
7069
7070		class UnregisterNodesResponse(FrozenClass):
7071		'''
7072		Unregisters one or more previously registered nodes.
7073
7074		:ivar TypeId:
7075		:vartype TypeId: NodeId
7076		:ivar ResponseHeader:
7077		:vartype ResponseHeader: ResponseHeader
7078		'''
7079
7080		ua_types = [
7081
7082		('TypeId', 'NodeId'),
7083		('ResponseHeader', 'ResponseHeader'),
7084		]
7085
7086		def __init__(self):
7087		self.TypeId = FourByteNodeId(ObjectIds.UnregisterNodesResponse_Encoding_DefaultBinary)
7088		self.ResponseHeader = ResponseHeader()
7089		self._freeze = True
7090
7091		def to_binary(self):
7092		packet = []
7093		packet.append(self.TypeId.to_binary())
7094		packet.append(self.ResponseHeader.to_binary())
7095		return b''.join(packet)
7096
7097		@staticmethod
7098		def from_binary(data):
7099		obj = UnregisterNodesResponse()
7100		obj.TypeId = NodeId.from_binary(data)
7101		obj.ResponseHeader = ResponseHeader.from_binary(data)
7102		return obj
7103
7104		def __str__(self):
7105		return 'UnregisterNodesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7106		'ResponseHeader:' + str(self.ResponseHeader) + ')'
7107
7108		__repr__ = __str__
7109
7110
7111		class EndpointConfiguration(FrozenClass):
		@@ 6523-6561 (lines=39) @@
6520		__repr__ = __str__
6521
6522
6523		class BrowsePath(FrozenClass):
6524		'''
6525		A request to translate a path into a node id.
6526
6527		:ivar StartingNode:
6528		:vartype StartingNode: NodeId
6529		:ivar RelativePath:
6530		:vartype RelativePath: RelativePath
6531		'''
6532
6533		ua_types = [
6534
6535		('StartingNode', 'NodeId'),
6536		('RelativePath', 'RelativePath'),
6537		]
6538
6539		def __init__(self):
6540		self.StartingNode = NodeId()
6541		self.RelativePath = RelativePath()
6542		self._freeze = True
6543
6544		def to_binary(self):
6545		packet = []
6546		packet.append(self.StartingNode.to_binary())
6547		packet.append(self.RelativePath.to_binary())
6548		return b''.join(packet)
6549
6550		@staticmethod
6551		def from_binary(data):
6552		obj = BrowsePath()
6553		obj.StartingNode = NodeId.from_binary(data)
6554		obj.RelativePath = RelativePath.from_binary(data)
6555		return obj
6556
6557		def __str__(self):
6558		return 'BrowsePath(' + 'StartingNode:' + str(self.StartingNode) + ', ' + \
6559		'RelativePath:' + str(self.RelativePath) + ')'
6560
6561		__repr__ = __str__
6562
6563
6564		class BrowsePathTarget(FrozenClass):
		@@ 4950-4988 (lines=39) @@
4947		__repr__ = __str__
4948
4949
4950		class AddNodesResult(FrozenClass):
4951		'''
4952		A result of an add node operation.
4953
4954		:ivar StatusCode:
4955		:vartype StatusCode: StatusCode
4956		:ivar AddedNodeId:
4957		:vartype AddedNodeId: NodeId
4958		'''
4959
4960		ua_types = [
4961
4962		('StatusCode', 'StatusCode'),
4963		('AddedNodeId', 'NodeId'),
4964		]
4965
4966		def __init__(self):
4967		self.StatusCode = StatusCode()
4968		self.AddedNodeId = NodeId()
4969		self._freeze = True
4970
4971		def to_binary(self):
4972		packet = []
4973		packet.append(self.StatusCode.to_binary())
4974		packet.append(self.AddedNodeId.to_binary())
4975		return b''.join(packet)
4976
4977		@staticmethod
4978		def from_binary(data):
4979		obj = AddNodesResult()
4980		obj.StatusCode = StatusCode.from_binary(data)
4981		obj.AddedNodeId = NodeId.from_binary(data)
4982		return obj
4983
4984		def __str__(self):
4985		return 'AddNodesResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \
4986		'AddedNodeId:' + str(self.AddedNodeId) + ')'
4987
4988		__repr__ = __str__
4989
4990
4991		class AddNodesParameters(FrozenClass):
		@@ 3950-3988 (lines=39) @@
3947		__repr__ = __str__
3948
3949
3950		class CloseSessionResponse(FrozenClass):
3951		'''
3952		Closes a session with the server.
3953
3954		:ivar TypeId:
3955		:vartype TypeId: NodeId
3956		:ivar ResponseHeader:
3957		:vartype ResponseHeader: ResponseHeader
3958		'''
3959
3960		ua_types = [
3961
3962		('TypeId', 'NodeId'),
3963		('ResponseHeader', 'ResponseHeader'),
3964		]
3965
3966		def __init__(self):
3967		self.TypeId = FourByteNodeId(ObjectIds.CloseSessionResponse_Encoding_DefaultBinary)
3968		self.ResponseHeader = ResponseHeader()
3969		self._freeze = True
3970
3971		def to_binary(self):
3972		packet = []
3973		packet.append(self.TypeId.to_binary())
3974		packet.append(self.ResponseHeader.to_binary())
3975		return b''.join(packet)
3976
3977		@staticmethod
3978		def from_binary(data):
3979		obj = CloseSessionResponse()
3980		obj.TypeId = NodeId.from_binary(data)
3981		obj.ResponseHeader = ResponseHeader.from_binary(data)
3982		return obj
3983
3984		def __str__(self):
3985		return 'CloseSessionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
3986		'ResponseHeader:' + str(self.ResponseHeader) + ')'
3987
3988		__repr__ = __str__
3989
3990
3991		class CancelParameters(FrozenClass):
		@@ 3024-3062 (lines=39) @@
3021		__repr__ = __str__
3022
3023
3024		class CloseSecureChannelResponse(FrozenClass):
3025		'''
3026		Closes a secure channel.
3027
3028		:ivar TypeId:
3029		:vartype TypeId: NodeId
3030		:ivar ResponseHeader:
3031		:vartype ResponseHeader: ResponseHeader
3032		'''
3033
3034		ua_types = [
3035
3036		('TypeId', 'NodeId'),
3037		('ResponseHeader', 'ResponseHeader'),
3038		]
3039
3040		def __init__(self):
3041		self.TypeId = FourByteNodeId(ObjectIds.CloseSecureChannelResponse_Encoding_DefaultBinary)
3042		self.ResponseHeader = ResponseHeader()
3043		self._freeze = True
3044
3045		def to_binary(self):
3046		packet = []
3047		packet.append(self.TypeId.to_binary())
3048		packet.append(self.ResponseHeader.to_binary())
3049		return b''.join(packet)
3050
3051		@staticmethod
3052		def from_binary(data):
3053		obj = CloseSecureChannelResponse()
3054		obj.TypeId = NodeId.from_binary(data)
3055		obj.ResponseHeader = ResponseHeader.from_binary(data)
3056		return obj
3057
3058		def __str__(self):
3059		return 'CloseSecureChannelResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
3060		'ResponseHeader:' + str(self.ResponseHeader) + ')'
3061
3062		__repr__ = __str__
3063
3064
3065		class SignedSoftwareCertificate(FrozenClass):
		@@ 2983-3021 (lines=39) @@
2980		__repr__ = __str__
2981
2982
2983		class CloseSecureChannelRequest(FrozenClass):
2984		'''
2985		Closes a secure channel.
2986
2987		:ivar TypeId:
2988		:vartype TypeId: NodeId
2989		:ivar RequestHeader:
2990		:vartype RequestHeader: RequestHeader
2991		'''
2992
2993		ua_types = [
2994
2995		('TypeId', 'NodeId'),
2996		('RequestHeader', 'RequestHeader'),
2997		]
2998
2999		def __init__(self):
3000		self.TypeId = FourByteNodeId(ObjectIds.CloseSecureChannelRequest_Encoding_DefaultBinary)
3001		self.RequestHeader = RequestHeader()
3002		self._freeze = True
3003
3004		def to_binary(self):
3005		packet = []
3006		packet.append(self.TypeId.to_binary())
3007		packet.append(self.RequestHeader.to_binary())
3008		return b''.join(packet)
3009
3010		@staticmethod
3011		def from_binary(data):
3012		obj = CloseSecureChannelRequest()
3013		obj.TypeId = NodeId.from_binary(data)
3014		obj.RequestHeader = RequestHeader.from_binary(data)
3015		return obj
3016
3017		def __str__(self):
3018		return 'CloseSecureChannelRequest(' + 'TypeId:' + str(self.TypeId) + ', ' + \
3019		'RequestHeader:' + str(self.RequestHeader) + ')'
3020
3021		__repr__ = __str__
3022
3023
3024		class CloseSecureChannelResponse(FrozenClass):
		@@ 2455-2493 (lines=39) @@
2452		__repr__ = __str__
2453
2454
2455		class RegisterServerResponse(FrozenClass):
2456		'''
2457		Registers a server with the discovery server.
2458
2459		:ivar TypeId:
2460		:vartype TypeId: NodeId
2461		:ivar ResponseHeader:
2462		:vartype ResponseHeader: ResponseHeader
2463		'''
2464
2465		ua_types = [
2466
2467		('TypeId', 'NodeId'),
2468		('ResponseHeader', 'ResponseHeader'),
2469		]
2470
2471		def __init__(self):
2472		self.TypeId = FourByteNodeId(ObjectIds.RegisterServerResponse_Encoding_DefaultBinary)
2473		self.ResponseHeader = ResponseHeader()
2474		self._freeze = True
2475
2476		def to_binary(self):
2477		packet = []
2478		packet.append(self.TypeId.to_binary())
2479		packet.append(self.ResponseHeader.to_binary())
2480		return b''.join(packet)
2481
2482		@staticmethod
2483		def from_binary(data):
2484		obj = RegisterServerResponse()
2485		obj.TypeId = NodeId.from_binary(data)
2486		obj.ResponseHeader = ResponseHeader.from_binary(data)
2487		return obj
2488
2489		def __str__(self):
2490		return 'RegisterServerResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
2491		'ResponseHeader:' + str(self.ResponseHeader) + ')'
2492
2493		__repr__ = __str__
2494
2495
2496		class DiscoveryConfiguration(FrozenClass):
		@@ 1575-1613 (lines=39) @@
1572		__repr__ = __str__
1573
1574
1575		class ServiceFault(FrozenClass):
1576		'''
1577		The response returned by all services when there is a service level error.
1578
1579		:ivar TypeId:
1580		:vartype TypeId: NodeId
1581		:ivar ResponseHeader:
1582		:vartype ResponseHeader: ResponseHeader
1583		'''
1584
1585		ua_types = [
1586
1587		('TypeId', 'NodeId'),
1588		('ResponseHeader', 'ResponseHeader'),
1589		]
1590
1591		def __init__(self):
1592		self.TypeId = FourByteNodeId(ObjectIds.ServiceFault_Encoding_DefaultBinary)
1593		self.ResponseHeader = ResponseHeader()
1594		self._freeze = True
1595
1596		def to_binary(self):
1597		packet = []
1598		packet.append(self.TypeId.to_binary())
1599		packet.append(self.ResponseHeader.to_binary())
1600		return b''.join(packet)
1601
1602		@staticmethod
1603		def from_binary(data):
1604		obj = ServiceFault()
1605		obj.TypeId = NodeId.from_binary(data)
1606		obj.ResponseHeader = ResponseHeader.from_binary(data)
1607		return obj
1608
1609		def __str__(self):
1610		return 'ServiceFault(' + 'TypeId:' + str(self.TypeId) + ', ' + \
1611		'ResponseHeader:' + str(self.ResponseHeader) + ')'
1612
1613		__repr__ = __str__
1614
1615
1616		class FindServersParameters(FrozenClass):
		@@ 14816-14852 (lines=37) @@
14813		__repr__ = __str__
14814
14815
14816		class SemanticChangeStructureDataType(FrozenClass):
14817		'''
14818		:ivar Affected:
14819		:vartype Affected: NodeId
14820		:ivar AffectedType:
14821		:vartype AffectedType: NodeId
14822		'''
14823
14824		ua_types = [
14825
14826		('Affected', 'NodeId'),
14827		('AffectedType', 'NodeId'),
14828		]
14829
14830		def __init__(self):
14831		self.Affected = NodeId()
14832		self.AffectedType = NodeId()
14833		self._freeze = True
14834
14835		def to_binary(self):
14836		packet = []
14837		packet.append(self.Affected.to_binary())
14838		packet.append(self.AffectedType.to_binary())
14839		return b''.join(packet)
14840
14841		@staticmethod
14842		def from_binary(data):
14843		obj = SemanticChangeStructureDataType()
14844		obj.Affected = NodeId.from_binary(data)
14845		obj.AffectedType = NodeId.from_binary(data)
14846		return obj
14847
14848		def __str__(self):
14849		return 'SemanticChangeStructureDataType(' + 'Affected:' + str(self.Affected) + ', ' + \
14850		'AffectedType:' + str(self.AffectedType) + ')'
14851
14852		__repr__ = __str__
14853
14854
14855		class Range(FrozenClass):
		@@ 14489-14525 (lines=37) @@
14486		__repr__ = __str__
14487
14488
14489		class StatusResult(FrozenClass):
14490		'''
14491		:ivar StatusCode:
14492		:vartype StatusCode: StatusCode
14493		:ivar DiagnosticInfo:
14494		:vartype DiagnosticInfo: DiagnosticInfo
14495		'''
14496
14497		ua_types = [
14498
14499		('StatusCode', 'StatusCode'),
14500		('DiagnosticInfo', 'DiagnosticInfo'),
14501		]
14502
14503		def __init__(self):
14504		self.StatusCode = StatusCode()
14505		self.DiagnosticInfo = DiagnosticInfo()
14506		self._freeze = True
14507
14508		def to_binary(self):
14509		packet = []
14510		packet.append(self.StatusCode.to_binary())
14511		packet.append(self.DiagnosticInfo.to_binary())
14512		return b''.join(packet)
14513
14514		@staticmethod
14515		def from_binary(data):
14516		obj = StatusResult()
14517		obj.StatusCode = StatusCode.from_binary(data)
14518		obj.DiagnosticInfo = DiagnosticInfo.from_binary(data)
14519		return obj
14520
14521		def __str__(self):
14522		return 'StatusResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \
14523		'DiagnosticInfo:' + str(self.DiagnosticInfo) + ')'
14524
14525		__repr__ = __str__
14526
14527
14528		class SubscriptionDiagnosticsDataType(FrozenClass):
		@@ 12813-12849 (lines=37) @@
12810		__repr__ = __str__
12811
12812
12813		class StatusChangeNotification(FrozenClass):
12814		'''
12815		:ivar Status:
12816		:vartype Status: StatusCode
12817		:ivar DiagnosticInfo:
12818		:vartype DiagnosticInfo: DiagnosticInfo
12819		'''
12820
12821		ua_types = [
12822
12823		('Status', 'StatusCode'),
12824		('DiagnosticInfo', 'DiagnosticInfo'),
12825		]
12826
12827		def __init__(self):
12828		self.Status = StatusCode()
12829		self.DiagnosticInfo = DiagnosticInfo()
12830		self._freeze = True
12831
12832		def to_binary(self):
12833		packet = []
12834		packet.append(self.Status.to_binary())
12835		packet.append(self.DiagnosticInfo.to_binary())
12836		return b''.join(packet)
12837
12838		@staticmethod
12839		def from_binary(data):
12840		obj = StatusChangeNotification()
12841		obj.Status = StatusCode.from_binary(data)
12842		obj.DiagnosticInfo = DiagnosticInfo.from_binary(data)
12843		return obj
12844
12845		def __str__(self):
12846		return 'StatusChangeNotification(' + 'Status:' + str(self.Status) + ', ' + \
12847		'DiagnosticInfo:' + str(self.DiagnosticInfo) + ')'
12848
12849		__repr__ = __str__
12850
12851
12852		class SubscriptionAcknowledgement(FrozenClass):

FreeOpcUa / python-opcua

Code Duplication Length = 37-39 lines in 11 locations

opcua/ua/uaprotocol_auto.py 11 locations