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

Code Duplication Length = 28-30 lines in 20 locations

opcua/ua/uaprotocol_auto.py 20 locations


    __repr__ = __str__


class RegisterNodesResponse(FrozenClass):
    '''
    Registers one or more nodes for repeated use within a session.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: RegisterNodesResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'RegisterNodesResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.RegisterNodesResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = RegisterNodesResult()
        self._freeze = True

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

    __repr__ = __str__


class UnregisterNodesParameters(FrozenClass):

    __repr__ = __str__


class BrowseNextResponse(FrozenClass):
    '''
    Continues one or more browse operations.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: BrowseNextResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'BrowseNextResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.BrowseNextResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = BrowseNextResult()
        self._freeze = True

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

    __repr__ = __str__


class RelativePathElement(FrozenClass):

    __repr__ = __str__


class DeleteReferencesResponse(FrozenClass):
    '''
    Delete one or more references from the server address space.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: DeleteReferencesResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'DeleteReferencesResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.DeleteReferencesResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = DeleteReferencesResult()
        self._freeze = True

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

    __repr__ = __str__


class ViewDescription(FrozenClass):

    __repr__ = __str__


class CancelResponse(FrozenClass):
    '''
    Cancels an outstanding request.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: CancelResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'CancelResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.CancelResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = CancelResult()
        self._freeze = True

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

    __repr__ = __str__


class NodeAttributes(FrozenClass):

    __repr__ = __str__


class ActivateSessionResponse(FrozenClass):
    '''
    Activates a session with the server.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: ActivateSessionResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'ActivateSessionResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.ActivateSessionResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = ActivateSessionResult()
        self._freeze = True

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

    __repr__ = __str__


class CloseSessionRequest(FrozenClass):

    __repr__ = __str__


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

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: CreateSessionResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'CreateSessionResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.CreateSessionResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = CreateSessionResult()
        self._freeze = True

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

    __repr__ = __str__


class UserIdentityToken(FrozenClass):

    __repr__ = __str__


class OpenSecureChannelResponse(FrozenClass):
    '''
    Creates a secure channel with a server.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: OpenSecureChannelResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'OpenSecureChannelResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.OpenSecureChannelResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = OpenSecureChannelResult()
        self._freeze = True

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

    __repr__ = __str__


class CloseSecureChannelRequest(FrozenClass):

    __repr__ = __str__


class GetEndpointsResponse(FrozenClass):
    '''
    Gets the endpoints used by the server.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Endpoints:
    :vartype Endpoints: EndpointDescription
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Endpoints', 'ListOfEndpointDescription'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.GetEndpointsResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Endpoints = []
        self._freeze = True

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

    __repr__ = __str__


class RegisteredServer(FrozenClass):

    __repr__ = __str__


class FindServersResponse(FrozenClass):
    '''
    Finds the servers known to the discovery server.

    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Servers:
    :vartype Servers: ApplicationDescription
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Servers', 'ListOfApplicationDescription'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.FindServersResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Servers = []
        self._freeze = True

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

    __repr__ = __str__


class ServerOnNetwork(FrozenClass):

    __repr__ = __str__


class TransferSubscriptionsResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: TransferSubscriptionsResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'TransferSubscriptionsResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.TransferSubscriptionsResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = TransferSubscriptionsResult()
        self._freeze = True

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

    __repr__ = __str__


class DeleteSubscriptionsParameters(FrozenClass):

    __repr__ = __str__


class RepublishResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar NotificationMessage:
    :vartype NotificationMessage: NotificationMessage
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('NotificationMessage', 'NotificationMessage'),
               ]

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

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

    __repr__ = __str__


class TransferResult(FrozenClass):

    __repr__ = __str__


class PublishResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: PublishResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'PublishResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.PublishResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = PublishResult()
        self._freeze = True

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

    __repr__ = __str__


class RepublishParameters(FrozenClass):

    __repr__ = __str__


class SetPublishingModeResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: SetPublishingModeResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'SetPublishingModeResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.SetPublishingModeResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = SetPublishingModeResult()
        self._freeze = True

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

    __repr__ = __str__


class NotificationMessage(FrozenClass):

    __repr__ = __str__


class ModifySubscriptionResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: ModifySubscriptionResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'ModifySubscriptionResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.ModifySubscriptionResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = ModifySubscriptionResult()
        self._freeze = True

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

    __repr__ = __str__


class SetPublishingModeParameters(FrozenClass):

    __repr__ = __str__


class CreateSubscriptionResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: CreateSubscriptionResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'CreateSubscriptionResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.CreateSubscriptionResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = CreateSubscriptionResult()
        self._freeze = True

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

    __repr__ = __str__


class ModifySubscriptionParameters(FrozenClass):

    __repr__ = __str__


class SetTriggeringResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: SetTriggeringResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'SetTriggeringResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.SetTriggeringResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = SetTriggeringResult()
        self._freeze = True

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

    __repr__ = __str__


class DeleteMonitoredItemsParameters(FrozenClass):

    __repr__ = __str__


class SetMonitoringModeResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: SetMonitoringModeResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'SetMonitoringModeResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.SetMonitoringModeResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = SetMonitoringModeResult()
        self._freeze = True

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

    __repr__ = __str__


class SetTriggeringParameters(FrozenClass):

    __repr__ = __str__


class QueryNextResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: QueryNextResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'QueryNextResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.QueryNextResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = QueryNextResult()
        self._freeze = True

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

    __repr__ = __str__


class ReadValueId(FrozenClass):

    __repr__ = __str__


class QueryFirstResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: QueryFirstResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'QueryFirstResult'),
               ]

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

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

    __repr__ = __str__


class QueryNextParameters(FrozenClass):

    __repr__ = __str__


class FindServersOnNetworkResponse(FrozenClass):
    '''
    :ivar TypeId:
    :vartype TypeId: NodeId
    :ivar ResponseHeader:
    :vartype ResponseHeader: ResponseHeader
    :ivar Parameters:
    :vartype Parameters: FindServersOnNetworkResult
    '''

    ua_types = [
        ('TypeId', 'NodeId'),
        ('ResponseHeader', 'ResponseHeader'),
        ('Parameters', 'FindServersOnNetworkResult'),
               ]

    def __init__(self):
        self.TypeId = FourByteNodeId(ObjectIds.FindServersOnNetworkResponse_Encoding_DefaultBinary)
        self.ResponseHeader = ResponseHeader()
        self.Parameters = FindServersOnNetworkResult()
        self._freeze = True

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

    __repr__ = __str__


class UserTokenPolicy(FrozenClass):

		@@ 4529-4558 (lines=30) @@
4526		__repr__ = __str__
4527
4528
4529		class RegisterNodesResponse(FrozenClass):
4530		'''
4531		Registers one or more nodes for repeated use within a session.
4532
4533		:ivar TypeId:
4534		:vartype TypeId: NodeId
4535		:ivar ResponseHeader:
4536		:vartype ResponseHeader: ResponseHeader
4537		:ivar Parameters:
4538		:vartype Parameters: RegisterNodesResult
4539		'''
4540
4541		ua_types = [
4542		('TypeId', 'NodeId'),
4543		('ResponseHeader', 'ResponseHeader'),
4544		('Parameters', 'RegisterNodesResult'),
4545		]
4546
4547		def __init__(self):
4548		self.TypeId = FourByteNodeId(ObjectIds.RegisterNodesResponse_Encoding_DefaultBinary)
4549		self.ResponseHeader = ResponseHeader()
4550		self.Parameters = RegisterNodesResult()
4551		self._freeze = True
4552
4553		def __str__(self):
4554		return 'RegisterNodesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
4555		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
4556		'Parameters:' + str(self.Parameters) + ')'
4557
4558		__repr__ = __str__
4559
4560
4561		class UnregisterNodesParameters(FrozenClass):
		@@ 4196-4225 (lines=30) @@
4193		__repr__ = __str__
4194
4195
4196		class BrowseNextResponse(FrozenClass):
4197		'''
4198		Continues one or more browse operations.
4199
4200		:ivar TypeId:
4201		:vartype TypeId: NodeId
4202		:ivar ResponseHeader:
4203		:vartype ResponseHeader: ResponseHeader
4204		:ivar Parameters:
4205		:vartype Parameters: BrowseNextResult
4206		'''
4207
4208		ua_types = [
4209		('TypeId', 'NodeId'),
4210		('ResponseHeader', 'ResponseHeader'),
4211		('Parameters', 'BrowseNextResult'),
4212		]
4213
4214		def __init__(self):
4215		self.TypeId = FourByteNodeId(ObjectIds.BrowseNextResponse_Encoding_DefaultBinary)
4216		self.ResponseHeader = ResponseHeader()
4217		self.Parameters = BrowseNextResult()
4218		self._freeze = True
4219
4220		def __str__(self):
4221		return 'BrowseNextResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
4222		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
4223		'Parameters:' + str(self.Parameters) + ')'
4224
4225		__repr__ = __str__
4226
4227
4228		class RelativePathElement(FrozenClass):
		@@ 3820-3849 (lines=30) @@
3817		__repr__ = __str__
3818
3819
3820		class DeleteReferencesResponse(FrozenClass):
3821		'''
3822		Delete one or more references from the server address space.
3823
3824		:ivar TypeId:
3825		:vartype TypeId: NodeId
3826		:ivar ResponseHeader:
3827		:vartype ResponseHeader: ResponseHeader
3828		:ivar Parameters:
3829		:vartype Parameters: DeleteReferencesResult
3830		'''
3831
3832		ua_types = [
3833		('TypeId', 'NodeId'),
3834		('ResponseHeader', 'ResponseHeader'),
3835		('Parameters', 'DeleteReferencesResult'),
3836		]
3837
3838		def __init__(self):
3839		self.TypeId = FourByteNodeId(ObjectIds.DeleteReferencesResponse_Encoding_DefaultBinary)
3840		self.ResponseHeader = ResponseHeader()
3841		self.Parameters = DeleteReferencesResult()
3842		self._freeze = True
3843
3844		def __str__(self):
3845		return 'DeleteReferencesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
3846		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
3847		'Parameters:' + str(self.Parameters) + ')'
3848
3849		__repr__ = __str__
3850
3851
3852		class ViewDescription(FrozenClass):
		@@ 2756-2785 (lines=30) @@
2753		__repr__ = __str__
2754
2755
2756		class CancelResponse(FrozenClass):
2757		'''
2758		Cancels an outstanding request.
2759
2760		:ivar TypeId:
2761		:vartype TypeId: NodeId
2762		:ivar ResponseHeader:
2763		:vartype ResponseHeader: ResponseHeader
2764		:ivar Parameters:
2765		:vartype Parameters: CancelResult
2766		'''
2767
2768		ua_types = [
2769		('TypeId', 'NodeId'),
2770		('ResponseHeader', 'ResponseHeader'),
2771		('Parameters', 'CancelResult'),
2772		]
2773
2774		def __init__(self):
2775		self.TypeId = FourByteNodeId(ObjectIds.CancelResponse_Encoding_DefaultBinary)
2776		self.ResponseHeader = ResponseHeader()
2777		self.Parameters = CancelResult()
2778		self._freeze = True
2779
2780		def __str__(self):
2781		return 'CancelResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
2782		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
2783		'Parameters:' + str(self.Parameters) + ')'
2784
2785		__repr__ = __str__
2786
2787
2788		class NodeAttributes(FrozenClass):
		@@ 2593-2622 (lines=30) @@
2590		__repr__ = __str__
2591
2592
2593		class ActivateSessionResponse(FrozenClass):
2594		'''
2595		Activates a session with the server.
2596
2597		:ivar TypeId:
2598		:vartype TypeId: NodeId
2599		:ivar ResponseHeader:
2600		:vartype ResponseHeader: ResponseHeader
2601		:ivar Parameters:
2602		:vartype Parameters: ActivateSessionResult
2603		'''
2604
2605		ua_types = [
2606		('TypeId', 'NodeId'),
2607		('ResponseHeader', 'ResponseHeader'),
2608		('Parameters', 'ActivateSessionResult'),
2609		]
2610
2611		def __init__(self):
2612		self.TypeId = FourByteNodeId(ObjectIds.ActivateSessionResponse_Encoding_DefaultBinary)
2613		self.ResponseHeader = ResponseHeader()
2614		self.Parameters = ActivateSessionResult()
2615		self._freeze = True
2616
2617		def __str__(self):
2618		return 'ActivateSessionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
2619		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
2620		'Parameters:' + str(self.Parameters) + ')'
2621
2622		__repr__ = __str__
2623
2624
2625		class CloseSessionRequest(FrozenClass):
		@@ 2294-2323 (lines=30) @@
2291		__repr__ = __str__
2292
2293
2294		class CreateSessionResponse(FrozenClass):
2295		'''
2296		Creates a new session with the server.
2297
2298		:ivar TypeId:
2299		:vartype TypeId: NodeId
2300		:ivar ResponseHeader:
2301		:vartype ResponseHeader: ResponseHeader
2302		:ivar Parameters:
2303		:vartype Parameters: CreateSessionResult
2304		'''
2305
2306		ua_types = [
2307		('TypeId', 'NodeId'),
2308		('ResponseHeader', 'ResponseHeader'),
2309		('Parameters', 'CreateSessionResult'),
2310		]
2311
2312		def __init__(self):
2313		self.TypeId = FourByteNodeId(ObjectIds.CreateSessionResponse_Encoding_DefaultBinary)
2314		self.ResponseHeader = ResponseHeader()
2315		self.Parameters = CreateSessionResult()
2316		self._freeze = True
2317
2318		def __str__(self):
2319		return 'CreateSessionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
2320		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
2321		'Parameters:' + str(self.Parameters) + ')'
2322
2323		__repr__ = __str__
2324
2325
2326		class UserIdentityToken(FrozenClass):
		@@ 2007-2036 (lines=30) @@
2004		__repr__ = __str__
2005
2006
2007		class OpenSecureChannelResponse(FrozenClass):
2008		'''
2009		Creates a secure channel with a server.
2010
2011		:ivar TypeId:
2012		:vartype TypeId: NodeId
2013		:ivar ResponseHeader:
2014		:vartype ResponseHeader: ResponseHeader
2015		:ivar Parameters:
2016		:vartype Parameters: OpenSecureChannelResult
2017		'''
2018
2019		ua_types = [
2020		('TypeId', 'NodeId'),
2021		('ResponseHeader', 'ResponseHeader'),
2022		('Parameters', 'OpenSecureChannelResult'),
2023		]
2024
2025		def __init__(self):
2026		self.TypeId = FourByteNodeId(ObjectIds.OpenSecureChannelResponse_Encoding_DefaultBinary)
2027		self.ResponseHeader = ResponseHeader()
2028		self.Parameters = OpenSecureChannelResult()
2029		self._freeze = True
2030
2031		def __str__(self):
2032		return 'OpenSecureChannelResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
2033		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
2034		'Parameters:' + str(self.Parameters) + ')'
2035
2036		__repr__ = __str__
2037
2038
2039		class CloseSecureChannelRequest(FrozenClass):
		@@ 1585-1614 (lines=30) @@
1582		__repr__ = __str__
1583
1584
1585		class GetEndpointsResponse(FrozenClass):
1586		'''
1587		Gets the endpoints used by the server.
1588
1589		:ivar TypeId:
1590		:vartype TypeId: NodeId
1591		:ivar ResponseHeader:
1592		:vartype ResponseHeader: ResponseHeader
1593		:ivar Endpoints:
1594		:vartype Endpoints: EndpointDescription
1595		'''
1596
1597		ua_types = [
1598		('TypeId', 'NodeId'),
1599		('ResponseHeader', 'ResponseHeader'),
1600		('Endpoints', 'ListOfEndpointDescription'),
1601		]
1602
1603		def __init__(self):
1604		self.TypeId = FourByteNodeId(ObjectIds.GetEndpointsResponse_Encoding_DefaultBinary)
1605		self.ResponseHeader = ResponseHeader()
1606		self.Endpoints = []
1607		self._freeze = True
1608
1609		def __str__(self):
1610		return 'GetEndpointsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
1611		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
1612		'Endpoints:' + str(self.Endpoints) + ')'
1613
1614		__repr__ = __str__
1615
1616
1617		class RegisteredServer(FrozenClass):
		@@ 1242-1271 (lines=30) @@
1239		__repr__ = __str__
1240
1241
1242		class FindServersResponse(FrozenClass):
1243		'''
1244		Finds the servers known to the discovery server.
1245
1246		:ivar TypeId:
1247		:vartype TypeId: NodeId
1248		:ivar ResponseHeader:
1249		:vartype ResponseHeader: ResponseHeader
1250		:ivar Servers:
1251		:vartype Servers: ApplicationDescription
1252		'''
1253
1254		ua_types = [
1255		('TypeId', 'NodeId'),
1256		('ResponseHeader', 'ResponseHeader'),
1257		('Servers', 'ListOfApplicationDescription'),
1258		]
1259
1260		def __init__(self):
1261		self.TypeId = FourByteNodeId(ObjectIds.FindServersResponse_Encoding_DefaultBinary)
1262		self.ResponseHeader = ResponseHeader()
1263		self.Servers = []
1264		self._freeze = True
1265
1266		def __str__(self):
1267		return 'FindServersResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
1268		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
1269		'Servers:' + str(self.Servers) + ')'
1270
1271		__repr__ = __str__
1272
1273
1274		class ServerOnNetwork(FrozenClass):
		@@ 8389-8416 (lines=28) @@
8386		__repr__ = __str__
8387
8388
8389		class TransferSubscriptionsResponse(FrozenClass):
8390		'''
8391		:ivar TypeId:
8392		:vartype TypeId: NodeId
8393		:ivar ResponseHeader:
8394		:vartype ResponseHeader: ResponseHeader
8395		:ivar Parameters:
8396		:vartype Parameters: TransferSubscriptionsResult
8397		'''
8398
8399		ua_types = [
8400		('TypeId', 'NodeId'),
8401		('ResponseHeader', 'ResponseHeader'),
8402		('Parameters', 'TransferSubscriptionsResult'),
8403		]
8404
8405		def __init__(self):
8406		self.TypeId = FourByteNodeId(ObjectIds.TransferSubscriptionsResponse_Encoding_DefaultBinary)
8407		self.ResponseHeader = ResponseHeader()
8408		self.Parameters = TransferSubscriptionsResult()
8409		self._freeze = True
8410
8411		def __str__(self):
8412		return 'TransferSubscriptionsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
8413		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
8414		'Parameters:' + str(self.Parameters) + ')'
8415
8416		__repr__ = __str__
8417
8418
8419		class DeleteSubscriptionsParameters(FrozenClass):
		@@ 8254-8281 (lines=28) @@
8251		__repr__ = __str__
8252
8253
8254		class RepublishResponse(FrozenClass):
8255		'''
8256		:ivar TypeId:
8257		:vartype TypeId: NodeId
8258		:ivar ResponseHeader:
8259		:vartype ResponseHeader: ResponseHeader
8260		:ivar NotificationMessage:
8261		:vartype NotificationMessage: NotificationMessage
8262		'''
8263
8264		ua_types = [
8265		('TypeId', 'NodeId'),
8266		('ResponseHeader', 'ResponseHeader'),
8267		('NotificationMessage', 'NotificationMessage'),
8268		]
8269
8270		def __init__(self):
8271		self.TypeId = FourByteNodeId(ObjectIds.RepublishResponse_Encoding_DefaultBinary)
8272		self.ResponseHeader = ResponseHeader()
8273		self.NotificationMessage = NotificationMessage()
8274		self._freeze = True
8275
8276		def __str__(self):
8277		return 'RepublishResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
8278		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
8279		'NotificationMessage:' + str(self.NotificationMessage) + ')'
8280
8281		__repr__ = __str__
8282
8283
8284		class TransferResult(FrozenClass):
		@@ 8169-8196 (lines=28) @@
8166		__repr__ = __str__
8167
8168
8169		class PublishResponse(FrozenClass):
8170		'''
8171		:ivar TypeId:
8172		:vartype TypeId: NodeId
8173		:ivar ResponseHeader:
8174		:vartype ResponseHeader: ResponseHeader
8175		:ivar Parameters:
8176		:vartype Parameters: PublishResult
8177		'''
8178
8179		ua_types = [
8180		('TypeId', 'NodeId'),
8181		('ResponseHeader', 'ResponseHeader'),
8182		('Parameters', 'PublishResult'),
8183		]
8184
8185		def __init__(self):
8186		self.TypeId = FourByteNodeId(ObjectIds.PublishResponse_Encoding_DefaultBinary)
8187		self.ResponseHeader = ResponseHeader()
8188		self.Parameters = PublishResult()
8189		self._freeze = True
8190
8191		def __str__(self):
8192		return 'PublishResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
8193		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
8194		'Parameters:' + str(self.Parameters) + ')'
8195
8196		__repr__ = __str__
8197
8198
8199		class RepublishParameters(FrozenClass):
		@@ 7833-7860 (lines=28) @@
7830		__repr__ = __str__
7831
7832
7833		class SetPublishingModeResponse(FrozenClass):
7834		'''
7835		:ivar TypeId:
7836		:vartype TypeId: NodeId
7837		:ivar ResponseHeader:
7838		:vartype ResponseHeader: ResponseHeader
7839		:ivar Parameters:
7840		:vartype Parameters: SetPublishingModeResult
7841		'''
7842
7843		ua_types = [
7844		('TypeId', 'NodeId'),
7845		('ResponseHeader', 'ResponseHeader'),
7846		('Parameters', 'SetPublishingModeResult'),
7847		]
7848
7849		def __init__(self):
7850		self.TypeId = FourByteNodeId(ObjectIds.SetPublishingModeResponse_Encoding_DefaultBinary)
7851		self.ResponseHeader = ResponseHeader()
7852		self.Parameters = SetPublishingModeResult()
7853		self._freeze = True
7854
7855		def __str__(self):
7856		return 'SetPublishingModeResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7857		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7858		'Parameters:' + str(self.Parameters) + ')'
7859
7860		__repr__ = __str__
7861
7862
7863		class NotificationMessage(FrozenClass):
		@@ 7723-7750 (lines=28) @@
7720		__repr__ = __str__
7721
7722
7723		class ModifySubscriptionResponse(FrozenClass):
7724		'''
7725		:ivar TypeId:
7726		:vartype TypeId: NodeId
7727		:ivar ResponseHeader:
7728		:vartype ResponseHeader: ResponseHeader
7729		:ivar Parameters:
7730		:vartype Parameters: ModifySubscriptionResult
7731		'''
7732
7733		ua_types = [
7734		('TypeId', 'NodeId'),
7735		('ResponseHeader', 'ResponseHeader'),
7736		('Parameters', 'ModifySubscriptionResult'),
7737		]
7738
7739		def __init__(self):
7740		self.TypeId = FourByteNodeId(ObjectIds.ModifySubscriptionResponse_Encoding_DefaultBinary)
7741		self.ResponseHeader = ResponseHeader()
7742		self.Parameters = ModifySubscriptionResult()
7743		self._freeze = True
7744
7745		def __str__(self):
7746		return 'ModifySubscriptionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7747		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7748		'Parameters:' + str(self.Parameters) + ')'
7749
7750		__repr__ = __str__
7751
7752
7753		class SetPublishingModeParameters(FrozenClass):
		@@ 7588-7615 (lines=28) @@
7585		__repr__ = __str__
7586
7587
7588		class CreateSubscriptionResponse(FrozenClass):
7589		'''
7590		:ivar TypeId:
7591		:vartype TypeId: NodeId
7592		:ivar ResponseHeader:
7593		:vartype ResponseHeader: ResponseHeader
7594		:ivar Parameters:
7595		:vartype Parameters: CreateSubscriptionResult
7596		'''
7597
7598		ua_types = [
7599		('TypeId', 'NodeId'),
7600		('ResponseHeader', 'ResponseHeader'),
7601		('Parameters', 'CreateSubscriptionResult'),
7602		]
7603
7604		def __init__(self):
7605		self.TypeId = FourByteNodeId(ObjectIds.CreateSubscriptionResponse_Encoding_DefaultBinary)
7606		self.ResponseHeader = ResponseHeader()
7607		self.Parameters = CreateSubscriptionResult()
7608		self._freeze = True
7609
7610		def __str__(self):
7611		return 'CreateSubscriptionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7612		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7613		'Parameters:' + str(self.Parameters) + ')'
7614
7615		__repr__ = __str__
7616
7617
7618		class ModifySubscriptionParameters(FrozenClass):
		@@ 7358-7385 (lines=28) @@
7355		__repr__ = __str__
7356
7357
7358		class SetTriggeringResponse(FrozenClass):
7359		'''
7360		:ivar TypeId:
7361		:vartype TypeId: NodeId
7362		:ivar ResponseHeader:
7363		:vartype ResponseHeader: ResponseHeader
7364		:ivar Parameters:
7365		:vartype Parameters: SetTriggeringResult
7366		'''
7367
7368		ua_types = [
7369		('TypeId', 'NodeId'),
7370		('ResponseHeader', 'ResponseHeader'),
7371		('Parameters', 'SetTriggeringResult'),
7372		]
7373
7374		def __init__(self):
7375		self.TypeId = FourByteNodeId(ObjectIds.SetTriggeringResponse_Encoding_DefaultBinary)
7376		self.ResponseHeader = ResponseHeader()
7377		self.Parameters = SetTriggeringResult()
7378		self._freeze = True
7379
7380		def __str__(self):
7381		return 'SetTriggeringResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7382		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7383		'Parameters:' + str(self.Parameters) + ')'
7384
7385		__repr__ = __str__
7386
7387
7388		class DeleteMonitoredItemsParameters(FrozenClass):
		@@ 7228-7255 (lines=28) @@
7225		__repr__ = __str__
7226
7227
7228		class SetMonitoringModeResponse(FrozenClass):
7229		'''
7230		:ivar TypeId:
7231		:vartype TypeId: NodeId
7232		:ivar ResponseHeader:
7233		:vartype ResponseHeader: ResponseHeader
7234		:ivar Parameters:
7235		:vartype Parameters: SetMonitoringModeResult
7236		'''
7237
7238		ua_types = [
7239		('TypeId', 'NodeId'),
7240		('ResponseHeader', 'ResponseHeader'),
7241		('Parameters', 'SetMonitoringModeResult'),
7242		]
7243
7244		def __init__(self):
7245		self.TypeId = FourByteNodeId(ObjectIds.SetMonitoringModeResponse_Encoding_DefaultBinary)
7246		self.ResponseHeader = ResponseHeader()
7247		self.Parameters = SetMonitoringModeResult()
7248		self._freeze = True
7249
7250		def __str__(self):
7251		return 'SetMonitoringModeResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7252		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7253		'Parameters:' + str(self.Parameters) + ')'
7254
7255		__repr__ = __str__
7256
7257
7258		class SetTriggeringParameters(FrozenClass):
		@@ 5400-5427 (lines=28) @@
5397		__repr__ = __str__
5398
5399
5400		class QueryNextResponse(FrozenClass):
5401		'''
5402		:ivar TypeId:
5403		:vartype TypeId: NodeId
5404		:ivar ResponseHeader:
5405		:vartype ResponseHeader: ResponseHeader
5406		:ivar Parameters:
5407		:vartype Parameters: QueryNextResult
5408		'''
5409
5410		ua_types = [
5411		('TypeId', 'NodeId'),
5412		('ResponseHeader', 'ResponseHeader'),
5413		('Parameters', 'QueryNextResult'),
5414		]
5415
5416		def __init__(self):
5417		self.TypeId = FourByteNodeId(ObjectIds.QueryNextResponse_Encoding_DefaultBinary)
5418		self.ResponseHeader = ResponseHeader()
5419		self.Parameters = QueryNextResult()
5420		self._freeze = True
5421
5422		def __str__(self):
5423		return 'QueryNextResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
5424		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
5425		'Parameters:' + str(self.Parameters) + ')'
5426
5427		__repr__ = __str__
5428
5429
5430		class ReadValueId(FrozenClass):
		@@ 5290-5317 (lines=28) @@
5287		__repr__ = __str__
5288
5289
5290		class QueryFirstResponse(FrozenClass):
5291		'''
5292		:ivar TypeId:
5293		:vartype TypeId: NodeId
5294		:ivar ResponseHeader:
5295		:vartype ResponseHeader: ResponseHeader
5296		:ivar Parameters:
5297		:vartype Parameters: QueryFirstResult
5298		'''
5299
5300		ua_types = [
5301		('TypeId', 'NodeId'),
5302		('ResponseHeader', 'ResponseHeader'),
5303		('Parameters', 'QueryFirstResult'),
5304		]
5305
5306		def __init__(self):
5307		self.TypeId = FourByteNodeId(ObjectIds.QueryFirstResponse_Encoding_DefaultBinary)
5308		self.ResponseHeader = ResponseHeader()
5309		self.Parameters = QueryFirstResult()
5310		self._freeze = True
5311
5312		def __str__(self):
5313		return 'QueryFirstResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
5314		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
5315		'Parameters:' + str(self.Parameters) + ')'
5316
5317		__repr__ = __str__
5318
5319
5320		class QueryNextParameters(FrozenClass):
		@@ 1394-1421 (lines=28) @@
1391		__repr__ = __str__
1392
1393
1394		class FindServersOnNetworkResponse(FrozenClass):
1395		'''
1396		:ivar TypeId:
1397		:vartype TypeId: NodeId
1398		:ivar ResponseHeader:
1399		:vartype ResponseHeader: ResponseHeader
1400		:ivar Parameters:
1401		:vartype Parameters: FindServersOnNetworkResult
1402		'''
1403
1404		ua_types = [
1405		('TypeId', 'NodeId'),
1406		('ResponseHeader', 'ResponseHeader'),
1407		('Parameters', 'FindServersOnNetworkResult'),
1408		]
1409
1410		def __init__(self):
1411		self.TypeId = FourByteNodeId(ObjectIds.FindServersOnNetworkResponse_Encoding_DefaultBinary)
1412		self.ResponseHeader = ResponseHeader()
1413		self.Parameters = FindServersOnNetworkResult()
1414		self._freeze = True
1415
1416		def __str__(self):
1417		return 'FindServersOnNetworkResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
1418		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
1419		'Parameters:' + str(self.Parameters) + ')'
1420
1421		__repr__ = __str__
1422
1423
1424		class UserTokenPolicy(FrozenClass):

FreeOpcUa / python-opcua

Code Duplication Length = 28-30 lines in 20 locations

opcua/ua/uaprotocol_auto.py 20 locations