sardanadefs

This module contains the most generic sardana constants and enumerations

Constants

EpsilonError = 1e-16

maximum difference between two floats so that they are considered equal

InvalidId = 0

A constant representing an invalid ID

InvalidAxis = 0

A constant representing an invalid axis

TYPE_ELEMENTS = set([2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

a set containning all “controllable” element types. Constant values belong to ElementType

TYPE_GROUP_ELEMENTS = set([12, 13])

a set containing all group element types. Constant values belong to ElementType

TYPE_MOVEABLE_ELEMENTS = set([9, 2, 12])

a set containing the type of elements which are moveable. Constant values belong to ElementType

TYPE_PHYSICAL_ELEMENTS = set([2, 3, 4, 5, 6, 7, 8])

a set containing the possible types of physical elements. Constant values belong to ElementType

TYPE_ACQUIRABLE_ELEMENTS = set([2, 3, 4, 5, 6, 7, 8, 9, 10])

a set containing the possible types of acquirable elements. Constant values belong to ElementType

TYPE_PSEUDO_ELEMENTS = set([9, 10])

a set containing the possible types of pseudo elements. Constant values belong to ElementType

SardanaServer = SardanaServer()

the global object containing the SardanaServer information

Enumerations

ServerRunMode = Enumeration('ServerRunMode', ['SynchPure', 'SynchThread', 'SynchProcess', 'AsynchThread', 'AsynchProcess'])

ServerRunMode enumeration. Possible values are:

  • SynchPure (0)
  • SynchThread (1)
  • SynchProcess (2)
  • AsynchThread (3)
  • AsynchProcess (4)
State = Enumeration('State', ['On', 'Off', 'Close', 'Open', 'Insert', 'Extract', 'Moving', 'Standby', 'Fault', 'Init', 'Running', 'Alarm', 'Disable', 'Unknown', 'Invalid'])

State enumeration. Possible values are:

  • On (0)
  • Off (1)
  • Close (2)
  • Open (3)
  • Insert (4)
  • Extract (5)
  • Moving (6)
  • Standby (7)
  • Fault (8)
  • Init (9)
  • Running (10)
  • Alarm (11)
  • Disable (12)
  • Unknown (13)
  • Invalid (14)
DataType = Enumeration('DataType', ['Integer', 'Double', 'String', 'Boolean', 'Encoded', 'Invalid'])

DataType enumeration. Possible values are:

  • Integer (0)
  • Double (1)
  • String (2)
  • Boolean (3)
  • Encoded (4)
  • Invalid (5)
DataFormat = Enumeration('DataFormat', ['Scalar', 'OneD', 'TwoD', 'Invalid'])

DataFormat enumeration. Possible values are:

  • Scalar (0)
  • OneD (1)
  • TwoD (2)
  • Invalid (3)
DataAccess = Enumeration('DataAccess', ['ReadOnly', 'ReadWrite', 'Invalid'])

DataAccess enumeration. Possible values are:

  • ReadOnly (0)
  • ReadWrite (1)
  • Invalid (2)
ElementType = Enumeration('ElementType', ['Pool', 'Controller', 'Motor', 'CTExpChannel', 'ZeroDExpChannel', 'OneDExpChannel', 'TwoDExpChannel', 'ComChannel', 'IORegister', 'PseudoMotor', 'PseudoCounter', 'Constraint', 'MotorGroup', 'MeasurementGroup', 'Instrument', 'ControllerClass', 'ControllerLibrary', 'MacroServer', 'Door', 'MacroClass', 'MacroLibrary', 'MacroFunction', 'External', 'Meta', 'ParameterType', 'Unknown'])

ElementType enumeration. Possible values are:

  • Pool (0)
  • Controller (1)
  • Motor (2)
  • CTExpChannel (3)
  • ZeroDExpChannel (4)
  • OneDExpChannel (5)
  • TwoDExpChannel (6)
  • ComChannel (7)
  • IORegister (8)
  • PseudoMotor (9)
  • PseudoCounter (10)
  • Constraint (11)
  • MotorGroup (12)
  • MeasurementGroup (13)
  • Instrument (14)
  • ControllerClass (15)
  • ControllerLibrary (16)
  • MacroServer (17)
  • Door (18)
  • MacroClass (19)
  • MacroLibrary (20)
  • MacroFunction (21)
  • External (22)
  • Meta (23)
  • ParameterType (24)
  • Unknown (25)
Interface = Enumeration('Interface', ['Object', 'PoolObject', 'Element', 'PoolElement', 'Acquirable', 'IORegister', 'Instrument', 'MacroServerObject', 'MacroCode', 'Class', 'MacroClass', 'Function', 'MacroServerElement', 'Door', 'Controller', 'External', 'MacroServer', 'Library', 'MacroLibrary', 'MacroFunction', 'ComChannel', 'ExpChannel', 'ZeroDExpChannel', 'Constraint', 'Macro', 'TwoDExpChannel', 'Moveable', 'OneDExpChannel', 'PseudoCounter', 'MeasurementGroup', 'PseudoMotor', 'Meta', 'ParameterType', 'MotorGroup', 'ControllerLibrary', 'Pool', 'Motor', 'CTExpChannel', 'ControllerClass'])

Interface enumeration. Possible values are:

  • Object (1)
  • PoolObject (3)
  • Element (5)
  • PoolElement (15)
  • Acquirable (31)
  • IORegister (63)
  • Instrument (79)
  • MacroServerObject (129)
  • MacroCode (385)
  • Class (513)
  • MacroClass (1921)
  • Function (2049)
  • MacroServerElement (4229)
  • Door (12421)
  • Controller (16399)
  • External (32769)
  • MacroServer (69765)
  • Library (131073)
  • MacroLibrary (393345)
  • MacroFunction (526721)
  • ComChannel (1048591)
  • ExpChannel (2097183)
  • ZeroDExpChannel (6291487)
  • Constraint (8388611)
  • Macro (17305473)
  • TwoDExpChannel (35651615)
  • Moveable (67108879)
  • OneDExpChannel (136314911)
  • PseudoCounter (270532639)
  • MeasurementGroup (536870927)
  • PseudoMotor (1140850719)
  • Meta (2147483648)
  • ParameterType (6442450944)
  • MotorGroup (8589934607)
  • ControllerLibrary (17180000259)
  • Pool (34359738383)
  • Motor (68786585631)
  • CTExpChannel (137441050655)
  • ControllerClass (274877907459)
Interfaces = {2147483648L: set([]), 1921L: set([385L, 513L]), 8388611L: set([3L]), 69765L: set([4229L]), 6442450944L: set([2147483648L]), 35651615L: set([2097183L]), 67108879L: set([15L]), 15L: set([3L, 5L]), 8589934607L: set([15L]), 3L: set([1L]), 34359738383L: set([15L]), 5L: set([1L]), 1140850719L: set([67108879L, 31L]), 17305473L: set([526721L, 1921L]), 1L: set([]), 4229L: set([129L, 5L]), 129L: set([1L]), 393345L: set([129L, 131073L]), 17180000259L: set([131073L, 3L]), 12421L: set([4229L]), 136314911L: set([2097183L]), 68786585631L: set([67108879L, 31L]), 385L: set([129L]), 513L: set([1L]), 131073L: set([1L]), 6291487L: set([2097183L]), 63L: set([31L]), 274877907459L: set([513L, 3L]), 16399L: set([15L]), 2097183L: set([31L]), 79L: set([15L]), 32769L: set([1L]), 536870927L: set([15L]), 2049L: set([1L]), 1048591L: set([15L]), 270532639L: set([2097183L]), 31L: set([15L]), 526721L: set([2049L, 385L]), 137441050655L: set([2097183L])}

a dictionary containing the direct interfaces supported by each type (dict <sardana.sardanadefs.Interface, set < sardana.sardanadefs.Interface> >)

InterfacesExpanded = {2147483648L: set([2147483648L]), 1921L: set([1921L, 385L, 513L, 129L, 1L]), 8388611L: set([8388611L, 1L, 3L]), 69765L: set([69765L, 1L, 5L, 4229L, 129L]), 6442450944L: set([2147483648L, 6442450944L]), 35651615L: set([1L, 3L, 5L, 2097183L, 15L, 35651615L, 31L]), 67108879L: set([3L, 1L, 67108879L, 5L, 15L]), 15L: set([1L, 3L, 5L, 15L]), 8589934607L: set([8589934607L, 3L, 1L, 5L, 15L]), 3L: set([1L, 3L]), 34359738383L: set([34359738383L, 1L, 3L, 5L, 15L]), 5L: set([1L, 5L]), 1140850719L: set([1L, 3L, 5L, 1140850719L, 67108879L, 15L, 31L]), 17305473L: set([17305473L, 385L, 1921L, 1L, 2049L, 129L, 526721L, 513L]), 1L: set([1L]), 4229L: set([1L, 5L, 4229L, 129L]), 129L: set([1L, 129L]), 393345L: set([129L, 393345L, 131073L, 1L]), 17180000259L: set([1L, 3L, 131073L, 17180000259L]), 12421L: set([129L, 1L, 5L, 4229L, 12421L]), 136314911L: set([1L, 3L, 5L, 2097183L, 15L, 136314911L, 31L]), 68786585631L: set([1L, 3L, 5L, 15L, 67108879L, 68786585631L, 31L]), 385L: set([129L, 385L, 1L]), 513L: set([1L, 513L]), 131073L: set([1L, 131073L]), 6291487L: set([1L, 3L, 5L, 2097183L, 15L, 6291487L, 31L]), 63L: set([1L, 3L, 5L, 15L, 63L, 31L]), 274877907459L: set([3L, 1L, 274877907459L, 513L]), 16399L: set([3L, 1L, 16399L, 5L, 15L]), 2097183L: set([1L, 3L, 5L, 15L, 2097183L, 31L]), 79L: set([3L, 1L, 15L, 5L, 79L]), 32769L: set([1L, 32769L]), 536870927L: set([536870927L, 1L, 3L, 5L, 15L]), 2049L: set([2049L, 1L]), 1048591L: set([1048591L, 1L, 3L, 5L, 15L]), 270532639L: set([1L, 3L, 5L, 2097183L, 15L, 31L, 270532639L]), 31L: set([3L, 1L, 31L, 5L, 15L]), 526721L: set([526721L, 2049L, 1L, 129L, 385L]), 137441050655L: set([1L, 3L, 5L, 2097183L, 15L, 137441050655L, 31L])}

a dictionary containing the all interfaces supported by each type. (dict <sardana.sardanadefs.Interface, set < sardana.sardanadefs.Interface> >)

INTERFACES = {'ParameterType': (set(['Meta']), 'A generic macro server parameter type'), 'ZeroDExpChannel': (set(['ExpChannel']), 'A 0D experimental channel'), 'MacroServer': (set(['MacroServerElement']), 'A MacroServer'), 'Constraint': (set(['PoolObject']), 'A constraint'), 'Acquirable': (set(['PoolElement']), 'An acquirable element'), 'TwoDExpChannel': (set(['ExpChannel']), 'A 2D experimental channel'), 'MacroLibrary': (set(['MacroServerObject', 'Library']), 'A macro server library'), 'IORegister': (set(['Acquirable']), 'An IO register'), 'Element': (set(['Object']), 'A generic sardana element'), 'ExpChannel': (set(['Acquirable']), 'A generic experimental channel'), 'Instrument': (set(['PoolElement']), 'An instrument'), 'MacroCode': (set(['MacroServerObject']), 'A macro server macro code'), 'OneDExpChannel': (set(['ExpChannel']), 'A 1D experimental channel'), 'PoolObject': (set(['Object']), 'A Pool object'), 'MacroClass': (set(['MacroCode', 'Class']), 'A macro server macro class'), 'PseudoCounter': (set(['ExpChannel']), 'A pseudo counter'), 'PoolElement': (set(['PoolObject', 'Element']), 'A Pool element'), 'MeasurementGroup': (set(['PoolElement']), 'A measurement group'), 'PseudoMotor': (set(['Acquirable', 'Moveable']), 'A pseudo motor'), 'Function': (set(['Object']), 'A generic sardana function'), 'MacroServerElement': (set(['MacroServerObject', 'Element']), 'A generic macro server element'), 'Macro': (set(['MacroFunction', 'MacroClass']), 'A macro server macro'), 'Door': (set(['MacroServerElement']), 'A macro server door'), 'MotorGroup': (set(['PoolElement']), 'A motor group'), 'Object': (set([]), 'A generic sardana object'), 'Library': (set(['Object']), 'A generic sardana library'), 'MacroServerObject': (set(['Object']), 'A generic macro server object'), 'ControllerLibrary': (set(['PoolObject', 'Library']), 'A controller library'), 'External': (set(['Object']), 'An external object'), 'Controller': (set(['PoolElement']), 'A controller'), 'Meta': (set([]), 'A generic sardana meta object'), 'ComChannel': (set(['PoolElement']), 'A communication channel'), 'Motor': (set(['Acquirable', 'Moveable']), 'a motor'), 'Moveable': (set(['PoolElement']), 'A moveable element'), 'MacroFunction': (set(['Function', 'MacroCode']), 'A macro server macro function'), 'ControllerClass': (set(['Class', 'PoolObject']), 'A controller class'), 'Class': (set(['Object']), 'A generic sardana class'), 'Pool': (set(['PoolElement']), 'A Pool'), 'CTExpChannel': (set(['ExpChannel']), 'A counter/timer experimental channel')}

a dictionary containing the direct interfaces supported by each type (dict<str, tuple<set<str, str>>>)

INTERFACES_EXPANDED = {'Acquirable': (set(['PoolElement', 'Object', 'Acquirable', 'PoolObject', 'Element']), 'An acquirable element'), 'IORegister': (set(['PoolObject', 'PoolElement', 'Acquirable', 'Object', 'IORegister', 'Element']), 'An IO register'), 'Instrument': (set(['Instrument', 'PoolElement', 'Object', 'PoolObject', 'Element']), 'An instrument'), 'PoolElement': (set(['PoolElement', 'Object', 'PoolObject', 'Element']), 'A Pool element'), 'MacroClass': (set(['MacroCode', 'Object', 'Class', 'MacroClass', 'MacroServerObject']), 'A macro server macro class'), 'Function': (set(['Function', 'Object']), 'A generic sardana function'), 'Door': (set(['MacroServerElement', 'Object', 'Door', 'MacroServerObject', 'Element']), 'A macro server door'), 'Object': (set(['Object']), 'A generic sardana object'), 'Controller': (set(['PoolElement', 'Controller', 'Object', 'PoolObject', 'Element']), 'A controller'), 'External': (set(['Object', 'External']), 'An external object'), 'MacroServer': (set(['MacroServerElement', 'Object', 'MacroServerObject', 'MacroServer', 'Element']), 'A MacroServer'), 'MacroLibrary': (set(['MacroLibrary', 'Object', 'MacroServerObject', 'Library']), 'A macro server library'), 'MacroFunction': (set(['Function', 'MacroCode', 'MacroFunction', 'Object', 'MacroServerObject']), 'A macro server macro function'), 'MacroServerObject': (set(['Object', 'MacroServerObject']), 'A generic macro server object'), 'ComChannel': (set(['PoolElement', 'Object', 'PoolObject', 'ComChannel', 'Element']), 'A communication channel'), 'ZeroDExpChannel': (set(['ExpChannel', 'ZeroDExpChannel', 'PoolObject', 'Acquirable', 'PoolElement', 'Object', 'Element']), 'A 0D experimental channel'), 'Constraint': (set(['Object', 'PoolObject', 'Constraint']), 'A constraint'), 'Macro': (set(['Function', 'Macro', 'Object', 'Class', 'MacroCode', 'MacroFunction', 'MacroServerObject', 'MacroClass']), 'A macro server macro'), 'TwoDExpChannel': (set(['ExpChannel', 'PoolObject', 'Acquirable', 'PoolElement', 'TwoDExpChannel', 'Object', 'Element']), 'A 2D experimental channel'), 'Moveable': (set(['PoolElement', 'Object', 'Moveable', 'PoolObject', 'Element']), 'A moveable element'), 'Element': (set(['Object', 'Element']), 'A generic sardana element'), 'ExpChannel': (set(['ExpChannel', 'PoolObject', 'PoolElement', 'Acquirable', 'Object', 'Element']), 'A generic experimental channel'), 'MacroCode': (set(['MacroCode', 'Object', 'MacroServerObject']), 'A macro server macro code'), 'OneDExpChannel': (set(['ExpChannel', 'OneDExpChannel', 'PoolObject', 'Acquirable', 'PoolElement', 'Object', 'Element']), 'A 1D experimental channel'), 'PoolObject': (set(['Object', 'PoolObject']), 'A Pool object'), 'PseudoCounter': (set(['ExpChannel', 'PoolObject', 'PseudoCounter', 'Acquirable', 'PoolElement', 'Object', 'Element']), 'A pseudo counter'), 'MeasurementGroup': (set(['PoolElement', 'Object', 'PoolObject', 'MeasurementGroup', 'Element']), 'A measurement group'), 'PseudoMotor': (set(['Acquirable', 'Object', 'Element', 'PoolObject', 'Moveable', 'PoolElement', 'PseudoMotor']), 'A pseudo motor'), 'ParameterType': (set(['ParameterType', 'Meta']), 'A generic macro server parameter type'), 'MacroServerElement': (set(['MacroServerElement', 'Object', 'MacroServerObject', 'Element']), 'A generic macro server element'), 'MotorGroup': (set(['PoolElement', 'MotorGroup', 'Object', 'PoolObject', 'Element']), 'A motor group'), 'Library': (set(['Object', 'Library']), 'A generic sardana library'), 'Class': (set(['Object', 'Class']), 'A generic sardana class'), 'ControllerLibrary': (set(['ControllerLibrary', 'Object', 'PoolObject', 'Library']), 'A controller library'), 'Meta': (set(['Meta']), 'A generic sardana meta object'), 'Pool': (set(['PoolElement', 'Object', 'PoolObject', 'Pool', 'Element']), 'A Pool'), 'Motor': (set(['Acquirable', 'Object', 'Element', 'PoolObject', 'Motor', 'Moveable', 'PoolElement']), 'a motor'), 'CTExpChannel': (set(['ExpChannel', 'PoolObject', 'CTExpChannel', 'Acquirable', 'PoolElement', 'Object', 'Element']), 'A counter/timer experimental channel'), 'ControllerClass': (set(['ControllerClass', 'Object', 'Class', 'PoolObject']), 'A controller class')}

a dictionary containing the all interfaces supported by each type (dict <str, set < str> >)

Functions

from_dtype_str(dtype)[source]

Transforms the given dtype parameter (string/DataType or None) into a tuple of two elements (str, DataFormat) where the first element is a string with a simplified data type.

  • If None is given, it returns (‘float’, DataFormat.Scalar)
  • If DataType is given, it returns (DataType, DataFormat.Scalar)
Parameters:dtype (str or None or DataType) – the data type to be transformed
Returns:a tuple <str, DataFormat> for the given dtype
Return type:tuple<str, DataFormat>
from_access_str(access)[source]

Transforms the given access parameter (string or DataAccess) into a simplified data access string.

Parameters:dtype (str) – the access to be transformed
Returns:a simple string for the given access
Return type:str
to_dtype_dformat(data)[source]

Transforms the given data parameter (string/ or sequence of string or sequence of sequence of string/DataType) into a tuple of two elements (DataType, DataFormat).

Parameters:data (str or seq<str> or seq<seq<str>>) – the data information to be transformed
Returns:a tuple <DataType, DataFormat> for the given data
Return type:tuple<DataType, DataFormat>
to_daccess(daccess)[source]

Transforms the given access parameter (string or None) into a DataAccess. If None is given returns DataAccess.ReadWrite

Parameters:dtype (str) – the access to be transformed
Returns:a DataAccess for the given access
Return type:DataAccess