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

Code Duplication Length = 39-43 lines in 10 locations

opcua/ua/uaprotocol_auto.py 10 locations


    __repr__ = __str__


class Annotation(FrozenClass):
    '''
    :ivar Message:
    :vartype Message: String
    :ivar UserName:
    :vartype UserName: String
    :ivar AnnotationTime:
    :vartype AnnotationTime: DateTime
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Message = None
        self.UserName = None
        self.AnnotationTime = datetime.now()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(pack_string(self.Message))
        packet.append(pack_string(self.UserName))
        packet.append(pack_datetime(self.AnnotationTime))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.Message = unpack_string(data)
        self.UserName = unpack_string(data)
        self.AnnotationTime = unpack_datetime(data)

    def __str__(self):
        return 'Annotation(' + 'Message:' + str(self.Message) + ', ' + \
               'UserName:' + str(self.UserName) + ', ' + \
               'AnnotationTime:' + str(self.AnnotationTime) + ')'

    __repr__ = __str__


ExtensionClasses = {

    __repr__ = __str__


class ModificationInfo(FrozenClass):
    '''
    :ivar ModificationTime:
    :vartype ModificationTime: DateTime
    :ivar UpdateType:
    :vartype UpdateType: HistoryUpdateType
    :ivar UserName:
    :vartype UserName: String
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.ModificationTime = datetime.now()
        self.UpdateType = HistoryUpdateType(0)
        self.UserName = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(pack_datetime(self.ModificationTime))
        packet.append(uatype_UInt32.pack(self.UpdateType.value))
        packet.append(pack_string(self.UserName))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.ModificationTime = unpack_datetime(data)
        self.UpdateType = HistoryUpdateType(uatype_UInt32.unpack(data.read(4))[0])
        self.UserName = unpack_string(data)

    def __str__(self):
        return 'ModificationInfo(' + 'ModificationTime:' + str(self.ModificationTime) + ', ' + \
               'UpdateType:' + str(self.UpdateType) + ', ' + \
               'UserName:' + str(self.UserName) + ')'

    __repr__ = __str__


class HistoryModifiedData(FrozenClass):

    __repr__ = __str__


class MdnsDiscoveryConfiguration(FrozenClass):
    '''
    The discovery information needed for mDNS registration.

    :ivar MdnsServerName:
    :vartype MdnsServerName: String
    :ivar ServerCapabilities:
    :vartype ServerCapabilities: String
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.MdnsServerName = None
        self.ServerCapabilities = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(pack_string(self.MdnsServerName))
        packet.append(uatype_Int32.pack(len(self.ServerCapabilities)))
        for fieldname in self.ServerCapabilities:
            packet.append(pack_string(fieldname))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.MdnsServerName = unpack_string(data)
        self.ServerCapabilities = unpack_uatype_array('String', data)

    def __str__(self):
        return 'MdnsDiscoveryConfiguration(' + 'MdnsServerName:' + str(self.MdnsServerName) + ', ' + \
               'ServerCapabilities:' + str(self.ServerCapabilities) + ')'

    __repr__ = __str__


class RegisterServer2Parameters(FrozenClass):

    __repr__ = __str__


class IssuedIdentityToken(FrozenClass):
    '''
    A token representing a user identified by a WS-Security XML token.

    :ivar PolicyId:
    :vartype PolicyId: String
    :ivar TokenData:
    :vartype TokenData: ByteString
    :ivar EncryptionAlgorithm:
    :vartype EncryptionAlgorithm: String
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.PolicyId = None
        self.TokenData = None
        self.EncryptionAlgorithm = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(pack_string(self.PolicyId))
        packet.append(pack_bytes(self.TokenData))
        packet.append(pack_string(self.EncryptionAlgorithm))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.PolicyId = unpack_string(data)
        self.TokenData = unpack_bytes(data)
        self.EncryptionAlgorithm = unpack_string(data)

    def __str__(self):
        return 'IssuedIdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \
               'TokenData:' + str(self.TokenData) + ', ' + \
               'EncryptionAlgorithm:' + str(self.EncryptionAlgorithm) + ')'

    __repr__ = __str__


class ActivateSessionParameters(FrozenClass):

    __repr__ = __str__


class RedundantServerDataType(FrozenClass):
    '''
    :ivar ServerId:
    :vartype ServerId: String
    :ivar ServiceLevel:
    :vartype ServiceLevel: Byte
    :ivar ServerState:
    :vartype ServerState: ServerState
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.ServerId = None
        self.ServiceLevel = 0
        self.ServerState = ServerState(0)
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(pack_string(self.ServerId))
        packet.append(uatype_Byte.pack(self.ServiceLevel))
        packet.append(uatype_UInt32.pack(self.ServerState.value))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.ServerId = unpack_string(data)
        self.ServiceLevel = uatype_Byte.unpack(data.read(1))[0]
        self.ServerState = ServerState(uatype_UInt32.unpack(data.read(4))[0])

    def __str__(self):
        return 'RedundantServerDataType(' + 'ServerId:' + str(self.ServerId) + ', ' + \
               'ServiceLevel:' + str(self.ServiceLevel) + ', ' + \
               'ServerState:' + str(self.ServerState) + ')'

    __repr__ = __str__


class EndpointUrlListDataType(FrozenClass):

    __repr__ = __str__


class EnumValueType(FrozenClass):
    '''
    A mapping between a value of an enumerated type and a name and description.

    :ivar Value:
    :vartype Value: Int64
    :ivar DisplayName:
    :vartype DisplayName: LocalizedText
    :ivar Description:
    :vartype Description: LocalizedText
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Value = 0
        self.DisplayName = LocalizedText()
        self.Description = LocalizedText()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int64.pack(self.Value))
        packet.append(self.DisplayName.to_binary())
        packet.append(self.Description.to_binary())
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.Value = uatype_Int64.unpack(data.read(8))[0]
        self.DisplayName = LocalizedText.from_binary(data)
        self.Description = LocalizedText.from_binary(data)

    def __str__(self):
        return 'EnumValueType(' + 'Value:' + str(self.Value) + ', ' + \
               'DisplayName:' + str(self.DisplayName) + ', ' + \
               'Description:' + str(self.Description) + ')'

    __repr__ = __str__


class OptionSet(FrozenClass):

    __repr__ = __str__


class QueryDataDescription(FrozenClass):
    '''
    :ivar RelativePath:
    :vartype RelativePath: RelativePath
    :ivar AttributeId:
    :vartype AttributeId: UInt32
    :ivar IndexRange:
    :vartype IndexRange: String
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.RelativePath = RelativePath()
        self.AttributeId = 0
        self.IndexRange = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.RelativePath.to_binary())
        packet.append(uatype_UInt32.pack(self.AttributeId))
        packet.append(pack_string(self.IndexRange))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.RelativePath = RelativePath.from_binary(data)
        self.AttributeId = uatype_UInt32.unpack(data.read(4))[0]
        self.IndexRange = unpack_string(data)

    def __str__(self):
        return 'QueryDataDescription(' + 'RelativePath:' + str(self.RelativePath) + ', ' + \
               'AttributeId:' + str(self.AttributeId) + ', ' + \
               'IndexRange:' + str(self.IndexRange) + ')'

    __repr__ = __str__


class NodeTypeDescription(FrozenClass):

    __repr__ = __str__


class ViewDescription(FrozenClass):
    '''
    The view to browse.

    :ivar ViewId:
    :vartype ViewId: NodeId
    :ivar Timestamp:
    :vartype Timestamp: DateTime
    :ivar ViewVersion:
    :vartype ViewVersion: UInt32
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.ViewId = NodeId()
        self.Timestamp = datetime.now()
        self.ViewVersion = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.ViewId.to_binary())
        packet.append(pack_datetime(self.Timestamp))
        packet.append(uatype_UInt32.pack(self.ViewVersion))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.ViewId = NodeId.from_binary(data)
        self.Timestamp = unpack_datetime(data)
        self.ViewVersion = uatype_UInt32.unpack(data.read(4))[0]

    def __str__(self):
        return 'ViewDescription(' + 'ViewId:' + str(self.ViewId) + ', ' + \
               'Timestamp:' + str(self.Timestamp) + ', ' + \
               'ViewVersion:' + str(self.ViewVersion) + ')'

    __repr__ = __str__


class BrowseDescription(FrozenClass):

    __repr__ = __str__


class AggregateFilterResult(FrozenClass):
    '''
    :ivar RevisedStartTime:
    :vartype RevisedStartTime: DateTime
    :ivar RevisedProcessingInterval:
    :vartype RevisedProcessingInterval: Double
    :ivar RevisedAggregateConfiguration:
    :vartype RevisedAggregateConfiguration: AggregateConfiguration
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.RevisedStartTime = datetime.now()
        self.RevisedProcessingInterval = 0
        self.RevisedAggregateConfiguration = AggregateConfiguration()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(pack_datetime(self.RevisedStartTime))
        packet.append(uatype_Double.pack(self.RevisedProcessingInterval))
        packet.append(self.RevisedAggregateConfiguration.to_binary())
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.RevisedStartTime = unpack_datetime(data)
        self.RevisedProcessingInterval = uatype_Double.unpack(data.read(8))[0]
        self.RevisedAggregateConfiguration = AggregateConfiguration.from_binary(data)

    def __str__(self):
        return 'AggregateFilterResult(' + 'RevisedStartTime:' + str(self.RevisedStartTime) + ', ' + \
               'RevisedProcessingInterval:' + str(self.RevisedProcessingInterval) + ', ' + \
               'RevisedAggregateConfiguration:' + str(self.RevisedAggregateConfiguration) + ')'

    __repr__ = __str__


class MonitoringParameters(FrozenClass):

    __repr__ = __str__


class OpenSecureChannelResult(FrozenClass):
    '''
    :ivar ServerProtocolVersion:
    :vartype ServerProtocolVersion: UInt32
    :ivar SecurityToken:
    :vartype SecurityToken: ChannelSecurityToken
    :ivar ServerNonce:
    :vartype ServerNonce: ByteString
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.ServerProtocolVersion = 0
        self.SecurityToken = ChannelSecurityToken()
        self.ServerNonce = None
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_UInt32.pack(self.ServerProtocolVersion))
        packet.append(self.SecurityToken.to_binary())
        packet.append(pack_bytes(self.ServerNonce))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.ServerProtocolVersion = uatype_UInt32.unpack(data.read(4))[0]
        self.SecurityToken = ChannelSecurityToken.from_binary(data)
        self.ServerNonce = unpack_bytes(data)

    def __str__(self):
        return 'OpenSecureChannelResult(' + 'ServerProtocolVersion:' + str(self.ServerProtocolVersion) + ', ' + \
               'SecurityToken:' + str(self.SecurityToken) + ', ' + \
               'ServerNonce:' + str(self.ServerNonce) + ')'

    __repr__ = __str__


class OpenSecureChannelResponse(FrozenClass):

		@@ 14041-14081 (lines=41) @@
14038		__repr__ = __str__
14039
14040
14041		class Annotation(FrozenClass):
14042		'''
14043		:ivar Message:
14044		:vartype Message: String
14045		:ivar UserName:
14046		:vartype UserName: String
14047		:ivar AnnotationTime:
14048		:vartype AnnotationTime: DateTime
14049		'''
14050		def __init__(self, binary=None):
14051		if binary is not None:
14052		self._binary_init(binary)
14053		self._freeze = True
14054		return
14055		self.Message = None
14056		self.UserName = None
14057		self.AnnotationTime = datetime.now()
14058		self._freeze = True
14059
14060		def to_binary(self):
14061		packet = []
14062		packet.append(pack_string(self.Message))
14063		packet.append(pack_string(self.UserName))
14064		packet.append(pack_datetime(self.AnnotationTime))
14065		return b''.join(packet)
14066
14067		@staticmethod
14068		def from_binary(data):
14069		return Annotation(data)
14070
14071		def _binary_init(self, data):
14072		self.Message = unpack_string(data)
14073		self.UserName = unpack_string(data)
14074		self.AnnotationTime = unpack_datetime(data)
14075
14076		def __str__(self):
14077		return 'Annotation(' + 'Message:' + str(self.Message) + ', ' + \
14078		'UserName:' + str(self.UserName) + ', ' + \
14079		'AnnotationTime:' + str(self.AnnotationTime) + ')'
14080
14081		__repr__ = __str__
14082
14083
14084		ExtensionClasses = {
		@@ 8265-8305 (lines=41) @@
8262		__repr__ = __str__
8263
8264
8265		class ModificationInfo(FrozenClass):
8266		'''
8267		:ivar ModificationTime:
8268		:vartype ModificationTime: DateTime
8269		:ivar UpdateType:
8270		:vartype UpdateType: HistoryUpdateType
8271		:ivar UserName:
8272		:vartype UserName: String
8273		'''
8274		def __init__(self, binary=None):
8275		if binary is not None:
8276		self._binary_init(binary)
8277		self._freeze = True
8278		return
8279		self.ModificationTime = datetime.now()
8280		self.UpdateType = HistoryUpdateType(0)
8281		self.UserName = None
8282		self._freeze = True
8283
8284		def to_binary(self):
8285		packet = []
8286		packet.append(pack_datetime(self.ModificationTime))
8287		packet.append(uatype_UInt32.pack(self.UpdateType.value))
8288		packet.append(pack_string(self.UserName))
8289		return b''.join(packet)
8290
8291		@staticmethod
8292		def from_binary(data):
8293		return ModificationInfo(data)
8294
8295		def _binary_init(self, data):
8296		self.ModificationTime = unpack_datetime(data)
8297		self.UpdateType = HistoryUpdateType(uatype_UInt32.unpack(data.read(4))[0])
8298		self.UserName = unpack_string(data)
8299
8300		def __str__(self):
8301		return 'ModificationInfo(' + 'ModificationTime:' + str(self.ModificationTime) + ', ' + \
8302		'UpdateType:' + str(self.UpdateType) + ', ' + \
8303		'UserName:' + str(self.UserName) + ')'
8304
8305		__repr__ = __str__
8306
8307
8308		class HistoryModifiedData(FrozenClass):
		@@ 2193-2231 (lines=39) @@
2190		__repr__ = __str__
2191
2192
2193		class MdnsDiscoveryConfiguration(FrozenClass):
2194		'''
2195		The discovery information needed for mDNS registration.
2196
2197		:ivar MdnsServerName:
2198		:vartype MdnsServerName: String
2199		:ivar ServerCapabilities:
2200		:vartype ServerCapabilities: String
2201		'''
2202		def __init__(self, binary=None):
2203		if binary is not None:
2204		self._binary_init(binary)
2205		self._freeze = True
2206		return
2207		self.MdnsServerName = None
2208		self.ServerCapabilities = []
2209		self._freeze = True
2210
2211		def to_binary(self):
2212		packet = []
2213		packet.append(pack_string(self.MdnsServerName))
2214		packet.append(uatype_Int32.pack(len(self.ServerCapabilities)))
2215		for fieldname in self.ServerCapabilities:
2216		packet.append(pack_string(fieldname))
2217		return b''.join(packet)
2218
2219		@staticmethod
2220		def from_binary(data):
2221		return MdnsDiscoveryConfiguration(data)
2222
2223		def _binary_init(self, data):
2224		self.MdnsServerName = unpack_string(data)
2225		self.ServerCapabilities = unpack_uatype_array('String', data)
2226
2227		def __str__(self):
2228		return 'MdnsDiscoveryConfiguration(' + 'MdnsServerName:' + str(self.MdnsServerName) + ', ' + \
2229		'ServerCapabilities:' + str(self.ServerCapabilities) + ')'
2230
2231		__repr__ = __str__
2232
2233
2234		class RegisterServer2Parameters(FrozenClass):
		@@ 3228-3270 (lines=43) @@
3225		__repr__ = __str__
3226
3227
3228		class IssuedIdentityToken(FrozenClass):
3229		'''
3230		A token representing a user identified by a WS-Security XML token.
3231
3232		:ivar PolicyId:
3233		:vartype PolicyId: String
3234		:ivar TokenData:
3235		:vartype TokenData: ByteString
3236		:ivar EncryptionAlgorithm:
3237		:vartype EncryptionAlgorithm: String
3238		'''
3239		def __init__(self, binary=None):
3240		if binary is not None:
3241		self._binary_init(binary)
3242		self._freeze = True
3243		return
3244		self.PolicyId = None
3245		self.TokenData = None
3246		self.EncryptionAlgorithm = None
3247		self._freeze = True
3248
3249		def to_binary(self):
3250		packet = []
3251		packet.append(pack_string(self.PolicyId))
3252		packet.append(pack_bytes(self.TokenData))
3253		packet.append(pack_string(self.EncryptionAlgorithm))
3254		return b''.join(packet)
3255
3256		@staticmethod
3257		def from_binary(data):
3258		return IssuedIdentityToken(data)
3259
3260		def _binary_init(self, data):
3261		self.PolicyId = unpack_string(data)
3262		self.TokenData = unpack_bytes(data)
3263		self.EncryptionAlgorithm = unpack_string(data)
3264
3265		def __str__(self):
3266		return 'IssuedIdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \
3267		'TokenData:' + str(self.TokenData) + ', ' + \
3268		'EncryptionAlgorithm:' + str(self.EncryptionAlgorithm) + ')'
3269
3270		__repr__ = __str__
3271
3272
3273		class ActivateSessionParameters(FrozenClass):
		@@ 12630-12670 (lines=41) @@
12627		__repr__ = __str__
12628
12629
12630		class RedundantServerDataType(FrozenClass):
12631		'''
12632		:ivar ServerId:
12633		:vartype ServerId: String
12634		:ivar ServiceLevel:
12635		:vartype ServiceLevel: Byte
12636		:ivar ServerState:
12637		:vartype ServerState: ServerState
12638		'''
12639		def __init__(self, binary=None):
12640		if binary is not None:
12641		self._binary_init(binary)
12642		self._freeze = True
12643		return
12644		self.ServerId = None
12645		self.ServiceLevel = 0
12646		self.ServerState = ServerState(0)
12647		self._freeze = True
12648
12649		def to_binary(self):
12650		packet = []
12651		packet.append(pack_string(self.ServerId))
12652		packet.append(uatype_Byte.pack(self.ServiceLevel))
12653		packet.append(uatype_UInt32.pack(self.ServerState.value))
12654		return b''.join(packet)
12655
12656		@staticmethod
12657		def from_binary(data):
12658		return RedundantServerDataType(data)
12659
12660		def _binary_init(self, data):
12661		self.ServerId = unpack_string(data)
12662		self.ServiceLevel = uatype_Byte.unpack(data.read(1))[0]
12663		self.ServerState = ServerState(uatype_UInt32.unpack(data.read(4))[0])
12664
12665		def __str__(self):
12666		return 'RedundantServerDataType(' + 'ServerId:' + str(self.ServerId) + ', ' + \
12667		'ServiceLevel:' + str(self.ServiceLevel) + ', ' + \
12668		'ServerState:' + str(self.ServerState) + ')'
12669
12670		__repr__ = __str__
12671
12672
12673		class EndpointUrlListDataType(FrozenClass):
		@@ 949-991 (lines=43) @@
946		__repr__ = __str__
947
948
949		class EnumValueType(FrozenClass):
950		'''
951		A mapping between a value of an enumerated type and a name and description.
952
953		:ivar Value:
954		:vartype Value: Int64
955		:ivar DisplayName:
956		:vartype DisplayName: LocalizedText
957		:ivar Description:
958		:vartype Description: LocalizedText
959		'''
960		def __init__(self, binary=None):
961		if binary is not None:
962		self._binary_init(binary)
963		self._freeze = True
964		return
965		self.Value = 0
966		self.DisplayName = LocalizedText()
967		self.Description = LocalizedText()
968		self._freeze = True
969
970		def to_binary(self):
971		packet = []
972		packet.append(uatype_Int64.pack(self.Value))
973		packet.append(self.DisplayName.to_binary())
974		packet.append(self.Description.to_binary())
975		return b''.join(packet)
976
977		@staticmethod
978		def from_binary(data):
979		return EnumValueType(data)
980
981		def _binary_init(self, data):
982		self.Value = uatype_Int64.unpack(data.read(8))[0]
983		self.DisplayName = LocalizedText.from_binary(data)
984		self.Description = LocalizedText.from_binary(data)
985
986		def __str__(self):
987		return 'EnumValueType(' + 'Value:' + str(self.Value) + ', ' + \
988		'DisplayName:' + str(self.DisplayName) + ', ' + \
989		'Description:' + str(self.Description) + ')'
990
991		__repr__ = __str__
992
993
994		class OptionSet(FrozenClass):
		@@ 6688-6728 (lines=41) @@
6685		__repr__ = __str__
6686
6687
6688		class QueryDataDescription(FrozenClass):
6689		'''
6690		:ivar RelativePath:
6691		:vartype RelativePath: RelativePath
6692		:ivar AttributeId:
6693		:vartype AttributeId: UInt32
6694		:ivar IndexRange:
6695		:vartype IndexRange: String
6696		'''
6697		def __init__(self, binary=None):
6698		if binary is not None:
6699		self._binary_init(binary)
6700		self._freeze = True
6701		return
6702		self.RelativePath = RelativePath()
6703		self.AttributeId = 0
6704		self.IndexRange = None
6705		self._freeze = True
6706
6707		def to_binary(self):
6708		packet = []
6709		packet.append(self.RelativePath.to_binary())
6710		packet.append(uatype_UInt32.pack(self.AttributeId))
6711		packet.append(pack_string(self.IndexRange))
6712		return b''.join(packet)
6713
6714		@staticmethod
6715		def from_binary(data):
6716		return QueryDataDescription(data)
6717
6718		def _binary_init(self, data):
6719		self.RelativePath = RelativePath.from_binary(data)
6720		self.AttributeId = uatype_UInt32.unpack(data.read(4))[0]
6721		self.IndexRange = unpack_string(data)
6722
6723		def __str__(self):
6724		return 'QueryDataDescription(' + 'RelativePath:' + str(self.RelativePath) + ', ' + \
6725		'AttributeId:' + str(self.AttributeId) + ', ' + \
6726		'IndexRange:' + str(self.IndexRange) + ')'
6727
6728		__repr__ = __str__
6729
6730
6731		class NodeTypeDescription(FrozenClass):
		@@ 5234-5276 (lines=43) @@
5231		__repr__ = __str__
5232
5233
5234		class ViewDescription(FrozenClass):
5235		'''
5236		The view to browse.
5237
5238		:ivar ViewId:
5239		:vartype ViewId: NodeId
5240		:ivar Timestamp:
5241		:vartype Timestamp: DateTime
5242		:ivar ViewVersion:
5243		:vartype ViewVersion: UInt32
5244		'''
5245		def __init__(self, binary=None):
5246		if binary is not None:
5247		self._binary_init(binary)
5248		self._freeze = True
5249		return
5250		self.ViewId = NodeId()
5251		self.Timestamp = datetime.now()
5252		self.ViewVersion = 0
5253		self._freeze = True
5254
5255		def to_binary(self):
5256		packet = []
5257		packet.append(self.ViewId.to_binary())
5258		packet.append(pack_datetime(self.Timestamp))
5259		packet.append(uatype_UInt32.pack(self.ViewVersion))
5260		return b''.join(packet)
5261
5262		@staticmethod
5263		def from_binary(data):
5264		return ViewDescription(data)
5265
5266		def _binary_init(self, data):
5267		self.ViewId = NodeId.from_binary(data)
5268		self.Timestamp = unpack_datetime(data)
5269		self.ViewVersion = uatype_UInt32.unpack(data.read(4))[0]
5270
5271		def __str__(self):
5272		return 'ViewDescription(' + 'ViewId:' + str(self.ViewId) + ', ' + \
5273		'Timestamp:' + str(self.Timestamp) + ', ' + \
5274		'ViewVersion:' + str(self.ViewVersion) + ')'
5275
5276		__repr__ = __str__
5277
5278
5279		class BrowseDescription(FrozenClass):
		@@ 9833-9873 (lines=41) @@
9830		__repr__ = __str__
9831
9832
9833		class AggregateFilterResult(FrozenClass):
9834		'''
9835		:ivar RevisedStartTime:
9836		:vartype RevisedStartTime: DateTime
9837		:ivar RevisedProcessingInterval:
9838		:vartype RevisedProcessingInterval: Double
9839		:ivar RevisedAggregateConfiguration:
9840		:vartype RevisedAggregateConfiguration: AggregateConfiguration
9841		'''
9842		def __init__(self, binary=None):
9843		if binary is not None:
9844		self._binary_init(binary)
9845		self._freeze = True
9846		return
9847		self.RevisedStartTime = datetime.now()
9848		self.RevisedProcessingInterval = 0
9849		self.RevisedAggregateConfiguration = AggregateConfiguration()
9850		self._freeze = True
9851
9852		def to_binary(self):
9853		packet = []
9854		packet.append(pack_datetime(self.RevisedStartTime))
9855		packet.append(uatype_Double.pack(self.RevisedProcessingInterval))
9856		packet.append(self.RevisedAggregateConfiguration.to_binary())
9857		return b''.join(packet)
9858
9859		@staticmethod
9860		def from_binary(data):
9861		return AggregateFilterResult(data)
9862
9863		def _binary_init(self, data):
9864		self.RevisedStartTime = unpack_datetime(data)
9865		self.RevisedProcessingInterval = uatype_Double.unpack(data.read(8))[0]
9866		self.RevisedAggregateConfiguration = AggregateConfiguration.from_binary(data)
9867
9868		def __str__(self):
9869		return 'AggregateFilterResult(' + 'RevisedStartTime:' + str(self.RevisedStartTime) + ', ' + \
9870		'RevisedProcessingInterval:' + str(self.RevisedProcessingInterval) + ', ' + \
9871		'RevisedAggregateConfiguration:' + str(self.RevisedAggregateConfiguration) + ')'
9872
9873		__repr__ = __str__
9874
9875
9876		class MonitoringParameters(FrozenClass):
		@@ 2535-2575 (lines=41) @@
2532		__repr__ = __str__
2533
2534
2535		class OpenSecureChannelResult(FrozenClass):
2536		'''
2537		:ivar ServerProtocolVersion:
2538		:vartype ServerProtocolVersion: UInt32
2539		:ivar SecurityToken:
2540		:vartype SecurityToken: ChannelSecurityToken
2541		:ivar ServerNonce:
2542		:vartype ServerNonce: ByteString
2543		'''
2544		def __init__(self, binary=None):
2545		if binary is not None:
2546		self._binary_init(binary)
2547		self._freeze = True
2548		return
2549		self.ServerProtocolVersion = 0
2550		self.SecurityToken = ChannelSecurityToken()
2551		self.ServerNonce = None
2552		self._freeze = True
2553
2554		def to_binary(self):
2555		packet = []
2556		packet.append(uatype_UInt32.pack(self.ServerProtocolVersion))
2557		packet.append(self.SecurityToken.to_binary())
2558		packet.append(pack_bytes(self.ServerNonce))
2559		return b''.join(packet)
2560
2561		@staticmethod
2562		def from_binary(data):
2563		return OpenSecureChannelResult(data)
2564
2565		def _binary_init(self, data):
2566		self.ServerProtocolVersion = uatype_UInt32.unpack(data.read(4))[0]
2567		self.SecurityToken = ChannelSecurityToken.from_binary(data)
2568		self.ServerNonce = unpack_bytes(data)
2569
2570		def __str__(self):
2571		return 'OpenSecureChannelResult(' + 'ServerProtocolVersion:' + str(self.ServerProtocolVersion) + ', ' + \
2572		'SecurityToken:' + str(self.SecurityToken) + ', ' + \
2573		'ServerNonce:' + str(self.ServerNonce) + ')'
2574
2575		__repr__ = __str__
2576
2577
2578		class OpenSecureChannelResponse(FrozenClass):

FreeOpcUa / python-opcua

Code Duplication Length = 39-43 lines in 10 locations

opcua/ua/uaprotocol_auto.py 10 locations