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

Code Duplication Length = 55-59 lines in 6 locations

opcua/ua/uaprotocol_auto.py 6 locations


    __repr__ = __str__


class SetTriggeringParameters(FrozenClass):
    '''
    :ivar SubscriptionId:
    :vartype SubscriptionId: UInt32
    :ivar TriggeringItemId:
    :vartype TriggeringItemId: UInt32
    :ivar LinksToAdd:
    :vartype LinksToAdd: UInt32
    :ivar LinksToRemove:
    :vartype LinksToRemove: UInt32
    '''

    ua_types = {
        'SubscriptionId': 'UInt32',
        'TriggeringItemId': 'UInt32',
        'LinksToAdd': 'UInt32',
        'LinksToRemove': 'UInt32',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SubscriptionId = 0
        self.TriggeringItemId = 0
        self.LinksToAdd = []
        self.LinksToRemove = []
        self._freeze = True

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

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

    def _binary_init(self, data):
        self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)
        self.TriggeringItemId = uabin.Primitives.UInt32.unpack(data)
        self.LinksToAdd = uabin.Primitives.UInt32.unpack_array(data)
        self.LinksToRemove = uabin.Primitives.UInt32.unpack_array(data)

    def __str__(self):
        return 'SetTriggeringParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \
               'TriggeringItemId:' + str(self.TriggeringItemId) + ', ' + \
               'LinksToAdd:' + str(self.LinksToAdd) + ', ' + \
               'LinksToRemove:' + str(self.LinksToRemove) + ')'

    __repr__ = __str__


class SetTriggeringRequest(FrozenClass):

    __repr__ = __str__


class ServerOnNetwork(FrozenClass):
    '''
    :ivar RecordId:
    :vartype RecordId: UInt32
    :ivar ServerName:
    :vartype ServerName: String
    :ivar DiscoveryUrl:
    :vartype DiscoveryUrl: String
    :ivar ServerCapabilities:
    :vartype ServerCapabilities: String
    '''

    ua_types = {
        'RecordId': 'UInt32',
        'ServerName': 'String',
        'DiscoveryUrl': 'String',
        'ServerCapabilities': 'String',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.RecordId = 0
        self.ServerName = None
        self.DiscoveryUrl = None
        self.ServerCapabilities = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.RecordId))
        packet.append(uabin.Primitives.String.pack(self.ServerName))
        packet.append(uabin.Primitives.String.pack(self.DiscoveryUrl))
        packet.append(uabin.Primitives.Int32.pack(len(self.ServerCapabilities)))
        for fieldname in self.ServerCapabilities:
            packet.append(uabin.Primitives.String.pack(fieldname))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.RecordId = uabin.Primitives.UInt32.unpack(data)
        self.ServerName = uabin.Primitives.String.unpack(data)
        self.DiscoveryUrl = uabin.Primitives.String.unpack(data)
        self.ServerCapabilities = uabin.Primitives.String.unpack_array(data)

    def __str__(self):
        return 'ServerOnNetwork(' + 'RecordId:' + str(self.RecordId) + ', ' + \
               'ServerName:' + str(self.ServerName) + ', ' + \
               'DiscoveryUrl:' + str(self.DiscoveryUrl) + ', ' + \
               'ServerCapabilities:' + str(self.ServerCapabilities) + ')'

    __repr__ = __str__


class FindServersOnNetworkParameters(FrozenClass):

    __repr__ = __str__


class UserNameIdentityToken(FrozenClass):
    '''
    A token representing a user identified by a user name and password.

    :ivar PolicyId:
    :vartype PolicyId: String
    :ivar UserName:
    :vartype UserName: String
    :ivar Password:
    :vartype Password: ByteString
    :ivar EncryptionAlgorithm:
    :vartype EncryptionAlgorithm: String
    '''

    ua_types = {
        'PolicyId': 'String',
        'UserName': 'String',
        'Password': 'ByteString',
        'EncryptionAlgorithm': 'String',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.PolicyId = None
        self.UserName = None
        self.Password = None
        self.EncryptionAlgorithm = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.String.pack(self.PolicyId))
        packet.append(uabin.Primitives.String.pack(self.UserName))
        packet.append(uabin.Primitives.ByteString.pack(self.Password))
        packet.append(uabin.Primitives.String.pack(self.EncryptionAlgorithm))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.PolicyId = uabin.Primitives.String.unpack(data)
        self.UserName = uabin.Primitives.String.unpack(data)
        self.Password = uabin.Primitives.ByteString.unpack(data)
        self.EncryptionAlgorithm = uabin.Primitives.String.unpack(data)

    def __str__(self):
        return 'UserNameIdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \
               'UserName:' + str(self.UserName) + ', ' + \
               'Password:' + str(self.Password) + ', ' + \
               'EncryptionAlgorithm:' + str(self.EncryptionAlgorithm) + ')'

    __repr__ = __str__


class X509IdentityToken(FrozenClass):

    __repr__ = __str__


class ChannelSecurityToken(FrozenClass):
    '''
    The token that identifies a set of keys for an active secure channel.

    :ivar ChannelId:
    :vartype ChannelId: UInt32
    :ivar TokenId:
    :vartype TokenId: UInt32
    :ivar CreatedAt:
    :vartype CreatedAt: DateTime
    :ivar RevisedLifetime:
    :vartype RevisedLifetime: UInt32
    '''

    ua_types = {
        'ChannelId': 'UInt32',
        'TokenId': 'UInt32',
        'CreatedAt': 'DateTime',
        'RevisedLifetime': 'UInt32',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.ChannelId = 0
        self.TokenId = 0
        self.CreatedAt = datetime.now()
        self.RevisedLifetime = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.ChannelId))
        packet.append(uabin.Primitives.UInt32.pack(self.TokenId))
        packet.append(uabin.Primitives.DateTime.pack(self.CreatedAt))
        packet.append(uabin.Primitives.UInt32.pack(self.RevisedLifetime))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.ChannelId = uabin.Primitives.UInt32.unpack(data)
        self.TokenId = uabin.Primitives.UInt32.unpack(data)
        self.CreatedAt = uabin.Primitives.DateTime.unpack(data)
        self.RevisedLifetime = uabin.Primitives.UInt32.unpack(data)

    def __str__(self):
        return 'ChannelSecurityToken(' + 'ChannelId:' + str(self.ChannelId) + ', ' + \
               'TokenId:' + str(self.TokenId) + ', ' + \
               'CreatedAt:' + str(self.CreatedAt) + ', ' + \
               'RevisedLifetime:' + str(self.RevisedLifetime) + ')'

    __repr__ = __str__


class OpenSecureChannelParameters(FrozenClass):

    __repr__ = __str__


class SamplingIntervalDiagnosticsDataType(FrozenClass):
    '''
    :ivar SamplingInterval:
    :vartype SamplingInterval: Double
    :ivar MonitoredItemCount:
    :vartype MonitoredItemCount: UInt32
    :ivar MaxMonitoredItemCount:
    :vartype MaxMonitoredItemCount: UInt32
    :ivar DisabledMonitoredItemCount:
    :vartype DisabledMonitoredItemCount: UInt32
    '''

    ua_types = {
        'SamplingInterval': 'Double',
        'MonitoredItemCount': 'UInt32',
        'MaxMonitoredItemCount': 'UInt32',
        'DisabledMonitoredItemCount': 'UInt32',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SamplingInterval = 0
        self.MonitoredItemCount = 0
        self.MaxMonitoredItemCount = 0
        self.DisabledMonitoredItemCount = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Double.pack(self.SamplingInterval))
        packet.append(uabin.Primitives.UInt32.pack(self.MonitoredItemCount))
        packet.append(uabin.Primitives.UInt32.pack(self.MaxMonitoredItemCount))
        packet.append(uabin.Primitives.UInt32.pack(self.DisabledMonitoredItemCount))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.SamplingInterval = uabin.Primitives.Double.unpack(data)
        self.MonitoredItemCount = uabin.Primitives.UInt32.unpack(data)
        self.MaxMonitoredItemCount = uabin.Primitives.UInt32.unpack(data)
        self.DisabledMonitoredItemCount = uabin.Primitives.UInt32.unpack(data)

    def __str__(self):
        return 'SamplingIntervalDiagnosticsDataType(' + 'SamplingInterval:' + str(self.SamplingInterval) + ', ' + \
               'MonitoredItemCount:' + str(self.MonitoredItemCount) + ', ' + \
               'MaxMonitoredItemCount:' + str(self.MaxMonitoredItemCount) + ', ' + \
               'DisabledMonitoredItemCount:' + str(self.DisabledMonitoredItemCount) + ')'

    __repr__ = __str__


class ServerDiagnosticsSummaryDataType(FrozenClass):

    __repr__ = __str__


class CreateSubscriptionResult(FrozenClass):
    '''
    :ivar SubscriptionId:
    :vartype SubscriptionId: UInt32
    :ivar RevisedPublishingInterval:
    :vartype RevisedPublishingInterval: Double
    :ivar RevisedLifetimeCount:
    :vartype RevisedLifetimeCount: UInt32
    :ivar RevisedMaxKeepAliveCount:
    :vartype RevisedMaxKeepAliveCount: UInt32
    '''

    ua_types = {
        'SubscriptionId': 'UInt32',
        'RevisedPublishingInterval': 'Double',
        'RevisedLifetimeCount': 'UInt32',
        'RevisedMaxKeepAliveCount': 'UInt32',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SubscriptionId = 0
        self.RevisedPublishingInterval = 0
        self.RevisedLifetimeCount = 0
        self.RevisedMaxKeepAliveCount = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.SubscriptionId))
        packet.append(uabin.Primitives.Double.pack(self.RevisedPublishingInterval))
        packet.append(uabin.Primitives.UInt32.pack(self.RevisedLifetimeCount))
        packet.append(uabin.Primitives.UInt32.pack(self.RevisedMaxKeepAliveCount))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)
        self.RevisedPublishingInterval = uabin.Primitives.Double.unpack(data)
        self.RevisedLifetimeCount = uabin.Primitives.UInt32.unpack(data)
        self.RevisedMaxKeepAliveCount = uabin.Primitives.UInt32.unpack(data)

    def __str__(self):
        return 'CreateSubscriptionResult(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \
               'RevisedPublishingInterval:' + str(self.RevisedPublishingInterval) + ', ' + \
               'RevisedLifetimeCount:' + str(self.RevisedLifetimeCount) + ', ' + \
               'RevisedMaxKeepAliveCount:' + str(self.RevisedMaxKeepAliveCount) + ')'

    __repr__ = __str__


class CreateSubscriptionResponse(FrozenClass):

		@@ 12070-12128 (lines=59) @@
12067		__repr__ = __str__
12068
12069
12070		class SetTriggeringParameters(FrozenClass):
12071		'''
12072		:ivar SubscriptionId:
12073		:vartype SubscriptionId: UInt32
12074		:ivar TriggeringItemId:
12075		:vartype TriggeringItemId: UInt32
12076		:ivar LinksToAdd:
12077		:vartype LinksToAdd: UInt32
12078		:ivar LinksToRemove:
12079		:vartype LinksToRemove: UInt32
12080		'''
12081
12082		ua_types = {
12083		'SubscriptionId': 'UInt32',
12084		'TriggeringItemId': 'UInt32',
12085		'LinksToAdd': 'UInt32',
12086		'LinksToRemove': 'UInt32',
12087		}
12088
12089		def __init__(self, binary=None):
12090		if binary is not None:
12091		self._binary_init(binary)
12092		self._freeze = True
12093		return
12094		self.SubscriptionId = 0
12095		self.TriggeringItemId = 0
12096		self.LinksToAdd = []
12097		self.LinksToRemove = []
12098		self._freeze = True
12099
12100		def to_binary(self):
12101		packet = []
12102		packet.append(uabin.Primitives.UInt32.pack(self.SubscriptionId))
12103		packet.append(uabin.Primitives.UInt32.pack(self.TriggeringItemId))
12104		packet.append(uabin.Primitives.Int32.pack(len(self.LinksToAdd)))
12105		for fieldname in self.LinksToAdd:
12106		packet.append(uabin.Primitives.UInt32.pack(fieldname))
12107		packet.append(uabin.Primitives.Int32.pack(len(self.LinksToRemove)))
12108		for fieldname in self.LinksToRemove:
12109		packet.append(uabin.Primitives.UInt32.pack(fieldname))
12110		return b''.join(packet)
12111
12112		@staticmethod
12113		def from_binary(data):
12114		return SetTriggeringParameters(data)
12115
12116		def _binary_init(self, data):
12117		self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)
12118		self.TriggeringItemId = uabin.Primitives.UInt32.unpack(data)
12119		self.LinksToAdd = uabin.Primitives.UInt32.unpack_array(data)
12120		self.LinksToRemove = uabin.Primitives.UInt32.unpack_array(data)
12121
12122		def __str__(self):
12123		return 'SetTriggeringParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \
12124		'TriggeringItemId:' + str(self.TriggeringItemId) + ', ' + \
12125		'LinksToAdd:' + str(self.LinksToAdd) + ', ' + \
12126		'LinksToRemove:' + str(self.LinksToRemove) + ')'
12127
12128		__repr__ = __str__
12129
12130
12131		class SetTriggeringRequest(FrozenClass):
		@@ 1600-1656 (lines=57) @@
1597		__repr__ = __str__
1598
1599
1600		class ServerOnNetwork(FrozenClass):
1601		'''
1602		:ivar RecordId:
1603		:vartype RecordId: UInt32
1604		:ivar ServerName:
1605		:vartype ServerName: String
1606		:ivar DiscoveryUrl:
1607		:vartype DiscoveryUrl: String
1608		:ivar ServerCapabilities:
1609		:vartype ServerCapabilities: String
1610		'''
1611
1612		ua_types = {
1613		'RecordId': 'UInt32',
1614		'ServerName': 'String',
1615		'DiscoveryUrl': 'String',
1616		'ServerCapabilities': 'String',
1617		}
1618
1619		def __init__(self, binary=None):
1620		if binary is not None:
1621		self._binary_init(binary)
1622		self._freeze = True
1623		return
1624		self.RecordId = 0
1625		self.ServerName = None
1626		self.DiscoveryUrl = None
1627		self.ServerCapabilities = []
1628		self._freeze = True
1629
1630		def to_binary(self):
1631		packet = []
1632		packet.append(uabin.Primitives.UInt32.pack(self.RecordId))
1633		packet.append(uabin.Primitives.String.pack(self.ServerName))
1634		packet.append(uabin.Primitives.String.pack(self.DiscoveryUrl))
1635		packet.append(uabin.Primitives.Int32.pack(len(self.ServerCapabilities)))
1636		for fieldname in self.ServerCapabilities:
1637		packet.append(uabin.Primitives.String.pack(fieldname))
1638		return b''.join(packet)
1639
1640		@staticmethod
1641		def from_binary(data):
1642		return ServerOnNetwork(data)
1643
1644		def _binary_init(self, data):
1645		self.RecordId = uabin.Primitives.UInt32.unpack(data)
1646		self.ServerName = uabin.Primitives.String.unpack(data)
1647		self.DiscoveryUrl = uabin.Primitives.String.unpack(data)
1648		self.ServerCapabilities = uabin.Primitives.String.unpack_array(data)
1649
1650		def __str__(self):
1651		return 'ServerOnNetwork(' + 'RecordId:' + str(self.RecordId) + ', ' + \
1652		'ServerName:' + str(self.ServerName) + ', ' + \
1653		'DiscoveryUrl:' + str(self.DiscoveryUrl) + ', ' + \
1654		'ServerCapabilities:' + str(self.ServerCapabilities) + ')'
1655
1656		__repr__ = __str__
1657
1658
1659		class FindServersOnNetworkParameters(FrozenClass):
		@@ 3458-3514 (lines=57) @@
3455		__repr__ = __str__
3456
3457
3458		class UserNameIdentityToken(FrozenClass):
3459		'''
3460		A token representing a user identified by a user name and password.
3461
3462		:ivar PolicyId:
3463		:vartype PolicyId: String
3464		:ivar UserName:
3465		:vartype UserName: String
3466		:ivar Password:
3467		:vartype Password: ByteString
3468		:ivar EncryptionAlgorithm:
3469		:vartype EncryptionAlgorithm: String
3470		'''
3471
3472		ua_types = {
3473		'PolicyId': 'String',
3474		'UserName': 'String',
3475		'Password': 'ByteString',
3476		'EncryptionAlgorithm': 'String',
3477		}
3478
3479		def __init__(self, binary=None):
3480		if binary is not None:
3481		self._binary_init(binary)
3482		self._freeze = True
3483		return
3484		self.PolicyId = None
3485		self.UserName = None
3486		self.Password = None
3487		self.EncryptionAlgorithm = None
3488		self._freeze = True
3489
3490		def to_binary(self):
3491		packet = []
3492		packet.append(uabin.Primitives.String.pack(self.PolicyId))
3493		packet.append(uabin.Primitives.String.pack(self.UserName))
3494		packet.append(uabin.Primitives.ByteString.pack(self.Password))
3495		packet.append(uabin.Primitives.String.pack(self.EncryptionAlgorithm))
3496		return b''.join(packet)
3497
3498		@staticmethod
3499		def from_binary(data):
3500		return UserNameIdentityToken(data)
3501
3502		def _binary_init(self, data):
3503		self.PolicyId = uabin.Primitives.String.unpack(data)
3504		self.UserName = uabin.Primitives.String.unpack(data)
3505		self.Password = uabin.Primitives.ByteString.unpack(data)
3506		self.EncryptionAlgorithm = uabin.Primitives.String.unpack(data)
3507
3508		def __str__(self):
3509		return 'UserNameIdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \
3510		'UserName:' + str(self.UserName) + ', ' + \
3511		'Password:' + str(self.Password) + ', ' + \
3512		'EncryptionAlgorithm:' + str(self.EncryptionAlgorithm) + ')'
3513
3514		__repr__ = __str__
3515
3516
3517		class X509IdentityToken(FrozenClass):
		@@ 2630-2686 (lines=57) @@
2627		__repr__ = __str__
2628
2629
2630		class ChannelSecurityToken(FrozenClass):
2631		'''
2632		The token that identifies a set of keys for an active secure channel.
2633
2634		:ivar ChannelId:
2635		:vartype ChannelId: UInt32
2636		:ivar TokenId:
2637		:vartype TokenId: UInt32
2638		:ivar CreatedAt:
2639		:vartype CreatedAt: DateTime
2640		:ivar RevisedLifetime:
2641		:vartype RevisedLifetime: UInt32
2642		'''
2643
2644		ua_types = {
2645		'ChannelId': 'UInt32',
2646		'TokenId': 'UInt32',
2647		'CreatedAt': 'DateTime',
2648		'RevisedLifetime': 'UInt32',
2649		}
2650
2651		def __init__(self, binary=None):
2652		if binary is not None:
2653		self._binary_init(binary)
2654		self._freeze = True
2655		return
2656		self.ChannelId = 0
2657		self.TokenId = 0
2658		self.CreatedAt = datetime.now()
2659		self.RevisedLifetime = 0
2660		self._freeze = True
2661
2662		def to_binary(self):
2663		packet = []
2664		packet.append(uabin.Primitives.UInt32.pack(self.ChannelId))
2665		packet.append(uabin.Primitives.UInt32.pack(self.TokenId))
2666		packet.append(uabin.Primitives.DateTime.pack(self.CreatedAt))
2667		packet.append(uabin.Primitives.UInt32.pack(self.RevisedLifetime))
2668		return b''.join(packet)
2669
2670		@staticmethod
2671		def from_binary(data):
2672		return ChannelSecurityToken(data)
2673
2674		def _binary_init(self, data):
2675		self.ChannelId = uabin.Primitives.UInt32.unpack(data)
2676		self.TokenId = uabin.Primitives.UInt32.unpack(data)
2677		self.CreatedAt = uabin.Primitives.DateTime.unpack(data)
2678		self.RevisedLifetime = uabin.Primitives.UInt32.unpack(data)
2679
2680		def __str__(self):
2681		return 'ChannelSecurityToken(' + 'ChannelId:' + str(self.ChannelId) + ', ' + \
2682		'TokenId:' + str(self.TokenId) + ', ' + \
2683		'CreatedAt:' + str(self.CreatedAt) + ', ' + \
2684		'RevisedLifetime:' + str(self.RevisedLifetime) + ')'
2685
2686		__repr__ = __str__
2687
2688
2689		class OpenSecureChannelParameters(FrozenClass):
		@@ 14531-14585 (lines=55) @@
14528		__repr__ = __str__
14529
14530
14531		class SamplingIntervalDiagnosticsDataType(FrozenClass):
14532		'''
14533		:ivar SamplingInterval:
14534		:vartype SamplingInterval: Double
14535		:ivar MonitoredItemCount:
14536		:vartype MonitoredItemCount: UInt32
14537		:ivar MaxMonitoredItemCount:
14538		:vartype MaxMonitoredItemCount: UInt32
14539		:ivar DisabledMonitoredItemCount:
14540		:vartype DisabledMonitoredItemCount: UInt32
14541		'''
14542
14543		ua_types = {
14544		'SamplingInterval': 'Double',
14545		'MonitoredItemCount': 'UInt32',
14546		'MaxMonitoredItemCount': 'UInt32',
14547		'DisabledMonitoredItemCount': 'UInt32',
14548		}
14549
14550		def __init__(self, binary=None):
14551		if binary is not None:
14552		self._binary_init(binary)
14553		self._freeze = True
14554		return
14555		self.SamplingInterval = 0
14556		self.MonitoredItemCount = 0
14557		self.MaxMonitoredItemCount = 0
14558		self.DisabledMonitoredItemCount = 0
14559		self._freeze = True
14560
14561		def to_binary(self):
14562		packet = []
14563		packet.append(uabin.Primitives.Double.pack(self.SamplingInterval))
14564		packet.append(uabin.Primitives.UInt32.pack(self.MonitoredItemCount))
14565		packet.append(uabin.Primitives.UInt32.pack(self.MaxMonitoredItemCount))
14566		packet.append(uabin.Primitives.UInt32.pack(self.DisabledMonitoredItemCount))
14567		return b''.join(packet)
14568
14569		@staticmethod
14570		def from_binary(data):
14571		return SamplingIntervalDiagnosticsDataType(data)
14572
14573		def _binary_init(self, data):
14574		self.SamplingInterval = uabin.Primitives.Double.unpack(data)
14575		self.MonitoredItemCount = uabin.Primitives.UInt32.unpack(data)
14576		self.MaxMonitoredItemCount = uabin.Primitives.UInt32.unpack(data)
14577		self.DisabledMonitoredItemCount = uabin.Primitives.UInt32.unpack(data)
14578
14579		def __str__(self):
14580		return 'SamplingIntervalDiagnosticsDataType(' + 'SamplingInterval:' + str(self.SamplingInterval) + ', ' + \
14581		'MonitoredItemCount:' + str(self.MonitoredItemCount) + ', ' + \
14582		'MaxMonitoredItemCount:' + str(self.MaxMonitoredItemCount) + ', ' + \
14583		'DisabledMonitoredItemCount:' + str(self.DisabledMonitoredItemCount) + ')'
14584
14585		__repr__ = __str__
14586
14587
14588		class ServerDiagnosticsSummaryDataType(FrozenClass):
		@@ 12603-12657 (lines=55) @@
12600		__repr__ = __str__
12601
12602
12603		class CreateSubscriptionResult(FrozenClass):
12604		'''
12605		:ivar SubscriptionId:
12606		:vartype SubscriptionId: UInt32
12607		:ivar RevisedPublishingInterval:
12608		:vartype RevisedPublishingInterval: Double
12609		:ivar RevisedLifetimeCount:
12610		:vartype RevisedLifetimeCount: UInt32
12611		:ivar RevisedMaxKeepAliveCount:
12612		:vartype RevisedMaxKeepAliveCount: UInt32
12613		'''
12614
12615		ua_types = {
12616		'SubscriptionId': 'UInt32',
12617		'RevisedPublishingInterval': 'Double',
12618		'RevisedLifetimeCount': 'UInt32',
12619		'RevisedMaxKeepAliveCount': 'UInt32',
12620		}
12621
12622		def __init__(self, binary=None):
12623		if binary is not None:
12624		self._binary_init(binary)
12625		self._freeze = True
12626		return
12627		self.SubscriptionId = 0
12628		self.RevisedPublishingInterval = 0
12629		self.RevisedLifetimeCount = 0
12630		self.RevisedMaxKeepAliveCount = 0
12631		self._freeze = True
12632
12633		def to_binary(self):
12634		packet = []
12635		packet.append(uabin.Primitives.UInt32.pack(self.SubscriptionId))
12636		packet.append(uabin.Primitives.Double.pack(self.RevisedPublishingInterval))
12637		packet.append(uabin.Primitives.UInt32.pack(self.RevisedLifetimeCount))
12638		packet.append(uabin.Primitives.UInt32.pack(self.RevisedMaxKeepAliveCount))
12639		return b''.join(packet)
12640
12641		@staticmethod
12642		def from_binary(data):
12643		return CreateSubscriptionResult(data)
12644
12645		def _binary_init(self, data):
12646		self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)
12647		self.RevisedPublishingInterval = uabin.Primitives.Double.unpack(data)
12648		self.RevisedLifetimeCount = uabin.Primitives.UInt32.unpack(data)
12649		self.RevisedMaxKeepAliveCount = uabin.Primitives.UInt32.unpack(data)
12650
12651		def __str__(self):
12652		return 'CreateSubscriptionResult(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \
12653		'RevisedPublishingInterval:' + str(self.RevisedPublishingInterval) + ', ' + \
12654		'RevisedLifetimeCount:' + str(self.RevisedLifetimeCount) + ', ' + \
12655		'RevisedMaxKeepAliveCount:' + str(self.RevisedMaxKeepAliveCount) + ')'
12656
12657		__repr__ = __str__
12658
12659
12660		class CreateSubscriptionResponse(FrozenClass):

FreeOpcUa / python-opcua

Code Duplication Length = 55-59 lines in 6 locations

opcua/ua/uaprotocol_auto.py 6 locations