pytrms 0.2.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

pytrms/helpers.py

@@ -1,9 +1,6 @@
-import pandas as pd
+import requests.exceptions
 
+class PTRConnectionError(requests.exceptions.ConnectionError):
+    pass
 
-def convert_labview_to_posix(ts):
-    '''Create a `Pandas.Timestamp` from LabView time.'''
-    posix_time = ts - 2082844800
-
-    return pd.Timestamp(posix_time, unit='s')
 

pytrms/instrument.py

@@ -1,8 +1,11 @@
-import time
 import os.path
+import time
+from abc import abstractmethod, ABC
+
+from .measurement import *
 
 
-class Instrument:
+class Instrument(ABC):
     '''
     Class for controlling the PTR instrument remotely.
 
@@ -11,163 +14,101 @@ class Instrument:
     instrument can be stopped. But trying to start a measurement twice will raise an
     exception (RuntimeError).
 
-    This is a singleton class, i.e. it is only instanciated once per script.
+    Note, that for every client PTR instrument there is only one instance of this class.
+    This is to prevent different instances to be in other states than the instrument.
     '''
 
     __instance = None
 
     def _new_state(self, newstate):
+        # Note: we get ourselves a nifty little state-machine :)
         self.__class__ = newstate
-        print(self)
 
-    def __new__(cls, client, buffer):
-        # make this class a singleton
+    def __new__(cls, backend):
+        # make this class a singleton..
         if cls._Instrument__instance is not None:
             # quick reminder: If __new__() does not return an instance of cls, then the
             # new instance’s __init__() method will *not* be invoked:
             return cls._Instrument__instance
-            #raise Exception('the Instrument class can only have one instance')
 
-        inst = object.__new__(cls)
-        cls._Instrument__instance = inst
-
-        # launch the buffer's thread..
-        if not buffer.is_alive():
-            buffer.daemon = True
-            buffer.start()
-        # ..and synchronize the PTR-instrument state with this Python object:
-        Instrument._new_state(inst, BusyInstrument)
-        if buffer.is_idle:
-            Instrument._new_state(inst, IdleInstrument)
+        # ..that is synchronized with the PTR-instrument state:
+        if backend.is_running:
+            cls = RunningInstrument
         else:
-            Instrument._new_state(inst, RunningInstrument)
+            cls = IdleInstrument
+
+        inst = object.__new__(cls)
+        Instrument._Instrument__instance = inst
 
         return inst
 
-    def __init__(self, client, buffer):
+    def __init__(self, backend):
         # dispatch all blocking calls to the client
-        # and fetch current data from the buffer!
-        self._client = client
-        self._buffer = buffer
+        self.backend = backend
 
+    @property
     def is_local(self):
         """Returns True if files are written to the local machine."""
-        host = self._client.host
-        return host == 'localhost' or host == '127.0.0.1'
-
-    def wait(self, seconds, reason=''):
-        if reason:
-            print(reason)
-        time.sleep(seconds)
+        host = str(self.backend.host)
+        return 'localhost' in host or '127.0.0.1' in host
 
     def get(self, varname):
         """Get the current value of a setting."""
-        return self._client.get(varname)
-
-    def set(self, varname, value):
-        """Set a variable to a new value."""
-        return self._client.set(varname, value)
+        # TODO :: this is not an interface implementation
+        raw = self.backend.get(varname)
+        if not isinstance(self.backend, MqttClient):
+            import json
+            jobj = json.loads(raw)
 
-    def __enter__(self):
-        # TODO :: implement proper context with dict of settings...
-        self.start()
-        return self
+            return jobj[0]['Act']['Real']
 
-    def __exit__(self, exc_type, exc_val, tb):
-        self.stop()
+        ## how it should be:
+        return raw
 
-    def start(self, path=''):
-        """Start a measurement on the PTR server.
-
-        'path' is the filename of the datafile to write to. 
-        If left blank, start a "quick measurement".
-
-        If pointing to a file and the file exist on the (local) server, this raises an exception.
-        To create unique filenames, use placeholders for year (%Y), month (%m), and so on,
-        for example `path=C:/Ionicon/Data/Sauerteig_%Y-%m-%d_%H-%M-%S.h5`.
+    def set(self, varname, value, unit='-'):
+        """Set a variable to a new value."""
+        return self.backend.set(varname, value, unit='-')
 
-        see also:
-        """
+    def start_measurement(self, filename=''):
         # this method must be implemented by each state
-        raise NotImplementedError()
+        raise RuntimeError("can't start %s" % self.__class__)
 
-    start.__doc__ += time.strftime.__doc__
+    start_measurement.__doc__ = Measurement.start.__doc__
 
-    def stop(self):
-        """Stop the current measurement on the PTR server."""
+    def stop_measurement(self):
         # this method must be implemented by each state
-        raise NotImplementedError()
+        raise RuntimeError("can't stop %s" % self.__class__)
 
-    def get_traces(self, kind='raw', index='abs_cycle'):
-        """Return the timeseries ("traces") of all masses, compounds and settings.
-
-        This will grow with time if a measurement is currently running and stop growing
-        once the measurement has been stopped. The tracedata is cleared, when a new
-        measurement is started.
-
-        'kind' is the type of traces and must be one of 'raw', 'concentration' or 'corrected'.
-
-        'index' specifies the desired index and must be one of 'abs_cycle', 'rel_cycle',
-        'abs_time' or 'rel_time'.
-        """
-        # TODO :: this method must be implemented by each state
-        raise NotImplementedError()
-
-    def follow(self, kind='raw'):
-        """Returns an iterator over the timeseries ("traces") of all masses, compounds and settings.
-
-        'kind' is the type of traces and must be one of 'raw', 'concentration' or 'corrected'.
-        """
-        # TODO :: this method must be implemented by each state
-        raise NotImplementedError()
+    stop_measurement.__doc__ = Measurement.stop.__doc__
 
 
 class IdleInstrument(Instrument):
 
-    def start(self, path=''):
+    def start_measurement(self, filename=''):
         # if we send a filepath to the server that does not exist there, the server will
         # open a dialog and "hang" (which I'd very much like to avoid).
         # the safest way is to not send a path at all and start a 'Quick' measurement.
         # but if the server is the local machine, we do our best to verify the path:
-        if path and self.is_local():
-            home = os.path.dirname(path)
+        if filename and self.is_local:
+            home = os.path.dirname(filename)
             os.makedirs(home, exist_ok=True)
-            base = os.path.basename(path)
+            base = os.path.basename(filename)
             if not base:
                 base = '%Y-%m-%d_%H-%M-%S.h5'
             base = time.strftime(base)
-            path = os.path.join(home, base)
-            if os.path.exists(path):
-                raise RuntimeError(f'path exists and cannot be overwritten')
+            filename = os.path.join(home, base)
+            if os.path.exists(filename):
+                raise RuntimeError(f'filename exists and cannot be overwritten')
 
-        self._new_state(BusyInstrument)
-        self._client.start_measurement(path)
-        self.start(path)
+        self.backend.start_measurement(filename)
+        self._new_state(RunningInstrument)
 
-    def stop(self):
-        raise RuntimeError('instrument is not running')
+        return RunningMeasurement(self)
 
 
 class RunningInstrument(Instrument):
 
-    def start(self, path=''):
-        raise RuntimeError('instrument is already running')
-
-    def stop(self):
-        self._new_state(BusyInstrument)
-        self._client.stop_measurement()
-        self.stop()
-
-
-class BusyInstrument(Instrument):
-
-    def start(self, path=''):
-        while self._buffer.is_idle:
-            time.sleep(0.01)
-        self._new_state(RunningInstrument)
-
-    def stop(self):
-        while not self._buffer.is_idle:
-            time.sleep(0.01)
+    def stop_measurement(self):
+        self.backend.stop_measurement()
         self._new_state(IdleInstrument)
 

pytrms/measurement.py

@@ -1,77 +1,160 @@
-import os.path
-from abc import abstractmethod
-from collections.abc import Iterable
+import time
+from glob import glob
+from operator import attrgetter
+from itertools import chain
+from abc import abstractmethod, ABC
 
+from .readers import IoniTOFReader
 
-class Measurement(Iterable):
-    """Base class for PTRMS-measurements or batch processing.
+__all__ = ['Measurement', 'PreparingMeasurement', 'RunningMeasurement', 'FinishedMeasurement']
 
-    Every instance is associated with exactly one `.filename` to a datafile.
-    The start time of the measurement is given by `.timezero`.
+
+class Measurement(ABC):
+    """Class for PTRMS-measurements and batch processing.
+
+    The start time of the measurement is given by `.time_of_meas`.
 
     A measurement is iterable over the 'rows' of its data. 
-    In the online case, this would slowly produce the current trace, one after another.
+    In the online case, this would slowly produce the current trace, one
+    after another.
     In the offline case, this would quickly iterate over the traces in the given
     measurement file.
     """
 
-    def is_local(self):
-        return os.path.exists(self.filename)
+    def _new_state(self, newstate):
+        # Note: we get ourselves a nifty little state-machine :)
+        self.__class__ = newstate
+
+    def start(self, filename=''):
+        """Start a measurement on the PTR server.
+
+        'filename' is the filename of the datafile to write to. 
+        If left blank, start a "quick measurement".
+
+        If pointing to a file and the file exist on the (local) server, this raises an exception.
+        To create unique filenames, use placeholders for year (%Y), month (%m), and so on,
+        for example `filename=C:/Ionicon/Data/Sauerteig_%Y-%m-%d_%H-%M-%S.h5`.
+
+        see also:
+        """
+        # this method must be implemented by each state
+        raise RuntimeError("can't start %s" % self.__class__)
+
+    # (see also: this docstring)
+    start.__doc__ += time.strftime.__doc__
+
+    def stop(self):
+        """Stop the current measurement on the PTR server."""
+        raise RuntimeError("can't stop %s" % self.__class__)
+
+    @abstractmethod
+    def __len__(self):
+        pass
+
 
-    def __init__(self, filename):
-        self._filename = filename
+class PreparingMeasurement(Measurement):
 
     @property
-    def filename(self):
-        return self._filename
-    
+    def single_spec_duration_ms(self):
+        return self.ptr.get('ACQ_SRV_SpecTime_ms')
+
+    @single_spec_duration_ms.setter
+    def single_spec_duration_ms(self, value):
+        self.ptr.set('ACQ_SRV_SpecTime_ms', int(value), unit='ms')
+
     @property
-    @abstractmethod
-    def timezero(self):
-        raise NotImplementedError()
+    def extraction_time_us(self):
+        return self.ptr.get('ACQ_SRV_ExtractTime')
+
+    @extraction_time_us.setter
+    def extraction_time_us(self, value):
+        self.ptr.set('ACQ_SRV_ExtractTime', int(value), unit='us')
 
     @property
-    @abstractmethod
-    def traces(self):
-        raise NotImplementedError()
+    def max_flight_time_us(self):
+        return self.ptr.get('ACQ_SRV_MaxFlighttime')
 
+    @max_flight_time_us.setter
+    def max_flight_time_us(self, value):
+        self.ptr.set('ACQ_SRV_MaxFlighttime', int(value), unit='us')
+
+    @property
+    def expected_mass_range_amu(self):
+        return self.ptr.get('ACQ_SRV_ExpectMRange')
 
-class OnlineMeasurement(Measurement):
+    @expected_mass_range_amu.setter
+    def expected_mass_range_amu(self, value):
+        self.ptr.set('ACQ_SRV_ExpectMRange', int(value), unit='amu')
 
-    # TODO :: ausbauen oder abreissen....
     def __init__(self, instrument):
-        super().__init__(filename)
-        self.instrument = instrument
+        self.ptr = instrument
 
-    @property
-    def timezero(self):
+    def start(self, filename=''):
+        self.ptr.start_measurement(filename)
+        self._new_state(RunningMeasurement)
+
+    def __len__(self):
         return 0
 
-    @property
-    def traces(self):
-        pass
 
-    def __iter__(self):
-        while issubclass(self.__class__, RunningMeasurement):
-            yield self.instrument.buffer.queue.get()
+class RunningMeasurement(Measurement):
+
+    def __init__(self, instrument):
+        self.ptr = instrument
+
+    def stop(self):
+        self.ptr.stop_measurement()
+        self._new_state(FinishedMeasurement)
+
+    def __len__(self):
+        return -1
 
 
-class OfflineMeasurement(Measurement):
+class FinishedMeasurement(Measurement):
 
-    def __init__(self, h5reader):
-        super().__init__(h5reader.path)
-        self.hr = h5reader
+    @classmethod
+    def _check(cls, sourcefiles):
+        _assumptions = ("incompatible files! "
+                "sourcefiles must have the same number-of-timebins and "
+                "the same instrument-type to be collected as a batch")
+
+        assert 1 == len(set(sf.inst_type          for sf in sourcefiles)), _assumptions
+        assert 1 == len(set(sf.number_of_timebins for sf in sourcefiles)), _assumptions
 
     @property
-    def timezero(self):
-        return self.hr.timezero
+    def number_of_timebins(self):
+        return next(iter(self.sourcefiles)).number_of_timebins
 
     @property
-    def traces(self):
-        """shortcut for `.get_traces(kind='concentration')`."""
-        return self.get_traces(kind='concentration')
+    def poisson_deadtime_ns(self):
+        return next(iter(self.sourcefiles)).poisson_deadtime_ns
+
+    @property
+    def pulsing_period_ns(self):
+        return next(iter(self.sourcefiles)).pulsing_period_ns
+
+    @property
+    def single_spec_duration_ms(self):
+        return next(iter(self.sourcefiles)).single_spec_duration_ms
+
+    @property
+    def start_delay_ns(self):
+        return next(iter(self.sourcefiles)).start_delay_ns
+
+    @property
+    def timebin_width_ps(self):
+        return next(iter(self.sourcefiles)).timebin_width_ps
+
+    def __init__(self, filenames, _reader=IoniTOFReader):
+        if isinstance(filenames, str):
+            filenames = glob(filenames)
+        if not len(filenames):
+            raise ValueError("file not found or empty glob expression")
+
+        self.sourcefiles = sorted((_reader(f) for f in filenames), key=attrgetter('time_of_file'))
+        self._check(self.sourcefiles)
 
-    def get_traces(self, kind='raw', index='abs_cycle', force_original=False):
+    def iter_traces(self, kind='raw', index='abs_cycle', force_original=False):
         """Return the timeseries ("traces") of all masses, compounds and settings.
 
         'kind' is the type of traces and must be one of 'raw', 'concentration' or
@@ -80,11 +163,9 @@ class OfflineMeasurement(Measurement):
         'index' specifies the desired index and must be one of 'abs_cycle', 'rel_cycle',
         'abs_time' or 'rel_time'.
 
-        If the traces have been post-processed in the Ionicon Viewer, those will be used,
-        unless `force_original=True`.
         """
-        return self.hr.get_all(kind, index, force_original)
+        return chain.from_iterable(sf.get_all(kind, index, force_original) for sf in self.sourcefiles)
 
-    def __iter__(self):
-        return iter(self.hr)
+    def __len__(self):
+        return sum(len(sf) for sf in self.sourcefiles)