Package MDSplus :: Module mdsdevice :: Class Device
[frames | no frames]

Type Device

object --+        
         |        
      Data --+    
             |    
      TreeNode --+
                 |
                Device


Used for device support classes. Provides ORIGINAL_PART_NAME, PART_NAME and Add methods and allows referencing of subnodes as conglomerate node attributes.

Use this class as a superclass for device support classes. When creating a device support class include a class attribute called "parts" which describe the subnodes of your device implementation. The parts attribute should be a list or tuple of dict objects where each dict is a description of each subnode. The dict object should include a minimum of a 'path' key whose value is the relative path of the node (be sure to include the leading period or colon) and a 'type' key whose value is the usage type of the node. In addition you may optionally specify a 'value' key whose value is the actual value to store into the node when it is first added in the tree. Instead of a 'value' key, you can provide a 'valueExpr' key whose value is a string which is python code to be evaluated before writing the result into the node. Use a valueExpr when you need to include references to other nodes in the device. Lastly the dict instance may contain an 'options' key whose values are node options specified as a tuple of strings. Note if you only specify one option include a trailing comma in the tuple.The "parts" attribute is used to implement the Add and PART_NAME and ORIGNAL_PART_NAME methods of the subclass.

You can also include a part_dict class attribute consisting of a dict() instance whose keys are attribute names and whose values are nid offsets. If you do not provide a part_dict attribute then one will be created from the part_names attribute where the part names are converted to lowercase and the colons and periods are replaced with underscores. Referencing a part name will return another instance of the same device with that node as the node in the Device subclass instance. The Device class also supports the part_name and original_part_name attributes which is the same as doing devinstance.PART_NAME(None). NOTE: Device subclass names MUST BE UPPERCASE!

Sample usage1:
  from MDSplus import Device

  class MYDEV(Device):
      parts=[{'path':':COMMENT','type':'text'},
             {'path':':INIT_ACTION','type':'action',
             'valueExpr':"Action(Dispatch(2,'CAMAC_SERVER','INIT',50,None),Method(None,'INIT',head))",
             'options':('no_write_shot',)},
             {'path':':STORE_ACTION','type':'action',
             'valueExpr':"Action(Dispatch(2,'CAMAC_SERVER','STORE',50,None),Method(None,'STORE',head))",
             'options':('no_write_shot',)},
             {'path':'.SETTINGS','type':'structure'},
             {'path':'.SETTINGS:KNOB1','type':'numeric'},
             {'path':'.SIGNALS','type':'structure'},
             {'path':'.SIGNALS:CHANNEL_1','type':'signal','options':('no_write_model','write_once')}]

      def init(self,arg):
          knob1=self.settings_knob1.record
          return 1

      def store(self,arg):
          from MDSplus import Signal
          self.signals_channel_1=Signal(32,None,42)
Sample usage2:
  from MDSplus import Device

      parts=[{'path':':COMMENT','type':'text'},
             {'path':':INIT_ACTION','type':'action',
             'valueExpr':"Action(Dispatch(2,'CAMAC_SERVER','INIT',50,None),Method(None,'INIT',head))",
             'options':('no_write_shot',)},
             {'path':':STORE_ACTION','type':'action',
             'valueExpr':"Action(Dispatch(2,'CAMAC_SERVER','STORE',50,None),Method(None,'STORE',head))",
             'options':('no_write_shot',)},
             {'path':'.SETTINGS','type':'structure'},
             {'path':'.SETTINGS:KNOB1','type':'numeric'},
             {'path':'.SIGNALS','type':'structure'},
             {'path':'.SIGNALS:CHANNEL_1','type':'signal','options':('no_write_model','write_once')}]

      part_dict={'knob1':5,'chan1':7}

      def init(self,arg):
          knob1=self.knob1.record
          return 1

      def store(self,arg):
          from MDSplus import Signal
          self.chan1=Signal(32,None,42)
If you need to reference attributes using computed names you can do something like:
   for i in range(16):
       self.__setattr__('signals_channel_%02d' % (i+1,),Signal(...))

Method Summary
None __init__(self, node)
Initialize a Device instance
  __class_init__(cls)
(Class method)
Device __getattr__(self, name)
Return TreeNode of subpart if name matches mangled node name.
Device subclass instance __new__(cls, node)
Create class instance. (Static method)
None __setattr__(self, name, value)
Set value into device subnode if name matches a mangled subpart node name.
  Add(cls, tree, path)
Used to add a device instance to an MDSplus tree. (Class method)
  DW_SETUP(self, *args)
Bring up a glade setup interface if one exists in the same package as the one providing the device subclass
  dw_setup(self, *args)
Bring up a glade setup interface if one exists in the same package as the one providing the device subclass
  onSetupWindowClose(self, window)
str ORIGINAL_PART_NAME(self, arg)
Method to return the original part name.
str PART_NAME(self, arg)
Method to return the original part name.
  waitForSetups(cls)
(Class method)
    Inherited from TreeNode
  __str__(self)
Convert TreeNode to string.
TreeNode addDevice(self, name, model)
Add device descendant.
TreeNode addNode(self, name, usage)
Add node
None addTag(self, tag)
Add a tagname to this node
None beginSegment(self, start, end, dimension, initialValueArray, idx)
Begin a record segment
None beginTimestampedSegment(self, array, idx)
Allocate space for a timestamped segment
Bool compare(self, value)
Returns True if this node contains the same data as specified in the value argument
bool containsVersions(self)
Return true if this node contains data versions
None delete(self)
Delete this node from the tree
None deleteData(self)
Delete data from this node
None doMethod(self, method, arg)
Execute method on conglomerate element
TreeNode getBrother(self)
Return sibling of this node
TreeNode getChild(self)
Return first child of this node.
TreeNodeArray getChildren(self)
Return TreeNodeArray of children nodes.
String getClass(self)
Return MDSplus class name of this node
int getCompressedLength(self)
Return compressed data length of this node
Int32 getConglomerateElt(self)
Return index of this node in a conglomerate
TreeNodeArray getConglomerateNodes(self)
Return TreeNodeArray of conglomerate elements
Data getData(self)
Return data
Int32 getDepth(self)
Get depth of this node in the tree
TreeNodeArray getDescendants(self)
Return TreeNodeArray of first level descendants (children and members).
String getDtype(self)
Return the name of the data type stored in this node
String getFullPath(self)
Return full path of this node
int getLength(self)
Return uncompressed data length of this node
str getLocalPath(self)
Return path relative to top of local tree
str getLocalTree(self)
Return tree containing this node
TreeNode getMember(self)
Return first member node
TreeNodeArray getMembers(self)
Return TreeNodeArray of this nodes members
String getMinPath(self)
Return shortest path string for this node
int getNid(self)
Return node index
TreeNode getNode(self, path)
Return tree node where path is relative to this node
String getNodeName(self)
Return node name
TreeNodeArray getNodeWild(self, path)
Return tree nodes where path is relative to this node
Int32 getNumChildren(self)
Return number of children nodes.
int getNumDescendants(self)
Return number of first level descendants (children and members)
Int32 getNumElts(self)
Return number of nodes in this conglomerate
int getNumMembers(self)
Return number of members
int getNumSegments(self)
return number of segments contained in this node
String getOriginalPartName(self)
Return the original part name of node in conglomerate
int getOwnerId(self)
Get id/gid value of account which wrote data to this node
TreeNode getParent(self)
Return parent of this node
String getPath(self)
Return path of this node
Signal | None getSegment(self, idx)
Return segment
Dimension getSegmentDim(self, idx)
Return dimension of segment
Data getSegmentEnd(self, idx)
return end of segment
Data getSegmentStart(self, idx)
return start of segment
int getStatus(self)
Return action completion status
ndarray getTags(self)
Return tags of this node
Uint64 getTimeInserted(self)
Return time data was written
Tree getTree(self)
Return Tree associated with this node
str getUsage(self)
Return usage of this node
bool isChild(self)
Return true if this is a child node
bool isCompressible(self)
Return true if node contains data which can be compressed
bool isCompressOnPut(self)
Return true if node is set to compress on put
bool isDoNotCompress(self)
Return true of compression is disabled for this node
bool isEssential(self)
Return true if successful action completion is essential
bool isIncludedInPulse(self)
Return true if this subtree is to be included in pulse file
bool isMember(self)
Return true if this is a member node
bool isNoWriteModel(self)
Return true if data storage to model is disabled for this node
bool isNoWriteShot(self)
Return true if data storage to pulse file is disabled for this node
bool isOn(self)
Return True if node is turned on, False if not.
bool isSegmented(self)
Return true if this node contains segmented records
bool isSetup(self)
Return true if data is setup information.
bool isWriteOnce(self)
Return true if node is set write once
None makeTimestampedSegment(self, timestampArray, array, idx, rows_filled)
Load a timestamped segment
None move(self, parent, newname)
Move node to another location in the tree and optionally rename the node
None putData(self, data)
Store data
None putRow(self, bufsize, array, timestamp)
Load a timestamped segment row
None putSegment(self, data, idx)
Load a segment in a node
None putTimestampedSegment(self, timestampArray, array)
Load a timestamped segment
None removeTag(self, tag)
Remove a tagname from this node
None rename(self, newname)
Rename node this node
None restoreContext(self)
Restore tree context.
None setCompressOnPut(self, flag)
Set compress on put state of this node
None setDoNotCompress(self, flag)
Set do not compress state of this node
None setEssential(self, flag)
Set essential state of this node
None setIncludedInPulse(self, flag)
Set include in pulse state of this node
None setNoWriteModel(self, flag)
Set no write model state for this node
None setNoWriteShot(self, flag)
Set no write shot state for this node
None setOn(self, flag)
Turn node on or off
None setSubtree(self, flag)
Enable/Disable node as a subtree
None setTree(self, tree)
Set Tree associated with this node
None setUsage(self, usage)
Set the usage of a node
None setWriteOnce(self, flag)
Set write once state of node
None updateSegment(self, start, end, dim, idx)
Update a segment
    Inherited from Data
Data __abs__(self)
Absolute value: x.__abs__() <==> abs(x)
Data __add__(self, y)
Add: x.__add__(y) <==> x+y
Data __and__(self, y)
And: x.__and__(y) <==> x&y
Data __div__(self, y)
Divide: x.__div__(y) <==> x/y
Bool __eq__(self, y)
Equals: x.__eq__(y) <==> x==y
Data __float__(self)
Float: x.__float__() <==> float(x)
Data __floordiv__(self, y)
Floordiv: x.__floordiv__(y) <==> x//y
Bool __ge__(self, y)
Greater or equal: x.__ge__(y) <==> x>=y
Data __getitem__(self, y)
Subscript: x.__getitem__(y) <==> x[y]
Bool __gt__(self, y)
Greater than: x.__gt__(y) <==> x>y
int __int__(self)
Integer: x.__int__() <==> int(x)
Data __invert__(self)
Binary not: x.__invert__() <==> ~x
Bool __le__(self, y)
Less than or equal: x.__le__(y) <==> x<=y
Data __len__(self)
Length: x.__len__() <==> len(x)
long __long__(self)
Convert this object to python long
Data __lshift__(self, y)
Lrft binary shift: x.__lshift__(y) <==> x<<y
Bool __lt__(self, y)
Less than: x.__lt__(y) <==> x<y
Data __mod__(self, y)
Modulus: x.__mod__(y) <==> x%y
Data __mul__(self, y)
Multiply: x.__mul__(y) <==> x*y
Data __ne__(self, y)
Not equal: x.__ne__(y) <==> x!=y
Data __neg__(self)
Negation: x.__neg__() <==> -x
Bool __nonzero__(self)
Not equal 0: x.__nonzero__() <==> x != 0
Data __or__(self, y)
Or: x.__or__(y) <==> x|y
Data __pos__(self)
Unary plus: x.__pos__() <==> +x
Data __radd__(self, y)
Reverse add: x.__radd__(y) <==> y+x
Data __rdiv__(self, y)
Reverse divide: x.__rdiv__(y) <==> y/x
string __repr__(self)
Return string representation
Data __rfloordiv__(self, y)
x.__rfloordiv__(y) <==> y//x
Data __rlshift__(self, y)
Reverse left binary shift: x.__rlshift__(y) <==> y<<x
Data __rmod__(self, y)
Reverse modulus: x.__rmod__(y) <==> y%x
Data __rmul__(self, y)
Multiply: x.__mul__(y) <==> x*y
Data __ror__(self, y)
Or: x.__or__(y) <==> x|y
Data __rrshift__(self, y)
Reverse right binary shift: x.__rrshift__(y) <==> y>>x
Data __rshift__(self, y)
Right binary shift: x.__rshift__(y) <==> x>>y
Data __rsub__(self, y)
Reverse subtract: x.__rsub__(y) <==> y-x
Data __rxor__(self, y)
Reverse xor: x.__rxor__(y) <==> y^x
Data __sub__(self, y)
Subtract: x.__sub__(y) <==> x-y
Data __xor__(self, y)
Xor: x.__xor__(y) <==> x^y
Bool bool(self)
Return boolean
Data compile(expr, *args)
Static method (routine in C++) which compiles the expression (via TdiCompile()) and returns the object instance correspondind to the compiled expression. (Static method)
Scalar,Array data(self)
Return primitimive value of the data.
string decompile(self)
Return string representation
Data deserialize(data)
Return Data from serialized buffer. (Static method)
Data dim_of(self, idx)
Return dimension of object
Data evaluate(self)
Return the result of TDI evaluate(this).
Data execute(expr, *args)
Execute and expression inserting optional arguments into the expression before evaluating (Static method)
Int8 getByte(self)
Convert this data into a byte.
Int8Array getByteArray(self)
Convert this data into a byte array.
Data getDimensionAt(self, idx)
Return dimension of object
Float64 getDouble(self)
Convert this data into a float64.
Data getError(self)
Get the error field.
Float32 getFloat(self)
Convert this data into a float32.
Data getHelp(self)
Returns the result of TDI GET_HELP(this).
Int32 getInt(self)
Convert this data into a int.
Int32Array getIntArray(self)
Convert this data into a int array.
Int64 getLong(self)
Convert this data into a long.
Int64Array getLongArray(self)
Convert this data into a long array.
Int32Array getShape(self)
Get the array dimensions as an integer array.
Int16 getShort(self)
Convert this data into a short.
Int16Array getShortArray(self)
Convert this data into a short array.
String getString(self)
Convert this data into a STRING.
Data getTdiVar(tdivarname)
Get value of tdi public variable (Static method)
Data getUnits(self)
Return the TDI evaluation of UNITS_OF(this).
Data makeData(value)
Return MDSplus data class from value. (Static method)
Bool mayHaveChanged(self)
return true if the represented data could have been changed since the last time this method has been called.
Data pop_dollar_value(self)
Pop $value for expression evaluation
None push_dollar_value(self)
Set $value for expression evaluation
Data raw_of(self)
Return raw part of object
Uint8Array serialize(self)
Return Uint8Array binary representation.
None setError(self, error)
Set the Error field for this Data instance.
None setHelp(self, help)
Set the Help field for this Data instance.
Data setTdiVar(self, tdivarname)
Set tdi public variable with this data
None setUnits(self, units)
Set units
Float32Array sind(self)
Return sin() of data assuming data is in degrees
Data units_of(self)
Return units part of the object
Data value_of(self)
Return value part of object
    Inherited from object
  __delattr__(...)
x.__delattr__('name') <==> del x.name
  __getattribute__(...)
x.__getattribute__('name') <==> x.name
  __hash__(x)
x.__hash__() <==> hash(x)
  __reduce__(...)
helper for pickle
  __reduce_ex__(...)
helper for pickle

Property Summary
    Inherited from Data
  descriptor
  error
  help
  units
  validation

Instance Variable Summary
    Inherited from TreeNode
int nid: node index of this node.
Tree tree: Tree instance that this node belongs to.

Class Variable Summary
NoneType gtkThread = None                                                                  

Instance Method Details

__init__(self, node)
(Constructor)

Initialize a Device instance
Parameters:
node - Conglomerate node of this device
           (type=TreeNode)
Returns:
None
Overrides:
MDSplus.treenode.TreeNode.__init__

__getattr__(self, name)
(Qualification operator)

Return TreeNode of subpart if name matches mangled node name.
Parameters:
name - part name. Node path with colons and periods replaced by underscores.
           (type=str)
Returns:
Device instance of device part
           (type=Device)
Overrides:
MDSplus.treenode.TreeNode.__getattr__

__setattr__(self, name, value)

Set value into device subnode if name matches a mangled subpart node name. Otherwise assign value to class instance attribute.
Parameters:
name - Name of attribute or device subpart
           (type=str)
value - Value of the attribute or device subpart
           (type=varied)
Returns:
None
Overrides:
MDSplus.treenode.TreeNode.__setattr__

DW_SETUP(self, *args)

Bring up a glade setup interface if one exists in the same package as the one providing the device subclass

The gtk.main() procedure must be run in a separate thread to avoid locking the main program. If this method is invoked via the Py() TDI function, care must be made to do unlock the python thread lock the first time a gtkMain thread is created. This thread unlocking has to be done in the Py TDI function after the GIL state has been restored. This method sets a public TDI variable, _PyReleaseThreadLock, which is inspected in the Py function and if defined, the Py function will release the thread lock. This locking scheme was arrived at after several days of trial and error and seems to work with at least Python versions 2.4 and 2.6.

dw_setup(self, *args)

Bring up a glade setup interface if one exists in the same package as the one providing the device subclass

The gtk.main() procedure must be run in a separate thread to avoid locking the main program. If this method is invoked via the Py() TDI function, care must be made to do unlock the python thread lock the first time a gtkMain thread is created. This thread unlocking has to be done in the Py TDI function after the GIL state has been restored. This method sets a public TDI variable, _PyReleaseThreadLock, which is inspected in the Py function and if defined, the Py function will release the thread lock. This locking scheme was arrived at after several days of trial and error and seems to work with at least Python versions 2.4 and 2.6.

ORIGINAL_PART_NAME(self, arg)

Method to return the original part name. Will return blank string if part_name class attribute not defined or node used to create instance is the head node or past the end of part_names tuple.
Parameters:
arg - Not used. Placeholder for do method argument
           (type=Use None)
Returns:
Part name of this node
           (type=str)

PART_NAME(self, arg)

Method to return the original part name. Will return blank string if part_name class attribute not defined or node used to create instance is the head node or past the end of part_names tuple.
Parameters:
arg - Not used. Placeholder for do method argument
           (type=Use None)
Returns:
Part name of this node
           (type=str)

Static Method Details

__new__(cls, node)

Create class instance. Initialize part_dict class attribute if necessary.
Parameters:
node - Not used
           (type=TreeNode)
Returns:
Instance of the device subclass
           (type=Device subclass instance)
Overrides:
__builtin__.object.__new__

Class Method Details

Add(cls, tree, path)

Used to add a device instance to an MDSplus tree. This method is invoked when a device is added to the tree when using utilities like mdstcl and the traverser. For this to work the device class name (uppercase only) and the package name must be returned in the MdsDevices tdi function. Also the Device subclass must include the parts attribute which is a list or tuple containing one dict instance per subnode of the device. The dict instance should include a 'path' key set to the relative node name path of the subnode. a 'type' key set to the usage string of the subnode and optionally a 'value' key or a 'valueExpr' key containing a value to initialized the node or a string containing python code which when evaluated during the adding of the device after the subnode has been created produces a data item to store in the node. And finally the dict instance can contain an 'options' key which should contain a list or tuple of strings of node attributes which will be turned on (i.e. write_once).

Class Variable Details

gtkThread

Type:
NoneType
Value:
None                                                                  

Generated by Epydoc 2.1 on Wed Aug 18 13:35:30 2010 http://epydoc.sf.net