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

Code Duplication Length = 62-71 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations



class DataTypeAttributes(FrozenClass):
    '''
    The attributes for a data type node.

    :ivar SpecifiedAttributes:
    :vartype SpecifiedAttributes: UInt32
    :ivar DisplayName:
    :vartype DisplayName: LocalizedText
    :ivar Description:
    :vartype Description: LocalizedText
    :ivar WriteMask:
    :vartype WriteMask: UInt32
    :ivar UserWriteMask:
    :vartype UserWriteMask: UInt32
    :ivar IsAbstract:
    :vartype IsAbstract: Boolean
    '''

    ua_types = {
        'SpecifiedAttributes': 'UInt32',
        'DisplayName': 'LocalizedText',
        'Description': 'LocalizedText',
        'WriteMask': 'UInt32',
        'UserWriteMask': 'UInt32',
        'IsAbstract': 'Boolean',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SpecifiedAttributes = 0
        self.DisplayName = LocalizedText()
        self.Description = LocalizedText()
        self.WriteMask = 0
        self.UserWriteMask = 0
        self.IsAbstract = True
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.SpecifiedAttributes))
        packet.append(self.DisplayName.to_binary())
        packet.append(self.Description.to_binary())
        packet.append(uabin.Primitives.UInt32.pack(self.WriteMask))
        packet.append(uabin.Primitives.UInt32.pack(self.UserWriteMask))
        packet.append(uabin.Primitives.Boolean.pack(self.IsAbstract))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.SpecifiedAttributes = uabin.Primitives.UInt32.unpack(data)
        self.DisplayName = LocalizedText.from_binary(data)
        self.Description = LocalizedText.from_binary(data)
        self.WriteMask = uabin.Primitives.UInt32.unpack(data)
        self.UserWriteMask = uabin.Primitives.UInt32.unpack(data)
        self.IsAbstract = uabin.Primitives.Boolean.unpack(data)

    def __str__(self):
        return 'DataTypeAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \
               'DisplayName:' + str(self.DisplayName) + ', ' + \
               'Description:' + str(self.Description) + ', ' + \
               'WriteMask:' + str(self.WriteMask) + ', ' + \
               'UserWriteMask:' + str(self.UserWriteMask) + ', ' + \
               'IsAbstract:' + str(self.IsAbstract) + ')'

    __repr__ = __str__


class ViewAttributes(FrozenClass):
    '''
    The attributes for a view node.


class ObjectTypeAttributes(FrozenClass):
    '''
    The attributes for an object type node.

    :ivar SpecifiedAttributes:
    :vartype SpecifiedAttributes: UInt32
    :ivar DisplayName:
    :vartype DisplayName: LocalizedText
    :ivar Description:
    :vartype Description: LocalizedText
    :ivar WriteMask:
    :vartype WriteMask: UInt32
    :ivar UserWriteMask:
    :vartype UserWriteMask: UInt32
    :ivar IsAbstract:
    :vartype IsAbstract: Boolean
    '''

    ua_types = {
        'SpecifiedAttributes': 'UInt32',
        'DisplayName': 'LocalizedText',
        'Description': 'LocalizedText',
        'WriteMask': 'UInt32',
        'UserWriteMask': 'UInt32',
        'IsAbstract': 'Boolean',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SpecifiedAttributes = 0
        self.DisplayName = LocalizedText()
        self.Description = LocalizedText()
        self.WriteMask = 0
        self.UserWriteMask = 0
        self.IsAbstract = True
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.SpecifiedAttributes))
        packet.append(self.DisplayName.to_binary())
        packet.append(self.Description.to_binary())
        packet.append(uabin.Primitives.UInt32.pack(self.WriteMask))
        packet.append(uabin.Primitives.UInt32.pack(self.UserWriteMask))
        packet.append(uabin.Primitives.Boolean.pack(self.IsAbstract))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.SpecifiedAttributes = uabin.Primitives.UInt32.unpack(data)
        self.DisplayName = LocalizedText.from_binary(data)
        self.Description = LocalizedText.from_binary(data)
        self.WriteMask = uabin.Primitives.UInt32.unpack(data)
        self.UserWriteMask = uabin.Primitives.UInt32.unpack(data)
        self.IsAbstract = uabin.Primitives.Boolean.unpack(data)

    def __str__(self):
        return 'ObjectTypeAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \
               'DisplayName:' + str(self.DisplayName) + ', ' + \
               'Description:' + str(self.Description) + ', ' + \
               'WriteMask:' + str(self.WriteMask) + ', ' + \
               'UserWriteMask:' + str(self.UserWriteMask) + ', ' + \
               'IsAbstract:' + str(self.IsAbstract) + ')'

    __repr__ = __str__


class VariableTypeAttributes(FrozenClass):
    '''
    The attributes for a variable type node.

        '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.utcnow()
        self.ViewVersion = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.ViewId.to_binary())
        packet.append(uabin.Primitives.DateTime.pack(self.Timestamp))
        packet.append(uabin.Primitives.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 = uabin.Primitives.DateTime.unpack(data)
        self.ViewVersion = uabin.Primitives.UInt32.unpack(data)

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

    __repr__ = __str__


class BrowseDescription(FrozenClass):
    '''
    A request to browse the the references from a node.

    :ivar NodeId:
    :vartype NodeId: NodeId
    :ivar BrowseDirection:
    :vartype BrowseDirection: BrowseDirection
    :ivar ReferenceTypeId:
    :vartype ReferenceTypeId: NodeId
    :ivar IncludeSubtypes:
    :vartype IncludeSubtypes: Boolean
    :ivar NodeClassMask:
    :vartype NodeClassMask: UInt32
    :ivar ResultMask:
    :vartype ResultMask: UInt32
    '''

    ua_types = {
        'NodeId': 'NodeId',
        'BrowseDirection': 'BrowseDirection',
        'ReferenceTypeId': 'NodeId',
        'IncludeSubtypes': 'Boolean',
        'NodeClassMask': 'UInt32',
        'ResultMask': 'UInt32',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.NodeId = NodeId()
        self.BrowseDirection = BrowseDirection(0)
        self.ReferenceTypeId = NodeId()
        self.IncludeSubtypes = True
        self.NodeClassMask = 0
        self.ResultMask = 0
        self._freeze = True



class AddReferencesItem(FrozenClass):
    '''
    A request to add a reference to the server address space.

    :ivar SourceNodeId:
    :vartype SourceNodeId: NodeId
    :ivar ReferenceTypeId:
    :vartype ReferenceTypeId: NodeId
    :ivar IsForward:
    :vartype IsForward: Boolean
    :ivar TargetServerUri:
    :vartype TargetServerUri: String
    :ivar TargetNodeId:
    :vartype TargetNodeId: ExpandedNodeId
    :ivar TargetNodeClass:
    :vartype TargetNodeClass: NodeClass
    '''

    ua_types = {
        'SourceNodeId': 'NodeId',
        'ReferenceTypeId': 'NodeId',
        'IsForward': 'Boolean',
        'TargetServerUri': 'String',
        'TargetNodeId': 'ExpandedNodeId',
        'TargetNodeClass': 'NodeClass',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SourceNodeId = NodeId()
        self.ReferenceTypeId = NodeId()
        self.IsForward = True
        self.TargetServerUri = None
        self.TargetNodeId = ExpandedNodeId()
        self.TargetNodeClass = NodeClass(0)
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(self.SourceNodeId.to_binary())
        packet.append(self.ReferenceTypeId.to_binary())
        packet.append(uabin.Primitives.Boolean.pack(self.IsForward))
        packet.append(uabin.Primitives.String.pack(self.TargetServerUri))
        packet.append(self.TargetNodeId.to_binary())
        packet.append(uabin.Primitives.UInt32.pack(self.TargetNodeClass.value))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.SourceNodeId = NodeId.from_binary(data)
        self.ReferenceTypeId = NodeId.from_binary(data)
        self.IsForward = uabin.Primitives.Boolean.unpack(data)
        self.TargetServerUri = uabin.Primitives.String.unpack(data)
        self.TargetNodeId = ExpandedNodeId.from_binary(data)
        self.TargetNodeClass = NodeClass(uabin.Primitives.UInt32.unpack(data))

    def __str__(self):
        return 'AddReferencesItem(' + 'SourceNodeId:' + str(self.SourceNodeId) + ', ' + \
               'ReferenceTypeId:' + str(self.ReferenceTypeId) + ', ' + \
               'IsForward:' + str(self.IsForward) + ', ' + \
               'TargetServerUri:' + str(self.TargetServerUri) + ', ' + \
               'TargetNodeId:' + str(self.TargetNodeId) + ', ' + \
               'TargetNodeClass:' + str(self.TargetNodeClass) + ')'

    __repr__ = __str__


class AddReferencesParameters(FrozenClass):
    '''
    :ivar ReferencesToAdd:


class ObjectAttributes(FrozenClass):
    '''
    The attributes for an object node.

    :ivar SpecifiedAttributes:
    :vartype SpecifiedAttributes: UInt32
    :ivar DisplayName:
    :vartype DisplayName: LocalizedText
    :ivar Description:
    :vartype Description: LocalizedText
    :ivar WriteMask:
    :vartype WriteMask: UInt32
    :ivar UserWriteMask:
    :vartype UserWriteMask: UInt32
    :ivar EventNotifier:
    :vartype EventNotifier: Byte
    '''

    ua_types = {
        'SpecifiedAttributes': 'UInt32',
        'DisplayName': 'LocalizedText',
        'Description': 'LocalizedText',
        'WriteMask': 'UInt32',
        'UserWriteMask': 'UInt32',
        'EventNotifier': 'Byte',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SpecifiedAttributes = 0
        self.DisplayName = LocalizedText()
        self.Description = LocalizedText()
        self.WriteMask = 0
        self.UserWriteMask = 0
        self.EventNotifier = 0
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.SpecifiedAttributes))
        packet.append(self.DisplayName.to_binary())
        packet.append(self.Description.to_binary())
        packet.append(uabin.Primitives.UInt32.pack(self.WriteMask))
        packet.append(uabin.Primitives.UInt32.pack(self.UserWriteMask))
        packet.append(uabin.Primitives.Byte.pack(self.EventNotifier))
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.SpecifiedAttributes = uabin.Primitives.UInt32.unpack(data)
        self.DisplayName = LocalizedText.from_binary(data)
        self.Description = LocalizedText.from_binary(data)
        self.WriteMask = uabin.Primitives.UInt32.unpack(data)
        self.UserWriteMask = uabin.Primitives.UInt32.unpack(data)
        self.EventNotifier = uabin.Primitives.Byte.unpack(data)

    def __str__(self):
        return 'ObjectAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \
               'DisplayName:' + str(self.DisplayName) + ', ' + \
               'Description:' + str(self.Description) + ', ' + \
               'WriteMask:' + str(self.WriteMask) + ', ' + \
               'UserWriteMask:' + str(self.UserWriteMask) + ', ' + \
               'EventNotifier:' + str(self.EventNotifier) + ')'

    __repr__ = __str__


class VariableAttributes(FrozenClass):
    '''
    The attributes for a variable node.

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.SelectClauses = []
        self.WhereClause = ContentFilter()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.Int32.pack(len(self.SelectClauses)))
        for fieldname in self.SelectClauses:
            packet.append(fieldname.to_binary())
        packet.append(self.WhereClause.to_binary())
        return b''.join(packet)

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

    def _binary_init(self, data):
        length = uabin.Primitives.Int32.unpack(data)
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(SimpleAttributeOperand.from_binary(data))
        self.SelectClauses = array
        self.WhereClause = ContentFilter.from_binary(data)

    def __str__(self):
        return 'EventFilter(' + 'SelectClauses:' + str(self.SelectClauses) + ', ' + \
               'WhereClause:' + str(self.WhereClause) + ')'

    __repr__ = __str__


class AggregateConfiguration(FrozenClass):
    '''
    :ivar UseServerCapabilitiesDefaults:
    :vartype UseServerCapabilitiesDefaults: Boolean
    :ivar TreatUncertainAsBad:
    :vartype TreatUncertainAsBad: Boolean
    :ivar PercentDataBad:
    :vartype PercentDataBad: Byte
    :ivar PercentDataGood:
    :vartype PercentDataGood: Byte
    :ivar UseSlopedExtrapolation:
    :vartype UseSlopedExtrapolation: Boolean
    '''

    ua_types = {
        'UseServerCapabilitiesDefaults': 'Boolean',
        'TreatUncertainAsBad': 'Boolean',
        'PercentDataBad': 'Byte',
        'PercentDataGood': 'Byte',
        'UseSlopedExtrapolation': 'Boolean',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.UseServerCapabilitiesDefaults = True
        self.TreatUncertainAsBad = True
        self.PercentDataBad = 0
        self.PercentDataGood = 0

        return b''.join(packet)

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

    def _binary_init(self, data):
        self.ServerViewCount = uabin.Primitives.UInt32.unpack(data)
        self.CurrentSessionCount = uabin.Primitives.UInt32.unpack(data)
        self.CumulatedSessionCount = uabin.Primitives.UInt32.unpack(data)
        self.SecurityRejectedSessionCount = uabin.Primitives.UInt32.unpack(data)
        self.RejectedSessionCount = uabin.Primitives.UInt32.unpack(data)
        self.SessionTimeoutCount = uabin.Primitives.UInt32.unpack(data)
        self.SessionAbortCount = uabin.Primitives.UInt32.unpack(data)
        self.CurrentSubscriptionCount = uabin.Primitives.UInt32.unpack(data)
        self.CumulatedSubscriptionCount = uabin.Primitives.UInt32.unpack(data)
        self.PublishingIntervalCount = uabin.Primitives.UInt32.unpack(data)
        self.SecurityRejectedRequestsCount = uabin.Primitives.UInt32.unpack(data)
        self.RejectedRequestsCount = uabin.Primitives.UInt32.unpack(data)

    def __str__(self):
        return 'ServerDiagnosticsSummaryDataType(' + 'ServerViewCount:' + str(self.ServerViewCount) + ', ' + \
               'CurrentSessionCount:' + str(self.CurrentSessionCount) + ', ' + \
               'CumulatedSessionCount:' + str(self.CumulatedSessionCount) + ', ' + \
               'SecurityRejectedSessionCount:' + str(self.SecurityRejectedSessionCount) + ', ' + \
               'RejectedSessionCount:' + str(self.RejectedSessionCount) + ', ' + \
               'SessionTimeoutCount:' + str(self.SessionTimeoutCount) + ', ' + \
               'SessionAbortCount:' + str(self.SessionAbortCount) + ', ' + \
               'CurrentSubscriptionCount:' + str(self.CurrentSubscriptionCount) + ', ' + \
               'CumulatedSubscriptionCount:' + str(self.CumulatedSubscriptionCount) + ', ' + \
               'PublishingIntervalCount:' + str(self.PublishingIntervalCount) + ', ' + \
               'SecurityRejectedRequestsCount:' + str(self.SecurityRejectedRequestsCount) + ', ' + \
               'RejectedRequestsCount:' + str(self.RejectedRequestsCount) + ')'

    __repr__ = __str__


class ServerStatusDataType(FrozenClass):
    '''
    :ivar StartTime:
    :vartype StartTime: DateTime
    :ivar CurrentTime:
    :vartype CurrentTime: DateTime
    :ivar State:
    :vartype State: ServerState
    :ivar BuildInfo:
    :vartype BuildInfo: BuildInfo
    :ivar SecondsTillShutdown:
    :vartype SecondsTillShutdown: UInt32
    :ivar ShutdownReason:
    :vartype ShutdownReason: LocalizedText
    '''

    ua_types = {
        'StartTime': 'DateTime',
        'CurrentTime': 'DateTime',
        'State': 'ServerState',
        'BuildInfo': 'BuildInfo',
        'SecondsTillShutdown': 'UInt32',
        'ShutdownReason': 'LocalizedText',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.StartTime = datetime.utcnow()
        self.CurrentTime = datetime.utcnow()
        self.State = ServerState(0)
        self.BuildInfo = BuildInfo()
        self.SecondsTillShutdown = 0
        self.ShutdownReason = LocalizedText()
        self._freeze = True


        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.NumValuesPerNode = 0
        self.StartTime = datetime.utcnow()
        self.EndTime = datetime.utcnow()
        self.Filter = EventFilter()
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uabin.Primitives.UInt32.pack(self.NumValuesPerNode))
        packet.append(uabin.Primitives.DateTime.pack(self.StartTime))
        packet.append(uabin.Primitives.DateTime.pack(self.EndTime))
        packet.append(self.Filter.to_binary())
        return b''.join(packet)

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

    def _binary_init(self, data):
        self.NumValuesPerNode = uabin.Primitives.UInt32.unpack(data)
        self.StartTime = uabin.Primitives.DateTime.unpack(data)
        self.EndTime = uabin.Primitives.DateTime.unpack(data)
        self.Filter = EventFilter.from_binary(data)

    def __str__(self):
        return 'ReadEventDetails(' + 'NumValuesPerNode:' + str(self.NumValuesPerNode) + ', ' + \
               'StartTime:' + str(self.StartTime) + ', ' + \
               'EndTime:' + str(self.EndTime) + ', ' + \
               'Filter:' + str(self.Filter) + ')'

    __repr__ = __str__


class ReadRawModifiedDetails(FrozenClass):
    '''
    :ivar IsReadModified:
    :vartype IsReadModified: Boolean
    :ivar StartTime:
    :vartype StartTime: DateTime
    :ivar EndTime:
    :vartype EndTime: DateTime
    :ivar NumValuesPerNode:
    :vartype NumValuesPerNode: UInt32
    :ivar ReturnBounds:
    :vartype ReturnBounds: Boolean
    '''

    ua_types = {
        'IsReadModified': 'Boolean',
        'StartTime': 'DateTime',
        'EndTime': 'DateTime',
        'NumValuesPerNode': 'UInt32',
        'ReturnBounds': 'Boolean',
               }

    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.IsReadModified = True
        self.StartTime = datetime.utcnow()
        self.EndTime = datetime.utcnow()
        self.NumValuesPerNode = 0

		@@ 4777-4847 (lines=71) @@
4774
4775		class DataTypeAttributes(FrozenClass):
4776		'''
4777		The attributes for a data type node.
4778
4779		:ivar SpecifiedAttributes:
4780		:vartype SpecifiedAttributes: UInt32
4781		:ivar DisplayName:
4782		:vartype DisplayName: LocalizedText
4783		:ivar Description:
4784		:vartype Description: LocalizedText
4785		:ivar WriteMask:
4786		:vartype WriteMask: UInt32
4787		:ivar UserWriteMask:
4788		:vartype UserWriteMask: UInt32
4789		:ivar IsAbstract:
4790		:vartype IsAbstract: Boolean
4791		'''
4792
4793		ua_types = {
4794		'SpecifiedAttributes': 'UInt32',
4795		'DisplayName': 'LocalizedText',
4796		'Description': 'LocalizedText',
4797		'WriteMask': 'UInt32',
4798		'UserWriteMask': 'UInt32',
4799		'IsAbstract': 'Boolean',
4800		}
4801
4802		def __init__(self, binary=None):
4803		if binary is not None:
4804		self._binary_init(binary)
4805		self._freeze = True
4806		return
4807		self.SpecifiedAttributes = 0
4808		self.DisplayName = LocalizedText()
4809		self.Description = LocalizedText()
4810		self.WriteMask = 0
4811		self.UserWriteMask = 0
4812		self.IsAbstract = True
4813		self._freeze = True
4814
4815		def to_binary(self):
4816		packet = []
4817		packet.append(uabin.Primitives.UInt32.pack(self.SpecifiedAttributes))
4818		packet.append(self.DisplayName.to_binary())
4819		packet.append(self.Description.to_binary())
4820		packet.append(uabin.Primitives.UInt32.pack(self.WriteMask))
4821		packet.append(uabin.Primitives.UInt32.pack(self.UserWriteMask))
4822		packet.append(uabin.Primitives.Boolean.pack(self.IsAbstract))
4823		return b''.join(packet)
4824
4825		@staticmethod
4826		def from_binary(data):
4827		return DataTypeAttributes(data)
4828
4829		def _binary_init(self, data):
4830		self.SpecifiedAttributes = uabin.Primitives.UInt32.unpack(data)
4831		self.DisplayName = LocalizedText.from_binary(data)
4832		self.Description = LocalizedText.from_binary(data)
4833		self.WriteMask = uabin.Primitives.UInt32.unpack(data)
4834		self.UserWriteMask = uabin.Primitives.UInt32.unpack(data)
4835		self.IsAbstract = uabin.Primitives.Boolean.unpack(data)
4836
4837		def __str__(self):
4838		return 'DataTypeAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \
4839		'DisplayName:' + str(self.DisplayName) + ', ' + \
4840		'Description:' + str(self.Description) + ', ' + \
4841		'WriteMask:' + str(self.WriteMask) + ', ' + \
4842		'UserWriteMask:' + str(self.UserWriteMask) + ', ' + \
4843		'IsAbstract:' + str(self.IsAbstract) + ')'
4844
4845		__repr__ = __str__
4846
4847
4848		class ViewAttributes(FrozenClass):
4849		'''
4850		The attributes for a view node.
		@@ 4514-4584 (lines=71) @@
4511
4512		class ObjectTypeAttributes(FrozenClass):
4513		'''
4514		The attributes for an object type node.
4515
4516		:ivar SpecifiedAttributes:
4517		:vartype SpecifiedAttributes: UInt32
4518		:ivar DisplayName:
4519		:vartype DisplayName: LocalizedText
4520		:ivar Description:
4521		:vartype Description: LocalizedText
4522		:ivar WriteMask:
4523		:vartype WriteMask: UInt32
4524		:ivar UserWriteMask:
4525		:vartype UserWriteMask: UInt32
4526		:ivar IsAbstract:
4527		:vartype IsAbstract: Boolean
4528		'''
4529
4530		ua_types = {
4531		'SpecifiedAttributes': 'UInt32',
4532		'DisplayName': 'LocalizedText',
4533		'Description': 'LocalizedText',
4534		'WriteMask': 'UInt32',
4535		'UserWriteMask': 'UInt32',
4536		'IsAbstract': 'Boolean',
4537		}
4538
4539		def __init__(self, binary=None):
4540		if binary is not None:
4541		self._binary_init(binary)
4542		self._freeze = True
4543		return
4544		self.SpecifiedAttributes = 0
4545		self.DisplayName = LocalizedText()
4546		self.Description = LocalizedText()
4547		self.WriteMask = 0
4548		self.UserWriteMask = 0
4549		self.IsAbstract = True
4550		self._freeze = True
4551
4552		def to_binary(self):
4553		packet = []
4554		packet.append(uabin.Primitives.UInt32.pack(self.SpecifiedAttributes))
4555		packet.append(self.DisplayName.to_binary())
4556		packet.append(self.Description.to_binary())
4557		packet.append(uabin.Primitives.UInt32.pack(self.WriteMask))
4558		packet.append(uabin.Primitives.UInt32.pack(self.UserWriteMask))
4559		packet.append(uabin.Primitives.Boolean.pack(self.IsAbstract))
4560		return b''.join(packet)
4561
4562		@staticmethod
4563		def from_binary(data):
4564		return ObjectTypeAttributes(data)
4565
4566		def _binary_init(self, data):
4567		self.SpecifiedAttributes = uabin.Primitives.UInt32.unpack(data)
4568		self.DisplayName = LocalizedText.from_binary(data)
4569		self.Description = LocalizedText.from_binary(data)
4570		self.WriteMask = uabin.Primitives.UInt32.unpack(data)
4571		self.UserWriteMask = uabin.Primitives.UInt32.unpack(data)
4572		self.IsAbstract = uabin.Primitives.Boolean.unpack(data)
4573
4574		def __str__(self):
4575		return 'ObjectTypeAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \
4576		'DisplayName:' + str(self.DisplayName) + ', ' + \
4577		'Description:' + str(self.Description) + ', ' + \
4578		'WriteMask:' + str(self.WriteMask) + ', ' + \
4579		'UserWriteMask:' + str(self.UserWriteMask) + ', ' + \
4580		'IsAbstract:' + str(self.IsAbstract) + ')'
4581
4582		__repr__ = __str__
4583
4584
4585		class VariableTypeAttributes(FrozenClass):
4586		'''
4587		The attributes for a variable type node.
		@@ 5963-6033 (lines=71) @@
5960		'ViewVersion': 'UInt32',
5961		}
5962
5963		def __init__(self, binary=None):
5964		if binary is not None:
5965		self._binary_init(binary)
5966		self._freeze = True
5967		return
5968		self.ViewId = NodeId()
5969		self.Timestamp = datetime.utcnow()
5970		self.ViewVersion = 0
5971		self._freeze = True
5972
5973		def to_binary(self):
5974		packet = []
5975		packet.append(self.ViewId.to_binary())
5976		packet.append(uabin.Primitives.DateTime.pack(self.Timestamp))
5977		packet.append(uabin.Primitives.UInt32.pack(self.ViewVersion))
5978		return b''.join(packet)
5979
5980		@staticmethod
5981		def from_binary(data):
5982		return ViewDescription(data)
5983
5984		def _binary_init(self, data):
5985		self.ViewId = NodeId.from_binary(data)
5986		self.Timestamp = uabin.Primitives.DateTime.unpack(data)
5987		self.ViewVersion = uabin.Primitives.UInt32.unpack(data)
5988
5989		def __str__(self):
5990		return 'ViewDescription(' + 'ViewId:' + str(self.ViewId) + ', ' + \
5991		'Timestamp:' + str(self.Timestamp) + ', ' + \
5992		'ViewVersion:' + str(self.ViewVersion) + ')'
5993
5994		__repr__ = __str__
5995
5996
5997		class BrowseDescription(FrozenClass):
5998		'''
5999		A request to browse the the references from a node.
6000
6001		:ivar NodeId:
6002		:vartype NodeId: NodeId
6003		:ivar BrowseDirection:
6004		:vartype BrowseDirection: BrowseDirection
6005		:ivar ReferenceTypeId:
6006		:vartype ReferenceTypeId: NodeId
6007		:ivar IncludeSubtypes:
6008		:vartype IncludeSubtypes: Boolean
6009		:ivar NodeClassMask:
6010		:vartype NodeClassMask: UInt32
6011		:ivar ResultMask:
6012		:vartype ResultMask: UInt32
6013		'''
6014
6015		ua_types = {
6016		'NodeId': 'NodeId',
6017		'BrowseDirection': 'BrowseDirection',
6018		'ReferenceTypeId': 'NodeId',
6019		'IncludeSubtypes': 'Boolean',
6020		'NodeClassMask': 'UInt32',
6021		'ResultMask': 'UInt32',
6022		}
6023
6024		def __init__(self, binary=None):
6025		if binary is not None:
6026		self._binary_init(binary)
6027		self._freeze = True
6028		return
6029		self.NodeId = NodeId()
6030		self.BrowseDirection = BrowseDirection(0)
6031		self.ReferenceTypeId = NodeId()
6032		self.IncludeSubtypes = True
6033		self.NodeClassMask = 0
6034		self.ResultMask = 0
6035		self._freeze = True
6036
		@@ 5223-5293 (lines=71) @@
5220
5221		class AddReferencesItem(FrozenClass):
5222		'''
5223		A request to add a reference to the server address space.
5224
5225		:ivar SourceNodeId:
5226		:vartype SourceNodeId: NodeId
5227		:ivar ReferenceTypeId:
5228		:vartype ReferenceTypeId: NodeId
5229		:ivar IsForward:
5230		:vartype IsForward: Boolean
5231		:ivar TargetServerUri:
5232		:vartype TargetServerUri: String
5233		:ivar TargetNodeId:
5234		:vartype TargetNodeId: ExpandedNodeId
5235		:ivar TargetNodeClass:
5236		:vartype TargetNodeClass: NodeClass
5237		'''
5238
5239		ua_types = {
5240		'SourceNodeId': 'NodeId',
5241		'ReferenceTypeId': 'NodeId',
5242		'IsForward': 'Boolean',
5243		'TargetServerUri': 'String',
5244		'TargetNodeId': 'ExpandedNodeId',
5245		'TargetNodeClass': 'NodeClass',
5246		}
5247
5248		def __init__(self, binary=None):
5249		if binary is not None:
5250		self._binary_init(binary)
5251		self._freeze = True
5252		return
5253		self.SourceNodeId = NodeId()
5254		self.ReferenceTypeId = NodeId()
5255		self.IsForward = True
5256		self.TargetServerUri = None
5257		self.TargetNodeId = ExpandedNodeId()
5258		self.TargetNodeClass = NodeClass(0)
5259		self._freeze = True
5260
5261		def to_binary(self):
5262		packet = []
5263		packet.append(self.SourceNodeId.to_binary())
5264		packet.append(self.ReferenceTypeId.to_binary())
5265		packet.append(uabin.Primitives.Boolean.pack(self.IsForward))
5266		packet.append(uabin.Primitives.String.pack(self.TargetServerUri))
5267		packet.append(self.TargetNodeId.to_binary())
5268		packet.append(uabin.Primitives.UInt32.pack(self.TargetNodeClass.value))
5269		return b''.join(packet)
5270
5271		@staticmethod
5272		def from_binary(data):
5273		return AddReferencesItem(data)
5274
5275		def _binary_init(self, data):
5276		self.SourceNodeId = NodeId.from_binary(data)
5277		self.ReferenceTypeId = NodeId.from_binary(data)
5278		self.IsForward = uabin.Primitives.Boolean.unpack(data)
5279		self.TargetServerUri = uabin.Primitives.String.unpack(data)
5280		self.TargetNodeId = ExpandedNodeId.from_binary(data)
5281		self.TargetNodeClass = NodeClass(uabin.Primitives.UInt32.unpack(data))
5282
5283		def __str__(self):
5284		return 'AddReferencesItem(' + 'SourceNodeId:' + str(self.SourceNodeId) + ', ' + \
5285		'ReferenceTypeId:' + str(self.ReferenceTypeId) + ', ' + \
5286		'IsForward:' + str(self.IsForward) + ', ' + \
5287		'TargetServerUri:' + str(self.TargetServerUri) + ', ' + \
5288		'TargetNodeId:' + str(self.TargetNodeId) + ', ' + \
5289		'TargetNodeClass:' + str(self.TargetNodeClass) + ')'
5290
5291		__repr__ = __str__
5292
5293
5294		class AddReferencesParameters(FrozenClass):
5295		'''
5296		:ivar ReferencesToAdd:
		@@ 4237-4307 (lines=71) @@
4234
4235		class ObjectAttributes(FrozenClass):
4236		'''
4237		The attributes for an object node.
4238
4239		:ivar SpecifiedAttributes:
4240		:vartype SpecifiedAttributes: UInt32
4241		:ivar DisplayName:
4242		:vartype DisplayName: LocalizedText
4243		:ivar Description:
4244		:vartype Description: LocalizedText
4245		:ivar WriteMask:
4246		:vartype WriteMask: UInt32
4247		:ivar UserWriteMask:
4248		:vartype UserWriteMask: UInt32
4249		:ivar EventNotifier:
4250		:vartype EventNotifier: Byte
4251		'''
4252
4253		ua_types = {
4254		'SpecifiedAttributes': 'UInt32',
4255		'DisplayName': 'LocalizedText',
4256		'Description': 'LocalizedText',
4257		'WriteMask': 'UInt32',
4258		'UserWriteMask': 'UInt32',
4259		'EventNotifier': 'Byte',
4260		}
4261
4262		def __init__(self, binary=None):
4263		if binary is not None:
4264		self._binary_init(binary)
4265		self._freeze = True
4266		return
4267		self.SpecifiedAttributes = 0
4268		self.DisplayName = LocalizedText()
4269		self.Description = LocalizedText()
4270		self.WriteMask = 0
4271		self.UserWriteMask = 0
4272		self.EventNotifier = 0
4273		self._freeze = True
4274
4275		def to_binary(self):
4276		packet = []
4277		packet.append(uabin.Primitives.UInt32.pack(self.SpecifiedAttributes))
4278		packet.append(self.DisplayName.to_binary())
4279		packet.append(self.Description.to_binary())
4280		packet.append(uabin.Primitives.UInt32.pack(self.WriteMask))
4281		packet.append(uabin.Primitives.UInt32.pack(self.UserWriteMask))
4282		packet.append(uabin.Primitives.Byte.pack(self.EventNotifier))
4283		return b''.join(packet)
4284
4285		@staticmethod
4286		def from_binary(data):
4287		return ObjectAttributes(data)
4288
4289		def _binary_init(self, data):
4290		self.SpecifiedAttributes = uabin.Primitives.UInt32.unpack(data)
4291		self.DisplayName = LocalizedText.from_binary(data)
4292		self.Description = LocalizedText.from_binary(data)
4293		self.WriteMask = uabin.Primitives.UInt32.unpack(data)
4294		self.UserWriteMask = uabin.Primitives.UInt32.unpack(data)
4295		self.EventNotifier = uabin.Primitives.Byte.unpack(data)
4296
4297		def __str__(self):
4298		return 'ObjectAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \
4299		'DisplayName:' + str(self.DisplayName) + ', ' + \
4300		'Description:' + str(self.Description) + ', ' + \
4301		'WriteMask:' + str(self.WriteMask) + ', ' + \
4302		'UserWriteMask:' + str(self.UserWriteMask) + ', ' + \
4303		'EventNotifier:' + str(self.EventNotifier) + ')'
4304
4305		__repr__ = __str__
4306
4307
4308		class VariableAttributes(FrozenClass):
4309		'''
4310		The attributes for a variable node.
		@@ 10961-11022 (lines=62) @@
10958		def __init__(self, binary=None):
10959		if binary is not None:
10960		self._binary_init(binary)
10961		self._freeze = True
10962		return
10963		self.SelectClauses = []
10964		self.WhereClause = ContentFilter()
10965		self._freeze = True
10966
10967		def to_binary(self):
10968		packet = []
10969		packet.append(uabin.Primitives.Int32.pack(len(self.SelectClauses)))
10970		for fieldname in self.SelectClauses:
10971		packet.append(fieldname.to_binary())
10972		packet.append(self.WhereClause.to_binary())
10973		return b''.join(packet)
10974
10975		@staticmethod
10976		def from_binary(data):
10977		return EventFilter(data)
10978
10979		def _binary_init(self, data):
10980		length = uabin.Primitives.Int32.unpack(data)
10981		array = []
10982		if length != -1:
10983		for _ in range(0, length):
10984		array.append(SimpleAttributeOperand.from_binary(data))
10985		self.SelectClauses = array
10986		self.WhereClause = ContentFilter.from_binary(data)
10987
10988		def __str__(self):
10989		return 'EventFilter(' + 'SelectClauses:' + str(self.SelectClauses) + ', ' + \
10990		'WhereClause:' + str(self.WhereClause) + ')'
10991
10992		__repr__ = __str__
10993
10994
10995		class AggregateConfiguration(FrozenClass):
10996		'''
10997		:ivar UseServerCapabilitiesDefaults:
10998		:vartype UseServerCapabilitiesDefaults: Boolean
10999		:ivar TreatUncertainAsBad:
11000		:vartype TreatUncertainAsBad: Boolean
11001		:ivar PercentDataBad:
11002		:vartype PercentDataBad: Byte
11003		:ivar PercentDataGood:
11004		:vartype PercentDataGood: Byte
11005		:ivar UseSlopedExtrapolation:
11006		:vartype UseSlopedExtrapolation: Boolean
11007		'''
11008
11009		ua_types = {
11010		'UseServerCapabilitiesDefaults': 'Boolean',
11011		'TreatUncertainAsBad': 'Boolean',
11012		'PercentDataBad': 'Byte',
11013		'PercentDataGood': 'Byte',
11014		'UseSlopedExtrapolation': 'Boolean',
11015		}
11016
11017		def __init__(self, binary=None):
11018		if binary is not None:
11019		self._binary_init(binary)
11020		self._freeze = True
11021		return
11022		self.UseServerCapabilitiesDefaults = True
11023		self.TreatUncertainAsBad = True
11024		self.PercentDataBad = 0
11025		self.PercentDataGood = 0
		@@ 14701-14769 (lines=69) @@
14698		return b''.join(packet)
14699
14700		@staticmethod
14701		def from_binary(data):
14702		return ServerDiagnosticsSummaryDataType(data)
14703
14704		def _binary_init(self, data):
14705		self.ServerViewCount = uabin.Primitives.UInt32.unpack(data)
14706		self.CurrentSessionCount = uabin.Primitives.UInt32.unpack(data)
14707		self.CumulatedSessionCount = uabin.Primitives.UInt32.unpack(data)
14708		self.SecurityRejectedSessionCount = uabin.Primitives.UInt32.unpack(data)
14709		self.RejectedSessionCount = uabin.Primitives.UInt32.unpack(data)
14710		self.SessionTimeoutCount = uabin.Primitives.UInt32.unpack(data)
14711		self.SessionAbortCount = uabin.Primitives.UInt32.unpack(data)
14712		self.CurrentSubscriptionCount = uabin.Primitives.UInt32.unpack(data)
14713		self.CumulatedSubscriptionCount = uabin.Primitives.UInt32.unpack(data)
14714		self.PublishingIntervalCount = uabin.Primitives.UInt32.unpack(data)
14715		self.SecurityRejectedRequestsCount = uabin.Primitives.UInt32.unpack(data)
14716		self.RejectedRequestsCount = uabin.Primitives.UInt32.unpack(data)
14717
14718		def __str__(self):
14719		return 'ServerDiagnosticsSummaryDataType(' + 'ServerViewCount:' + str(self.ServerViewCount) + ', ' + \
14720		'CurrentSessionCount:' + str(self.CurrentSessionCount) + ', ' + \
14721		'CumulatedSessionCount:' + str(self.CumulatedSessionCount) + ', ' + \
14722		'SecurityRejectedSessionCount:' + str(self.SecurityRejectedSessionCount) + ', ' + \
14723		'RejectedSessionCount:' + str(self.RejectedSessionCount) + ', ' + \
14724		'SessionTimeoutCount:' + str(self.SessionTimeoutCount) + ', ' + \
14725		'SessionAbortCount:' + str(self.SessionAbortCount) + ', ' + \
14726		'CurrentSubscriptionCount:' + str(self.CurrentSubscriptionCount) + ', ' + \
14727		'CumulatedSubscriptionCount:' + str(self.CumulatedSubscriptionCount) + ', ' + \
14728		'PublishingIntervalCount:' + str(self.PublishingIntervalCount) + ', ' + \
14729		'SecurityRejectedRequestsCount:' + str(self.SecurityRejectedRequestsCount) + ', ' + \
14730		'RejectedRequestsCount:' + str(self.RejectedRequestsCount) + ')'
14731
14732		__repr__ = __str__
14733
14734
14735		class ServerStatusDataType(FrozenClass):
14736		'''
14737		:ivar StartTime:
14738		:vartype StartTime: DateTime
14739		:ivar CurrentTime:
14740		:vartype CurrentTime: DateTime
14741		:ivar State:
14742		:vartype State: ServerState
14743		:ivar BuildInfo:
14744		:vartype BuildInfo: BuildInfo
14745		:ivar SecondsTillShutdown:
14746		:vartype SecondsTillShutdown: UInt32
14747		:ivar ShutdownReason:
14748		:vartype ShutdownReason: LocalizedText
14749		'''
14750
14751		ua_types = {
14752		'StartTime': 'DateTime',
14753		'CurrentTime': 'DateTime',
14754		'State': 'ServerState',
14755		'BuildInfo': 'BuildInfo',
14756		'SecondsTillShutdown': 'UInt32',
14757		'ShutdownReason': 'LocalizedText',
14758		}
14759
14760		def __init__(self, binary=None):
14761		if binary is not None:
14762		self._binary_init(binary)
14763		self._freeze = True
14764		return
14765		self.StartTime = datetime.utcnow()
14766		self.CurrentTime = datetime.utcnow()
14767		self.State = ServerState(0)
14768		self.BuildInfo = BuildInfo()
14769		self.SecondsTillShutdown = 0
14770		self.ShutdownReason = LocalizedText()
14771		self._freeze = True
14772
		@@ 9163-9224 (lines=62) @@
9160		if binary is not None:
9161		self._binary_init(binary)
9162		self._freeze = True
9163		return
9164		self.NumValuesPerNode = 0
9165		self.StartTime = datetime.utcnow()
9166		self.EndTime = datetime.utcnow()
9167		self.Filter = EventFilter()
9168		self._freeze = True
9169
9170		def to_binary(self):
9171		packet = []
9172		packet.append(uabin.Primitives.UInt32.pack(self.NumValuesPerNode))
9173		packet.append(uabin.Primitives.DateTime.pack(self.StartTime))
9174		packet.append(uabin.Primitives.DateTime.pack(self.EndTime))
9175		packet.append(self.Filter.to_binary())
9176		return b''.join(packet)
9177
9178		@staticmethod
9179		def from_binary(data):
9180		return ReadEventDetails(data)
9181
9182		def _binary_init(self, data):
9183		self.NumValuesPerNode = uabin.Primitives.UInt32.unpack(data)
9184		self.StartTime = uabin.Primitives.DateTime.unpack(data)
9185		self.EndTime = uabin.Primitives.DateTime.unpack(data)
9186		self.Filter = EventFilter.from_binary(data)
9187
9188		def __str__(self):
9189		return 'ReadEventDetails(' + 'NumValuesPerNode:' + str(self.NumValuesPerNode) + ', ' + \
9190		'StartTime:' + str(self.StartTime) + ', ' + \
9191		'EndTime:' + str(self.EndTime) + ', ' + \
9192		'Filter:' + str(self.Filter) + ')'
9193
9194		__repr__ = __str__
9195
9196
9197		class ReadRawModifiedDetails(FrozenClass):
9198		'''
9199		:ivar IsReadModified:
9200		:vartype IsReadModified: Boolean
9201		:ivar StartTime:
9202		:vartype StartTime: DateTime
9203		:ivar EndTime:
9204		:vartype EndTime: DateTime
9205		:ivar NumValuesPerNode:
9206		:vartype NumValuesPerNode: UInt32
9207		:ivar ReturnBounds:
9208		:vartype ReturnBounds: Boolean
9209		'''
9210
9211		ua_types = {
9212		'IsReadModified': 'Boolean',
9213		'StartTime': 'DateTime',
9214		'EndTime': 'DateTime',
9215		'NumValuesPerNode': 'UInt32',
9216		'ReturnBounds': 'Boolean',
9217		}
9218
9219		def __init__(self, binary=None):
9220		if binary is not None:
9221		self._binary_init(binary)
9222		self._freeze = True
9223		return
9224		self.IsReadModified = True
9225		self.StartTime = datetime.utcnow()
9226		self.EndTime = datetime.utcnow()
9227		self.NumValuesPerNode = 0

FreeOpcUa / python-opcua

Code Duplication Length = 62-71 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations