pytrms 0.9.3__tar.gz → 0.9.6__tar.gz

{pytrms-0.9.3 → pytrms-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pytrms
-Version: 0.9.3
+Version: 0.9.6
 Summary: Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS).
 License: GPL-2.0
 Author: Moritz Koenemann

{pytrms-0.9.3 → pytrms-0.9.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pytrms"
-version = "0.9.3"
+version = "0.9.6"
 description = "Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS)."
 authors = ["Moritz Koenemann <moritz.koenemann@ionicon.com>"]
 license = "GPL-2.0"

pytrms-0.9.6/pytrms/__init__.py

@@ -0,0 +1,42 @@
+_version = '0.9.6'
+
+__all__ = ['load', 'connect']
+
+
+def load(path):
+    '''Open a datafile for post-analysis or batch processing.
+
+    `path` may be a glob-expression to collect a whole batch.
+
+    returns a `Measurement` instance.
+    '''
+    import glob
+    from .measurement import FinishedMeasurement
+
+    files = glob.glob(path)
+
+    return FinishedMeasurement(*files)
+
+
+def connect(host='localhost', port=None, method='mqtt'):
+    '''Connect a client to a running measurement server.
+
+    'method' is the preferred connection, either 'mqtt' (default), 'webapi' or 'modbus'.
+
+    returns an `Instrument` if connected successfully.
+    '''
+    from .instrument import Instrument
+
+    if method.lower() == 'mqtt':
+        from .clients.mqtt import MqttClient as _client
+    elif method.lower() == 'webapi':
+        from .clients.ioniclient import IoniClient as _client
+    elif method.lower() == 'modbus':
+        from .modbus import IoniconModbus as _client
+    else:
+        raise NotImplementedError(str(method))
+
+    backend = _client(host, port) if port is not None else _client(host)
+
+    return Instrument(backend)
+

{pytrms-0.9.3 → pytrms-0.9.6}/pytrms/clients/db_api.py

@@ -123,6 +123,7 @@ class IoniConnect(IoniClientBase):
             'high':   lambda p: p.borders[1],
             'shift':  attrgetter('shift'),
             'multiplier': attrgetter('multiplier'),
+            'resolution': attrgetter('resolution'),
         }
         # normalize the input argument and create a hashable set:
         updates = dict()

{pytrms-0.9.3 → pytrms-0.9.6}/pytrms/clients/mqtt.py

@@ -326,12 +326,14 @@ def follow_state(client, self, msg):
     # replace the current state with the new element:
     self._server_state.append(state)
     meas_running = (state == "ACQ_Aquire")  # yes, there's a typo, plz keep it :)
-    just_started = (meas_running and not msg.retain)
     if meas_running:
         # signal the relevant thread(s) that we need an update:
         self._calcconzinfo.append(_NOT_INIT)
-    if just_started:
-        # invalidate the source-file until we get a new one:
+    if not meas_running:
+        # Note: the user-interface in `.current_sourcefile` checks for the
+        #  above _server_state and expects an initialized filename if and
+        #  only if the server is running! Therefore, we can safely
+        #  invalidate the source-file until we get a new one:
         self._sf_filename.append(_NOT_INIT)
 
 follow_state.topics = ["DataCollection/Act/ACQ_SRV_CurrentState"]
@@ -359,7 +361,8 @@ def follow_act_set_values(client, self, msg):
         server, kind, parID = msg.topic.split('/')
         if server == "DataCollection":
             # Note: this topic doesn't strictly follow the convention and is handled separately
-            return
+            if kind != "Set":
+                return
 
         if server == "Sequencer":
             # Note: this is a separate program and will be ignored (has its own AUTO_-numbers et.c.)
@@ -730,6 +733,7 @@ class MqttClient(MqttClientBase):
         * Elements will be buffered up to a maximum of `buffer_size` cycles (default: 300).
         * Cycles recorded prior to calling `next()` on the iterator may be missed,
           so ideally this should be set up before any measurement is running.
+        * Once the measurement stops, this iterator will raise `StopIteration`.
         * [Important]: When the buffer runs full, a `queue.Full` exception will be raised!
           Therefore, the caller should consume the iterator as soon as possible while the
           measurement is running.
@@ -740,7 +744,10 @@ class MqttClient(MqttClientBase):
 
         def callback(client, self, msg):
             try:
-                q.put_nowait(_parse_fullcycle(msg.payload, need_add_data=True))
+                _fc = _parse_fullcycle(msg.payload, need_add_data=True)
+                # IoniTOF cycle-indexing starts at 1, while 0 marks idle state:
+                if _fc.timecycle.abs_cycle > 0:
+                    q.put_nowait(_fc)
                 log.debug(f"received fullcycle, buffer at ({q.qsize()}/{q.maxsize})")
             except queue.Full:
                 # DO NOT FAIL INSIDE THE CALLBACK!
@@ -764,7 +771,20 @@ class MqttClient(MqttClientBase):
             #  if block is true and timeout is None, [the q.get()] operation goes into an
             #  uninterruptible wait on an underlying lock. This means that no exceptions
             #  can occur, and in particular a SIGINT will not trigger a KeyboardInterrupt!
-            yield q.get(block=True, timeout=timeout_s)  # waiting for measurement to run...
+            if timeout_s is None and not self.is_running:
+                log.warn(f"waiting indefinitely for measurement to run...")
+
+            yield q.get(block=True, timeout=timeout_s)
+
+            # make double sure that there's more to come..
+            _started_at = time.monotonic()
+            while timeout_s is None or time.monotonic() < _started_at + timeout_s:
+                if self.is_running:
+                    break
+
+                time.sleep(10e-3)
+            else:
+                raise TimeoutError(f"[{self}] received specdata, but measurement won't start");
 
             while self.is_running or not q.empty():
                 if q.full():
@@ -782,7 +802,7 @@ class MqttClient(MqttClientBase):
 
         except queue.Empty:
             assert timeout_s is not None, "this should never happen"
-            raise TimeoutError("no measurement running after {timeout_s} seconds")
+            raise TimeoutError(f"no measurement running after {timeout_s} seconds")
 
         finally:
             #  ...also, when using more than one iterator, the first to finish will

{pytrms-0.9.3 → pytrms-0.9.6}/pytrms/data/ParaIDs.csv

@@ -38,9 +38,9 @@ ID	Name	DataType	Access	ServerName	LVWriteQueueName	SharedVariable	PrettyName	Un
 36	DPS_IhcOnOff	BOOL	RW	PTR	PTR_Write		Ihc On/Off		
 37	DPS_Pdrift_Ctrl_OnOff		RW	PTR	PTR_Write		p-drift controlled		
 38	DPS_Pdrift_Ctrl_Val		RW	PTR	PTR_Write		p-drift ctrl Value  		
-39	SourceValve		RW	PTR	PTR_Write		Source Valve		
-40	PrimionIdx		RW	PTR	PTR_Write		Prim Ion Idx		
-41	E/N	DBL	R				E/N	Td	
+39	SourceValve	DBL	RW	PTR	PTR_Write		Source Valve		
+40	PrimionIdx	I32	RW	PTR	PTR_Write		Prim Ion Idx		
+41	E_N	DBL	R				E/N	Td	
 42	FC_H2O	DBL	R	PTR	PTR_Write		FC H2O	sccm	
 43	SmartGAS1_Conc	DBL	R	PTR			Conz1 SG		
 44	SmartGAS2_Conc	DBL	R	PTR			Conz2 SG		
@@ -66,16 +66,16 @@ ID	Name	DataType	Access	ServerName	LVWriteQueueName	SharedVariable	PrettyName	Un
 64	Spare_64 								
 65	Spare_65 								
 66	Spare_66 								
-67	Spare_67 								
-68	Spare_68 								
-69	Spare_69 								
+67	MPV_Dir_1	I32		PTR	PTR_Write		MPV Dir		
+68	MPV_Dir_2	I32		PTR	PTR_Write		MPV Dir2		
+69	MPV_Dir_3	I32		PTR	PTR_Write		MPV Dir3		
 70	MPV_1			PTR	PTR_Write		MPValve1		
 71	MPV_2			PTR	PTR_Write		MPValve2		
 72	MPV_3			PTR	PTR_Write		MPValve3		
 73	DPS_Uf	DBL	RW	PTR	PTR_Write		Uf	V	
 74	DPS_U1	DBL	RW	PTR	PTR_Write		UF1	V	
 75	DPS_U2	DBL	RW	PTR	PTR_Write		UF2	V	
-76	Spare_76 								
+76	DPS_IhcOnOff_Neg	BOOL	RW	PTR	PTR_Write		Ihc On/Off		
 77	Spare_77 								
 78	Spare_78 								
 79	Spare_79 								
@@ -323,7 +323,7 @@ ID	Name	DataType	Access	ServerName	LVWriteQueueName	SharedVariable	PrettyName	Un
 321	GC2_ConstantTemperature	DBL	RW	PTR			GC2 Temp Set		
 322	GC2_FC	DBL	RW	PTR			FC GC		
 323	GC2_FC_Makeup	DBL	RW	PTR			FC FastGC Makeup		
-324	Spare324								
+324	GC2_FC_Ri	DBL	RW	PTR			FC FastGC Ri		
 325	Spare325								
 326	Spare326								
 327	Spare327								

{pytrms-0.9.3 → pytrms-0.9.6}/pytrms/instrument.py

@@ -2,7 +2,12 @@ import os.path
 import time
 from abc import abstractmethod, ABC
 
-from .measurement import *
+from .measurement import (
+        RunningMeasurement,
+        FinishedMeasurement,
+)
+
+__all__ = ['Instrument']
 
 
 class Instrument(ABC):
@@ -24,25 +29,26 @@ class Instrument(ABC):
         self.__class__ = newstate
 
     def __new__(cls, backend):
-        # make this class a singleton..
+        # Note (reminder): If __new__() does not return an instance of cls,
+        #  then the new instance’s __init__() method will *not* be invoked!
+        #
+        # This aside, we override the __new__ method to make this class a
+        #  singleton that reflects the PTR-instrument state and dispatches
+        #  to one of its subclass implementations.
         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
 
-        # ..that is synchronized with the PTR-instrument state:
         if backend.is_running:
-            cls = RunningInstrument
+            inst = object.__new__(_RunningInstrument)
         else:
-            cls = IdleInstrument
+            inst = object.__new__(_IdleInstrument)
 
-        inst = object.__new__(cls)
         Instrument._Instrument__instance = inst
 
         return inst
 
     def __init__(self, backend):
-        # dispatch all blocking calls to the client
+        # Note: this will be called *once* per Python process!
         self.backend = backend
 
     @property
@@ -53,15 +59,17 @@ class Instrument(ABC):
 
     def get(self, varname):
         """Get the current value of a setting."""
-        # TODO :: this is not an interface implementation
+        # TODO :: this is not an interface implementation...
         raw = self.backend.get(varname)
+
+        from .clients.mqtt import MqttClient
         if not isinstance(self.backend, MqttClient):
             import json
             jobj = json.loads(raw)
 
             return jobj[0]['Act']['Real']
 
-        ## how it should be:
+        ## ...how it should be: just:
         return raw
 
     def set(self, varname, value, unit='-'):
@@ -79,7 +87,7 @@ class Instrument(ABC):
         raise RuntimeError("can't stop %s" % self.__class__)
 
 
-class IdleInstrument(Instrument):
+class _IdleInstrument(Instrument):
 
     def start_measurement(self, filename=''):
         dirname = os.path.dirname(filename)
@@ -108,12 +116,12 @@ class IdleInstrument(Instrument):
         return RunningMeasurement(self)
 
 
-class RunningInstrument(Instrument):
+class _RunningInstrument(Instrument):
 
     def stop_measurement(self):
         self.backend.stop_measurement()
         self._new_state(IdleInstrument)
 
         # TODO :: this catches only one sourcefile.. it'll do for simple cases:
-        return FinishedMeasurement(_current_sourcefile)
+        return FinishedMeasurement(self._current_sourcefile)
 

{pytrms-0.9.3 → pytrms-0.9.6}/pytrms/measurement.py

@@ -26,6 +26,10 @@ class Measurement(ABC):
         # Note: we get ourselves a nifty little state-machine :)
         self.__class__ = newstate
 
+    @property
+    def is_running(self):
+        return self.__class__ == RunningMeasurement
+
     def start(self, filename=''):
         """Start a measurement on the PTR server.
 
@@ -48,10 +52,6 @@ class Measurement(ABC):
         """Stop the current measurement on the PTR server."""
         raise RuntimeError("can't stop %s" % self.__class__)
 
-    @abstractmethod
-    def __len__(self):
-        pass
-
 
 class PreparingMeasurement(Measurement):
 
@@ -94,8 +94,17 @@ class PreparingMeasurement(Measurement):
         self.ptr.start_measurement(filename)
         self._new_state(RunningMeasurement)
 
-    def __len__(self):
-        return 0
+    def __iter__(self):
+        from .clients.mqtt import MqttClient
+        if not isinstance(self.ptr.backend, MqttClient):
+            raise NotImplementedError("iteration only provided w/ backend 'mqtt'")
+
+        print("warning: the measurement needs to be started externally")
+        while not self.ptr.backend.is_running:
+            time.sleep(50e-3)
+
+        self._new_state(RunningMeasurement)
+        yield from iter(self)
 
 
 class RunningMeasurement(Measurement):
@@ -107,51 +116,95 @@ class RunningMeasurement(Measurement):
         self.ptr.stop_measurement()
         self._new_state(FinishedMeasurement)
 
-    def __len__(self):
-        return -1
+    def __iter__(self):
+        from .clients.mqtt import MqttClient
+        if not isinstance(self.ptr.backend, MqttClient):
+            raise NotImplementedError("iteration only provided w/ backend 'mqtt'")
+
+        if not self.ptr.backend.is_connected:
+            raise Exception("no connection to instrument")
+
+        timeout_s = 15
+        ssd_s = 1e-3 * float(self.ptr.get('ACQ_SRV_SpecTime_ms'))
+        last_rel_cycle = -1
+        sourcefile = ''
+        for specdata in self.ptr.backend.iter_specdata(timeout_s=timeout_s+ssd_s, buffer_size=300):
+            if last_rel_cycle == -1 or specdata.timecycle.rel_cycle < last_rel_cycle:
+                # the source-file has been switched, so wait for the new path:
+                started_at = time.monotonic()
+                while time.monotonic() < started_at + timeout_s:
+                    candidate = self.ptr.backend.current_sourcefile
+                    if candidate and candidate != sourcefile:
+                        sourcefile = candidate
+                        break
+
+                    time.sleep(10e-3)
+                else:
+                    raise TimeoutError(f"no new sourcefile after ({timeout_s = })")
+            last_rel_cycle = specdata.timecycle.rel_cycle
+
+            yield sourcefile, specdata
+
+        if not self.ptr.backend.is_running:
+            self._new_state(FinishedMeasurement)
+            ## TODO :: das hier braucht noch seine .sourcefiles !!
+            self.sourcefiles = []
 
 
 class FinishedMeasurement(Measurement):
 
     @classmethod
-    def _check(cls, sourcefiles):
+    def _check(cls, _readers):
         _assumptions = ("incompatible files! "
-                "sourcefiles must have the same number-of-timebins and "
+                "_readers 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
+        assert 1 == len(set(sf.inst_type          for sf in _readers)), _assumptions
+        assert 1 == len(set(sf.number_of_timebins for sf in _readers)), _assumptions
 
     @property
     def number_of_timebins(self):
-        return next(iter(self.sourcefiles)).number_of_timebins
+        return next(iter(self._readers)).number_of_timebins
 
     @property
     def poisson_deadtime_ns(self):
-        return next(iter(self.sourcefiles)).poisson_deadtime_ns
+        return next(iter(self._readers)).poisson_deadtime_ns
 
     @property
     def pulsing_period_ns(self):
-        return next(iter(self.sourcefiles)).pulsing_period_ns
+        return next(iter(self._readers)).pulsing_period_ns
 
     @property
     def single_spec_duration_ms(self):
-        return next(iter(self.sourcefiles)).single_spec_duration_ms
+        return next(iter(self._readers)).single_spec_duration_ms
 
     @property
     def start_delay_ns(self):
-        return next(iter(self.sourcefiles)).start_delay_ns
+        return next(iter(self._readers)).start_delay_ns
 
     @property
     def timebin_width_ps(self):
-        return next(iter(self.sourcefiles)).timebin_width_ps
+        return next(iter(self._readers)).timebin_width_ps
+
+    def __new__(cls, *args, **kwargs):
+        # TODO :: das hier passt mal **ueberhaupt gar nicht** in das "state-machine"-
+        ##  schema hinein!! Wie soll man das init-ialisieren, wenn bloss _new_state
+        ##  ge-called wird ???!?!?!?!?
+
+        # quick reminder: If __new__() does not return an instance of cls, then the
+        # new instance’s __init__() method will *not* be invoked:
+        print(*args, **kwargs)
+
+        inst = object.__new__(cls)
+
+        return inst
 
     def __init__(self, *filenames, _reader=IoniTOFReader):
         if not len(filenames):
             raise ValueError("no filename given")
 
-        self.sourcefiles = sorted((_reader(f) for f in filenames), key=attrgetter('time_of_file'))
-        self._check(self.sourcefiles)
+        self._readers = sorted((_reader(f) for f in filenames), key=attrgetter('time_of_file'))
+        self._check(self._readers)
 
     def read_traces(self, kind='conc', index='abs_cycle', force_original=False):
         """Return the timeseries ("traces") of all masses, compounds and settings.
@@ -163,11 +216,10 @@ class FinishedMeasurement(Measurement):
         'abs_time' or 'rel_time'.
 
         """
-        return pd.concat(sf.read_all(kind, index, force_original) for sf in self.sourcefiles)
+        return pd.concat(sf.read_all(kind, index, force_original) for sf in self._readers)
 
     def __iter__(self):
-        return iter(self.sourcefiles)
-
-    def __len__(self):
-        return len(self.sourcefiles)
+        for reader in self._readers:
+            for specdata in reader.iter_specdata():
+                yield reader.filename, specdata
 

pytrms-0.9.3/pytrms/__init__.py

@@ -1,38 +0,0 @@
-_version = '0.9.3'
-
-__all__ = ['load', 'connect']
-
-
-def load(path):
-    '''Open a datafile for post-analysis or batch processing.
-
-    `path` may be a glob-expression to collect a whole batch.
-
-    returns a `Measurement` instance.
-    '''
-    import glob
-    from .measurement import FinishedMeasurement
-
-    files = glob.glob(path)
-
-    return FinishedMeasurement(*files)
-
-def connect(host=None, method='webapi'):
-    '''Connect a client to a running measurement server.
-
-    'method' is the preferred connection, either 'webapi' (default) or 'modbus'.
-
-    returns an `Instrument` if connected successfully.
-    '''
-    from .instrument import Instrument
-
-    if method.lower() == 'webapi':
-        from .clients.ioniclient import IoniClient
-        return IoniClient(host)
-
-    if method.lower() == 'modbus':
-        from .modbus import IoniconModbus
-        return IoniconModbus(host)
-
-    raise NotImplementedError(str(method))
-