remove 'maxage' argument for read_* methods

'maxage' is not really used at any place. remove it, as this makes
the code cleaner

Change-Id: I6f10b4ab91fc57640336db1832716ca9012eb241
Reviewed-on: https://forge.frm2.tum.de/review/20347
Tested-by: JenkinsCodeReview <bjoern_pedersen@frm2.tum.de>
Reviewed-by: Enrico Faulhaber <enrico.faulhaber@frm2.tum.de>
Reviewed-by: Markus Zolliker <markus.zolliker@psi.ch>

secop/lib/sequence.py

@@ -127,7 +127,7 @@ class SequencerMixin(object):
         """Can be called to check if a sequence is currently running."""
         return self._seq_thread and self._seq_thread.isAlive()
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         if self.seq_is_alive():
             return self.Status.BUSY, u'moving: ' + self._seq_phase
         elif self._seq_error:
@@ -139,7 +139,7 @@ class SequencerMixin(object):
                 return self.Status.ERROR, self._seq_stopped
             return self.Status.WARN, self._seq_stopped
         if hasattr(self, u'read_hw_status'):
-            return self.read_hw_status(maxage)
+            return self.read_hw_status()
         return self.Status.IDLE, u''
 
     def do_stop(self):

secop/metaclass.py

@@ -140,11 +140,11 @@ class ModuleMeta(type):
                     break
                 rfunc = getattr(base, 'read_' + pname, None)
 
-            def wrapped_rfunc(self, maxage=0, pname=pname, rfunc=rfunc):
+            def wrapped_rfunc(self, pname=pname, rfunc=rfunc):
                 if rfunc:
                     self.log.debug("rfunc(%s): call %r" % (pname, rfunc))
                     try:
-                        value = rfunc(self, maxage)
+                        value = rfunc(self)
                     except Exception as e:
                         pobj = self.accessibles[pname]
                         self.DISPATCHER.announce_update_error(self, pname, pobj, e)

secop/modules.py

@@ -352,7 +352,7 @@ class Drivable(Writable):
     # improved polling: may poll faster if module is BUSY
     def pollParams(self, nr=0):
         # poll status first
-        self.read_status(0)
+        self.read_status()
         fastpoll = self.isBusy()
         for pname, pobj in self.parameters.items():
             if not pobj.poll:

secop/simulation.py

@@ -47,7 +47,7 @@ class SimBase(object):
                 self.accessibles[k] = Parameter('extra_param: %s' % k.strip(),
                                        datatype=FloatRange(),
                                        default=0.0)
-                def reader(maxage=0, pname=k):
+                def reader(pname=k):
                     self.log.debug('simulated reading %s' % pname)
                     return self.accessibles[pname].value
                 setattr(self, 'read_' + k, reader)
@@ -71,7 +71,7 @@ class SimBase(object):
     def sim(self):
         return True
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         if 'jitter' in self.accessibles:
             return self._value + self.jitter*(0.5-random.random())
         return self._value
@@ -95,7 +95,7 @@ class SimWritable(SimBase, Writable):
         SimBase.__init__(self, cfgdict)
         Writable.__init__(self, devname, logger, cfgdict, dispatcher)
         self._value = self.accessibles['value'].default
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self.target
     def write_target(self, value):
         self.value = value

secop_demo/cryo.py

@@ -140,16 +140,16 @@ class Cryostat(CryoBase):
         self._stopflag = False
         self._thread = mkthread(self.thread)
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         # instead of asking a 'Hardware' take the value from the simulation
         return self.status
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         # return regulation value (averaged regulation temp)
         return self.regulationtemp + \
             self.jitter * (0.5 - random.random())
 
-    def read_target(self, maxage=0):
+    def read_target(self):
         return self.target
 
     def write_target(self, value):
@@ -162,7 +162,7 @@ class Cryostat(CryoBase):
         self.status = self.Status.BUSY, 'new target set'
         return value
 
-    def read_maxpower(self, maxage=0):
+    def read_maxpower(self):
         return self.maxpower
 
     def write_maxpower(self, newpower):
@@ -176,7 +176,7 @@ class Cryostat(CryoBase):
         self.p, self.i, self.d = newpid
         return (self.p, self.i, self.d)
 
-    def read_pid(self, maxage=0):
+    def read_pid(self):
         return (self.p, self.i, self.d)
 
     def do_stop(self):

secop_demo/modules.py

@@ -53,13 +53,13 @@ class Switch(Drivable):
                                  ),
     }
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         # could ask HW
         # we just return the value of the target here.
         self._update()
         return self.value
 
-    def read_target(self, maxage=0):
+    def read_target(self):
         # could ask HW
         return self.target
 
@@ -69,7 +69,7 @@ class Switch(Drivable):
         # note: setting self.target to the new value is done after this....
         # note: we may also return the read-back value from the hw here
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         self.log.info("read status")
         info = self._update()
         if self.target == self.value:
@@ -129,7 +129,7 @@ class MagneticField(Drivable):
         _thread.daemon = True
         _thread.start()
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self.value
 
     def write_target(self, value):
@@ -139,7 +139,7 @@ class MagneticField(Drivable):
         # note: setting self.target to the new value is done after this....
         # note: we may also return the read-back value from the hw here
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         if self._state == self._state.enum.idle:
             return (self.Status.PERSIST, 'at field') if self.value else \
                    (self.Status.IDLE, 'zero field')
@@ -206,7 +206,7 @@ class CoilTemp(Readable):
                         ),
     }
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return round(2.3 + random.random(), 3)
 
 
@@ -275,7 +275,7 @@ class Label(Readable):
                        ),
     }
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         strings = [self.system]
 
         dev_ts = self.DISPATCHER.get_module(self.subdev_ts)

secop_demo/test.py

@@ -44,7 +44,7 @@ class LN2(Readable):
     but the implementation may do anything
     """
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return round(100 * random.random(), 1)
 
 
@@ -60,7 +60,7 @@ class Heater(Drivable):
                                 ),
     }
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return round(100 * random.random(), 1)
 
     def write_target(self, target):
@@ -90,7 +90,7 @@ class Temp(Drivable):
         ),
     }
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return round(100 * random.random(), 1)
 
     def write_target(self, target):

secop_ess/epics.py

@@ -103,10 +103,10 @@ class EpicsReadable(Readable):
             pv = PV(pv_name + ".VAL")
             pv.value = write_value
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self._read_pv(self.value_pv)
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         # XXX: comparison may need to be a little unsharp
         # XXX: Hardware may have it's own idea about the status: how to obtain?
         if self.status_pv != 'unset':
@@ -164,16 +164,16 @@ class EpicsDrivable(Drivable):
             pv = PV(pv_name + ".VAL")
             pv.value = write_value
 
-    def read_target(self, maxage=0):
+    def read_target(self):
         return self._read_pv(self.target_pv)
 
     def write_target(self, write_value):
         self._write_pv(self.target_pv, write_value)
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self._read_pv(self.value_pv)
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         # XXX: comparison may need to be a little unsharp
         # XXX: Hardware may have it's own idea about the status: how to obtain?
         if self.status_pv != 'unset':
@@ -204,7 +204,7 @@ class EpicsTempCtrl(EpicsDrivable):
                                 datatype=StringType(), default="unset", export=False,),
     }
 
-    def read_target(self, maxage=0):
+    def read_target(self):
         return self._read_pv(self.target_pv)
 
     def write_target(self, write_value):
@@ -213,19 +213,19 @@ class EpicsTempCtrl(EpicsDrivable):
         # update our status
         self.read_status()
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self._read_pv(self.value_pv)
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         # XXX: comparison may need to collect a history to detect oscillations
-        at_target = abs(self.read_value(maxage) - self.read_target(maxage)) \
+        at_target = abs(self.read_value() - self.read_target()) \
             <= self.tolerance
         if at_target:
             return (Drivable.Status.IDLE, 'at Target')
         return (Drivable.Status.BUSY, 'Moving')
 
     # TODO: add support for strings over epics pv
-    # def read_heaterrange(self, maxage=0):
+    # def read_heaterrange(self):
     #    return self._read_pv(self.heaterrange_pv)
 
     # TODO: add support for strings over epics pv

secop_mlz/amagnet.py

@@ -142,9 +142,9 @@ class GarfieldMagnet(SequencerMixin, Drivable):
         self._currentsource = self.DISPATCHER.get_module(
             self.subdev_currentsource)
         self.init_sequencer(fault_on_error=False, fault_on_stop=False)
-        self._symmetry.read_value(0)
+        self._symmetry.read_value()
 
-    def read_calibration(self, maxage=0):
+    def read_calibration(self):
         try:
             try:
                 return self.calibrationtable[self._symmetry.value]
@@ -175,13 +175,13 @@ class GarfieldMagnet(SequencerMixin, Drivable):
         limits = self._checkLimits(value)
         return limits
 
-    def read_abslimits(self, maxage=0):
+    def read_abslimits(self):
         maxfield = self._current2field(self._currentsource.abslimits[1])
         # limit to configured value (if any)
         maxfield = min(maxfield, max(self.accessibles['abslimits'].default))
         return -maxfield, maxfield
 
-    def read_ramp(self, maxage=0):
+    def read_ramp(self):
         # This is an approximation!
         return self.calibration[0] * abs(self._currentsource.ramp)
 
@@ -213,26 +213,26 @@ class GarfieldMagnet(SequencerMixin, Drivable):
         # unsafe to switch, go to safe state first
         self._currentsource.write_target(0)
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self._current2field(
-            self._currentsource.read_value(maxage) *
+            self._currentsource.read_value() *
             self._get_field_polarity())
 
-    def read_hw_status(self, maxage=0):
+    def read_hw_status(self):
         # called from SequencerMixin.read_status if no sequence is running
         if self._enable.value == 'Off':
             return self.Status.WARN, 'Disabled'
-        if self._enable.read_status(maxage)[0] != self.Status.IDLE:
+        if self._enable.read_status()[0] != self.Status.IDLE:
             return self._enable.status
         if self._polswitch.value in ['0', 0]:
             return self.Status.IDLE, 'Shorted, ' + self._currentsource.status[1]
         if self._symmetry.value in ['short', 0]:
             return self._currentsource.status[
                 0], 'Shorted, ' + self._currentsource.status[1]
-        return self._currentsource.read_status(maxage)
+        return self._currentsource.read_status()
 
     def write_target(self, target):
-        if target != 0 and self._symmetry.read_value(0) in ['short', 0]:
+        if target != 0 and self._symmetry.read_value() in ['short', 0]:
             raise DisabledError(
                 'Symmetry is shorted, please select another symmetry first!')
 
@@ -245,7 +245,7 @@ class GarfieldMagnet(SequencerMixin, Drivable):
         seq.append(Step('preparing', 0, self._prepare_ramp))
         seq.append(Step('recover', 0, self._recover))
         if current_polarity != wanted_polarity:
-            if self._currentsource.read_value(0) > 0.1:
+            if self._currentsource.read_value() > 0.1:
                 # switching only allowed if current is low enough -> ramp down
                 # first
                 seq.append(
@@ -286,7 +286,7 @@ class GarfieldMagnet(SequencerMixin, Drivable):
 
     def _recover(self, store):
         # check for interlock
-        if self._currentsource.read_status(0)[0] != self.Status.ERROR:
+        if self._currentsource.read_status()[0] != self.Status.ERROR:
             return
         # recover from interlock
         ramp = self._currentsource.ramp
@@ -303,11 +303,11 @@ class GarfieldMagnet(SequencerMixin, Drivable):
     def _ramp_current(self, store, target):
         if abs(self._currentsource.value - target) <= 0.05:
             # done with this step if no longer BUSY
-            return self._currentsource.read_status(0)[0] == 'BUSY'
+            return self._currentsource.read_status()[0] == 'BUSY'
         if self._currentsource.status[0] != 'BUSY':
             if self._enable.status[0] == 'ERROR':
                 self._enable.do_reset()
-                self._enable.read_status(0)
+                self._enable.read_status()
             self._enable.write_target('On')
             self._enable._hw_wait()
             self._currentsource.write_target(target)
@@ -316,15 +316,15 @@ class GarfieldMagnet(SequencerMixin, Drivable):
     def _ramp_current_cleanup(self, store, step_was_busy, target):
         # don't cleanup if step finished
         if step_was_busy:
-            self._currentsource.write_target(self._currentsource.read_value(0))
+            self._currentsource.write_target(self._currentsource.read_value())
         self._currentsource.window = max(store.old_window, 10)
 
     def _set_polarity(self, store, target):
-        if self._polswitch.read_status(0)[0] == self.Status.BUSY:
+        if self._polswitch.read_status()[0] == self.Status.BUSY:
             return True
         if int(self._polswitch.value) == int(target):
             return False  # done with this step
-        if self._polswitch.read_value(0) != 0:
+        if self._polswitch.read_value() != 0:
             self._polswitch.write_target(0)
         else:
             self._polswitch.write_target(target)

secop_mlz/entangle.py

@@ -229,7 +229,7 @@ class PyTangoDevice(Module):
 
     def _hw_wait(self):
         """Wait until hardware status is not BUSY."""
-        while self.read_status(0)[0] == Drivable.Status.BUSY:
+        while self.read_status()[0] == Drivable.Status.BUSY:
             sleep(0.3)
 
     def _getProperty(self, name, dev=None):
@@ -361,7 +361,7 @@ class PyTangoDevice(Module):
         self.log.debug('PyTango error: %s', fulldesc)
         raise exclass(self, fulldesc)
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         # Query status code and string
         tangoState = self._dev.State()
         tangoStatus = self._dev.Status()
@@ -389,7 +389,7 @@ class AnalogInput(PyTangoDevice, Readable):
         if attrInfo.unit != 'No unit':
             self.accessibles['value'].unit = attrInfo.unit
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self._dev.value
 
 
@@ -481,12 +481,12 @@ class AnalogOutput(PyTangoDevice, Drivable):
             # else: remove a stale point
             self._history.pop(0)
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         value = self._dev.value
         self._history.append((currenttime(), value))
         return value
 
-    def read_target(self, maxage=0):
+    def read_target(self):
         attrObj = self._dev.read_attribute('value')
         return attrObj.w_value
 
@@ -511,7 +511,7 @@ class AnalogOutput(PyTangoDevice, Drivable):
 
         return stable and at_target
 
-    def read_status(self, maxage=0):
+    def read_status(self):
         if self._isAtTarget():
             self._timeout = None
             self._moving = False
@@ -584,7 +584,7 @@ class AnalogOutput(PyTangoDevice, Drivable):
             self._timeout = None
         self._moving = True
         self._history = []  # clear history
-        self.read_status(0)  # poll our status to keep it updated
+        self.read_status()  # poll our status to keep it updated
 
     def _hw_wait(self):
         while super(AnalogOutput, self).read_status()[0] == self.Status.BUSY:
@@ -620,18 +620,18 @@ class Actuator(AnalogOutput):
                                ),
     }
 
-    def read_speed(self, maxage=0):
+    def read_speed(self):
         return self._dev.speed
 
     def write_speed(self, value):
         self._dev.speed = value
 
-    def read_ramp(self, maxage=0):
+    def read_ramp(self):
         return self.read_speed() * 60
 
     def write_ramp(self, value):
         self.write_speed(value / 60.)
-        return self.read_speed(0) * 60
+        return self.read_speed() * 60
 
     def do_setposition(self, value=FloatRange()):
         self._dev.Adjust(value)
@@ -660,16 +660,16 @@ class Motor(Actuator):
         'reference': Command('Do a reference run', argument=None, result=None),
     }
 
-    def read_refpos(self, maxage=0):
+    def read_refpos(self):
         return float(self._getProperty('refpos'))
 
-    def read_accel(self, maxage=0):
+    def read_accel(self):
         return self._dev.accel
 
     def write_accel(self, value):
         self._dev.accel = value
 
-    def read_decel(self, maxage=0):
+    def read_decel(self):
         return self._dev.decel
 
     def write_decel(self, value):
@@ -712,32 +712,32 @@ class TemperatureController(Actuator):
         'precision': Override(default=0.1),
     }
 
-    def read_ramp(self, maxage=0):
+    def read_ramp(self):
         return self._dev.ramp
 
     def write_ramp(self, value):
         self._dev.ramp = value
         return self._dev.ramp
 
-    def read_p(self, maxage=0):
+    def read_p(self):
         return self._dev.p
 
     def write_p(self, value):
         self._dev.p = value
 
-    def read_i(self, maxage=0):
+    def read_i(self):
         return self._dev.i
 
     def write_i(self, value):
         self._dev.i = value
 
-    def read_d(self, maxage=0):
+    def read_d(self):
         return self._dev.d
 
     def write_d(self, value):
         self._dev.d = value
 
-    def read_pid(self, maxage=0):
+    def read_pid(self):
         self.read_p()
         self.read_i()
         self.read_d()
@@ -748,10 +748,10 @@ class TemperatureController(Actuator):
         self._dev.i = value[1]
         self._dev.d = value[2]
 
-    def read_setpoint(self, maxage=0):
+    def read_setpoint(self):
         return self._dev.setpoint
 
-    def read_heateroutput(self, maxage=0):
+    def read_heateroutput(self):
         return self._dev.heaterOutput
 
 
@@ -768,16 +768,16 @@ class PowerSupply(Actuator):
                          datatype=FloatRange(), poll=-5),
     }
 
-    def read_ramp(self, maxage=0):
+    def read_ramp(self):
         return self._dev.ramp
 
     def write_ramp(self, value):
         self._dev.ramp = value
 
-    def read_voltage(self, maxage=0):
+    def read_voltage(self):
         return self._dev.voltage
 
-    def read_current(self, maxage=0):
+    def read_current(self):
         return self._dev.current
 
 
@@ -789,7 +789,7 @@ class DigitalInput(PyTangoDevice, Readable):
         'value': Override(datatype=IntRange()),
     }
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self._dev.value
 
 
@@ -810,7 +810,7 @@ class NamedDigitalInput(DigitalInput):
         except Exception as e:
             raise ValueError('Illegal Value for mapping: %r' % e)
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         value = self._dev.value
         return value  # mapping is done by datatype upon export()
 
@@ -832,7 +832,7 @@ class PartialDigitalInput(NamedDigitalInput):
         self._mask = (1 << self.bitwidth) - 1
         # self.accessibles['value'].datatype = IntRange(0, self._mask)
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         raw_value = self._dev.value
         value = (raw_value >> self.startbit) & self._mask
         return value  # mapping is done by datatype upon export()
@@ -848,14 +848,14 @@ class DigitalOutput(PyTangoDevice, Drivable):
         'target': Override(datatype=IntRange()),
     }
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         return self._dev.value  # mapping is done by datatype upon export()
 
     def write_target(self, value):
         self._dev.value = value
         self.read_value()
 
-    def read_target(self, maxage=0):
+    def read_target(self):
         attrObj = self._dev.read_attribute('value')
         return attrObj.w_value
 
@@ -903,7 +903,7 @@ class PartialDigitalOutput(NamedDigitalOutput):
         # self.accessibles['value'].datatype = IntRange(0, self._mask)
         # self.accessibles['target'].datatype = IntRange(0, self._mask)
 
-    def read_value(self, maxage=0):
+    def read_value(self):
         raw_value = self._dev.value
         value = (raw_value >> self.startbit) & self._mask
         return value  # mapping is done by datatype upon export()
@@ -933,19 +933,19 @@ class StringIO(PyTangoDevice, Module):
                              group='communication'),
     }
 
-    def read_bustimeout(self, maxage=0):
+    def read_bustimeout(self):
         return self._dev.communicationTimeout
 
     def write_bustimeout(self, value):
         self._dev.communicationTimeout = value
 
-    def read_endofline(self, maxage=0):
+    def read_endofline(self):
         return self._dev.endOfLine
 
     def write_endofline(self, value):
         self._dev.endOfLine = value
 
-    def read_startofline(self, maxage=0):
+    def read_startofline(self):
         return self._dev.startOfLine
 
     def write_startofline(self, value):