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




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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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

		@@ 4493-4522 (lines=30) @@
4490
4491
4492		class RegisterNodesResponse(FrozenClass):
4493		'''
4494		Registers one or more nodes for repeated use within a session.
4495
4496		:ivar TypeId:
4497		:vartype TypeId: NodeId
4498		:ivar ResponseHeader:
4499		:vartype ResponseHeader: ResponseHeader
4500		:ivar Parameters:
4501		:vartype Parameters: RegisterNodesResult
4502		'''
4503
4504		ua_types = [
4505		('TypeId', 'NodeId'),
4506		('ResponseHeader', 'ResponseHeader'),
4507		('Parameters', 'RegisterNodesResult'),
4508		]
4509
4510		def __init__(self):
4511		self.TypeId = FourByteNodeId(ObjectIds.RegisterNodesResponse_Encoding_DefaultBinary)
4512		self.ResponseHeader = ResponseHeader()
4513		self.Parameters = RegisterNodesResult()
4514		self._freeze = True
4515
4516		def __str__(self):
4517		return 'RegisterNodesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
4518		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
4519		'Parameters:' + str(self.Parameters) + ')'
4520
4521		__repr__ = __str__
4522
4523
4524		class UnregisterNodesParameters(FrozenClass):
4525		'''
		@@ 4160-4189 (lines=30) @@
4157
4158
4159		class BrowseNextResponse(FrozenClass):
4160		'''
4161		Continues one or more browse operations.
4162
4163		:ivar TypeId:
4164		:vartype TypeId: NodeId
4165		:ivar ResponseHeader:
4166		:vartype ResponseHeader: ResponseHeader
4167		:ivar Parameters:
4168		:vartype Parameters: BrowseNextResult
4169		'''
4170
4171		ua_types = [
4172		('TypeId', 'NodeId'),
4173		('ResponseHeader', 'ResponseHeader'),
4174		('Parameters', 'BrowseNextResult'),
4175		]
4176
4177		def __init__(self):
4178		self.TypeId = FourByteNodeId(ObjectIds.BrowseNextResponse_Encoding_DefaultBinary)
4179		self.ResponseHeader = ResponseHeader()
4180		self.Parameters = BrowseNextResult()
4181		self._freeze = True
4182
4183		def __str__(self):
4184		return 'BrowseNextResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
4185		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
4186		'Parameters:' + str(self.Parameters) + ')'
4187
4188		__repr__ = __str__
4189
4190
4191		class RelativePathElement(FrozenClass):
4192		'''
		@@ 3784-3813 (lines=30) @@
3781
3782
3783		class DeleteReferencesResponse(FrozenClass):
3784		'''
3785		Delete one or more references from the server address space.
3786
3787		:ivar TypeId:
3788		:vartype TypeId: NodeId
3789		:ivar ResponseHeader:
3790		:vartype ResponseHeader: ResponseHeader
3791		:ivar Parameters:
3792		:vartype Parameters: DeleteReferencesResult
3793		'''
3794
3795		ua_types = [
3796		('TypeId', 'NodeId'),
3797		('ResponseHeader', 'ResponseHeader'),
3798		('Parameters', 'DeleteReferencesResult'),
3799		]
3800
3801		def __init__(self):
3802		self.TypeId = FourByteNodeId(ObjectIds.DeleteReferencesResponse_Encoding_DefaultBinary)
3803		self.ResponseHeader = ResponseHeader()
3804		self.Parameters = DeleteReferencesResult()
3805		self._freeze = True
3806
3807		def __str__(self):
3808		return 'DeleteReferencesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
3809		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
3810		'Parameters:' + str(self.Parameters) + ')'
3811
3812		__repr__ = __str__
3813
3814
3815		class ViewDescription(FrozenClass):
3816		'''
		@@ 2720-2749 (lines=30) @@
2717
2718
2719		class CancelResponse(FrozenClass):
2720		'''
2721		Cancels an outstanding request.
2722
2723		:ivar TypeId:
2724		:vartype TypeId: NodeId
2725		:ivar ResponseHeader:
2726		:vartype ResponseHeader: ResponseHeader
2727		:ivar Parameters:
2728		:vartype Parameters: CancelResult
2729		'''
2730
2731		ua_types = [
2732		('TypeId', 'NodeId'),
2733		('ResponseHeader', 'ResponseHeader'),
2734		('Parameters', 'CancelResult'),
2735		]
2736
2737		def __init__(self):
2738		self.TypeId = FourByteNodeId(ObjectIds.CancelResponse_Encoding_DefaultBinary)
2739		self.ResponseHeader = ResponseHeader()
2740		self.Parameters = CancelResult()
2741		self._freeze = True
2742
2743		def __str__(self):
2744		return 'CancelResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
2745		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
2746		'Parameters:' + str(self.Parameters) + ')'
2747
2748		__repr__ = __str__
2749
2750
2751		class NodeAttributes(FrozenClass):
2752		'''
		@@ 2557-2586 (lines=30) @@
2554
2555
2556		class ActivateSessionResponse(FrozenClass):
2557		'''
2558		Activates a session with the server.
2559
2560		:ivar TypeId:
2561		:vartype TypeId: NodeId
2562		:ivar ResponseHeader:
2563		:vartype ResponseHeader: ResponseHeader
2564		:ivar Parameters:
2565		:vartype Parameters: ActivateSessionResult
2566		'''
2567
2568		ua_types = [
2569		('TypeId', 'NodeId'),
2570		('ResponseHeader', 'ResponseHeader'),
2571		('Parameters', 'ActivateSessionResult'),
2572		]
2573
2574		def __init__(self):
2575		self.TypeId = FourByteNodeId(ObjectIds.ActivateSessionResponse_Encoding_DefaultBinary)
2576		self.ResponseHeader = ResponseHeader()
2577		self.Parameters = ActivateSessionResult()
2578		self._freeze = True
2579
2580		def __str__(self):
2581		return 'ActivateSessionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
2582		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
2583		'Parameters:' + str(self.Parameters) + ')'
2584
2585		__repr__ = __str__
2586
2587
2588		class CloseSessionRequest(FrozenClass):
2589		'''
		@@ 2258-2287 (lines=30) @@
2255
2256
2257		class CreateSessionResponse(FrozenClass):
2258		'''
2259		Creates a new session with the server.
2260
2261		:ivar TypeId:
2262		:vartype TypeId: NodeId
2263		:ivar ResponseHeader:
2264		:vartype ResponseHeader: ResponseHeader
2265		:ivar Parameters:
2266		:vartype Parameters: CreateSessionResult
2267		'''
2268
2269		ua_types = [
2270		('TypeId', 'NodeId'),
2271		('ResponseHeader', 'ResponseHeader'),
2272		('Parameters', 'CreateSessionResult'),
2273		]
2274
2275		def __init__(self):
2276		self.TypeId = FourByteNodeId(ObjectIds.CreateSessionResponse_Encoding_DefaultBinary)
2277		self.ResponseHeader = ResponseHeader()
2278		self.Parameters = CreateSessionResult()
2279		self._freeze = True
2280
2281		def __str__(self):
2282		return 'CreateSessionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
2283		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
2284		'Parameters:' + str(self.Parameters) + ')'
2285
2286		__repr__ = __str__
2287
2288
2289		class UserIdentityToken(FrozenClass):
2290		'''
		@@ 1971-2000 (lines=30) @@
1968
1969
1970		class OpenSecureChannelResponse(FrozenClass):
1971		'''
1972		Creates a secure channel with a server.
1973
1974		:ivar TypeId:
1975		:vartype TypeId: NodeId
1976		:ivar ResponseHeader:
1977		:vartype ResponseHeader: ResponseHeader
1978		:ivar Parameters:
1979		:vartype Parameters: OpenSecureChannelResult
1980		'''
1981
1982		ua_types = [
1983		('TypeId', 'NodeId'),
1984		('ResponseHeader', 'ResponseHeader'),
1985		('Parameters', 'OpenSecureChannelResult'),
1986		]
1987
1988		def __init__(self):
1989		self.TypeId = FourByteNodeId(ObjectIds.OpenSecureChannelResponse_Encoding_DefaultBinary)
1990		self.ResponseHeader = ResponseHeader()
1991		self.Parameters = OpenSecureChannelResult()
1992		self._freeze = True
1993
1994		def __str__(self):
1995		return 'OpenSecureChannelResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
1996		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
1997		'Parameters:' + str(self.Parameters) + ')'
1998
1999		__repr__ = __str__
2000
2001
2002		class CloseSecureChannelRequest(FrozenClass):
2003		'''
		@@ 1549-1578 (lines=30) @@
1546
1547
1548		class GetEndpointsResponse(FrozenClass):
1549		'''
1550		Gets the endpoints used by the server.
1551
1552		:ivar TypeId:
1553		:vartype TypeId: NodeId
1554		:ivar ResponseHeader:
1555		:vartype ResponseHeader: ResponseHeader
1556		:ivar Endpoints:
1557		:vartype Endpoints: EndpointDescription
1558		'''
1559
1560		ua_types = [
1561		('TypeId', 'NodeId'),
1562		('ResponseHeader', 'ResponseHeader'),
1563		('Endpoints', 'ListOfEndpointDescription'),
1564		]
1565
1566		def __init__(self):
1567		self.TypeId = FourByteNodeId(ObjectIds.GetEndpointsResponse_Encoding_DefaultBinary)
1568		self.ResponseHeader = ResponseHeader()
1569		self.Endpoints = []
1570		self._freeze = True
1571
1572		def __str__(self):
1573		return 'GetEndpointsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
1574		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
1575		'Endpoints:' + str(self.Endpoints) + ')'
1576
1577		__repr__ = __str__
1578
1579
1580		class RegisteredServer(FrozenClass):
1581		'''
		@@ 1206-1235 (lines=30) @@
1203
1204
1205		class FindServersResponse(FrozenClass):
1206		'''
1207		Finds the servers known to the discovery server.
1208
1209		:ivar TypeId:
1210		:vartype TypeId: NodeId
1211		:ivar ResponseHeader:
1212		:vartype ResponseHeader: ResponseHeader
1213		:ivar Servers:
1214		:vartype Servers: ApplicationDescription
1215		'''
1216
1217		ua_types = [
1218		('TypeId', 'NodeId'),
1219		('ResponseHeader', 'ResponseHeader'),
1220		('Servers', 'ListOfApplicationDescription'),
1221		]
1222
1223		def __init__(self):
1224		self.TypeId = FourByteNodeId(ObjectIds.FindServersResponse_Encoding_DefaultBinary)
1225		self.ResponseHeader = ResponseHeader()
1226		self.Servers = []
1227		self._freeze = True
1228
1229		def __str__(self):
1230		return 'FindServersResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
1231		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
1232		'Servers:' + str(self.Servers) + ')'
1233
1234		__repr__ = __str__
1235
1236
1237		class ServerOnNetwork(FrozenClass):
1238		'''
		@@ 8353-8380 (lines=28) @@
8350
8351
8352		class TransferSubscriptionsResponse(FrozenClass):
8353		'''
8354		:ivar TypeId:
8355		:vartype TypeId: NodeId
8356		:ivar ResponseHeader:
8357		:vartype ResponseHeader: ResponseHeader
8358		:ivar Parameters:
8359		:vartype Parameters: TransferSubscriptionsResult
8360		'''
8361
8362		ua_types = [
8363		('TypeId', 'NodeId'),
8364		('ResponseHeader', 'ResponseHeader'),
8365		('Parameters', 'TransferSubscriptionsResult'),
8366		]
8367
8368		def __init__(self):
8369		self.TypeId = FourByteNodeId(ObjectIds.TransferSubscriptionsResponse_Encoding_DefaultBinary)
8370		self.ResponseHeader = ResponseHeader()
8371		self.Parameters = TransferSubscriptionsResult()
8372		self._freeze = True
8373
8374		def __str__(self):
8375		return 'TransferSubscriptionsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
8376		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
8377		'Parameters:' + str(self.Parameters) + ')'
8378
8379		__repr__ = __str__
8380
8381
8382		class DeleteSubscriptionsParameters(FrozenClass):
8383		'''
		@@ 8218-8245 (lines=28) @@
8215
8216
8217		class RepublishResponse(FrozenClass):
8218		'''
8219		:ivar TypeId:
8220		:vartype TypeId: NodeId
8221		:ivar ResponseHeader:
8222		:vartype ResponseHeader: ResponseHeader
8223		:ivar NotificationMessage:
8224		:vartype NotificationMessage: NotificationMessage
8225		'''
8226
8227		ua_types = [
8228		('TypeId', 'NodeId'),
8229		('ResponseHeader', 'ResponseHeader'),
8230		('NotificationMessage', 'NotificationMessage'),
8231		]
8232
8233		def __init__(self):
8234		self.TypeId = FourByteNodeId(ObjectIds.RepublishResponse_Encoding_DefaultBinary)
8235		self.ResponseHeader = ResponseHeader()
8236		self.NotificationMessage = NotificationMessage()
8237		self._freeze = True
8238
8239		def __str__(self):
8240		return 'RepublishResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
8241		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
8242		'NotificationMessage:' + str(self.NotificationMessage) + ')'
8243
8244		__repr__ = __str__
8245
8246
8247		class TransferResult(FrozenClass):
8248		'''
		@@ 8133-8160 (lines=28) @@
8130
8131
8132		class PublishResponse(FrozenClass):
8133		'''
8134		:ivar TypeId:
8135		:vartype TypeId: NodeId
8136		:ivar ResponseHeader:
8137		:vartype ResponseHeader: ResponseHeader
8138		:ivar Parameters:
8139		:vartype Parameters: PublishResult
8140		'''
8141
8142		ua_types = [
8143		('TypeId', 'NodeId'),
8144		('ResponseHeader', 'ResponseHeader'),
8145		('Parameters', 'PublishResult'),
8146		]
8147
8148		def __init__(self):
8149		self.TypeId = FourByteNodeId(ObjectIds.PublishResponse_Encoding_DefaultBinary)
8150		self.ResponseHeader = ResponseHeader()
8151		self.Parameters = PublishResult()
8152		self._freeze = True
8153
8154		def __str__(self):
8155		return 'PublishResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
8156		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
8157		'Parameters:' + str(self.Parameters) + ')'
8158
8159		__repr__ = __str__
8160
8161
8162		class RepublishParameters(FrozenClass):
8163		'''
		@@ 7797-7824 (lines=28) @@
7794
7795
7796		class SetPublishingModeResponse(FrozenClass):
7797		'''
7798		:ivar TypeId:
7799		:vartype TypeId: NodeId
7800		:ivar ResponseHeader:
7801		:vartype ResponseHeader: ResponseHeader
7802		:ivar Parameters:
7803		:vartype Parameters: SetPublishingModeResult
7804		'''
7805
7806		ua_types = [
7807		('TypeId', 'NodeId'),
7808		('ResponseHeader', 'ResponseHeader'),
7809		('Parameters', 'SetPublishingModeResult'),
7810		]
7811
7812		def __init__(self):
7813		self.TypeId = FourByteNodeId(ObjectIds.SetPublishingModeResponse_Encoding_DefaultBinary)
7814		self.ResponseHeader = ResponseHeader()
7815		self.Parameters = SetPublishingModeResult()
7816		self._freeze = True
7817
7818		def __str__(self):
7819		return 'SetPublishingModeResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7820		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7821		'Parameters:' + str(self.Parameters) + ')'
7822
7823		__repr__ = __str__
7824
7825
7826		class NotificationMessage(FrozenClass):
7827		'''
		@@ 7687-7714 (lines=28) @@
7684
7685
7686		class ModifySubscriptionResponse(FrozenClass):
7687		'''
7688		:ivar TypeId:
7689		:vartype TypeId: NodeId
7690		:ivar ResponseHeader:
7691		:vartype ResponseHeader: ResponseHeader
7692		:ivar Parameters:
7693		:vartype Parameters: ModifySubscriptionResult
7694		'''
7695
7696		ua_types = [
7697		('TypeId', 'NodeId'),
7698		('ResponseHeader', 'ResponseHeader'),
7699		('Parameters', 'ModifySubscriptionResult'),
7700		]
7701
7702		def __init__(self):
7703		self.TypeId = FourByteNodeId(ObjectIds.ModifySubscriptionResponse_Encoding_DefaultBinary)
7704		self.ResponseHeader = ResponseHeader()
7705		self.Parameters = ModifySubscriptionResult()
7706		self._freeze = True
7707
7708		def __str__(self):
7709		return 'ModifySubscriptionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7710		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7711		'Parameters:' + str(self.Parameters) + ')'
7712
7713		__repr__ = __str__
7714
7715
7716		class SetPublishingModeParameters(FrozenClass):
7717		'''
		@@ 7552-7579 (lines=28) @@
7549
7550
7551		class CreateSubscriptionResponse(FrozenClass):
7552		'''
7553		:ivar TypeId:
7554		:vartype TypeId: NodeId
7555		:ivar ResponseHeader:
7556		:vartype ResponseHeader: ResponseHeader
7557		:ivar Parameters:
7558		:vartype Parameters: CreateSubscriptionResult
7559		'''
7560
7561		ua_types = [
7562		('TypeId', 'NodeId'),
7563		('ResponseHeader', 'ResponseHeader'),
7564		('Parameters', 'CreateSubscriptionResult'),
7565		]
7566
7567		def __init__(self):
7568		self.TypeId = FourByteNodeId(ObjectIds.CreateSubscriptionResponse_Encoding_DefaultBinary)
7569		self.ResponseHeader = ResponseHeader()
7570		self.Parameters = CreateSubscriptionResult()
7571		self._freeze = True
7572
7573		def __str__(self):
7574		return 'CreateSubscriptionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7575		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7576		'Parameters:' + str(self.Parameters) + ')'
7577
7578		__repr__ = __str__
7579
7580
7581		class ModifySubscriptionParameters(FrozenClass):
7582		'''
		@@ 7322-7349 (lines=28) @@
7319
7320
7321		class SetTriggeringResponse(FrozenClass):
7322		'''
7323		:ivar TypeId:
7324		:vartype TypeId: NodeId
7325		:ivar ResponseHeader:
7326		:vartype ResponseHeader: ResponseHeader
7327		:ivar Parameters:
7328		:vartype Parameters: SetTriggeringResult
7329		'''
7330
7331		ua_types = [
7332		('TypeId', 'NodeId'),
7333		('ResponseHeader', 'ResponseHeader'),
7334		('Parameters', 'SetTriggeringResult'),
7335		]
7336
7337		def __init__(self):
7338		self.TypeId = FourByteNodeId(ObjectIds.SetTriggeringResponse_Encoding_DefaultBinary)
7339		self.ResponseHeader = ResponseHeader()
7340		self.Parameters = SetTriggeringResult()
7341		self._freeze = True
7342
7343		def __str__(self):
7344		return 'SetTriggeringResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7345		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7346		'Parameters:' + str(self.Parameters) + ')'
7347
7348		__repr__ = __str__
7349
7350
7351		class DeleteMonitoredItemsParameters(FrozenClass):
7352		'''
		@@ 7192-7219 (lines=28) @@
7189
7190
7191		class SetMonitoringModeResponse(FrozenClass):
7192		'''
7193		:ivar TypeId:
7194		:vartype TypeId: NodeId
7195		:ivar ResponseHeader:
7196		:vartype ResponseHeader: ResponseHeader
7197		:ivar Parameters:
7198		:vartype Parameters: SetMonitoringModeResult
7199		'''
7200
7201		ua_types = [
7202		('TypeId', 'NodeId'),
7203		('ResponseHeader', 'ResponseHeader'),
7204		('Parameters', 'SetMonitoringModeResult'),
7205		]
7206
7207		def __init__(self):
7208		self.TypeId = FourByteNodeId(ObjectIds.SetMonitoringModeResponse_Encoding_DefaultBinary)
7209		self.ResponseHeader = ResponseHeader()
7210		self.Parameters = SetMonitoringModeResult()
7211		self._freeze = True
7212
7213		def __str__(self):
7214		return 'SetMonitoringModeResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
7215		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
7216		'Parameters:' + str(self.Parameters) + ')'
7217
7218		__repr__ = __str__
7219
7220
7221		class SetTriggeringParameters(FrozenClass):
7222		'''
		@@ 5364-5391 (lines=28) @@
5361
5362
5363		class QueryNextResponse(FrozenClass):
5364		'''
5365		:ivar TypeId:
5366		:vartype TypeId: NodeId
5367		:ivar ResponseHeader:
5368		:vartype ResponseHeader: ResponseHeader
5369		:ivar Parameters:
5370		:vartype Parameters: QueryNextResult
5371		'''
5372
5373		ua_types = [
5374		('TypeId', 'NodeId'),
5375		('ResponseHeader', 'ResponseHeader'),
5376		('Parameters', 'QueryNextResult'),
5377		]
5378
5379		def __init__(self):
5380		self.TypeId = FourByteNodeId(ObjectIds.QueryNextResponse_Encoding_DefaultBinary)
5381		self.ResponseHeader = ResponseHeader()
5382		self.Parameters = QueryNextResult()
5383		self._freeze = True
5384
5385		def __str__(self):
5386		return 'QueryNextResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
5387		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
5388		'Parameters:' + str(self.Parameters) + ')'
5389
5390		__repr__ = __str__
5391
5392
5393		class ReadValueId(FrozenClass):
5394		'''
		@@ 5254-5281 (lines=28) @@
5251
5252
5253		class QueryFirstResponse(FrozenClass):
5254		'''
5255		:ivar TypeId:
5256		:vartype TypeId: NodeId
5257		:ivar ResponseHeader:
5258		:vartype ResponseHeader: ResponseHeader
5259		:ivar Parameters:
5260		:vartype Parameters: QueryFirstResult
5261		'''
5262
5263		ua_types = [
5264		('TypeId', 'NodeId'),
5265		('ResponseHeader', 'ResponseHeader'),
5266		('Parameters', 'QueryFirstResult'),
5267		]
5268
5269		def __init__(self):
5270		self.TypeId = FourByteNodeId(ObjectIds.QueryFirstResponse_Encoding_DefaultBinary)
5271		self.ResponseHeader = ResponseHeader()
5272		self.Parameters = QueryFirstResult()
5273		self._freeze = True
5274
5275		def __str__(self):
5276		return 'QueryFirstResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
5277		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
5278		'Parameters:' + str(self.Parameters) + ')'
5279
5280		__repr__ = __str__
5281
5282
5283		class QueryNextParameters(FrozenClass):
5284		'''
		@@ 1358-1385 (lines=28) @@
1355
1356
1357		class FindServersOnNetworkResponse(FrozenClass):
1358		'''
1359		:ivar TypeId:
1360		:vartype TypeId: NodeId
1361		:ivar ResponseHeader:
1362		:vartype ResponseHeader: ResponseHeader
1363		:ivar Parameters:
1364		:vartype Parameters: FindServersOnNetworkResult
1365		'''
1366
1367		ua_types = [
1368		('TypeId', 'NodeId'),
1369		('ResponseHeader', 'ResponseHeader'),
1370		('Parameters', 'FindServersOnNetworkResult'),
1371		]
1372
1373		def __init__(self):
1374		self.TypeId = FourByteNodeId(ObjectIds.FindServersOnNetworkResponse_Encoding_DefaultBinary)
1375		self.ResponseHeader = ResponseHeader()
1376		self.Parameters = FindServersOnNetworkResult()
1377		self._freeze = True
1378
1379		def __str__(self):
1380		return 'FindServersOnNetworkResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \
1381		'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \
1382		'Parameters:' + str(self.Parameters) + ')'
1383
1384		__repr__ = __str__
1385
1386
1387		class UserTokenPolicy(FrozenClass):
1388		'''

FreeOpcUa / python-opcua

Code Duplication Length = 28-30 lines in 20 locations

opcua/ua/uaprotocol_auto.py 20 locations