|
@@ 6947-7017 (lines=71) @@
|
| 6944 |
|
:vartype ReferenceTypeId: NodeId |
| 6945 |
|
:ivar IsInverse: |
| 6946 |
|
:vartype IsInverse: Boolean |
| 6947 |
|
:ivar IncludeSubtypes: |
| 6948 |
|
:vartype IncludeSubtypes: Boolean |
| 6949 |
|
:ivar TargetName: |
| 6950 |
|
:vartype TargetName: QualifiedName |
| 6951 |
|
''' |
| 6952 |
|
|
| 6953 |
|
ua_types = ( |
| 6954 |
|
|
| 6955 |
|
('ReferenceTypeId', 'NodeId'), |
| 6956 |
|
('IsInverse', 'Boolean'), |
| 6957 |
|
('IncludeSubtypes', 'Boolean'), |
| 6958 |
|
('TargetName', 'QualifiedName'), |
| 6959 |
|
) |
| 6960 |
|
|
| 6961 |
|
def __init__(self, binary=None): |
| 6962 |
|
if binary is not None: |
| 6963 |
|
self._binary_init(binary) |
| 6964 |
|
self._freeze = True |
| 6965 |
|
return |
| 6966 |
|
self.ReferenceTypeId = NodeId() |
| 6967 |
|
self.IsInverse = True |
| 6968 |
|
self.IncludeSubtypes = True |
| 6969 |
|
self.TargetName = QualifiedName() |
| 6970 |
|
self._freeze = True |
| 6971 |
|
|
| 6972 |
|
def to_binary(self): |
| 6973 |
|
packet = [] |
| 6974 |
|
packet.append(self.ReferenceTypeId.to_binary()) |
| 6975 |
|
packet.append(uabin.Primitives.Boolean.pack(self.IsInverse)) |
| 6976 |
|
packet.append(uabin.Primitives.Boolean.pack(self.IncludeSubtypes)) |
| 6977 |
|
packet.append(self.TargetName.to_binary()) |
| 6978 |
|
return b''.join(packet) |
| 6979 |
|
|
| 6980 |
|
@staticmethod |
| 6981 |
|
def from_binary(data): |
| 6982 |
|
return RelativePathElement(data) |
| 6983 |
|
|
| 6984 |
|
def _binary_init(self, data): |
| 6985 |
|
self.ReferenceTypeId = NodeId.from_binary(data) |
| 6986 |
|
self.IsInverse = uabin.Primitives.Boolean.unpack(data) |
| 6987 |
|
self.IncludeSubtypes = uabin.Primitives.Boolean.unpack(data) |
| 6988 |
|
self.TargetName = QualifiedName.from_binary(data) |
| 6989 |
|
|
| 6990 |
|
def __str__(self): |
| 6991 |
|
return 'RelativePathElement(' + 'ReferenceTypeId:' + str(self.ReferenceTypeId) + ', ' + \ |
| 6992 |
|
'IsInverse:' + str(self.IsInverse) + ', ' + \ |
| 6993 |
|
'IncludeSubtypes:' + str(self.IncludeSubtypes) + ', ' + \ |
| 6994 |
|
'TargetName:' + str(self.TargetName) + ')' |
| 6995 |
|
|
| 6996 |
|
__repr__ = __str__ |
| 6997 |
|
|
| 6998 |
|
|
| 6999 |
|
class RelativePath(FrozenClass): |
| 7000 |
|
''' |
| 7001 |
|
A relative path constructed from reference types and browse names. |
| 7002 |
|
|
| 7003 |
|
:ivar Elements: |
| 7004 |
|
:vartype Elements: RelativePathElement |
| 7005 |
|
''' |
| 7006 |
|
|
| 7007 |
|
ua_types = ( |
| 7008 |
|
|
| 7009 |
|
('Elements', 'ListOfRelativePathElement'), |
| 7010 |
|
) |
| 7011 |
|
|
| 7012 |
|
def __init__(self, binary=None): |
| 7013 |
|
if binary is not None: |
| 7014 |
|
self._binary_init(binary) |
| 7015 |
|
self._freeze = True |
| 7016 |
|
return |
| 7017 |
|
self.Elements = [] |
| 7018 |
|
self._freeze = True |
| 7019 |
|
|
| 7020 |
|
def to_binary(self): |
|
@@ 6327-6397 (lines=71) @@
|
| 6324 |
|
'ViewVersion:' + str(self.ViewVersion) + ')' |
| 6325 |
|
|
| 6326 |
|
__repr__ = __str__ |
| 6327 |
|
|
| 6328 |
|
|
| 6329 |
|
class BrowseDescription(FrozenClass): |
| 6330 |
|
''' |
| 6331 |
|
A request to browse the the references from a node. |
| 6332 |
|
|
| 6333 |
|
:ivar NodeId: |
| 6334 |
|
:vartype NodeId: NodeId |
| 6335 |
|
:ivar BrowseDirection: |
| 6336 |
|
:vartype BrowseDirection: BrowseDirection |
| 6337 |
|
:ivar ReferenceTypeId: |
| 6338 |
|
:vartype ReferenceTypeId: NodeId |
| 6339 |
|
:ivar IncludeSubtypes: |
| 6340 |
|
:vartype IncludeSubtypes: Boolean |
| 6341 |
|
:ivar NodeClassMask: |
| 6342 |
|
:vartype NodeClassMask: UInt32 |
| 6343 |
|
:ivar ResultMask: |
| 6344 |
|
:vartype ResultMask: UInt32 |
| 6345 |
|
''' |
| 6346 |
|
|
| 6347 |
|
ua_types = ( |
| 6348 |
|
|
| 6349 |
|
('NodeId', 'NodeId'), |
| 6350 |
|
('BrowseDirection', 'BrowseDirection'), |
| 6351 |
|
('ReferenceTypeId', 'NodeId'), |
| 6352 |
|
('IncludeSubtypes', 'Boolean'), |
| 6353 |
|
('NodeClassMask', 'UInt32'), |
| 6354 |
|
('ResultMask', 'UInt32'), |
| 6355 |
|
) |
| 6356 |
|
|
| 6357 |
|
def __init__(self, binary=None): |
| 6358 |
|
if binary is not None: |
| 6359 |
|
self._binary_init(binary) |
| 6360 |
|
self._freeze = True |
| 6361 |
|
return |
| 6362 |
|
self.NodeId = NodeId() |
| 6363 |
|
self.BrowseDirection = BrowseDirection(0) |
| 6364 |
|
self.ReferenceTypeId = NodeId() |
| 6365 |
|
self.IncludeSubtypes = True |
| 6366 |
|
self.NodeClassMask = 0 |
| 6367 |
|
self.ResultMask = 0 |
| 6368 |
|
self._freeze = True |
| 6369 |
|
|
| 6370 |
|
def to_binary(self): |
| 6371 |
|
packet = [] |
| 6372 |
|
packet.append(self.NodeId.to_binary()) |
| 6373 |
|
packet.append(uabin.Primitives.UInt32.pack(self.BrowseDirection.value)) |
| 6374 |
|
packet.append(self.ReferenceTypeId.to_binary()) |
| 6375 |
|
packet.append(uabin.Primitives.Boolean.pack(self.IncludeSubtypes)) |
| 6376 |
|
packet.append(uabin.Primitives.UInt32.pack(self.NodeClassMask)) |
| 6377 |
|
packet.append(uabin.Primitives.UInt32.pack(self.ResultMask)) |
| 6378 |
|
return b''.join(packet) |
| 6379 |
|
|
| 6380 |
|
@staticmethod |
| 6381 |
|
def from_binary(data): |
| 6382 |
|
return BrowseDescription(data) |
| 6383 |
|
|
| 6384 |
|
def _binary_init(self, data): |
| 6385 |
|
self.NodeId = NodeId.from_binary(data) |
| 6386 |
|
self.BrowseDirection = BrowseDirection(uabin.Primitives.UInt32.unpack(data)) |
| 6387 |
|
self.ReferenceTypeId = NodeId.from_binary(data) |
| 6388 |
|
self.IncludeSubtypes = uabin.Primitives.Boolean.unpack(data) |
| 6389 |
|
self.NodeClassMask = uabin.Primitives.UInt32.unpack(data) |
| 6390 |
|
self.ResultMask = uabin.Primitives.UInt32.unpack(data) |
| 6391 |
|
|
| 6392 |
|
def __str__(self): |
| 6393 |
|
return 'BrowseDescription(' + 'NodeId:' + str(self.NodeId) + ', ' + \ |
| 6394 |
|
'BrowseDirection:' + str(self.BrowseDirection) + ', ' + \ |
| 6395 |
|
'ReferenceTypeId:' + str(self.ReferenceTypeId) + ', ' + \ |
| 6396 |
|
'IncludeSubtypes:' + str(self.IncludeSubtypes) + ', ' + \ |
| 6397 |
|
'NodeClassMask:' + str(self.NodeClassMask) + ', ' + \ |
| 6398 |
|
'ResultMask:' + str(self.ResultMask) + ')' |
| 6399 |
|
|
| 6400 |
|
__repr__ = __str__ |
|
@@ 5611-5681 (lines=71) @@
|
| 5608 |
|
'TargetNodeClass:' + str(self.TargetNodeClass) + ')' |
| 5609 |
|
|
| 5610 |
|
__repr__ = __str__ |
| 5611 |
|
|
| 5612 |
|
|
| 5613 |
|
class AddReferencesParameters(FrozenClass): |
| 5614 |
|
''' |
| 5615 |
|
:ivar ReferencesToAdd: |
| 5616 |
|
:vartype ReferencesToAdd: AddReferencesItem |
| 5617 |
|
''' |
| 5618 |
|
|
| 5619 |
|
ua_types = ( |
| 5620 |
|
|
| 5621 |
|
('ReferencesToAdd', 'ListOfAddReferencesItem'), |
| 5622 |
|
) |
| 5623 |
|
|
| 5624 |
|
def __init__(self, binary=None): |
| 5625 |
|
if binary is not None: |
| 5626 |
|
self._binary_init(binary) |
| 5627 |
|
self._freeze = True |
| 5628 |
|
return |
| 5629 |
|
self.ReferencesToAdd = [] |
| 5630 |
|
self._freeze = True |
| 5631 |
|
|
| 5632 |
|
def to_binary(self): |
| 5633 |
|
packet = [] |
| 5634 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.ReferencesToAdd))) |
| 5635 |
|
for fieldname in self.ReferencesToAdd: |
| 5636 |
|
packet.append(fieldname.to_binary()) |
| 5637 |
|
return b''.join(packet) |
| 5638 |
|
|
| 5639 |
|
@staticmethod |
| 5640 |
|
def from_binary(data): |
| 5641 |
|
return AddReferencesParameters(data) |
| 5642 |
|
|
| 5643 |
|
def _binary_init(self, data): |
| 5644 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 5645 |
|
array = [] |
| 5646 |
|
if length != -1: |
| 5647 |
|
for _ in range(0, length): |
| 5648 |
|
array.append(AddReferencesItem.from_binary(data)) |
| 5649 |
|
self.ReferencesToAdd = array |
| 5650 |
|
|
| 5651 |
|
def __str__(self): |
| 5652 |
|
return 'AddReferencesParameters(' + 'ReferencesToAdd:' + str(self.ReferencesToAdd) + ')' |
| 5653 |
|
|
| 5654 |
|
__repr__ = __str__ |
| 5655 |
|
|
| 5656 |
|
|
| 5657 |
|
class AddReferencesRequest(FrozenClass): |
| 5658 |
|
''' |
| 5659 |
|
Adds one or more references to the server address space. |
| 5660 |
|
|
| 5661 |
|
:ivar TypeId: |
| 5662 |
|
:vartype TypeId: NodeId |
| 5663 |
|
:ivar RequestHeader: |
| 5664 |
|
:vartype RequestHeader: RequestHeader |
| 5665 |
|
:ivar Parameters: |
| 5666 |
|
:vartype Parameters: AddReferencesParameters |
| 5667 |
|
''' |
| 5668 |
|
|
| 5669 |
|
ua_types = ( |
| 5670 |
|
|
| 5671 |
|
('TypeId', 'NodeId'), |
| 5672 |
|
('RequestHeader', 'RequestHeader'), |
| 5673 |
|
('Parameters', 'AddReferencesParameters'), |
| 5674 |
|
) |
| 5675 |
|
|
| 5676 |
|
def __init__(self, binary=None): |
| 5677 |
|
if binary is not None: |
| 5678 |
|
self._binary_init(binary) |
| 5679 |
|
self._freeze = True |
| 5680 |
|
return |
| 5681 |
|
self.TypeId = FourByteNodeId(ObjectIds.AddReferencesRequest_Encoding_DefaultBinary) |
| 5682 |
|
self.RequestHeader = RequestHeader() |
| 5683 |
|
self.Parameters = AddReferencesParameters() |
| 5684 |
|
self._freeze = True |
|
@@ 5398-5468 (lines=71) @@
|
| 5395 |
|
def from_binary(data): |
| 5396 |
|
return AddNodesParameters(data) |
| 5397 |
|
|
| 5398 |
|
def _binary_init(self, data): |
| 5399 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 5400 |
|
array = [] |
| 5401 |
|
if length != -1: |
| 5402 |
|
for _ in range(0, length): |
| 5403 |
|
array.append(AddNodesItem.from_binary(data)) |
| 5404 |
|
self.NodesToAdd = array |
| 5405 |
|
|
| 5406 |
|
def __str__(self): |
| 5407 |
|
return 'AddNodesParameters(' + 'NodesToAdd:' + str(self.NodesToAdd) + ')' |
| 5408 |
|
|
| 5409 |
|
__repr__ = __str__ |
| 5410 |
|
|
| 5411 |
|
|
| 5412 |
|
class AddNodesRequest(FrozenClass): |
| 5413 |
|
''' |
| 5414 |
|
Adds one or more nodes to the server address space. |
| 5415 |
|
|
| 5416 |
|
:ivar TypeId: |
| 5417 |
|
:vartype TypeId: NodeId |
| 5418 |
|
:ivar RequestHeader: |
| 5419 |
|
:vartype RequestHeader: RequestHeader |
| 5420 |
|
:ivar Parameters: |
| 5421 |
|
:vartype Parameters: AddNodesParameters |
| 5422 |
|
''' |
| 5423 |
|
|
| 5424 |
|
ua_types = ( |
| 5425 |
|
|
| 5426 |
|
('TypeId', 'NodeId'), |
| 5427 |
|
('RequestHeader', 'RequestHeader'), |
| 5428 |
|
('Parameters', 'AddNodesParameters'), |
| 5429 |
|
) |
| 5430 |
|
|
| 5431 |
|
def __init__(self, binary=None): |
| 5432 |
|
if binary is not None: |
| 5433 |
|
self._binary_init(binary) |
| 5434 |
|
self._freeze = True |
| 5435 |
|
return |
| 5436 |
|
self.TypeId = FourByteNodeId(ObjectIds.AddNodesRequest_Encoding_DefaultBinary) |
| 5437 |
|
self.RequestHeader = RequestHeader() |
| 5438 |
|
self.Parameters = AddNodesParameters() |
| 5439 |
|
self._freeze = True |
| 5440 |
|
|
| 5441 |
|
def to_binary(self): |
| 5442 |
|
packet = [] |
| 5443 |
|
packet.append(self.TypeId.to_binary()) |
| 5444 |
|
packet.append(self.RequestHeader.to_binary()) |
| 5445 |
|
packet.append(self.Parameters.to_binary()) |
| 5446 |
|
return b''.join(packet) |
| 5447 |
|
|
| 5448 |
|
@staticmethod |
| 5449 |
|
def from_binary(data): |
| 5450 |
|
return AddNodesRequest(data) |
| 5451 |
|
|
| 5452 |
|
def _binary_init(self, data): |
| 5453 |
|
self.TypeId = NodeId.from_binary(data) |
| 5454 |
|
self.RequestHeader = RequestHeader.from_binary(data) |
| 5455 |
|
self.Parameters = AddNodesParameters.from_binary(data) |
| 5456 |
|
|
| 5457 |
|
def __str__(self): |
| 5458 |
|
return 'AddNodesRequest(' + 'TypeId:' + str(self.TypeId) + ', ' + \ |
| 5459 |
|
'RequestHeader:' + str(self.RequestHeader) + ', ' + \ |
| 5460 |
|
'Parameters:' + str(self.Parameters) + ')' |
| 5461 |
|
|
| 5462 |
|
__repr__ = __str__ |
| 5463 |
|
|
| 5464 |
|
|
| 5465 |
|
class AddNodesResponse(FrozenClass): |
| 5466 |
|
''' |
| 5467 |
|
Adds one or more nodes to the server address space. |
| 5468 |
|
|
| 5469 |
|
:ivar TypeId: |
| 5470 |
|
:vartype TypeId: NodeId |
| 5471 |
|
:ivar ResponseHeader: |
|
@@ 5157-5227 (lines=71) @@
|
| 5154 |
|
'UserWriteMask:' + str(self.UserWriteMask) + ', ' + \ |
| 5155 |
|
'IsAbstract:' + str(self.IsAbstract) + ')' |
| 5156 |
|
|
| 5157 |
|
__repr__ = __str__ |
| 5158 |
|
|
| 5159 |
|
|
| 5160 |
|
class ViewAttributes(FrozenClass): |
| 5161 |
|
''' |
| 5162 |
|
The attributes for a view node. |
| 5163 |
|
|
| 5164 |
|
:ivar SpecifiedAttributes: |
| 5165 |
|
:vartype SpecifiedAttributes: UInt32 |
| 5166 |
|
:ivar DisplayName: |
| 5167 |
|
:vartype DisplayName: LocalizedText |
| 5168 |
|
:ivar Description: |
| 5169 |
|
:vartype Description: LocalizedText |
| 5170 |
|
:ivar WriteMask: |
| 5171 |
|
:vartype WriteMask: UInt32 |
| 5172 |
|
:ivar UserWriteMask: |
| 5173 |
|
:vartype UserWriteMask: UInt32 |
| 5174 |
|
:ivar ContainsNoLoops: |
| 5175 |
|
:vartype ContainsNoLoops: Boolean |
| 5176 |
|
:ivar EventNotifier: |
| 5177 |
|
:vartype EventNotifier: Byte |
| 5178 |
|
''' |
| 5179 |
|
|
| 5180 |
|
ua_types = ( |
| 5181 |
|
|
| 5182 |
|
('SpecifiedAttributes', 'UInt32'), |
| 5183 |
|
('DisplayName', 'LocalizedText'), |
| 5184 |
|
('Description', 'LocalizedText'), |
| 5185 |
|
('WriteMask', 'UInt32'), |
| 5186 |
|
('UserWriteMask', 'UInt32'), |
| 5187 |
|
('ContainsNoLoops', 'Boolean'), |
| 5188 |
|
('EventNotifier', 'Byte'), |
| 5189 |
|
) |
| 5190 |
|
|
| 5191 |
|
def __init__(self, binary=None): |
| 5192 |
|
if binary is not None: |
| 5193 |
|
self._binary_init(binary) |
| 5194 |
|
self._freeze = True |
| 5195 |
|
return |
| 5196 |
|
self.SpecifiedAttributes = 0 |
| 5197 |
|
self.DisplayName = LocalizedText() |
| 5198 |
|
self.Description = LocalizedText() |
| 5199 |
|
self.WriteMask = 0 |
| 5200 |
|
self.UserWriteMask = 0 |
| 5201 |
|
self.ContainsNoLoops = True |
| 5202 |
|
self.EventNotifier = 0 |
| 5203 |
|
self._freeze = True |
| 5204 |
|
|
| 5205 |
|
def to_binary(self): |
| 5206 |
|
packet = [] |
| 5207 |
|
packet.append(uabin.Primitives.UInt32.pack(self.SpecifiedAttributes)) |
| 5208 |
|
packet.append(self.DisplayName.to_binary()) |
| 5209 |
|
packet.append(self.Description.to_binary()) |
| 5210 |
|
packet.append(uabin.Primitives.UInt32.pack(self.WriteMask)) |
| 5211 |
|
packet.append(uabin.Primitives.UInt32.pack(self.UserWriteMask)) |
| 5212 |
|
packet.append(uabin.Primitives.Boolean.pack(self.ContainsNoLoops)) |
| 5213 |
|
packet.append(uabin.Primitives.Byte.pack(self.EventNotifier)) |
| 5214 |
|
return b''.join(packet) |
| 5215 |
|
|
| 5216 |
|
@staticmethod |
| 5217 |
|
def from_binary(data): |
| 5218 |
|
return ViewAttributes(data) |
| 5219 |
|
|
| 5220 |
|
def _binary_init(self, data): |
| 5221 |
|
self.SpecifiedAttributes = uabin.Primitives.UInt32.unpack(data) |
| 5222 |
|
self.DisplayName = LocalizedText.from_binary(data) |
| 5223 |
|
self.Description = LocalizedText.from_binary(data) |
| 5224 |
|
self.WriteMask = uabin.Primitives.UInt32.unpack(data) |
| 5225 |
|
self.UserWriteMask = uabin.Primitives.UInt32.unpack(data) |
| 5226 |
|
self.ContainsNoLoops = uabin.Primitives.Boolean.unpack(data) |
| 5227 |
|
self.EventNotifier = uabin.Primitives.Byte.unpack(data) |
| 5228 |
|
|
| 5229 |
|
def __str__(self): |
| 5230 |
|
return 'ViewAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \ |
|
@@ 14294-14362 (lines=69) @@
|
| 14291 |
|
('SubscriptionId', 'UInt32'), |
| 14292 |
|
('RetransmitSequenceNumber', 'UInt32'), |
| 14293 |
|
) |
| 14294 |
|
|
| 14295 |
|
def __init__(self, binary=None): |
| 14296 |
|
if binary is not None: |
| 14297 |
|
self._binary_init(binary) |
| 14298 |
|
self._freeze = True |
| 14299 |
|
return |
| 14300 |
|
self.SubscriptionId = 0 |
| 14301 |
|
self.RetransmitSequenceNumber = 0 |
| 14302 |
|
self._freeze = True |
| 14303 |
|
|
| 14304 |
|
def to_binary(self): |
| 14305 |
|
packet = [] |
| 14306 |
|
packet.append(uabin.Primitives.UInt32.pack(self.SubscriptionId)) |
| 14307 |
|
packet.append(uabin.Primitives.UInt32.pack(self.RetransmitSequenceNumber)) |
| 14308 |
|
return b''.join(packet) |
| 14309 |
|
|
| 14310 |
|
@staticmethod |
| 14311 |
|
def from_binary(data): |
| 14312 |
|
return RepublishParameters(data) |
| 14313 |
|
|
| 14314 |
|
def _binary_init(self, data): |
| 14315 |
|
self.SubscriptionId = uabin.Primitives.UInt32.unpack(data) |
| 14316 |
|
self.RetransmitSequenceNumber = uabin.Primitives.UInt32.unpack(data) |
| 14317 |
|
|
| 14318 |
|
def __str__(self): |
| 14319 |
|
return 'RepublishParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \ |
| 14320 |
|
'RetransmitSequenceNumber:' + str(self.RetransmitSequenceNumber) + ')' |
| 14321 |
|
|
| 14322 |
|
__repr__ = __str__ |
| 14323 |
|
|
| 14324 |
|
|
| 14325 |
|
class RepublishRequest(FrozenClass): |
| 14326 |
|
''' |
| 14327 |
|
:ivar TypeId: |
| 14328 |
|
:vartype TypeId: NodeId |
| 14329 |
|
:ivar RequestHeader: |
| 14330 |
|
:vartype RequestHeader: RequestHeader |
| 14331 |
|
:ivar Parameters: |
| 14332 |
|
:vartype Parameters: RepublishParameters |
| 14333 |
|
''' |
| 14334 |
|
|
| 14335 |
|
ua_types = ( |
| 14336 |
|
|
| 14337 |
|
('TypeId', 'NodeId'), |
| 14338 |
|
('RequestHeader', 'RequestHeader'), |
| 14339 |
|
('Parameters', 'RepublishParameters'), |
| 14340 |
|
) |
| 14341 |
|
|
| 14342 |
|
def __init__(self, binary=None): |
| 14343 |
|
if binary is not None: |
| 14344 |
|
self._binary_init(binary) |
| 14345 |
|
self._freeze = True |
| 14346 |
|
return |
| 14347 |
|
self.TypeId = FourByteNodeId(ObjectIds.RepublishRequest_Encoding_DefaultBinary) |
| 14348 |
|
self.RequestHeader = RequestHeader() |
| 14349 |
|
self.Parameters = RepublishParameters() |
| 14350 |
|
self._freeze = True |
| 14351 |
|
|
| 14352 |
|
def to_binary(self): |
| 14353 |
|
packet = [] |
| 14354 |
|
packet.append(self.TypeId.to_binary()) |
| 14355 |
|
packet.append(self.RequestHeader.to_binary()) |
| 14356 |
|
packet.append(self.Parameters.to_binary()) |
| 14357 |
|
return b''.join(packet) |
| 14358 |
|
|
| 14359 |
|
@staticmethod |
| 14360 |
|
def from_binary(data): |
| 14361 |
|
return RepublishRequest(data) |
| 14362 |
|
|
| 14363 |
|
def _binary_init(self, data): |
| 14364 |
|
self.TypeId = NodeId.from_binary(data) |
| 14365 |
|
self.RequestHeader = RequestHeader.from_binary(data) |
|
@@ 12454-12522 (lines=69) @@
|
| 12451 |
|
def __init__(self, binary=None): |
| 12452 |
|
if binary is not None: |
| 12453 |
|
self._binary_init(binary) |
| 12454 |
|
self._freeze = True |
| 12455 |
|
return |
| 12456 |
|
self.Results = [] |
| 12457 |
|
self.DiagnosticInfos = [] |
| 12458 |
|
self._freeze = True |
| 12459 |
|
|
| 12460 |
|
def to_binary(self): |
| 12461 |
|
packet = [] |
| 12462 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.Results))) |
| 12463 |
|
for fieldname in self.Results: |
| 12464 |
|
packet.append(fieldname.to_binary()) |
| 12465 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos))) |
| 12466 |
|
for fieldname in self.DiagnosticInfos: |
| 12467 |
|
packet.append(fieldname.to_binary()) |
| 12468 |
|
return b''.join(packet) |
| 12469 |
|
|
| 12470 |
|
@staticmethod |
| 12471 |
|
def from_binary(data): |
| 12472 |
|
return SetMonitoringModeResult(data) |
| 12473 |
|
|
| 12474 |
|
def _binary_init(self, data): |
| 12475 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 12476 |
|
array = [] |
| 12477 |
|
if length != -1: |
| 12478 |
|
for _ in range(0, length): |
| 12479 |
|
array.append(StatusCode.from_binary(data)) |
| 12480 |
|
self.Results = array |
| 12481 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 12482 |
|
array = [] |
| 12483 |
|
if length != -1: |
| 12484 |
|
for _ in range(0, length): |
| 12485 |
|
array.append(DiagnosticInfo.from_binary(data)) |
| 12486 |
|
self.DiagnosticInfos = array |
| 12487 |
|
|
| 12488 |
|
def __str__(self): |
| 12489 |
|
return 'SetMonitoringModeResult(' + 'Results:' + str(self.Results) + ', ' + \ |
| 12490 |
|
'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')' |
| 12491 |
|
|
| 12492 |
|
__repr__ = __str__ |
| 12493 |
|
|
| 12494 |
|
|
| 12495 |
|
class SetMonitoringModeResponse(FrozenClass): |
| 12496 |
|
''' |
| 12497 |
|
:ivar TypeId: |
| 12498 |
|
:vartype TypeId: NodeId |
| 12499 |
|
:ivar ResponseHeader: |
| 12500 |
|
:vartype ResponseHeader: ResponseHeader |
| 12501 |
|
:ivar Parameters: |
| 12502 |
|
:vartype Parameters: SetMonitoringModeResult |
| 12503 |
|
''' |
| 12504 |
|
|
| 12505 |
|
ua_types = ( |
| 12506 |
|
|
| 12507 |
|
('TypeId', 'NodeId'), |
| 12508 |
|
('ResponseHeader', 'ResponseHeader'), |
| 12509 |
|
('Parameters', 'SetMonitoringModeResult'), |
| 12510 |
|
) |
| 12511 |
|
|
| 12512 |
|
def __init__(self, binary=None): |
| 12513 |
|
if binary is not None: |
| 12514 |
|
self._binary_init(binary) |
| 12515 |
|
self._freeze = True |
| 12516 |
|
return |
| 12517 |
|
self.TypeId = FourByteNodeId(ObjectIds.SetMonitoringModeResponse_Encoding_DefaultBinary) |
| 12518 |
|
self.ResponseHeader = ResponseHeader() |
| 12519 |
|
self.Parameters = SetMonitoringModeResult() |
| 12520 |
|
self._freeze = True |
| 12521 |
|
|
| 12522 |
|
def to_binary(self): |
| 12523 |
|
packet = [] |
| 12524 |
|
packet.append(self.TypeId.to_binary()) |
| 12525 |
|
packet.append(self.ResponseHeader.to_binary()) |
|
@@ 11833-11901 (lines=69) @@
|
| 11830 |
|
self._freeze = True |
| 11831 |
|
return |
| 11832 |
|
self.StatusCode = StatusCode() |
| 11833 |
|
self.MonitoredItemId = 0 |
| 11834 |
|
self.RevisedSamplingInterval = 0 |
| 11835 |
|
self.RevisedQueueSize = 0 |
| 11836 |
|
self.FilterResult = None |
| 11837 |
|
self._freeze = True |
| 11838 |
|
|
| 11839 |
|
def to_binary(self): |
| 11840 |
|
packet = [] |
| 11841 |
|
packet.append(self.StatusCode.to_binary()) |
| 11842 |
|
packet.append(uabin.Primitives.UInt32.pack(self.MonitoredItemId)) |
| 11843 |
|
packet.append(uabin.Primitives.Double.pack(self.RevisedSamplingInterval)) |
| 11844 |
|
packet.append(uabin.Primitives.UInt32.pack(self.RevisedQueueSize)) |
| 11845 |
|
packet.append(extensionobject_to_binary(self.FilterResult)) |
| 11846 |
|
return b''.join(packet) |
| 11847 |
|
|
| 11848 |
|
@staticmethod |
| 11849 |
|
def from_binary(data): |
| 11850 |
|
return MonitoredItemCreateResult(data) |
| 11851 |
|
|
| 11852 |
|
def _binary_init(self, data): |
| 11853 |
|
self.StatusCode = StatusCode.from_binary(data) |
| 11854 |
|
self.MonitoredItemId = uabin.Primitives.UInt32.unpack(data) |
| 11855 |
|
self.RevisedSamplingInterval = uabin.Primitives.Double.unpack(data) |
| 11856 |
|
self.RevisedQueueSize = uabin.Primitives.UInt32.unpack(data) |
| 11857 |
|
self.FilterResult = extensionobject_from_binary(data) |
| 11858 |
|
|
| 11859 |
|
def __str__(self): |
| 11860 |
|
return 'MonitoredItemCreateResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \ |
| 11861 |
|
'MonitoredItemId:' + str(self.MonitoredItemId) + ', ' + \ |
| 11862 |
|
'RevisedSamplingInterval:' + str(self.RevisedSamplingInterval) + ', ' + \ |
| 11863 |
|
'RevisedQueueSize:' + str(self.RevisedQueueSize) + ', ' + \ |
| 11864 |
|
'FilterResult:' + str(self.FilterResult) + ')' |
| 11865 |
|
|
| 11866 |
|
__repr__ = __str__ |
| 11867 |
|
|
| 11868 |
|
|
| 11869 |
|
class CreateMonitoredItemsParameters(FrozenClass): |
| 11870 |
|
''' |
| 11871 |
|
:ivar SubscriptionId: |
| 11872 |
|
:vartype SubscriptionId: UInt32 |
| 11873 |
|
:ivar TimestampsToReturn: |
| 11874 |
|
:vartype TimestampsToReturn: TimestampsToReturn |
| 11875 |
|
:ivar ItemsToCreate: |
| 11876 |
|
:vartype ItemsToCreate: MonitoredItemCreateRequest |
| 11877 |
|
''' |
| 11878 |
|
|
| 11879 |
|
ua_types = ( |
| 11880 |
|
|
| 11881 |
|
('SubscriptionId', 'UInt32'), |
| 11882 |
|
('TimestampsToReturn', 'TimestampsToReturn'), |
| 11883 |
|
('ItemsToCreate', 'ListOfMonitoredItemCreateRequest'), |
| 11884 |
|
) |
| 11885 |
|
|
| 11886 |
|
def __init__(self, binary=None): |
| 11887 |
|
if binary is not None: |
| 11888 |
|
self._binary_init(binary) |
| 11889 |
|
self._freeze = True |
| 11890 |
|
return |
| 11891 |
|
self.SubscriptionId = 0 |
| 11892 |
|
self.TimestampsToReturn = TimestampsToReturn(0) |
| 11893 |
|
self.ItemsToCreate = [] |
| 11894 |
|
self._freeze = True |
| 11895 |
|
|
| 11896 |
|
def to_binary(self): |
| 11897 |
|
packet = [] |
| 11898 |
|
packet.append(uabin.Primitives.UInt32.pack(self.SubscriptionId)) |
| 11899 |
|
packet.append(uabin.Primitives.UInt32.pack(self.TimestampsToReturn.value)) |
| 11900 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.ItemsToCreate))) |
| 11901 |
|
for fieldname in self.ItemsToCreate: |
| 11902 |
|
packet.append(fieldname.to_binary()) |
| 11903 |
|
return b''.join(packet) |
| 11904 |
|
|
|
@@ 11555-11623 (lines=69) @@
|
| 11552 |
|
return |
| 11553 |
|
self._freeze = True |
| 11554 |
|
|
| 11555 |
|
def to_binary(self): |
| 11556 |
|
packet = [] |
| 11557 |
|
return b''.join(packet) |
| 11558 |
|
|
| 11559 |
|
@staticmethod |
| 11560 |
|
def from_binary(data): |
| 11561 |
|
return MonitoringFilterResult(data) |
| 11562 |
|
|
| 11563 |
|
def _binary_init(self, data): |
| 11564 |
|
pass |
| 11565 |
|
|
| 11566 |
|
def __str__(self): |
| 11567 |
|
return 'MonitoringFilterResult(' + + ')' |
| 11568 |
|
|
| 11569 |
|
__repr__ = __str__ |
| 11570 |
|
|
| 11571 |
|
|
| 11572 |
|
class EventFilterResult(FrozenClass): |
| 11573 |
|
''' |
| 11574 |
|
:ivar SelectClauseResults: |
| 11575 |
|
:vartype SelectClauseResults: StatusCode |
| 11576 |
|
:ivar SelectClauseDiagnosticInfos: |
| 11577 |
|
:vartype SelectClauseDiagnosticInfos: DiagnosticInfo |
| 11578 |
|
:ivar WhereClauseResult: |
| 11579 |
|
:vartype WhereClauseResult: ContentFilterResult |
| 11580 |
|
''' |
| 11581 |
|
|
| 11582 |
|
ua_types = ( |
| 11583 |
|
|
| 11584 |
|
('SelectClauseResults', 'ListOfStatusCode'), |
| 11585 |
|
('SelectClauseDiagnosticInfos', 'ListOfDiagnosticInfo'), |
| 11586 |
|
('WhereClauseResult', 'ContentFilterResult'), |
| 11587 |
|
) |
| 11588 |
|
|
| 11589 |
|
def __init__(self, binary=None): |
| 11590 |
|
if binary is not None: |
| 11591 |
|
self._binary_init(binary) |
| 11592 |
|
self._freeze = True |
| 11593 |
|
return |
| 11594 |
|
self.SelectClauseResults = [] |
| 11595 |
|
self.SelectClauseDiagnosticInfos = [] |
| 11596 |
|
self.WhereClauseResult = ContentFilterResult() |
| 11597 |
|
self._freeze = True |
| 11598 |
|
|
| 11599 |
|
def to_binary(self): |
| 11600 |
|
packet = [] |
| 11601 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.SelectClauseResults))) |
| 11602 |
|
for fieldname in self.SelectClauseResults: |
| 11603 |
|
packet.append(fieldname.to_binary()) |
| 11604 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.SelectClauseDiagnosticInfos))) |
| 11605 |
|
for fieldname in self.SelectClauseDiagnosticInfos: |
| 11606 |
|
packet.append(fieldname.to_binary()) |
| 11607 |
|
packet.append(self.WhereClauseResult.to_binary()) |
| 11608 |
|
return b''.join(packet) |
| 11609 |
|
|
| 11610 |
|
@staticmethod |
| 11611 |
|
def from_binary(data): |
| 11612 |
|
return EventFilterResult(data) |
| 11613 |
|
|
| 11614 |
|
def _binary_init(self, data): |
| 11615 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 11616 |
|
array = [] |
| 11617 |
|
if length != -1: |
| 11618 |
|
for _ in range(0, length): |
| 11619 |
|
array.append(StatusCode.from_binary(data)) |
| 11620 |
|
self.SelectClauseResults = array |
| 11621 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 11622 |
|
array = [] |
| 11623 |
|
if length != -1: |
| 11624 |
|
for _ in range(0, length): |
| 11625 |
|
array.append(DiagnosticInfo.from_binary(data)) |
| 11626 |
|
self.SelectClauseDiagnosticInfos = array |
|
@@ 10802-10870 (lines=69) @@
|
| 10799 |
|
if length != -1: |
| 10800 |
|
for _ in range(0, length): |
| 10801 |
|
array.append(DiagnosticInfo.from_binary(data)) |
| 10802 |
|
self.DiagnosticInfos = array |
| 10803 |
|
|
| 10804 |
|
def __str__(self): |
| 10805 |
|
return 'HistoryUpdateResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \ |
| 10806 |
|
'OperationResults:' + str(self.OperationResults) + ', ' + \ |
| 10807 |
|
'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')' |
| 10808 |
|
|
| 10809 |
|
__repr__ = __str__ |
| 10810 |
|
|
| 10811 |
|
|
| 10812 |
|
class HistoryUpdateParameters(FrozenClass): |
| 10813 |
|
''' |
| 10814 |
|
:ivar HistoryUpdateDetails: |
| 10815 |
|
:vartype HistoryUpdateDetails: ExtensionObject |
| 10816 |
|
''' |
| 10817 |
|
|
| 10818 |
|
ua_types = ( |
| 10819 |
|
|
| 10820 |
|
('HistoryUpdateDetails', 'ListOfExtensionObject'), |
| 10821 |
|
) |
| 10822 |
|
|
| 10823 |
|
def __init__(self, binary=None): |
| 10824 |
|
if binary is not None: |
| 10825 |
|
self._binary_init(binary) |
| 10826 |
|
self._freeze = True |
| 10827 |
|
return |
| 10828 |
|
self.HistoryUpdateDetails = [] |
| 10829 |
|
self._freeze = True |
| 10830 |
|
|
| 10831 |
|
def to_binary(self): |
| 10832 |
|
packet = [] |
| 10833 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.HistoryUpdateDetails))) |
| 10834 |
|
for fieldname in self.HistoryUpdateDetails: |
| 10835 |
|
packet.append(extensionobject_to_binary(fieldname)) |
| 10836 |
|
return b''.join(packet) |
| 10837 |
|
|
| 10838 |
|
@staticmethod |
| 10839 |
|
def from_binary(data): |
| 10840 |
|
return HistoryUpdateParameters(data) |
| 10841 |
|
|
| 10842 |
|
def _binary_init(self, data): |
| 10843 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 10844 |
|
array = [] |
| 10845 |
|
if length != -1: |
| 10846 |
|
for _ in range(0, length): |
| 10847 |
|
array.append(extensionobject_from_binary(data)) |
| 10848 |
|
self.HistoryUpdateDetails = array |
| 10849 |
|
|
| 10850 |
|
def __str__(self): |
| 10851 |
|
return 'HistoryUpdateParameters(' + 'HistoryUpdateDetails:' + str(self.HistoryUpdateDetails) + ')' |
| 10852 |
|
|
| 10853 |
|
__repr__ = __str__ |
| 10854 |
|
|
| 10855 |
|
|
| 10856 |
|
class HistoryUpdateRequest(FrozenClass): |
| 10857 |
|
''' |
| 10858 |
|
:ivar TypeId: |
| 10859 |
|
:vartype TypeId: NodeId |
| 10860 |
|
:ivar RequestHeader: |
| 10861 |
|
:vartype RequestHeader: RequestHeader |
| 10862 |
|
:ivar Parameters: |
| 10863 |
|
:vartype Parameters: HistoryUpdateParameters |
| 10864 |
|
''' |
| 10865 |
|
|
| 10866 |
|
ua_types = ( |
| 10867 |
|
|
| 10868 |
|
('TypeId', 'NodeId'), |
| 10869 |
|
('RequestHeader', 'RequestHeader'), |
| 10870 |
|
('Parameters', 'HistoryUpdateParameters'), |
| 10871 |
|
) |
| 10872 |
|
|
| 10873 |
|
def __init__(self, binary=None): |
|
@@ 10503-10571 (lines=69) @@
|
| 10500 |
|
|
| 10501 |
|
def to_binary(self): |
| 10502 |
|
packet = [] |
| 10503 |
|
packet.append(self.NodeId.to_binary()) |
| 10504 |
|
packet.append(uabin.Primitives.UInt32.pack(self.PerformInsertReplace.value)) |
| 10505 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.UpdateValues))) |
| 10506 |
|
for fieldname in self.UpdateValues: |
| 10507 |
|
packet.append(fieldname.to_binary()) |
| 10508 |
|
return b''.join(packet) |
| 10509 |
|
|
| 10510 |
|
@staticmethod |
| 10511 |
|
def from_binary(data): |
| 10512 |
|
return UpdateStructureDataDetails(data) |
| 10513 |
|
|
| 10514 |
|
def _binary_init(self, data): |
| 10515 |
|
self.NodeId = NodeId.from_binary(data) |
| 10516 |
|
self.PerformInsertReplace = PerformUpdateType(uabin.Primitives.UInt32.unpack(data)) |
| 10517 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 10518 |
|
array = [] |
| 10519 |
|
if length != -1: |
| 10520 |
|
for _ in range(0, length): |
| 10521 |
|
array.append(DataValue.from_binary(data)) |
| 10522 |
|
self.UpdateValues = array |
| 10523 |
|
|
| 10524 |
|
def __str__(self): |
| 10525 |
|
return 'UpdateStructureDataDetails(' + 'NodeId:' + str(self.NodeId) + ', ' + \ |
| 10526 |
|
'PerformInsertReplace:' + str(self.PerformInsertReplace) + ', ' + \ |
| 10527 |
|
'UpdateValues:' + str(self.UpdateValues) + ')' |
| 10528 |
|
|
| 10529 |
|
__repr__ = __str__ |
| 10530 |
|
|
| 10531 |
|
|
| 10532 |
|
class UpdateEventDetails(FrozenClass): |
| 10533 |
|
''' |
| 10534 |
|
:ivar NodeId: |
| 10535 |
|
:vartype NodeId: NodeId |
| 10536 |
|
:ivar PerformInsertReplace: |
| 10537 |
|
:vartype PerformInsertReplace: PerformUpdateType |
| 10538 |
|
:ivar Filter: |
| 10539 |
|
:vartype Filter: EventFilter |
| 10540 |
|
:ivar EventData: |
| 10541 |
|
:vartype EventData: HistoryEventFieldList |
| 10542 |
|
''' |
| 10543 |
|
|
| 10544 |
|
ua_types = ( |
| 10545 |
|
|
| 10546 |
|
('NodeId', 'NodeId'), |
| 10547 |
|
('PerformInsertReplace', 'PerformUpdateType'), |
| 10548 |
|
('Filter', 'EventFilter'), |
| 10549 |
|
('EventData', 'ListOfHistoryEventFieldList'), |
| 10550 |
|
) |
| 10551 |
|
|
| 10552 |
|
def __init__(self, binary=None): |
| 10553 |
|
if binary is not None: |
| 10554 |
|
self._binary_init(binary) |
| 10555 |
|
self._freeze = True |
| 10556 |
|
return |
| 10557 |
|
self.NodeId = NodeId() |
| 10558 |
|
self.PerformInsertReplace = PerformUpdateType(0) |
| 10559 |
|
self.Filter = EventFilter() |
| 10560 |
|
self.EventData = [] |
| 10561 |
|
self._freeze = True |
| 10562 |
|
|
| 10563 |
|
def to_binary(self): |
| 10564 |
|
packet = [] |
| 10565 |
|
packet.append(self.NodeId.to_binary()) |
| 10566 |
|
packet.append(uabin.Primitives.UInt32.pack(self.PerformInsertReplace.value)) |
| 10567 |
|
packet.append(self.Filter.to_binary()) |
| 10568 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.EventData))) |
| 10569 |
|
for fieldname in self.EventData: |
| 10570 |
|
packet.append(fieldname.to_binary()) |
| 10571 |
|
return b''.join(packet) |
| 10572 |
|
|
| 10573 |
|
@staticmethod |
| 10574 |
|
def from_binary(data): |
|
@@ 9914-9982 (lines=69) @@
|
| 9911 |
|
for _ in range(0, length): |
| 9912 |
|
array.append(ModificationInfo.from_binary(data)) |
| 9913 |
|
self.ModificationInfos = array |
| 9914 |
|
|
| 9915 |
|
def __str__(self): |
| 9916 |
|
return 'HistoryModifiedData(' + 'DataValues:' + str(self.DataValues) + ', ' + \ |
| 9917 |
|
'ModificationInfos:' + str(self.ModificationInfos) + ')' |
| 9918 |
|
|
| 9919 |
|
__repr__ = __str__ |
| 9920 |
|
|
| 9921 |
|
|
| 9922 |
|
class HistoryEvent(FrozenClass): |
| 9923 |
|
''' |
| 9924 |
|
:ivar Events: |
| 9925 |
|
:vartype Events: HistoryEventFieldList |
| 9926 |
|
''' |
| 9927 |
|
|
| 9928 |
|
ua_types = ( |
| 9929 |
|
|
| 9930 |
|
('Events', 'ListOfHistoryEventFieldList'), |
| 9931 |
|
) |
| 9932 |
|
|
| 9933 |
|
def __init__(self, binary=None): |
| 9934 |
|
if binary is not None: |
| 9935 |
|
self._binary_init(binary) |
| 9936 |
|
self._freeze = True |
| 9937 |
|
return |
| 9938 |
|
self.Events = [] |
| 9939 |
|
self._freeze = True |
| 9940 |
|
|
| 9941 |
|
def to_binary(self): |
| 9942 |
|
packet = [] |
| 9943 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.Events))) |
| 9944 |
|
for fieldname in self.Events: |
| 9945 |
|
packet.append(fieldname.to_binary()) |
| 9946 |
|
return b''.join(packet) |
| 9947 |
|
|
| 9948 |
|
@staticmethod |
| 9949 |
|
def from_binary(data): |
| 9950 |
|
return HistoryEvent(data) |
| 9951 |
|
|
| 9952 |
|
def _binary_init(self, data): |
| 9953 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 9954 |
|
array = [] |
| 9955 |
|
if length != -1: |
| 9956 |
|
for _ in range(0, length): |
| 9957 |
|
array.append(HistoryEventFieldList.from_binary(data)) |
| 9958 |
|
self.Events = array |
| 9959 |
|
|
| 9960 |
|
def __str__(self): |
| 9961 |
|
return 'HistoryEvent(' + 'Events:' + str(self.Events) + ')' |
| 9962 |
|
|
| 9963 |
|
__repr__ = __str__ |
| 9964 |
|
|
| 9965 |
|
|
| 9966 |
|
class HistoryReadParameters(FrozenClass): |
| 9967 |
|
''' |
| 9968 |
|
:ivar HistoryReadDetails: |
| 9969 |
|
:vartype HistoryReadDetails: ExtensionObject |
| 9970 |
|
:ivar TimestampsToReturn: |
| 9971 |
|
:vartype TimestampsToReturn: TimestampsToReturn |
| 9972 |
|
:ivar ReleaseContinuationPoints: |
| 9973 |
|
:vartype ReleaseContinuationPoints: Boolean |
| 9974 |
|
:ivar NodesToRead: |
| 9975 |
|
:vartype NodesToRead: HistoryReadValueId |
| 9976 |
|
''' |
| 9977 |
|
|
| 9978 |
|
ua_types = ( |
| 9979 |
|
|
| 9980 |
|
('HistoryReadDetails', 'ExtensionObject'), |
| 9981 |
|
('TimestampsToReturn', 'TimestampsToReturn'), |
| 9982 |
|
('ReleaseContinuationPoints', 'Boolean'), |
| 9983 |
|
('NodesToRead', 'ListOfHistoryReadValueId'), |
| 9984 |
|
) |
| 9985 |
|
|
|
@@ 9693-9761 (lines=69) @@
|
| 9690 |
|
packet.append(uabin.Primitives.Double.pack(self.ProcessingInterval)) |
| 9691 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.AggregateType))) |
| 9692 |
|
for fieldname in self.AggregateType: |
| 9693 |
|
packet.append(fieldname.to_binary()) |
| 9694 |
|
packet.append(self.AggregateConfiguration.to_binary()) |
| 9695 |
|
return b''.join(packet) |
| 9696 |
|
|
| 9697 |
|
@staticmethod |
| 9698 |
|
def from_binary(data): |
| 9699 |
|
return ReadProcessedDetails(data) |
| 9700 |
|
|
| 9701 |
|
def _binary_init(self, data): |
| 9702 |
|
self.StartTime = uabin.Primitives.DateTime.unpack(data) |
| 9703 |
|
self.EndTime = uabin.Primitives.DateTime.unpack(data) |
| 9704 |
|
self.ProcessingInterval = uabin.Primitives.Double.unpack(data) |
| 9705 |
|
length = uabin.Primitives.Int32.unpack(data) |
| 9706 |
|
array = [] |
| 9707 |
|
if length != -1: |
| 9708 |
|
for _ in range(0, length): |
| 9709 |
|
array.append(NodeId.from_binary(data)) |
| 9710 |
|
self.AggregateType = array |
| 9711 |
|
self.AggregateConfiguration = AggregateConfiguration.from_binary(data) |
| 9712 |
|
|
| 9713 |
|
def __str__(self): |
| 9714 |
|
return 'ReadProcessedDetails(' + 'StartTime:' + str(self.StartTime) + ', ' + \ |
| 9715 |
|
'EndTime:' + str(self.EndTime) + ', ' + \ |
| 9716 |
|
'ProcessingInterval:' + str(self.ProcessingInterval) + ', ' + \ |
| 9717 |
|
'AggregateType:' + str(self.AggregateType) + ', ' + \ |
| 9718 |
|
'AggregateConfiguration:' + str(self.AggregateConfiguration) + ')' |
| 9719 |
|
|
| 9720 |
|
__repr__ = __str__ |
| 9721 |
|
|
| 9722 |
|
|
| 9723 |
|
class ReadAtTimeDetails(FrozenClass): |
| 9724 |
|
''' |
| 9725 |
|
:ivar ReqTimes: |
| 9726 |
|
:vartype ReqTimes: DateTime |
| 9727 |
|
:ivar UseSimpleBounds: |
| 9728 |
|
:vartype UseSimpleBounds: Boolean |
| 9729 |
|
''' |
| 9730 |
|
|
| 9731 |
|
ua_types = ( |
| 9732 |
|
|
| 9733 |
|
('ReqTimes', 'ListOfDateTime'), |
| 9734 |
|
('UseSimpleBounds', 'Boolean'), |
| 9735 |
|
) |
| 9736 |
|
|
| 9737 |
|
def __init__(self, binary=None): |
| 9738 |
|
if binary is not None: |
| 9739 |
|
self._binary_init(binary) |
| 9740 |
|
self._freeze = True |
| 9741 |
|
return |
| 9742 |
|
self.ReqTimes = [] |
| 9743 |
|
self.UseSimpleBounds = True |
| 9744 |
|
self._freeze = True |
| 9745 |
|
|
| 9746 |
|
def to_binary(self): |
| 9747 |
|
packet = [] |
| 9748 |
|
packet.append(uabin.Primitives.Int32.pack(len(self.ReqTimes))) |
| 9749 |
|
for fieldname in self.ReqTimes: |
| 9750 |
|
packet.append(uabin.Primitives.DateTime.pack(fieldname)) |
| 9751 |
|
packet.append(uabin.Primitives.Boolean.pack(self.UseSimpleBounds)) |
| 9752 |
|
return b''.join(packet) |
| 9753 |
|
|
| 9754 |
|
@staticmethod |
| 9755 |
|
def from_binary(data): |
| 9756 |
|
return ReadAtTimeDetails(data) |
| 9757 |
|
|
| 9758 |
|
def _binary_init(self, data): |
| 9759 |
|
self.ReqTimes = uabin.Primitives.DateTime.unpack_array(data) |
| 9760 |
|
self.UseSimpleBounds = uabin.Primitives.Boolean.unpack(data) |
| 9761 |
|
|
| 9762 |
|
def __str__(self): |
| 9763 |
|
return 'ReadAtTimeDetails(' + 'ReqTimes:' + str(self.ReqTimes) + ', ' + \ |
| 9764 |
|
'UseSimpleBounds:' + str(self.UseSimpleBounds) + ')' |
|
@@ 8940-9008 (lines=69) @@
|
| 8937 |
|
|
| 8938 |
|
def _binary_init(self, data): |
| 8939 |
|
self.TypeId = NodeId.from_binary(data) |
| 8940 |
|
self.ResponseHeader = ResponseHeader.from_binary(data) |
| 8941 |
|
self.Parameters = QueryFirstResult.from_binary(data) |
| 8942 |
|
|
| 8943 |
|
def __str__(self): |
| 8944 |
|
return 'QueryFirstResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \ |
| 8945 |
|
'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \ |
| 8946 |
|
'Parameters:' + str(self.Parameters) + ')' |
| 8947 |
|
|
| 8948 |
|
__repr__ = __str__ |
| 8949 |
|
|
| 8950 |
|
|
| 8951 |
|
class QueryNextParameters(FrozenClass): |
| 8952 |
|
''' |
| 8953 |
|
:ivar ReleaseContinuationPoint: |
| 8954 |
|
:vartype ReleaseContinuationPoint: Boolean |
| 8955 |
|
:ivar ContinuationPoint: |
| 8956 |
|
:vartype ContinuationPoint: ByteString |
| 8957 |
|
''' |
| 8958 |
|
|
| 8959 |
|
ua_types = ( |
| 8960 |
|
|
| 8961 |
|
('ReleaseContinuationPoint', 'Boolean'), |
| 8962 |
|
('ContinuationPoint', 'ByteString'), |
| 8963 |
|
) |
| 8964 |
|
|
| 8965 |
|
def __init__(self, binary=None): |
| 8966 |
|
if binary is not None: |
| 8967 |
|
self._binary_init(binary) |
| 8968 |
|
self._freeze = True |
| 8969 |
|
return |
| 8970 |
|
self.ReleaseContinuationPoint = True |
| 8971 |
|
self.ContinuationPoint = None |
| 8972 |
|
self._freeze = True |
| 8973 |
|
|
| 8974 |
|
def to_binary(self): |
| 8975 |
|
packet = [] |
| 8976 |
|
packet.append(uabin.Primitives.Boolean.pack(self.ReleaseContinuationPoint)) |
| 8977 |
|
packet.append(uabin.Primitives.ByteString.pack(self.ContinuationPoint)) |
| 8978 |
|
return b''.join(packet) |
| 8979 |
|
|
| 8980 |
|
@staticmethod |
| 8981 |
|
def from_binary(data): |
| 8982 |
|
return QueryNextParameters(data) |
| 8983 |
|
|
| 8984 |
|
def _binary_init(self, data): |
| 8985 |
|
self.ReleaseContinuationPoint = uabin.Primitives.Boolean.unpack(data) |
| 8986 |
|
self.ContinuationPoint = uabin.Primitives.ByteString.unpack(data) |
| 8987 |
|
|
| 8988 |
|
def __str__(self): |
| 8989 |
|
return 'QueryNextParameters(' + 'ReleaseContinuationPoint:' + str(self.ReleaseContinuationPoint) + ', ' + \ |
| 8990 |
|
'ContinuationPoint:' + str(self.ContinuationPoint) + ')' |
| 8991 |
|
|
| 8992 |
|
__repr__ = __str__ |
| 8993 |
|
|
| 8994 |
|
|
| 8995 |
|
class QueryNextRequest(FrozenClass): |
| 8996 |
|
''' |
| 8997 |
|
:ivar TypeId: |
| 8998 |
|
:vartype TypeId: NodeId |
| 8999 |
|
:ivar RequestHeader: |
| 9000 |
|
:vartype RequestHeader: RequestHeader |
| 9001 |
|
:ivar Parameters: |
| 9002 |
|
:vartype Parameters: QueryNextParameters |
| 9003 |
|
''' |
| 9004 |
|
|
| 9005 |
|
ua_types = ( |
| 9006 |
|
|
| 9007 |
|
('TypeId', 'NodeId'), |
| 9008 |
|
('RequestHeader', 'RequestHeader'), |
| 9009 |
|
('Parameters', 'QueryNextParameters'), |
| 9010 |
|
) |
| 9011 |
|
|
|
@@ 2566-2634 (lines=69) @@
|
| 2563 |
|
('RequestHeader', 'RequestHeader'), |
| 2564 |
|
('Server', 'RegisteredServer'), |
| 2565 |
|
) |
| 2566 |
|
|
| 2567 |
|
def __init__(self, binary=None): |
| 2568 |
|
if binary is not None: |
| 2569 |
|
self._binary_init(binary) |
| 2570 |
|
self._freeze = True |
| 2571 |
|
return |
| 2572 |
|
self.TypeId = FourByteNodeId(ObjectIds.RegisterServerRequest_Encoding_DefaultBinary) |
| 2573 |
|
self.RequestHeader = RequestHeader() |
| 2574 |
|
self.Server = RegisteredServer() |
| 2575 |
|
self._freeze = True |
| 2576 |
|
|
| 2577 |
|
def to_binary(self): |
| 2578 |
|
packet = [] |
| 2579 |
|
packet.append(self.TypeId.to_binary()) |
| 2580 |
|
packet.append(self.RequestHeader.to_binary()) |
| 2581 |
|
packet.append(self.Server.to_binary()) |
| 2582 |
|
return b''.join(packet) |
| 2583 |
|
|
| 2584 |
|
@staticmethod |
| 2585 |
|
def from_binary(data): |
| 2586 |
|
return RegisterServerRequest(data) |
| 2587 |
|
|
| 2588 |
|
def _binary_init(self, data): |
| 2589 |
|
self.TypeId = NodeId.from_binary(data) |
| 2590 |
|
self.RequestHeader = RequestHeader.from_binary(data) |
| 2591 |
|
self.Server = RegisteredServer.from_binary(data) |
| 2592 |
|
|
| 2593 |
|
def __str__(self): |
| 2594 |
|
return 'RegisterServerRequest(' + 'TypeId:' + str(self.TypeId) + ', ' + \ |
| 2595 |
|
'RequestHeader:' + str(self.RequestHeader) + ', ' + \ |
| 2596 |
|
'Server:' + str(self.Server) + ')' |
| 2597 |
|
|
| 2598 |
|
__repr__ = __str__ |
| 2599 |
|
|
| 2600 |
|
|
| 2601 |
|
class RegisterServerResponse(FrozenClass): |
| 2602 |
|
''' |
| 2603 |
|
Registers a server with the discovery server. |
| 2604 |
|
|
| 2605 |
|
:ivar TypeId: |
| 2606 |
|
:vartype TypeId: NodeId |
| 2607 |
|
:ivar ResponseHeader: |
| 2608 |
|
:vartype ResponseHeader: ResponseHeader |
| 2609 |
|
''' |
| 2610 |
|
|
| 2611 |
|
ua_types = ( |
| 2612 |
|
|
| 2613 |
|
('TypeId', 'NodeId'), |
| 2614 |
|
('ResponseHeader', 'ResponseHeader'), |
| 2615 |
|
) |
| 2616 |
|
|
| 2617 |
|
def __init__(self, binary=None): |
| 2618 |
|
if binary is not None: |
| 2619 |
|
self._binary_init(binary) |
| 2620 |
|
self._freeze = True |
| 2621 |
|
return |
| 2622 |
|
self.TypeId = FourByteNodeId(ObjectIds.RegisterServerResponse_Encoding_DefaultBinary) |
| 2623 |
|
self.ResponseHeader = ResponseHeader() |
| 2624 |
|
self._freeze = True |
| 2625 |
|
|
| 2626 |
|
def to_binary(self): |
| 2627 |
|
packet = [] |
| 2628 |
|
packet.append(self.TypeId.to_binary()) |
| 2629 |
|
packet.append(self.ResponseHeader.to_binary()) |
| 2630 |
|
return b''.join(packet) |
| 2631 |
|
|
| 2632 |
|
@staticmethod |
| 2633 |
|
def from_binary(data): |
| 2634 |
|
return RegisterServerResponse(data) |
| 2635 |
|
|
| 2636 |
|
def _binary_init(self, data): |
| 2637 |
|
self.TypeId = NodeId.from_binary(data) |
FreeOpcUa /
python-opcua
