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


    __repr__ = __str__


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

    __repr__ = __str__


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

        'ViewId': 'NodeId',
        'Timestamp': 'DateTime',
        '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

    __repr__ = __str__


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

    __repr__ = __str__


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

               }

    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

        packet.append(uabin.Primitives.UInt32.pack(self.SecurityRejectedRequestsCount))
        packet.append(uabin.Primitives.UInt32.pack(self.RejectedRequestsCount))
        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()


    def __init__(self, binary=None):
        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()

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

FreeOpcUa / python-opcua

Code Duplication Length = 62-71 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations