コード例 #1
0
 def getValue(self):
     text = self.text()
     model_obj = self.getModelObj()
     if model_obj is None:
         return None
     val = self.validator()
     try:
         model_type = model_obj.type
         model_format = model_obj.data_format
         if model_type in [DataType.Integer, DataType.Float]:
             try:
                 q = Quantity(text)
                 # allow implicit units (assume wvalue.units implicitly)
                 if q.dimensionless:
                     q = Quantity(q.magnitude, val.units)
                 return q
             except:
                 return None
         elif model_type == DataType.Boolean:
             if model_format == DataFormat._0D:
                 return bool(int(eval(text)))
             else:
                 return numpy.array(eval(text), dtype=int).astype(bool)
         elif model_type == DataType.String:
             if model_format == DataFormat._0D:
                 return str(text)
             else:
                 return numpy.array(eval(text), dtype=str).tolist()
         elif model_type == DataType.Bytes:
             return bytes(text)
         else:
             raise TypeError('Unsupported model type "%s"', model_type)
     except Exception, e:
         self.warning('Cannot return value for "%s". Reason: %r', text, e)
         return None
コード例 #2
0
 def _getDecodePyTangoAttr(self, attr_name, cfg):
     """Helper for decode the PyTango attribute infoex
     """
     dev = PyTango.DeviceProxy(self.DEV_NAME)
     infoex = dev.get_attribute_config_ex(attr_name)[0]
     unit = unit_from_tango(infoex.unit)
     if cfg in ['range', 'alarms', 'warnings']:
         if cfg == 'range':
             low = infoex.min_value
             high = infoex.max_value
         elif cfg == 'alarms':
             low = infoex.alarms.min_alarm
             high = infoex.alarms.max_alarm
         elif cfg == 'warnings':
             low = infoex.alarms.min_warning
             high = infoex.alarms.max_warning
         if low == 'Not specified':
             low = '-inf'
         if high == 'Not specified':
             high = 'inf'
         return [Quantity(float(low), unit), Quantity(float(high), unit)]
     elif cfg == 'label':
         return infoex.label
     else:
         return None
コード例 #3
0
ファイル: tangoattribute.py プロジェクト: napppoli/taurus
    def __init__(self, attr=None, pytango_dev_attr=None, config=None):
        # config parameter is kept for backwards compatibility only
        TaurusAttrValue.__init__(self)
        if config is not None:
            from taurus.core.util.log import deprecated
            deprecated(dep='"config" kwarg', alt='"attr"', rel='4.0')
            attr = config
        if attr is None:
            self._attrRef = None
        else:
            self._attrRef = weakref.proxy(attr)
        self.config = self._attrRef  # bck-compat

        self._pytango_dev_attr = p = pytango_dev_attr
        if p is None:
            self._pytango_dev_attr = p = PyTango.DeviceAttribute()
            return

        if self._attrRef is None:
            return

        numerical = (PyTango.is_numerical_type(self._attrRef._tango_data_type,
                                               inc_array=True)
                     or p.type == PyTango.CmdArgType.DevUChar)

        if p.has_failed:
            self.error = PyTango.DevFailed(*p.get_err_stack())
        else:
            # spectra and images can be empty without failing
            if p.is_empty and self._attrRef.data_format != DataFormat._0D:
                dtype = FROM_TANGO_TO_NUMPY_TYPE.get(
                    self._attrRef._tango_data_type)
                if self._attrRef.data_format == DataFormat._1D:
                    shape = (0, )
                elif self._attrRef.data_format == DataFormat._2D:
                    shape = (0, 0)
                p.value = numpy.empty(shape, dtype=dtype)
                if not (numerical or self._attrRef.type == DataType.Boolean):
                    # generate a nested empty list of given shape
                    p.value = []
                    for _ in xrange(len(shape) - 1):
                        p.value = [p.value]

        rvalue = p.value
        wvalue = p.w_value
        if numerical:
            units = self._attrRef._units
            if rvalue is not None:
                rvalue = Quantity(rvalue, units=units)
            if wvalue is not None:
                wvalue = Quantity(wvalue, units=units)
        elif isinstance(rvalue, PyTango._PyTango.DevState):
            rvalue = DevState[str(rvalue)]

        self.rvalue = rvalue
        self.wvalue = wvalue
        self.time = p.time  # TODO: decode this into a TaurusTimeVal
        self.quality = quality_from_tango(p.quality)
コード例 #4
0
 def __decode_limit(self, l, h):
     units = self.__pv.units
     if l is None or numpy.isnan(l):
         l = None
     else:
         l = Quantity(l, units)
     if l is None or numpy.isnan(h):
         h = None
     else:
         h = Quantity(h, units)
     return [l, h]
コード例 #5
0
ファイル: taurusvaluestable.py プロジェクト: tcsgmrt/taurus
def _value2Quantity(value, units):
    '''
    Creates a Quantity from value and forces units if the vaule is unitless

    :param value: (int, float or str) a number or a string from which a quantity
                  can be created
    :param units: (str or Pint units) Units to use if the value is unitless
    :return: (Quantity)
    '''
    q = Quantity(value)
    if q.unitless:
        q = Quantity(q, units)
    return q
コード例 #6
0
 def test1():
     n = 'eval:@c=taurus.core.evaluation.test.res.mymod.MyClass(987)/c.foo'
     a = taurus.Attribute(n)
     print "READ 1:   ", a.read()
     # print a.range
     print "WRITE+READ", a.write(Quantity(999, "m"))
     print "READ 2:   ", a.read(cache=False)
コード例 #7
0
 def applyTransformation(self):
     if self._transformation is None:
         return
     try:
         evaluator = self.getParentObj()
         rvalue = evaluator.eval(self._transformation)
         value_dimension = len(numpy.shape(rvalue))
         value_dformat = DataFormat(value_dimension)
         self.data_format = value_dformat
         self.type = self._encodeType(rvalue, value_dformat)
         if self.type is None:
             raise TypeError("Unsupported returned type, %r" % rvalue)
         if self.type in [DataType.Integer, DataType.Float] and\
                 not isinstance(rvalue, Quantity):
             self.debug("Transformation converted to Quantity")
             rvalue = Quantity(rvalue)
         elif self.type == DataType.Boolean and value_dimension > 1:
             self.debug("Transformation converted to numpy.array")
             rvalue = numpy.array(rvalue)
         self._value.rvalue = rvalue
         self._value.time = TaurusTimeVal.now()
         self._value.quality = AttrQuality.ATTR_VALID
     except Exception, e:
         self._value.quality = AttrQuality.ATTR_INVALID
         msg = " the function '%s' could not be evaluated. Reason: %s" \
             % (self._transformation, repr(e))
         self.warning(msg)
コード例 #8
0
def get_quantity(value, units=None, fmt=None):
    if value is None:
        return None
    res = Quantity(value, units=units)
    if fmt is not None:
        res.default_format = fmt + res.default_format
    return res
コード例 #9
0
 def setAlarms(self, *limits):
     if isinstance(limits[0], list):
         limits = limits[0]
     low, high = limits
     low = Quantity(low)
     high = Quantity(high)
     TaurusAttribute.setAlarms(self, [low, high])
     infoex = self._pytango_attrinfoex
     if low.magnitude != float('-inf'):
         infoex.alarms.min_alarm = str(low.to(self._units).magnitude)
     else:
         infoex.alarms.min_alarm = 'Not specified'
     if high.magnitude != float('inf'):
         infoex.alarms.max_alarm = str(high.to(self._units).magnitude)
     else:
         infoex.alarms.max_alarm = 'Not specified'
     self._applyConfig()
コード例 #10
0
    def setTop(self, top):
        """
        Set maximum limit

        :param top: (Quantity or None) maximum acceptable value or None if it is
                    not to be enforced
        """
        self._top = Quantity(top)
コード例 #11
0
    def setBottom(self, bottom):
        """
        Set minimum limit

        :param bottom: (Quantity or None) minimum acceptable value or None if it
                       is not to be enforced
        """
        self._bottom = Quantity(bottom)
コード例 #12
0
ファイル: taurusspinbox.py プロジェクト: tcsgmrt/taurus
 def _getSingleStepQuantity(self):
     """
     :return: (Quantity) returns a single step with the units of the current
              value
     """
     value = self.getValue()
     if value is None:
         return None
     return Quantity(self.getSingleStep(), value.units)
コード例 #13
0
 def getValue(self):
     text = self.text()
     model_obj = self.getModelObj()
     if model_obj is None:
         return None
     val = self.validator()
     try:
         model_type = model_obj.type
         model_format = model_obj.data_format
         if model_type in [DataType.Integer, DataType.Float]:
             try:
                 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 # workaround for https://github.com/hgrecco/pint/issues/614
                 text = text.lstrip('0') or '0'
                 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 q = Quantity(text)
                 # allow implicit units (assume wvalue.units implicitly)
                 if q.unitless:
                     q = Quantity(q.magnitude, val.units)
                 return q
             except:
                 return None
         elif model_type == DataType.Boolean:
             if model_format == DataFormat._0D:
                 return bool(int(eval(text)))
             else:
                 return numpy.array(eval(text), dtype=int).astype(bool)
         elif model_type == DataType.String:
             if model_format == DataFormat._0D:
                 return str(text)
             else:
                 return numpy.array(eval(text), dtype=str).tolist()
         elif model_type == DataType.Bytes:
             return bytes(text)
         else:
             raise TypeError('Unsupported model type "%s"' % model_type)
     except Exception as e:
         msg = 'Cannot return value for "%s". Reason: %r'
         if text in (str(None), self.getNoneValue()):
             self.debug(msg, text, e)
         else:
             self.warning(msg, text, e)
         return None
コード例 #14
0
ファイル: tangoattribute.py プロジェクト: napppoli/taurus
 def setRange(self, *limits):
     if isinstance(limits[0], list):
         limits = limits[0]
     low, high = limits
     low = Quantity(low)
     if low.unitless:
         low = Quantity(low.magnitude, self._units)
     high = Quantity(high)
     if high.unitless:
         high = Quantity(high.magnitude, self._units)
     TaurusAttribute.setRange(self, [low, high])
     infoex = self._pytango_attrinfoex
     if low.magnitude != float('-inf'):
         infoex.min_value = str(low.to(self._units).magnitude)
     else:
         infoex.min_value = 'Not specified'
     if high.magnitude != float('inf'):
         infoex.max_value = str(high.to(self._units).magnitude)
     else:
         infoex.max_value = 'Not specified'
     self._applyConfig()
コード例 #15
0
ファイル: dev_example.py プロジェクト: tcsgmrt/taurus
    def getFreeSpace(self, dir):
        """ return free space (in bytes).
        (Recipe adapted from `http://stackoverflow.com/questions/51658`)
        """
        if platform.system() == 'Windows':
            free_bytes = ctypes.c_ulonglong(0)
            ctypes.windll.kernel32.GetDiskFreeSpaceExW(
                ctypes.c_wchar_p(dir), None, None, ctypes.pointer(free_bytes))
            ret = free_bytes.value
        else:
            s = os.statvfs(dir)
            ret = s.f_bsize * s.f_bavail

        return Quantity(ret, 'B')
コード例 #16
0
 def _validate(self, input, pos):
     """Reimplemented from :class:`QValidator` to validate if the input
     string is a representation of a quantity within the set bottom and top
     limits
     """
     try:
         q = Quantity(input)
     except:
         return Qt.QValidator.Intermediate, input, pos
     if self._implicit_units is not None:
         if q.dimensionless:
             # "cast" to implicit units
             q = Quantity(q.magnitude, self.units)
         # check coherence with implicit units
         elif self._implicit_units.dimensionality != q.dimensionality:
             return Qt.QValidator.Intermediate, input, pos
     try:
         if self.bottom is not None and q < self.bottom:
             return Qt.QValidator.Intermediate, input, pos
         if self.top is not None and q > self.top:
             return Qt.QValidator.Intermediate, input, pos
     except DimensionalityError:
         return Qt.QValidator.Intermediate, input, pos
     return Qt.QValidator.Acceptable, input, pos
コード例 #17
0
    def decode(self, pv):
        """Decodes an epics PV object into a TaurusValue, and also updates other
         properties of the Attribute object
        """
        attr_value = TaurusAttrValue()
        if not pv.connected:
            attr_value.error = ChannelAccessException('PV "%s" not connected' %
                                                      pv.pvname)
            return attr_value
        v = pv.value
        # type
        try:
            self.type = Dbr2TaurusType[pv.ftype]
        except KeyError:
            raise ValueError('Unsupported epics type "%s"' % pv.type)
        # writable
        self.writable = pv.write_access
        # data_format
        if numpy.isscalar(v):
            self.data_format = DataFormat._0D
        else:
            self.data_format = DataFormat(len(numpy.shape(v)))
        # units and limits support
        if self.type in (DataType.Integer, DataType.Float):
            v = Quantity(v, pv.units)
            self._range = self.__decode_limit(pv.lower_ctrl_limit,
                                              pv.upper_ctrl_limit)
            self._alarm = self.__decode_limit(pv.lower_alarm_limit,
                                              pv.upper_alarm_limit)
            self._warning = self.__decode_limit(pv.lower_warning_limit,
                                                pv.upper_warning_limit)

        # rvalue
        attr_value.rvalue = v
        # wvalue
        if pv.write_access:
            attr_value.wvalue = v
        # time
        if pv.timestamp is None:
            attr_value.time = TaurusTimeVal.now()
        else:
            attr_value.time = TaurusTimeVal.fromtimestamp(pv.timestamp)
        # quality
        if pv.severity > 0:
            attr_value.quality = AttrQuality.ATTR_ALARM
        else:
            attr_value.quality = AttrQuality.ATTR_VALID
        return attr_value
コード例 #18
0
    def __assertValidValue(self, exp, got, msg):
        # if we are dealing with quantities, use the magnitude for comparing
        if isinstance(got, Quantity):
            got = got.to(Quantity(exp).units).magnitude
        if isinstance(exp, Quantity):
            exp = exp.magnitude
        try:
            # for those values that can be handled by numpy.allclose()
            chk = numpy.allclose(got, exp)
        except:
            # for the rest
            if isinstance(got, numpy.ndarray):
                got = got.tolist()
            chk = bool(got == exp)

        self.assertTrue(chk, msg)
コード例 #19
0
    def _set_value(self, value):
        '''for backwards compat with taurus < 4'''
        debug('Setting %r to %s' % (value, self.name))

        if self.rvalue is None:  # we do not have a previous rvalue
            import numpy
            dtype = numpy.array(value).dtype
            if numpy.issubdtype(dtype, int) or numpy.issubdtype(dtype, float):
                msg = 'Refusing to set ambiguous value (deprecated .value API)'
                raise ValueError(msg)
            else:
                self.rvalue = value
        elif hasattr(self.rvalue, 'units'):  # we do have it and is a Quantity
            self.rvalue = Quantity(value, units=self.rvalue.units)
        else:  # we do have a previous value and is not a quantity
            self.rvalue = value
コード例 #20
0
ファイル: tangoattribute.py プロジェクト: napppoli/taurus
    def _decodeAttrInfoEx(self, pytango_attrinfoex=None):
        if pytango_attrinfoex is None:
            self._pytango_attrinfoex = PyTango.AttributeInfoEx()
        else:
            self._pytango_attrinfoex = i = pytango_attrinfoex

            self.writable = i.writable != PyTango.AttrWriteType.READ
            self._label = i.label
            self.data_format = data_format_from_tango(i.data_format)
            desc = description_from_tango(i.description)
            if desc != "":
                self._description = desc
            self.type = data_type_from_tango(i.data_type)
            ###############################################################
            # changed in taurus4: range, alarm and warning now return
            # quantities if appropriate
            units = self._unit_from_tango(i.unit)
            if PyTango.is_numerical_type(i.data_type, inc_array=True):
                Q_ = partial(quantity_from_tango_str,
                             units=units,
                             dtype=i.data_type)
                ninf, inf = float('-inf'), float('inf')
                min_value = Q_(i.min_value) or Quantity(ninf, units)
                max_value = Q_(i.max_value) or Quantity(inf, units)
                min_alarm = Q_(i.alarms.min_alarm) or Quantity(ninf, units)
                max_alarm = Q_(i.alarms.max_alarm) or Quantity(inf, units)
                min_warning = Q_(i.alarms.min_warning) or Quantity(ninf, units)
                max_warning = Q_(i.alarms.max_warning) or Quantity(inf, units)
                self._range = [min_value, max_value]
                self._warning = [min_warning, max_warning]
                self._alarm = [min_alarm, max_alarm]

            ###############################################################
            # The following members will be accessed via __getattr__
            # self.standard_unit
            # self.display_unit
            # self.disp_level
            ###############################################################
            # Tango-specific extension of TaurusConfigValue
            self.display_level = display_level_from_tango(i.disp_level)
            self.tango_writable = i.writable
            self.max_dim = i.max_dim_x, i.max_dim_y
            ###############################################################
            fmt = standard_display_format_from_tango(i.data_type, i.format)
            self.format_spec = fmt.lstrip('%')  # format specifier
            match = re.search("[^\.]*\.(?P<precision>[0-9]+)[eEfFgG%]", fmt)
            if match:
                self.precision = int(match.group(1))
            # self._units and self._display_format is to be used by
            # TangoAttrValue for performance reasons. Do not rely on it in other
            # code
            self._units = units
コード例 #21
0
    def decode(self, data_frame):
        """
        Decode the DataFrame to the corresponding python attribute
        :param data_frame: (pandas.DataFrame)
        :return: taurus valid type
        """
        columns_count = len(data_frame.columns)
        attr_value_np = data_frame.as_matrix()

        if columns_count < 2:
            attr_value_np = attr_value_np.reshape(-1)

            if len(attr_value_np) == 1:
                self.data_format = DataFormat._0D
                attr_value_np = attr_value_np[0]
            else:
                self.data_format = DataFormat._1D
        else:
            if len(attr_value_np) == 1:
                self.data_format = DataFormat._1D
                attr_value_np = attr_value_np[0]
            else:
                self.data_format = DataFormat._2D

        try:
            npdtype = attr_value_np.dtype.kind
            self.type = self.npdtype2taurusdtype.get(npdtype)
        except AttributeError:
            self.type = self.npdtype2taurusdtype.get("O")

        if self.isNumeric():
            value = Quantity(attr_value_np, units="dimensionless")
        elif self.data_format == DataFormat._0D:
            value = attr_value_np
        elif self.type is DataType.String or self.type is DataType.Boolean:
            value = attr_value_np.tolist()

        if self.type == self.npdtype2taurusdtype["O"] and columns_count >= 2:
            for row_idx in range(len(value)):
                for item_idx in range(len(value[row_idx])):
                    value[row_idx][item_idx] = str(value[row_idx][item_idx])

        return value
コード例 #22
0
 def applyTransformation(self):
     if self._transformation is None:
         return
     try:
         evaluator = self.getParentObj()
         rvalue = evaluator.eval(self._transformation)
         # ---------------------------------------------------------
         # Workaround for https://github.com/hgrecco/pint/issues/509
         # The numpy.shape method over a Quantity mutates
         # the type of its magnitude.
         # TODO: remove "if" when the bug is solved in pint
         if hasattr(rvalue, "magnitude"):
             value_dimension = len(numpy.shape(rvalue.magnitude))
         else:
             value_dimension = len(numpy.shape(rvalue))
         # ---------------------------------------------------------
         value_dformat = DataFormat(value_dimension)
         self.data_format = value_dformat
         self.type = self._encodeType(rvalue, value_dformat)
         if self.type is None:
             raise TypeError("Unsupported returned type, %r" % rvalue)
         if self.type in [DataType.Integer, DataType.Float] and\
                 not isinstance(rvalue, Quantity):
             self.debug("Transformation converted to Quantity")
             rvalue = Quantity(rvalue)
         elif self.type == DataType.Boolean and value_dimension > 1:
             self.debug("Transformation converted to numpy.array")
             rvalue = numpy.array(rvalue)
         self._value.rvalue = rvalue
         self._value.time = TaurusTimeVal.now()
         self._value.quality = AttrQuality.ATTR_VALID
     except Exception, e:
         self._value.quality = AttrQuality.ATTR_INVALID
         msg = " the function '%s' could not be evaluated. Reason: %s" \
             % (self._transformation, repr(e))
         self.warning(msg)
コード例 #23
0
import numpy
import taurus
from taurus.core import TaurusAttrValue, DataType
from taurus.external import unittest
from taurus.external.pint import Quantity
from taurus.test import insertTest

BASE_DIR = os.path.dirname(os.path.realpath(__file__))


# =========================================================================
# Tests of return types
# =========================================================================
@insertTest(helper_name="read_attr",
            attr_fullname='pds-csv:{}/res/file-csv::["int1"]'.format(BASE_DIR),
            expected=dict(rvalue=Quantity([1, 2, 3], 'dimensionless'),
                          type=DataType.Integer),
            expected_dim=1)
@insertTest(helper_name="read_attr",
            attr_fullname='pds-csv:%s/res/file-csv::{"usecols":["int1"]}' %
            BASE_DIR,
            expected=dict(rvalue=Quantity([1, 2, 3], 'dimensionless'),
                          type=DataType.Integer),
            expected_dim=1)
@insertTest(helper_name="read_attr",
            attr_fullname='pds-csv:%s/res/file-csv::["int1"],'
            '{"usecols":["int1"]}' % BASE_DIR,
            expected=dict(rvalue=Quantity([1, 2, 3], 'dimensionless'),
                          type=DataType.Integer),
            expected_dim=1)
@insertTest(helper_name="read_attr",
コード例 #24
0
_FLOAT_SPE = _INT_SPE * .1
_BOOL_IMG = numpy.array([[True, False], [False, True]])
_BOOL_SPE = [True, False]
_STR = 'foo BAR |-+#@!?_[]{}'
_UINT8_IMG = numpy.array([[1, 2], [3, 4]], dtype='uint8')
_UINT8_SPE = _UINT8_IMG[1, :]

# ==============================================================================
# Test writing fragment values


@insertTest(helper_name='write_read_conf',
            attr_name='short_scalar_nu',
            cfg='range',
            value=[float('-inf'), float('inf')],
            expected=[Quantity(float('-inf')),
                      Quantity(float('inf'))])
@insertTest(helper_name='write_read_conf',
            attr_name='short_scalar_nu',
            cfg='range',
            value=[Quantity(float('-inf')),
                   Quantity(float('inf'))],
            expected=[Quantity(float('-inf')),
                      Quantity(float('inf'))])
@insertTest(helper_name='write_read_conf',
            attr_name='short_scalar_nu',
            cfg='range',
            value=[100, 300],
            expected=[Quantity(100), Quantity(300)])
@insertTest(helper_name='write_read_conf',
            attr_name='short_scalar_nu',
コード例 #25
0
"""Test for epicsattributes..."""

import os
import numpy
import subprocess
from taurus.external import unittest
from taurus.external.pint import Quantity
import taurus
from taurus.test import insertTest, getResourcePath
from taurus.core.taurusbasetypes import DataType, AttrQuality, DataFormat
from taurus.core.taurusbasetypes import TaurusAttrValue


@insertTest(helper_name='write_read_attr',
            attrname='ca:test:a',
            setvalue=Quantity('1000mm'),
            expected=dict(rvalue=Quantity('1m'),
                          type=DataType.Float,
                          writable=True,
                          data_format=DataFormat._0D,
                          range=[Quantity('-10m'), Quantity('10m')],
                          alarms=[None, None],
                          warnings=[None, None],
                          ),
            expected_attrv=dict(rvalue=Quantity('1m'),
                                wvalue=Quantity('1m'),
                                quality=AttrQuality.ATTR_VALID,
                                error=None,
                                ),
            )
class AttributeTestCase(unittest.TestCase):
コード例 #26
0
ファイル: test_epicsattribute.py プロジェクト: tcsgmrt/taurus
import os
import sys
import numpy
import subprocess
from taurus.external import unittest
from taurus.external.pint import Quantity
import taurus
from taurus.test import insertTest, getResourcePath
from taurus.core.taurusbasetypes import DataType, AttrQuality, DataFormat
from taurus.core.taurusbasetypes import TaurusAttrValue


@insertTest(helper_name='write_read_attr',
            attrname='ca:test:a',
            setvalue=Quantity('1000mm'),
            expected=dict(
                rvalue=Quantity('1m'),
                type=DataType.Float,
                writable=True,
                data_format=DataFormat._0D,
                range=[Quantity('-10m'), Quantity('10m')],
                alarms=[None, None],
                warnings=[None, None],
            ),
            expected_attrv=dict(
                rvalue=Quantity('1m'),
                wvalue=Quantity('1m'),
                quality=AttrQuality.ATTR_VALID,
                error=None,
            ))
コード例 #27
0
            expected=dict(rvalue=8,
                          value=8,
                          wvalue=None,
                          w_value=None,
                          type=DataType.Integer))
@insertTest(helper_name='read_attr',
            name='eval:"split.split".split("split")',
            expected=dict(rvalue=['', '.', ''],
                          value=['', '.', ''],
                          wvalue=None,
                          w_value=None,
                          label='"split.split".split("split")',
                          type=DataType.String))
@insertTest(helper_name='read_attr',
            name='eval:Quantity(1.0)',
            expected=dict(rvalue=Quantity(1.0),
                          value=1.0,
                          w_value=None,
                          wvalue=None,
                          label='Quantity(1.0)',
                          type=DataType.Float,
                          data_format=DataFormat._0D))
@insertTest(helper_name='read_attr',
            name='eval:Quantity("1km")',
            expected=dict(rvalue=Quantity(1000, 'm'),
                          value=1,
                          w_value=None,
                          wvalue=None,
                          label='Quantity("1km")',
                          type=DataType.Integer,
                          data_format=DataFormat._0D))
コード例 #28
0
 def _stepBy(self, v):
     value = self.getValue()
     self.setValue(value + Quantity(v, value.units))
コード例 #29
0
ファイル: test_evalattribute.py プロジェクト: tcsgmrt/taurus
# __all__ = []

import numpy
from taurus.external import unittest
from taurus.external.pint import Quantity
import taurus
from taurus.test import insertTest
from taurus.core.taurusbasetypes import DataType, DataFormat, AttrQuality
from taurus.core.evaluation.evalattribute import EvaluationAttrValue


@insertTest(helper_name='read_attr',
            attr_fullname='eval:1',
            expected=dict(
                rvalue=Quantity(1, 'dimensionless'),
                type=DataType.Integer,
                label='1',
                writable=False,
            ),
            expected_attrv=dict(rvalue=Quantity([], 'dimensionless'),
                                wvalue=None),
            expectedshape=None)
@insertTest(helper_name='read_attr',
            attr_fullname='eval:Quantity("1m")+Quantity("2m")',
            expected=dict(
                rvalue=Quantity(3, 'm'),
                type=DataType.Integer,
                label='Quantity("1m")+Quantity("2m")',
                writable=False,
            ),
コード例 #30
0
 def __init__(self, foomag=123):
     self._foo = Quantity(foomag, "m")