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

Code Duplication Length = 37-39 lines in 15 locations

opcua/ua/uaprotocol_auto.py 15 locations


    __repr__ = __str__


class X509IdentityToken(FrozenClass):
    '''
    A token representing a user identified by an X509 certificate.

    :ivar PolicyId:
    :vartype PolicyId: String
    :ivar CertificateData:
    :vartype CertificateData: ByteString
    '''

    ua_types = [

        ('PolicyId', 'String'),
        ('CertificateData', 'ByteString'),
               ]

    def __init__(self):
        self.PolicyId = None
        self.CertificateData = None
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = X509IdentityToken()
        self.PolicyId = uabin.Primitives.String.unpack(data)
        self.CertificateData = uabin.Primitives.ByteString.unpack(data)
        return obj

    def __str__(self):
        return 'X509IdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \
               'CertificateData:' + str(self.CertificateData) + ')'

    __repr__ = __str__


class KerberosIdentityToken(FrozenClass):

    __repr__ = __str__


class SignatureData(FrozenClass):
    '''
    A digital signature.

    :ivar Algorithm:
    :vartype Algorithm: String
    :ivar Signature:
    :vartype Signature: ByteString
    '''

    ua_types = [

        ('Algorithm', 'String'),
        ('Signature', 'ByteString'),
               ]

    def __init__(self):
        self.Algorithm = None
        self.Signature = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.String.pack(self.Algorithm))
        packet.append(uabin.Primitives.ByteString.pack(self.Signature))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = SignatureData()
        self.Algorithm = uabin.Primitives.String.unpack(data)
        self.Signature = uabin.Primitives.ByteString.unpack(data)
        return obj

    def __str__(self):
        return 'SignatureData(' + 'Algorithm:' + str(self.Algorithm) + ', ' + \
               'Signature:' + str(self.Signature) + ')'

    __repr__ = __str__


class CreateSessionParameters(FrozenClass):

    __repr__ = __str__


class SignedSoftwareCertificate(FrozenClass):
    '''
    A software certificate with a digital signature.

    :ivar CertificateData:
    :vartype CertificateData: ByteString
    :ivar Signature:
    :vartype Signature: ByteString
    '''

    ua_types = [

        ('CertificateData', 'ByteString'),
        ('Signature', 'ByteString'),
               ]

    def __init__(self):
        self.CertificateData = None
        self.Signature = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.ByteString.pack(self.CertificateData))
        packet.append(uabin.Primitives.ByteString.pack(self.Signature))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = SignedSoftwareCertificate()
        self.CertificateData = uabin.Primitives.ByteString.unpack(data)
        self.Signature = uabin.Primitives.ByteString.unpack(data)
        return obj

    def __str__(self):
        return 'SignedSoftwareCertificate(' + 'CertificateData:' + str(self.CertificateData) + ', ' + \
               'Signature:' + str(self.Signature) + ')'

    __repr__ = __str__


class SignatureData(FrozenClass):

    __repr__ = __str__


class OptionSet(FrozenClass):
    '''
    This abstract Structured DataType is the base DataType for all DataTypes representing a bit mask.

    :ivar Value:
    :vartype Value: ByteString
    :ivar ValidBits:
    :vartype ValidBits: ByteString
    '''

    ua_types = [

        ('Value', 'ByteString'),
        ('ValidBits', 'ByteString'),
               ]

    def __init__(self):
        self.Value = None
        self.ValidBits = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.ByteString.pack(self.Value))
        packet.append(uabin.Primitives.ByteString.pack(self.ValidBits))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = OptionSet()
        self.Value = uabin.Primitives.ByteString.unpack(data)
        self.ValidBits = uabin.Primitives.ByteString.unpack(data)
        return obj

    def __str__(self):
        return 'OptionSet(' + 'Value:' + str(self.Value) + ', ' + \
               'ValidBits:' + str(self.ValidBits) + ')'

    __repr__ = __str__


class Union(FrozenClass):

    __repr__ = __str__


class XVType(FrozenClass):
    '''
    :ivar X:
    :vartype X: Double
    :ivar Value:
    :vartype Value: Float
    '''

    ua_types = [

        ('X', 'Double'),
        ('Value', 'Float'),
               ]

    def __init__(self):
        self.X = 0
        self.Value = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Double.pack(self.X))
        packet.append(uabin.Primitives.Float.pack(self.Value))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = XVType()
        self.X = uabin.Primitives.Double.unpack(data)
        self.Value = uabin.Primitives.Float.unpack(data)
        return obj

    def __str__(self):
        return 'XVType(' + 'X:' + str(self.X) + ', ' + \
               'Value:' + str(self.Value) + ')'

    __repr__ = __str__


class ProgramDiagnosticDataType(FrozenClass):

    __repr__ = __str__


class DoubleComplexNumberType(FrozenClass):
    '''
    :ivar Real:
    :vartype Real: Double
    :ivar Imaginary:
    :vartype Imaginary: Double
    '''

    ua_types = [

        ('Real', 'Double'),
        ('Imaginary', 'Double'),
               ]

    def __init__(self):
        self.Real = 0
        self.Imaginary = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Double.pack(self.Real))
        packet.append(uabin.Primitives.Double.pack(self.Imaginary))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = DoubleComplexNumberType()
        self.Real = uabin.Primitives.Double.unpack(data)
        self.Imaginary = uabin.Primitives.Double.unpack(data)
        return obj

    def __str__(self):
        return 'DoubleComplexNumberType(' + 'Real:' + str(self.Real) + ', ' + \
               'Imaginary:' + str(self.Imaginary) + ')'

    __repr__ = __str__


class AxisInformation(FrozenClass):

    __repr__ = __str__


class ComplexNumberType(FrozenClass):
    '''
    :ivar Real:
    :vartype Real: Float
    :ivar Imaginary:
    :vartype Imaginary: Float
    '''

    ua_types = [

        ('Real', 'Float'),
        ('Imaginary', 'Float'),
               ]

    def __init__(self):
        self.Real = 0
        self.Imaginary = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Float.pack(self.Real))
        packet.append(uabin.Primitives.Float.pack(self.Imaginary))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = ComplexNumberType()
        self.Real = uabin.Primitives.Float.unpack(data)
        self.Imaginary = uabin.Primitives.Float.unpack(data)
        return obj

    def __str__(self):
        return 'ComplexNumberType(' + 'Real:' + str(self.Real) + ', ' + \
               'Imaginary:' + str(self.Imaginary) + ')'

    __repr__ = __str__


class DoubleComplexNumberType(FrozenClass):

    __repr__ = __str__


class Range(FrozenClass):
    '''
    :ivar Low:
    :vartype Low: Double
    :ivar High:
    :vartype High: Double
    '''

    ua_types = [

        ('Low', 'Double'),
        ('High', 'Double'),
               ]

    def __init__(self):
        self.Low = 0
        self.High = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Double.pack(self.Low))
        packet.append(uabin.Primitives.Double.pack(self.High))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = Range()
        self.Low = uabin.Primitives.Double.unpack(data)
        self.High = uabin.Primitives.Double.unpack(data)
        return obj

    def __str__(self):
        return 'Range(' + 'Low:' + str(self.Low) + ', ' + \
               'High:' + str(self.High) + ')'

    __repr__ = __str__


class EUInformation(FrozenClass):

    __repr__ = __str__


class ServiceCounterDataType(FrozenClass):
    '''
    :ivar TotalCount:
    :vartype TotalCount: UInt32
    :ivar ErrorCount:
    :vartype ErrorCount: UInt32
    '''

    ua_types = [

        ('TotalCount', 'UInt32'),
        ('ErrorCount', 'UInt32'),
               ]

    def __init__(self):
        self.TotalCount = 0
        self.ErrorCount = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.TotalCount))
        packet.append(uabin.Primitives.UInt32.pack(self.ErrorCount))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = ServiceCounterDataType()
        self.TotalCount = uabin.Primitives.UInt32.unpack(data)
        self.ErrorCount = uabin.Primitives.UInt32.unpack(data)
        return obj

    def __str__(self):
        return 'ServiceCounterDataType(' + 'TotalCount:' + str(self.TotalCount) + ', ' + \
               'ErrorCount:' + str(self.ErrorCount) + ')'

    __repr__ = __str__


class StatusResult(FrozenClass):

    __repr__ = __str__


class RepublishParameters(FrozenClass):
    '''
    :ivar SubscriptionId:
    :vartype SubscriptionId: UInt32
    :ivar RetransmitSequenceNumber:
    :vartype RetransmitSequenceNumber: UInt32
    '''

    ua_types = [

        ('SubscriptionId', 'UInt32'),
        ('RetransmitSequenceNumber', 'UInt32'),
               ]

    def __init__(self):
        self.SubscriptionId = 0
        self.RetransmitSequenceNumber = 0
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = RepublishParameters()
        self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)
        self.RetransmitSequenceNumber = uabin.Primitives.UInt32.unpack(data)
        return obj

    def __str__(self):
        return 'RepublishParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \
               'RetransmitSequenceNumber:' + str(self.RetransmitSequenceNumber) + ')'

    __repr__ = __str__


class RepublishRequest(FrozenClass):

    __repr__ = __str__


class SubscriptionAcknowledgement(FrozenClass):
    '''
    :ivar SubscriptionId:
    :vartype SubscriptionId: UInt32
    :ivar SequenceNumber:
    :vartype SequenceNumber: UInt32
    '''

    ua_types = [

        ('SubscriptionId', 'UInt32'),
        ('SequenceNumber', 'UInt32'),
               ]

    def __init__(self):
        self.SubscriptionId = 0
        self.SequenceNumber = 0
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = SubscriptionAcknowledgement()
        self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)
        self.SequenceNumber = uabin.Primitives.UInt32.unpack(data)
        return obj

    def __str__(self):
        return 'SubscriptionAcknowledgement(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \
               'SequenceNumber:' + str(self.SequenceNumber) + ')'

    __repr__ = __str__


class PublishParameters(FrozenClass):

    __repr__ = __str__


class MonitoredItemNotification(FrozenClass):
    '''
    :ivar ClientHandle:
    :vartype ClientHandle: UInt32
    :ivar Value:
    :vartype Value: DataValue
    '''

    ua_types = [

        ('ClientHandle', 'UInt32'),
        ('Value', 'DataValue'),
               ]

    def __init__(self):
        self.ClientHandle = 0
        self.Value = DataValue()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.ClientHandle))
        packet.append(self.Value.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = MonitoredItemNotification()
        self.ClientHandle = uabin.Primitives.UInt32.unpack(data)
        obj.Value = DataValue.from_binary(data)
        return obj

    def __str__(self):
        return 'MonitoredItemNotification(' + 'ClientHandle:' + str(self.ClientHandle) + ', ' + \
               'Value:' + str(self.Value) + ')'

    __repr__ = __str__


class EventNotificationList(FrozenClass):

    __repr__ = __str__


class QueryNextParameters(FrozenClass):
    '''
    :ivar ReleaseContinuationPoint:
    :vartype ReleaseContinuationPoint: Boolean
    :ivar ContinuationPoint:
    :vartype ContinuationPoint: ByteString
    '''

    ua_types = [

        ('ReleaseContinuationPoint', 'Boolean'),
        ('ContinuationPoint', 'ByteString'),
               ]

    def __init__(self):
        self.ReleaseContinuationPoint = True
        self.ContinuationPoint = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Boolean.pack(self.ReleaseContinuationPoint))
        packet.append(uabin.Primitives.ByteString.pack(self.ContinuationPoint))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = QueryNextParameters()
        self.ReleaseContinuationPoint = uabin.Primitives.Boolean.unpack(data)
        self.ContinuationPoint = uabin.Primitives.ByteString.unpack(data)
        return obj

    def __str__(self):
        return 'QueryNextParameters(' + 'ReleaseContinuationPoint:' + str(self.ReleaseContinuationPoint) + ', ' + \
               'ContinuationPoint:' + str(self.ContinuationPoint) + ')'

    __repr__ = __str__


class QueryNextRequest(FrozenClass):

    __repr__ = __str__


class KerberosIdentityToken(FrozenClass):
    '''
    :ivar PolicyId:
    :vartype PolicyId: String
    :ivar TicketData:
    :vartype TicketData: ByteString
    '''

    ua_types = [

        ('PolicyId', 'String'),
        ('TicketData', 'ByteString'),
               ]

    def __init__(self):
        self.PolicyId = None
        self.TicketData = None
        self._freeze = True

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

    @staticmethod
    def from_binary(data):
        obj = KerberosIdentityToken()
        self.PolicyId = uabin.Primitives.String.unpack(data)
        self.TicketData = uabin.Primitives.ByteString.unpack(data)
        return obj

    def __str__(self):
        return 'KerberosIdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \
               'TicketData:' + str(self.TicketData) + ')'

    __repr__ = __str__


class IssuedIdentityToken(FrozenClass):

    __repr__ = __str__


class TimeZoneDataType(FrozenClass):
    '''
    :ivar Offset:
    :vartype Offset: Int16
    :ivar DaylightSavingInOffset:
    :vartype DaylightSavingInOffset: Boolean
    '''

    ua_types = [

        ('Offset', 'Int16'),
        ('DaylightSavingInOffset', 'Boolean'),
               ]

    def __init__(self):
        self.Offset = 0
        self.DaylightSavingInOffset = True
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Int16.pack(self.Offset))
        packet.append(uabin.Primitives.Boolean.pack(self.DaylightSavingInOffset))
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        obj = TimeZoneDataType()
        self.Offset = uabin.Primitives.Int16.unpack(data)
        self.DaylightSavingInOffset = uabin.Primitives.Boolean.unpack(data)
        return obj

    def __str__(self):
        return 'TimeZoneDataType(' + 'Offset:' + str(self.Offset) + ', ' + \
               'DaylightSavingInOffset:' + str(self.DaylightSavingInOffset) + ')'

    __repr__ = __str__


class ApplicationDescription(FrozenClass):

		@@ 3549-3587 (lines=39) @@
3546		__repr__ = __str__
3547
3548
3549		class X509IdentityToken(FrozenClass):
3550		'''
3551		A token representing a user identified by an X509 certificate.
3552
3553		:ivar PolicyId:
3554		:vartype PolicyId: String
3555		:ivar CertificateData:
3556		:vartype CertificateData: ByteString
3557		'''
3558
3559		ua_types = [
3560
3561		('PolicyId', 'String'),
3562		('CertificateData', 'ByteString'),
3563		]
3564
3565		def __init__(self):
3566		self.PolicyId = None
3567		self.CertificateData = None
3568		self._freeze = True
3569
3570		def to_binary(self):
3571		packet = []
3572		packet.append(uabin.Primitives.String.pack(self.PolicyId))
3573		packet.append(uabin.Primitives.ByteString.pack(self.CertificateData))
3574		return b''.join(packet)
3575
3576		@staticmethod
3577		def from_binary(data):
3578		obj = X509IdentityToken()
3579		self.PolicyId = uabin.Primitives.String.unpack(data)
3580		self.CertificateData = uabin.Primitives.ByteString.unpack(data)
3581		return obj
3582
3583		def __str__(self):
3584		return 'X509IdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \
3585		'CertificateData:' + str(self.CertificateData) + ')'
3586
3587		__repr__ = __str__
3588
3589
3590		class KerberosIdentityToken(FrozenClass):
		@@ 3106-3144 (lines=39) @@
3103		__repr__ = __str__
3104
3105
3106		class SignatureData(FrozenClass):
3107		'''
3108		A digital signature.
3109
3110		:ivar Algorithm:
3111		:vartype Algorithm: String
3112		:ivar Signature:
3113		:vartype Signature: ByteString
3114		'''
3115
3116		ua_types = [
3117
3118		('Algorithm', 'String'),
3119		('Signature', 'ByteString'),
3120		]
3121
3122		def __init__(self):
3123		self.Algorithm = None
3124		self.Signature = None
3125		self._freeze = True
3126
3127		def to_binary(self):
3128		packet = []
3129		packet.append(uabin.Primitives.String.pack(self.Algorithm))
3130		packet.append(uabin.Primitives.ByteString.pack(self.Signature))
3131		return b''.join(packet)
3132
3133		@staticmethod
3134		def from_binary(data):
3135		obj = SignatureData()
3136		self.Algorithm = uabin.Primitives.String.unpack(data)
3137		self.Signature = uabin.Primitives.ByteString.unpack(data)
3138		return obj
3139
3140		def __str__(self):
3141		return 'SignatureData(' + 'Algorithm:' + str(self.Algorithm) + ', ' + \
3142		'Signature:' + str(self.Signature) + ')'
3143
3144		__repr__ = __str__
3145
3146
3147		class CreateSessionParameters(FrozenClass):
		@@ 3065-3103 (lines=39) @@
3062		__repr__ = __str__
3063
3064
3065		class SignedSoftwareCertificate(FrozenClass):
3066		'''
3067		A software certificate with a digital signature.
3068
3069		:ivar CertificateData:
3070		:vartype CertificateData: ByteString
3071		:ivar Signature:
3072		:vartype Signature: ByteString
3073		'''
3074
3075		ua_types = [
3076
3077		('CertificateData', 'ByteString'),
3078		('Signature', 'ByteString'),
3079		]
3080
3081		def __init__(self):
3082		self.CertificateData = None
3083		self.Signature = None
3084		self._freeze = True
3085
3086		def to_binary(self):
3087		packet = []
3088		packet.append(uabin.Primitives.ByteString.pack(self.CertificateData))
3089		packet.append(uabin.Primitives.ByteString.pack(self.Signature))
3090		return b''.join(packet)
3091
3092		@staticmethod
3093		def from_binary(data):
3094		obj = SignedSoftwareCertificate()
3095		self.CertificateData = uabin.Primitives.ByteString.unpack(data)
3096		self.Signature = uabin.Primitives.ByteString.unpack(data)
3097		return obj
3098
3099		def __str__(self):
3100		return 'SignedSoftwareCertificate(' + 'CertificateData:' + str(self.CertificateData) + ', ' + \
3101		'Signature:' + str(self.Signature) + ')'
3102
3103		__repr__ = __str__
3104
3105
3106		class SignatureData(FrozenClass):
		@@ 1242-1280 (lines=39) @@
1239		__repr__ = __str__
1240
1241
1242		class OptionSet(FrozenClass):
1243		'''
1244		This abstract Structured DataType is the base DataType for all DataTypes representing a bit mask.
1245
1246		:ivar Value:
1247		:vartype Value: ByteString
1248		:ivar ValidBits:
1249		:vartype ValidBits: ByteString
1250		'''
1251
1252		ua_types = [
1253
1254		('Value', 'ByteString'),
1255		('ValidBits', 'ByteString'),
1256		]
1257
1258		def __init__(self):
1259		self.Value = None
1260		self.ValidBits = None
1261		self._freeze = True
1262
1263		def to_binary(self):
1264		packet = []
1265		packet.append(uabin.Primitives.ByteString.pack(self.Value))
1266		packet.append(uabin.Primitives.ByteString.pack(self.ValidBits))
1267		return b''.join(packet)
1268
1269		@staticmethod
1270		def from_binary(data):
1271		obj = OptionSet()
1272		self.Value = uabin.Primitives.ByteString.unpack(data)
1273		self.ValidBits = uabin.Primitives.ByteString.unpack(data)
1274		return obj
1275
1276		def __str__(self):
1277		return 'OptionSet(' + 'Value:' + str(self.Value) + ', ' + \
1278		'ValidBits:' + str(self.ValidBits) + ')'
1279
1280		__repr__ = __str__
1281
1282
1283		class Union(FrozenClass):
		@@ 15087-15123 (lines=37) @@
15084		__repr__ = __str__
15085
15086
15087		class XVType(FrozenClass):
15088		'''
15089		:ivar X:
15090		:vartype X: Double
15091		:ivar Value:
15092		:vartype Value: Float
15093		'''
15094
15095		ua_types = [
15096
15097		('X', 'Double'),
15098		('Value', 'Float'),
15099		]
15100
15101		def __init__(self):
15102		self.X = 0
15103		self.Value = 0
15104		self._freeze = True
15105
15106		def to_binary(self):
15107		packet = []
15108		packet.append(uabin.Primitives.Double.pack(self.X))
15109		packet.append(uabin.Primitives.Float.pack(self.Value))
15110		return b''.join(packet)
15111
15112		@staticmethod
15113		def from_binary(data):
15114		obj = XVType()
15115		self.X = uabin.Primitives.Double.unpack(data)
15116		self.Value = uabin.Primitives.Float.unpack(data)
15117		return obj
15118
15119		def __str__(self):
15120		return 'XVType(' + 'X:' + str(self.X) + ', ' + \
15121		'Value:' + str(self.Value) + ')'
15122
15123		__repr__ = __str__
15124
15125
15126		class ProgramDiagnosticDataType(FrozenClass):
		@@ 14986-15022 (lines=37) @@
14983		__repr__ = __str__
14984
14985
14986		class DoubleComplexNumberType(FrozenClass):
14987		'''
14988		:ivar Real:
14989		:vartype Real: Double
14990		:ivar Imaginary:
14991		:vartype Imaginary: Double
14992		'''
14993
14994		ua_types = [
14995
14996		('Real', 'Double'),
14997		('Imaginary', 'Double'),
14998		]
14999
15000		def __init__(self):
15001		self.Real = 0
15002		self.Imaginary = 0
15003		self._freeze = True
15004
15005		def to_binary(self):
15006		packet = []
15007		packet.append(uabin.Primitives.Double.pack(self.Real))
15008		packet.append(uabin.Primitives.Double.pack(self.Imaginary))
15009		return b''.join(packet)
15010
15011		@staticmethod
15012		def from_binary(data):
15013		obj = DoubleComplexNumberType()
15014		self.Real = uabin.Primitives.Double.unpack(data)
15015		self.Imaginary = uabin.Primitives.Double.unpack(data)
15016		return obj
15017
15018		def __str__(self):
15019		return 'DoubleComplexNumberType(' + 'Real:' + str(self.Real) + ', ' + \
15020		'Imaginary:' + str(self.Imaginary) + ')'
15021
15022		__repr__ = __str__
15023
15024
15025		class AxisInformation(FrozenClass):
		@@ 14947-14983 (lines=37) @@
14944		__repr__ = __str__
14945
14946
14947		class ComplexNumberType(FrozenClass):
14948		'''
14949		:ivar Real:
14950		:vartype Real: Float
14951		:ivar Imaginary:
14952		:vartype Imaginary: Float
14953		'''
14954
14955		ua_types = [
14956
14957		('Real', 'Float'),
14958		('Imaginary', 'Float'),
14959		]
14960
14961		def __init__(self):
14962		self.Real = 0
14963		self.Imaginary = 0
14964		self._freeze = True
14965
14966		def to_binary(self):
14967		packet = []
14968		packet.append(uabin.Primitives.Float.pack(self.Real))
14969		packet.append(uabin.Primitives.Float.pack(self.Imaginary))
14970		return b''.join(packet)
14971
14972		@staticmethod
14973		def from_binary(data):
14974		obj = ComplexNumberType()
14975		self.Real = uabin.Primitives.Float.unpack(data)
14976		self.Imaginary = uabin.Primitives.Float.unpack(data)
14977		return obj
14978
14979		def __str__(self):
14980		return 'ComplexNumberType(' + 'Real:' + str(self.Real) + ', ' + \
14981		'Imaginary:' + str(self.Imaginary) + ')'
14982
14983		__repr__ = __str__
14984
14985
14986		class DoubleComplexNumberType(FrozenClass):
		@@ 14855-14891 (lines=37) @@
14852		__repr__ = __str__
14853
14854
14855		class Range(FrozenClass):
14856		'''
14857		:ivar Low:
14858		:vartype Low: Double
14859		:ivar High:
14860		:vartype High: Double
14861		'''
14862
14863		ua_types = [
14864
14865		('Low', 'Double'),
14866		('High', 'Double'),
14867		]
14868
14869		def __init__(self):
14870		self.Low = 0
14871		self.High = 0
14872		self._freeze = True
14873
14874		def to_binary(self):
14875		packet = []
14876		packet.append(uabin.Primitives.Double.pack(self.Low))
14877		packet.append(uabin.Primitives.Double.pack(self.High))
14878		return b''.join(packet)
14879
14880		@staticmethod
14881		def from_binary(data):
14882		obj = Range()
14883		self.Low = uabin.Primitives.Double.unpack(data)
14884		self.High = uabin.Primitives.Double.unpack(data)
14885		return obj
14886
14887		def __str__(self):
14888		return 'Range(' + 'Low:' + str(self.Low) + ', ' + \
14889		'High:' + str(self.High) + ')'
14890
14891		__repr__ = __str__
14892
14893
14894		class EUInformation(FrozenClass):
		@@ 14450-14486 (lines=37) @@
14447		__repr__ = __str__
14448
14449
14450		class ServiceCounterDataType(FrozenClass):
14451		'''
14452		:ivar TotalCount:
14453		:vartype TotalCount: UInt32
14454		:ivar ErrorCount:
14455		:vartype ErrorCount: UInt32
14456		'''
14457
14458		ua_types = [
14459
14460		('TotalCount', 'UInt32'),
14461		('ErrorCount', 'UInt32'),
14462		]
14463
14464		def __init__(self):
14465		self.TotalCount = 0
14466		self.ErrorCount = 0
14467		self._freeze = True
14468
14469		def to_binary(self):
14470		packet = []
14471		packet.append(uabin.Primitives.UInt32.pack(self.TotalCount))
14472		packet.append(uabin.Primitives.UInt32.pack(self.ErrorCount))
14473		return b''.join(packet)
14474
14475		@staticmethod
14476		def from_binary(data):
14477		obj = ServiceCounterDataType()
14478		self.TotalCount = uabin.Primitives.UInt32.unpack(data)
14479		self.ErrorCount = uabin.Primitives.UInt32.unpack(data)
14480		return obj
14481
14482		def __str__(self):
14483		return 'ServiceCounterDataType(' + 'TotalCount:' + str(self.TotalCount) + ', ' + \
14484		'ErrorCount:' + str(self.ErrorCount) + ')'
14485
14486		__repr__ = __str__
14487
14488
14489		class StatusResult(FrozenClass):
		@@ 13105-13141 (lines=37) @@
13102		__repr__ = __str__
13103
13104
13105		class RepublishParameters(FrozenClass):
13106		'''
13107		:ivar SubscriptionId:
13108		:vartype SubscriptionId: UInt32
13109		:ivar RetransmitSequenceNumber:
13110		:vartype RetransmitSequenceNumber: UInt32
13111		'''
13112
13113		ua_types = [
13114
13115		('SubscriptionId', 'UInt32'),
13116		('RetransmitSequenceNumber', 'UInt32'),
13117		]
13118
13119		def __init__(self):
13120		self.SubscriptionId = 0
13121		self.RetransmitSequenceNumber = 0
13122		self._freeze = True
13123
13124		def to_binary(self):
13125		packet = []
13126		packet.append(uabin.Primitives.UInt32.pack(self.SubscriptionId))
13127		packet.append(uabin.Primitives.UInt32.pack(self.RetransmitSequenceNumber))
13128		return b''.join(packet)
13129
13130		@staticmethod
13131		def from_binary(data):
13132		obj = RepublishParameters()
13133		self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)
13134		self.RetransmitSequenceNumber = uabin.Primitives.UInt32.unpack(data)
13135		return obj
13136
13137		def __str__(self):
13138		return 'RepublishParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \
13139		'RetransmitSequenceNumber:' + str(self.RetransmitSequenceNumber) + ')'
13140
13141		__repr__ = __str__
13142
13143
13144		class RepublishRequest(FrozenClass):
		@@ 12852-12888 (lines=37) @@
12849		__repr__ = __str__
12850
12851
12852		class SubscriptionAcknowledgement(FrozenClass):
12853		'''
12854		:ivar SubscriptionId:
12855		:vartype SubscriptionId: UInt32
12856		:ivar SequenceNumber:
12857		:vartype SequenceNumber: UInt32
12858		'''
12859
12860		ua_types = [
12861
12862		('SubscriptionId', 'UInt32'),
12863		('SequenceNumber', 'UInt32'),
12864		]
12865
12866		def __init__(self):
12867		self.SubscriptionId = 0
12868		self.SequenceNumber = 0
12869		self._freeze = True
12870
12871		def to_binary(self):
12872		packet = []
12873		packet.append(uabin.Primitives.UInt32.pack(self.SubscriptionId))
12874		packet.append(uabin.Primitives.UInt32.pack(self.SequenceNumber))
12875		return b''.join(packet)
12876
12877		@staticmethod
12878		def from_binary(data):
12879		obj = SubscriptionAcknowledgement()
12880		self.SubscriptionId = uabin.Primitives.UInt32.unpack(data)
12881		self.SequenceNumber = uabin.Primitives.UInt32.unpack(data)
12882		return obj
12883
12884		def __str__(self):
12885		return 'SubscriptionAcknowledgement(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \
12886		'SequenceNumber:' + str(self.SequenceNumber) + ')'
12887
12888		__repr__ = __str__
12889
12890
12891		class PublishParameters(FrozenClass):
		@@ 12650-12686 (lines=37) @@
12647		__repr__ = __str__
12648
12649
12650		class MonitoredItemNotification(FrozenClass):
12651		'''
12652		:ivar ClientHandle:
12653		:vartype ClientHandle: UInt32
12654		:ivar Value:
12655		:vartype Value: DataValue
12656		'''
12657
12658		ua_types = [
12659
12660		('ClientHandle', 'UInt32'),
12661		('Value', 'DataValue'),
12662		]
12663
12664		def __init__(self):
12665		self.ClientHandle = 0
12666		self.Value = DataValue()
12667		self._freeze = True
12668
12669		def to_binary(self):
12670		packet = []
12671		packet.append(uabin.Primitives.UInt32.pack(self.ClientHandle))
12672		packet.append(self.Value.to_binary())
12673		return b''.join(packet)
12674
12675		@staticmethod
12676		def from_binary(data):
12677		obj = MonitoredItemNotification()
12678		self.ClientHandle = uabin.Primitives.UInt32.unpack(data)
12679		obj.Value = DataValue.from_binary(data)
12680		return obj
12681
12682		def __str__(self):
12683		return 'MonitoredItemNotification(' + 'ClientHandle:' + str(self.ClientHandle) + ', ' + \
12684		'Value:' + str(self.Value) + ')'
12685
12686		__repr__ = __str__
12687
12688
12689		class EventNotificationList(FrozenClass):
		@@ 8264-8300 (lines=37) @@
8261		__repr__ = __str__
8262
8263
8264		class QueryNextParameters(FrozenClass):
8265		'''
8266		:ivar ReleaseContinuationPoint:
8267		:vartype ReleaseContinuationPoint: Boolean
8268		:ivar ContinuationPoint:
8269		:vartype ContinuationPoint: ByteString
8270		'''
8271
8272		ua_types = [
8273
8274		('ReleaseContinuationPoint', 'Boolean'),
8275		('ContinuationPoint', 'ByteString'),
8276		]
8277
8278		def __init__(self):
8279		self.ReleaseContinuationPoint = True
8280		self.ContinuationPoint = None
8281		self._freeze = True
8282
8283		def to_binary(self):
8284		packet = []
8285		packet.append(uabin.Primitives.Boolean.pack(self.ReleaseContinuationPoint))
8286		packet.append(uabin.Primitives.ByteString.pack(self.ContinuationPoint))
8287		return b''.join(packet)
8288
8289		@staticmethod
8290		def from_binary(data):
8291		obj = QueryNextParameters()
8292		self.ReleaseContinuationPoint = uabin.Primitives.Boolean.unpack(data)
8293		self.ContinuationPoint = uabin.Primitives.ByteString.unpack(data)
8294		return obj
8295
8296		def __str__(self):
8297		return 'QueryNextParameters(' + 'ReleaseContinuationPoint:' + str(self.ReleaseContinuationPoint) + ', ' + \
8298		'ContinuationPoint:' + str(self.ContinuationPoint) + ')'
8299
8300		__repr__ = __str__
8301
8302
8303		class QueryNextRequest(FrozenClass):
		@@ 3590-3626 (lines=37) @@
3587		__repr__ = __str__
3588
3589
3590		class KerberosIdentityToken(FrozenClass):
3591		'''
3592		:ivar PolicyId:
3593		:vartype PolicyId: String
3594		:ivar TicketData:
3595		:vartype TicketData: ByteString
3596		'''
3597
3598		ua_types = [
3599
3600		('PolicyId', 'String'),
3601		('TicketData', 'ByteString'),
3602		]
3603
3604		def __init__(self):
3605		self.PolicyId = None
3606		self.TicketData = None
3607		self._freeze = True
3608
3609		def to_binary(self):
3610		packet = []
3611		packet.append(uabin.Primitives.String.pack(self.PolicyId))
3612		packet.append(uabin.Primitives.ByteString.pack(self.TicketData))
3613		return b''.join(packet)
3614
3615		@staticmethod
3616		def from_binary(data):
3617		obj = KerberosIdentityToken()
3618		self.PolicyId = uabin.Primitives.String.unpack(data)
3619		self.TicketData = uabin.Primitives.ByteString.unpack(data)
3620		return obj
3621
3622		def __str__(self):
3623		return 'KerberosIdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \
3624		'TicketData:' + str(self.TicketData) + ')'
3625
3626		__repr__ = __str__
3627
3628
3629		class IssuedIdentityToken(FrozenClass):
		@@ 1311-1347 (lines=37) @@
1308		__repr__ = __str__
1309
1310
1311		class TimeZoneDataType(FrozenClass):
1312		'''
1313		:ivar Offset:
1314		:vartype Offset: Int16
1315		:ivar DaylightSavingInOffset:
1316		:vartype DaylightSavingInOffset: Boolean
1317		'''
1318
1319		ua_types = [
1320
1321		('Offset', 'Int16'),
1322		('DaylightSavingInOffset', 'Boolean'),
1323		]
1324
1325		def __init__(self):
1326		self.Offset = 0
1327		self.DaylightSavingInOffset = True
1328		self._freeze = True
1329
1330		def to_binary(self):
1331		packet = []
1332		packet.append(uabin.Primitives.Int16.pack(self.Offset))
1333		packet.append(uabin.Primitives.Boolean.pack(self.DaylightSavingInOffset))
1334		return b''.join(packet)
1335
1336		@staticmethod
1337		def from_binary(data):
1338		obj = TimeZoneDataType()
1339		self.Offset = uabin.Primitives.Int16.unpack(data)
1340		self.DaylightSavingInOffset = uabin.Primitives.Boolean.unpack(data)
1341		return obj
1342
1343		def __str__(self):
1344		return 'TimeZoneDataType(' + 'Offset:' + str(self.Offset) + ', ' + \
1345		'DaylightSavingInOffset:' + str(self.DaylightSavingInOffset) + ')'
1346
1347		__repr__ = __str__
1348
1349
1350		class ApplicationDescription(FrozenClass):

FreeOpcUa / python-opcua

Code Duplication Length = 37-39 lines in 15 locations

opcua/ua/uaprotocol_auto.py 15 locations