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

pytrms/__init__.py

@@ -1,4 +1,4 @@
-_version = '0.9.0'
+_version = '0.9.1'
 
 __all__ = ['load', 'connect']
 
@@ -23,7 +23,6 @@ def connect(host=None, method='webapi'):
     returns an `Instrument` if connected successfully.
     '''
     from .instrument import Instrument
-    from .helpers import PTRConnectionError
 
     if method.lower() == 'webapi':
         from .clients.ioniclient import IoniClient

pytrms/clients/db_api.py

@@ -4,6 +4,7 @@ import json
 import requests
 
 from . import _logging
+from .ssevent import SSEventListener
 from .._base import IoniClientBase
 
 log = _logging.getLogger(__name__)
@@ -82,7 +83,7 @@ class IoniConnect(IoniClientBase):
         if not endpoint.startswith('/'):
             endpoint = '/' + endpoint
         if not isinstance(data, str):
-            data = json.dumps(data)
+            data = json.dumps(data, ensure_ascii=False)  # default is `True`, escapes Umlaute!
         if 'headers' not in kwargs:
             kwargs['headers'] = {'content-type': 'application/hal+json'}
         elif 'content-type' not in (k.lower() for k in kwargs['headers']):
@@ -94,93 +95,84 @@ class IoniConnect(IoniClientBase):
 
         return r
 
-    def iter_events(self):
-        """Follow the server-sent-events (SSE) on the DB-API."""
-        r = self.session.request('GET', self.url + "/api/events",
-                headers={'accept': 'text/event-stream'}, stream=True)
-        r.raise_for_status()
-        kv_pair = dict()
-        for line in r.iter_lines():
-            # empty newlines serve as keep-alive and end-of-entry:
-            if not line:
-                if kv_pair:
-                    yield kv_pair
-                    kv_pair = dict()
-                else:
-                    log.debug("sse: still kept alive...")
-                continue
-
-            key, val = line.decode().split(':')
-            kv_pair[key] = val.strip()
-
-    def refresh_comp_dict(self):
-        j = self.get('/api/components')
-        self.comp_dict = {component["shortName"]: component
-            for component in j["_embedded"]["components"]}
-    
-    def get_component(self, short_name):
-        if not len(self.comp_dict):
-            self.refresh_comp_dict()
-    
-        return self.comp_dict[short_name]
-
-    def create_component(self, short_name):
-        payload = {
-            "shortName": short_name
+    def sync(self, peaktable):
+        """Compare and upload any differences in `peaktable` to the database."""
+        from pytrms.peaktable import Peak, PeakTable
+        from operator import attrgetter
+
+        # Note: a `Peak` is a hashable object that serves as a key that
+        #  distinguishes between peaks as defined by PyTRMS:
+        make_key = lambda peak: Peak(center=peak['center'], label=peak['name'], shift=peak['shift'])
+
+        if isinstance(peaktable, str):
+            log.info(f"loading peaktable '{peaktable}'...")
+            peaktable = PeakTable.from_file(peaktable)
+
+        # get the PyTRMS- and IoniConnect-peaks on the same page:
+        conv = {
+            'name':   attrgetter('label'),
+            'center': attrgetter('center'),
+            'kRate':  attrgetter('k_rate'),
+            'low':    lambda p: p.borders[0],
+            'high':   lambda p: p.borders[1],
+            'shift':  attrgetter('shift'),
+            'multiplier': attrgetter('multiplier'),
         }
-        self.post('/api/components', payload)
-        self.refresh_comp_dict()
-
-    def create_average(self, endpoint, run, step, action=0, use_mean=True):
-
-        params = {'run': int(run), 'step': int(step), 'usemean': bool(use_mean)}
-        if (action != 0):
-            params['action'] = int(action)
-
-        timecycles = self.get(endpoint, params)
-        self.current_avg_endpoint = self.post('/api/averages', timecycles)
-
-    def save_component_values(self, new_values):
-        """
-        Post Components to the database.
+        # normalize the input argument and create a hashable set:
+        updates = dict()
+        for peak in peaktable:
+            payload = {k: conv[k](peak) for k in conv}
+            updates[make_key(payload)] = {'payload': payload}
+
+        log.info(f"fetching current peaktable from the server...")
+        # create a comparable collection of peaks already on the database by
+        # reducing the keys in the response to what we actually want to update:
+        db_peaks = {make_key(p): {
+                    'payload': {k: p[k] for k in conv.keys()},
+                    'self':   p['_links']['self'],
+                    'parent': p['_links'].get('parent'),
+                    } for p in self.get('/api/peaks')['_embedded']['peaks']}
+
+        to_update = updates.keys() & db_peaks.keys()
+        to_upload = updates.keys() - db_peaks.keys()
+        updated = 0
+        for key in sorted(to_update):
+            # check if an existing peak needs an update
+            if db_peaks[key]['payload'] == updates[key]['payload']:
+                # nothing to do..
+                log.debug(f"up-to-date: {key}")
+                continue
 
-        `new_values`    dictionary {name~>value}
-        """
-        if self.current_avg_endpoint is None:
-            raise Exception("create average first")
-    
-        payload = {
-            "quantities": [
-                {
-                    "componentID": self.get_component(name)["componentID"],
-                    "value": value
-                } for name, value in new_values.items()
-            ]
+            self.put(db_peaks[key]['self']['href'], updates[key]['payload'])
+            log.info(f"updated:    {key}")
+            updated += 1
+
+        if len(to_upload):
+            # Note: POSTing the embedded-collection is *miles faster*
+            #  than doing separate requests for each peak!
+            payload = {'_embedded': {'peaks': [updates[key]['payload'] for key in sorted(to_upload)]}}
+            self.post('/api/peaks', payload)
+            for key in sorted(to_upload): log.info(f"added new:  {key}")
+
+        # Note: this disregards the peak-parent-relationship, but in
+        #  order to implement this correctly, one would need to check
+        #  if the parent-peak with a specific 'parentID' is already
+        #  uploaded and search it.. there's an endpoint
+        #   'LINK /api/peaks/{parentID} Location: /api/peaks/{childID}'
+        #  to link a child to its parent, but it remains complicated.
+        # TODO :: maybe later implement parent-peaks!?
+
+        return {
+                'added': len(to_upload),
+                'updated': updated,
+                'up-to-date': len(to_update) - updated,
         }
-        endpoint = self.current_avg_endpoint + '/component_traces'
-        self.put(endpoint, payload)
 
-    def save_instrument_values(self, new_values):
-        """
-        Post Parameters to the database.
+    def iter_events(self, event_re=r".*"):
+        """Follow the server-sent-events (SSE) on the DB-API.
 
-        `new_values`    dictionary {name~>value}
+        `event_re`  a regular expression to filter events (default: matches everything)
         """
-        # 13.07.: SCHNELL, SCHNELL (es ist 17 Uhr 57 und ich will die Modbus-instrument
-        #  daten noch hochladen):
-        #  this expects a namedtuple as defined in Modbus client: .set, .act, .par_id
-        if self.current_avg_endpoint is None:
-            raise Exception("create average first")
-    
-        payload = {
-            "quantities": [
-                {
-                    "parameterID": item.par_id,
-                    "setValue": item.set,
-                    "actMean": item.act
-                } for name, item in new_values.items()
-            ]
-        }
-        endpoint = self.current_avg_endpoint + '/parameter_traces'  # on the DB it's called parameter... :\
-        self.put(endpoint, payload)
+        yield from SSEventListener(event_re, host_url=self.url, endpoint="/api/events",
+                session=self.session)
 

pytrms/clients/ioniclient.py

@@ -18,17 +18,17 @@ class IoniClient:
     Access the Ionicon WebAPI.
 
     Usage:
-    >>> client = IoniClient()
-    >>> client.get('TPS_Pull_H')
+    > client = IoniClient()
+    > client.get('TPS_Pull_H')
     {'TPS_Pull_H': 123.45, ... }
 
-    >>> client.set('TPS_Pull_H', 42)
+    > client.set('TPS_Pull_H', 42)
     {'TPS_Pull_H': 42.0, ... }
 
-    >>> client.start_measurement()
+    > client.start_measurement()
     ACK
 
-    >>> client.host, client.port
+    > client.host, client.port
     ('localhost', 8002)
     
     '''
@@ -85,19 +85,3 @@ class IoniClient:
 
     def stop_measurement(self):
         return self.set('ACQ_SRV_Stop_Meas', 1)
-
-
-if __name__ == '__main__':
-    import sys
-    client = IoniClient()
-
-    if len(sys.argv) == 2:
-        print(client.get(sys.argv[1]))
-    elif len(sys.argv) == 3:
-        print(client.set(sys.argv[1], sys.argv[2]))
-    else:
-        print(f"""\
-                usage:
-                  python {sys.argv[0]} <varname> [<value>]
-              """)
-

pytrms/clients/modbus.py

@@ -9,7 +9,7 @@ from collections import namedtuple
 from functools import lru_cache
 from itertools import tee
 
-from pyModbusTCP import client
+import pyModbusTCP.client
 
 from . import _par_id_file
 from .._base.ioniclient import IoniClientBase
@@ -19,9 +19,28 @@ log = logging.getLogger(__name__)
 __all__ = ['IoniconModbus']
 
 
+def _patch_is_open():
+    # Note: the .is_open and .timeout attributes were changed
+    #  from a function to a property!
+    # 
+    # 0.2.0 2022-06-05
+    # 
+    #  - ModbusClient: parameters are now properties instead of methods (more intuitive).
+    # 
+    # from the [changelog](https://github.com/sourceperl/pyModbusTCP/blob/master/CHANGES):
+    major, minor, patch = pyModbusTCP.__version__.split('.')
+    if int(minor) < 2:
+        return lambda mc: mc.is_open()
+    else:
+        return lambda mc: mc.is_open
+
+_is_open = _patch_is_open()
+
 with open(_par_id_file) as f:
     it = iter(f)
-    assert next(it).startswith('ID\tName'), "Modbus parameter file is corrupt: " + f.name
+    assert next(it).startswith('ID\tName'), ("Modbus parameter file is corrupt: "
+            + f.name
+            + "\n\ntry re-installing the PyTRMS python package to fix it!")
     _id_to_descr = {int(id_): name for id_, name, *_ in (line.strip().split('\t') for line in it)}
 
 # look-up-table for c_structs (see docstring of struct-module for more info).
@@ -59,10 +78,10 @@ def _unpack(registers, format='>f'):
     representation, respectively.
 
     >>> _unpack([17448, 0], 'float')
-    672.
+    672.0
 
     >>> _unpack([17446, 32768], 'float')
-    666.
+    666.0
     
     >>> _unpack([16875, 61191, 54426, 37896], 'double')
     3749199524.83057
@@ -132,7 +151,7 @@ class IoniconModbus(IoniClientBase):
 
     @property
     def is_connected(self):
-        if not self.mc.is_open:
+        if not _is_open(self.mc):
             return False
 
         # wait for the IoniTOF alive-counter to change (1 second max)...
@@ -175,7 +194,18 @@ class IoniconModbus(IoniClientBase):
 
     def __init__(self, host='localhost', port=502):
         super().__init__(host, port)
-        self.mc = client.ModbusClient(host=self.host, port=self.port)
+        # Note: we patch the behaviour such, that it behaves like pre-0.2
+        #  (from the time of development of this module), BUT we skip the
+        #  auto_close-feature for the sake of speed:
+        # 
+        # 0.2.0 2022-06-05
+        # 
+        #  - ModbusClient: now TCP auto open mode is active by default (auto_open=True, auto_close=False).
+        #
+        # from the [changelog](https://github.com/sourceperl/pyModbusTCP/blob/master/CHANGES)
+        self.mc = pyModbusTCP.client.ModbusClient(host=self.host, port=self.port,
+                auto_open = False, auto_close = False
+        )
         # try connect immediately:
         try:
             self.connect()
@@ -185,8 +215,11 @@ class IoniconModbus(IoniClientBase):
 
     def connect(self, timeout_s=10):
         log.info(f"[{self}] connecting to Modbus server...")
-        self.mc.timeout = timeout_s
-        self.mc.auto_open = True
+        # Note: .timeout-attribute changed to a property with 0.2.0 (see comments above)
+        if callable(self.mc.timeout):
+            self.mc.timeout(timeout_s)
+        else:
+            self.mc.timeout = timeout_s
         if not self.mc.open():
             raise TimeoutError(f"[{self}] no connection to modbus socket")
 
@@ -201,7 +234,7 @@ class IoniconModbus(IoniClientBase):
             raise TimeoutError(f"[{self}] no connection to IoniTOF");
 
     def disconnect(self):
-        if self.mc.is_open:
+        if _is_open(self.mc):
             self.mc.close()
 
     @property
@@ -452,9 +485,9 @@ class IoniconModbus(IoniClientBase):
         _read = self.mc.read_holding_registers if is_holding_register else self.mc.read_input_registers
         
         register = _read(addr, n_bytes)
-        if register is None and self.mc.is_open:
+        if register is None and _is_open(self.mc):
             raise IOError(f"unable to read ({n_bytes}) registers at [{addr}] from connection")
-        elif register is None and not self.mc.is_open:
+        elif register is None and not _is_open(self.mc):
             raise IOError("trying to read from closed Modbus-connection")
 
         return _unpack(register, c_format)

pytrms/clients/mqtt.py

@@ -325,9 +325,14 @@ def follow_state(client, self, msg):
     log.debug(f"[{self}] new server-state: " + str(state))
     # replace the current state with the new element:
     self._server_state.append(state)
-    if state == "ACQ_Aquire":  # yes, there's a typo, plz keep it :)
-        self._calcconzinfo.append(_NOT_INIT)  # invalidate
-        # Note: this signals to the relevant thread that we need an update
+    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:
+        self._sf_filename.append(_NOT_INIT)
 
 follow_state.topics = ["DataCollection/Act/ACQ_SRV_CurrentState"]
 
@@ -404,8 +409,8 @@ _NOT_INIT = object()
 class MqttClient(MqttClientBase):
     """a simplified client for the Ionicon MQTT API.
 
-    >>> mq = MqttClient()
-    >>> mq.write('TCP_MCP_B', 3400)
+    > mq = MqttClient()
+    > mq.write('TCP_MCP_B', 3400)
     ValueError()
 
     """
@@ -463,11 +468,27 @@ class MqttClient(MqttClientBase):
 
     @property
     def current_sourcefile(self):
-        '''Returns the path to the hdf5-file that is currently (or soon to be) written.
+        '''Returns the path to the hdf5-file that is currently being written.
         
-        May be an empty string if no sourcefile has yet been set.
+        Returns an empty string if no measurement is running.
         '''
-        return self._sf_filename[0]
+        if not self.is_running:
+            return ""
+
+        if self._sf_filename[0] is not _NOT_INIT:
+            return self._sf_filename[0]
+
+        # Note: '_NOT_INIT' is set by us on start of acquisition, so we'd expect
+        #  to receive the source-file-topic after a (generous) timeout:
+        timeout_s = 15
+        started_at = time.monotonic()
+        while time.monotonic() < started_at + timeout_s:
+            if self._sf_filename[0] is not _NOT_INIT:
+                return self._sf_filename[0]
+    
+            time.sleep(10e-3)
+        else:
+            raise TimeoutError(f"[{self}] unable to retrieve source-file after ({timeout_s = })");
 
     @property
     def current_cycle(self):
@@ -508,12 +529,10 @@ class MqttClient(MqttClientBase):
         if _lut is self.set_values and is_read_only:
             raise ValueError(f"'{parID}' is read-only, did you mean `kind='act'`?")
 
-        # Note: The values should need NO! time to be populated from the MQTT topics,
-        #  because all topics are published as *retained* by the PTR-server.
-        #  However, a short timeout is respected before raising a `KeyError`:
-        try:
-            return _lut[parID]
-        except KeyError as exc:
+        if not parID in _lut:
+            # Note: The values should need NO! time to be populated from the MQTT topics,
+            #  because all topics are published as *retained* by the PTR-server.
+            #  However, a short timeout is respected before raising a `KeyError`:
             time.sleep(200e-3)
             rv = _lut.get(parID)
             if rv is not None:
@@ -525,6 +544,7 @@ class MqttClient(MqttClientBase):
                 "set" if parID in self.set_values else
                 "")
             raise KeyError(str(parID) + (' (did you mean `kind="%s"`?)' % error_hint) if error_hint else "")
+        return _lut[parID]
 
     def get_table(self, table_name):
         timeout_s = 10

pytrms/clients/ssevent.py

@@ -1,48 +1,19 @@
 import re
-import logging
+from collections import namedtuple
 from collections.abc import Iterable
 
 import requests
 
-from . import ionitof_url
+from . import _logging
 
-log = logging.getLogger()
+log = _logging.getLogger()
 
+_event_rv = namedtuple('ssevent', ['event', 'data'])
 
 class SSEventListener(Iterable):
 
-    def __init__(self, endpoint=''):
-        if not endpoint:
-            endpoint = ionitof_url + '/api/timing/stream'
-        self.endpoint = endpoint
-        self._response = None
-        self.subscriptions = set()
-
-    def subscribe(self, event='cycle'):
-        """Listen for events matching the given string or regular expression.
-
-        This will already match if the string is contained in the event-topic.
-        """
-        if self._response is None:
-            r = requests.get(self.endpoint, headers={'accept': 'text/event-stream'}, stream=True)
-            if not r.ok:
-                log.error(f"no connection to {self.endpoint} (got [{r.status_code}])")
-                r.raise_for_status()
-
-            self._response = r
-
-        regex = re.compile('.*' + event + '.*')  # be rather loose with matching..
-        self.subscriptions.add(regex)
-
-    def unsubscribe(self, event='cycle'):
-        self.subscriptions.remove(event)
-        if not len(self.subscriptions):
-            log.debug(f"closing connection to {self.endpoint}")
-            self._response.close()
-            self._response = None
-
     @staticmethod
-    def line_stream(response):
+    def _line_stream(response):
         # Note: using .iter_content() seems to yield results faster than .iter_lines()
         line = ''
         for bite in response.iter_content(chunk_size=1, decode_unicode=True):
@@ -51,32 +22,56 @@ class SSEventListener(Iterable):
                 yield line
                 line = ''
 
-    def items(self):
-        for msg in self:
-            yield self.event, msg
+    def __init__(self, event_re=None, host_url='http://127.0.0.1:5066',
+            endpoint='/api/events', session=None):
+        self.uri = host_url + endpoint
+        if session is not None:
+            self._get = session.get
+        else:
+            self._get = requests.get
+        self._connect_response = None
+        self.subscriptions = set()
+        if event_re is not None:
+            self.subscribe(event_re)
+
+    def subscribe(self, event_re):
+        """Listen for events matching the given string or regular expression."""
+        self.subscriptions.add(re.compile(event_re))
+        if self._connect_response is None:
+            r = self._get(self.uri, headers={'accept': 'text/event-stream'}, stream=True)
+            if not r.ok:
+                log.error(f"no connection to {self.uri} (got [{r.status_code}])")
+                r.raise_for_status()
+
+            self._connect_response = r
+
+    def unsubscribe(self, event_re):
+        """Stop listening for certain events."""
+        self.subscriptions.remove(re.compile(event_re))
+        if not len(self.subscriptions):
+            log.debug(f"closing connection to {self.uri}")
+            self._connect_response.close()
+            self._connect_response = None
 
     def __iter__(self):
-        if self._response is None:
+        if self._connect_response is None:
             raise Exception("call .subscribe() first to listen for events")
 
-        for line in self.line_stream(self._response):  # blocks...
+        event = msg = ''
+        for line in self._line_stream(self._connect_response):  # blocks...
             if not line.strip():
+                if event and any(re.match(sub, event) for sub in self.subscriptions):
+                    yield _event_rv(event, msg)
+                    event = msg = ''
+                else:
+                    log.log(_logging.TRACE, "sse: still alive...")
                 continue
 
-            key, msg = line.split(':', maxsplit=1)
-            msg = msg.strip()
+            key, val = line.split(':', maxsplit=1)
             if key == 'event':
-                self.event = msg
-
-                if not any(sub.match(self.event) for sub in self.subscriptions):
-                    log.debug(f"skipping event <{msg}>")
-                    continue
-
+                event = val.strip()
             elif key == 'data':
-                yield msg
-
+                msg += val.strip()
             else:
-                log.warning(f"skipping unknown key <{key}> in stream")
-                continue
-
+                log.warning(f"unknown SSE-key <{key}> in stream")
 

pytrms/compose/composition.py

@@ -4,6 +4,7 @@ import itertools
 import logging
 from collections.abc import Iterable
 from collections import namedtuple
+from itertools import tee
 from functools import wraps
 
 __all__ = ['Step', 'Composition']
@@ -30,14 +31,19 @@ class Step:
     >>> step.set_values
     {'DPS_Udrift': 500}
 
-    Note, that no Automation-numbers can be defined in the step:
+    Note, that no Automation-numbers can be defined in the step..
     >>> Step("H50", {'AUTO_UseMean': 0}, 10, start_delay=2)
     Traceback (most recent call last):
       ...
     AssertionError: Automation numbers cannot be defined
 
-    '''
+    ..and neither can a 'OP_Mode' alongside anything else:
+    >>> Step("Odd2", {'DPS_Udrift': 345, 'OP_Mode': 2}, 10, start_delay=2)
+    Traceback (most recent call last):
+      ...
+    AssertionError: if 'OP_Mode' is specified, nothing else can be
 
+    '''
     protected_keys = ['AME_RunNumber', 'AME_StepNumber', 'AUTO_UseMean'] 
     
     def __init__(self, name, set_values, duration, start_delay):
@@ -51,8 +57,13 @@ class Step:
         assert self.start_delay >= 0
         assert self.start_delay < self.duration
 
-        for key in self.set_values.keys():
+        for key in self.set_values:
             assert key not in Step.protected_keys, "Automation numbers cannot be defined"
+        if 'OP_Mode' in self.set_values:
+            assert len(self.set_values) == 1, "if 'OP_Mode' is specified, nothing else can be"
+
+    def __repr__(self):
+        return f"{self.name}: ({self.start_delay}/{self.duration}) sec ~> {self.set_values}"
 
 
 class Composition(Iterable):
@@ -77,15 +88,34 @@ class Composition(Iterable):
     >>> list(co.sequence())
     [(8, {'Eins': 1}), (18, {'Zwei': 2})]
     
-    ...with an action-number at the start...
+    ...with an action-number at the start (note, that AME-numbers are 1 cycle ahead)...
     >>> co.start_action = 7
     >>> list(co.sequence())
-    [(8, {'AME_ActionNumber': 7}), (8, {'Eins': 1}), (18, {'Zwei': 2})]
+    [(9, {'AME_ActionNumber': 7}), (8, {'Eins': 1}), (18, {'Zwei': 2})]
 
     ...or with automation numbers, where the 'start_delay' comes into play:
     >>> co.generate_automation = True
-    >>> list(co.sequence())
-    [(8, {'AME_ActionNumber': 7}), (8, {'Eins': 1, 'AME_StepNumber': 1, 'AME_RunNumber': 1}), (8, {'AUTO_UseMean': 0}), (10, {'AUTO_UseMean': 1}), (18, {'Zwei': 2, 'AME_StepNumber': 2}), (18, {'AUTO_UseMean': 0}), (21, {'AUTO_UseMean': 1})]
+    >>> seq = co.sequence()
+    >>> next(seq)
+    (9, {'AME_ActionNumber': 7})
+    
+    >>> next(seq)
+    (8, {'Eins': 1})
+
+    >>> next(seq)
+    (9, {'AME_StepNumber': 1, 'AME_RunNumber': 1, 'AUTO_UseMean': 0})
+
+    >>> next(seq)
+    (11, {'AUTO_UseMean': 1})
+
+    >>> next(seq)
+    (18, {'Zwei': 2})
+
+    >>> next(seq)
+    (19, {'AME_StepNumber': 2, 'AUTO_UseMean': 0})
+
+    >>> next(seq)
+    (22, {'AUTO_UseMean': 1})
     
     '''
 
@@ -122,6 +152,67 @@ class Composition(Iterable):
     def dump(self, ofstream):
         json.dump(self, ofstream, indent=2, default=vars)
 
+    def translate_op_modes(self, preset_items, check=True):
+        '''Given the `preset_items` (from a presets-file), compile a list of set_values.
+
+        >>> presets = {}
+        >>> presets[0] = ('H3O+', {('Drift', 'Global_System.DriftPressureSet', 'FLOAT'): 2.6})
+        >>> presets[2] = ('O3+', {('T-Drift[°C]', 'Global_Temperatures.TempsSet[0]', 'FLOAT'): 75.0})
+
+        next, define a couple of Steps that use the presets (a.k.a. 'OP_Mode'):
+        >>> steps = []
+        >>> steps.append(Step('uno', {'OP_Mode': 0}, 10, 2))  # set p-Drift by OP_Mode
+        >>> steps.append(Step('due', {'Udrift': 420.0, 'T-Drift': 81.0}, 10, 2))
+        >>> steps.append(Step('tre', {'OP_Mode': 2}, 10, 2))  # set T-Drift by OP_Mode
+
+        the Composition of these steps will translate to the output underneath.
+        note, that the set-value for Pdrift_Ctrl is carried along with each step:
+        >>> co = Composition(steps)
+        >>> co.translate_op_modes(presets, check=False)
+        [{'DPS_Pdrift_Ctrl_Val': 2.6}, {'Udrift': 420.0, 'T-Drift': 81.0, 'DPS_Pdrift_Ctrl_Val': 2.6}, {'T-Drift': 75.0, 'DPS_Pdrift_Ctrl_Val': 2.6, 'Udrift': 420.0}]
+
+        Since we didn't specify the full set of reaction-parameters, the self-check will fail:
+        >>> co.translate_op_modes(presets, check=True)
+        Traceback (most recent call last):
+            ...
+        AssertionError: reaction-data missing in presets
+
+        '''
+        if preset_items is None:
+            raise ValueError('preset_items is None')
+
+        # Note: the `preset_items` is a dict[step_index] ~> (name, preset_items)
+        #  and in the items one would expect these keys:
+        preset_keys = {
+            'PrimionIdx':       ('PrimionIdx', '', 'INT'),
+            'TransmissionIdx':  ('TransmissionIdx', '', 'INT'),
+            'DPS_Udrift':       ('UDrift', 'Global_DTS500.TR_DTS500_Set[0].SetU_Udrift', 'FLOAT'),
+            'DPS_Pdrift_Ctrl_Val': ('Drift', 'Global_System.DriftPressureSet', 'FLOAT'),
+            'T-Drift':          ('T-Drift[°C]', 'Global_Temperatures.TempsSet[0]', 'FLOAT'),
+        }
+        # make a deep copy of the `set_values`:
+        set_values = [dict(step.set_values) for step in self.steps]
+        carry = dict()
+        for entry in set_values:
+            # replace OP_Mode with the stuff found in preset_items
+            if 'OP_Mode' in entry:
+                index = entry['OP_Mode']
+                name, items = preset_items[index]
+                for parID, key in preset_keys.items():
+                    if key in items:
+                        entry[parID] = items[key]
+                del entry['OP_Mode']
+
+            # Note: each preset is only an update of set-values over what has already
+            #  been set. thus, when following the sequence of OP_Modes, each one must
+            #  carry with it the set-values of all its predecessors:
+            carry.update(entry)
+            entry.update(carry)
+            if check:
+                assert all(key in entry for key in preset_keys), "reaction-data missing in presets"
+        
+        return set_values
+
     def sequence(self):
         '''A (possibly infinite) iterator over this Composition's future_cycles and steps.
 
@@ -130,27 +221,31 @@ class Composition(Iterable):
         The first 'future_cycle' is 0 unless otherwise specified with class-parameter 'start_cycle'.
         This generates AME_Run/Step-Number and AUTO_UseMean unless otherwise specified.
         '''
+        _offset_ame = True  # whether ame-numbers should mark the *next* cycle, see [#2897]
+        
         future_cycle = self.start_cycle
         if self.start_action is not None:
-            yield future_cycle, dict([(self.ACTION_MARKER, int(self.start_action))])
+            yield future_cycle + int(_offset_ame), dict([(self.ACTION_MARKER, int(self.start_action))])
         
-        for run, step, current in self:
-            automation = {self.STEP_MARKER: step}
-            if step == 1:
-                automation[self.RUN_MARKER] = run
+        for run, step, step_info in self:
+            yield future_cycle, dict(step_info.set_values)
 
-            set_values = dict(current.set_values)
             if self.generate_automation:
-                set_values = dict(**set_values, **automation)
-
-            yield future_cycle, set_values
-
-            # insert two updates for AUTO_UseMean flag:
-            if self.generate_automation and current.start_delay > 0:
-                yield future_cycle, {self.USE_MARKER: 0}
-                yield future_cycle + current.start_delay, {self.USE_MARKER: 1}
-
-            future_cycle = future_cycle + current.duration
+                automation = {self.STEP_MARKER: step}
+                if step == 1:
+                    automation[self.RUN_MARKER] = run
+
+                if step_info.start_delay == 0:
+                    # all cycles get the AUTO_UseMean flag set to True:
+                    automation[self.USE_MARKER] = 1
+                    yield future_cycle + int(_offset_ame), automation
+                else:
+                    # split into two updates for AUTO_UseMean flag:
+                    automation[self.USE_MARKER] = 0
+                    yield future_cycle + int(_offset_ame), automation
+                    yield future_cycle + int(_offset_ame) + step_info.start_delay, {self.USE_MARKER: 1}
+
+            future_cycle = future_cycle + step_info.duration
 
     @coroutine
     def schedule_routine(self, schedule_fun):

pytrms/helpers.py

@@ -1,6 +1,120 @@
-import requests.exceptions
+"""@file helpers.py
 
-class PTRConnectionError(requests.exceptions.ConnectionError):
-    pass
+common helper functions.
+"""
 
+def convert_labview_to_posix(lv_time_utc, utc_offset_sec):
+    '''Create a `pandas.Timestamp` from LabView time.'''
+    from pandas import Timestamp
+    
+    # change epoch from 01.01.1904 to 01.01.1970:
+    posix_time = lv_time_utc - 2082844800
+    # the tz must be specified in isoformat like '+02:30'..
+    tz_sec = int(utc_offset_sec)
+    tz_designator = '{0}{1:02d}:{2:02d}'.format(
+            '+' if tz_sec >= 0 else '-', tz_sec // 3600, tz_sec % 3600 // 60)
+
+    return Timestamp(posix_time, unit='s', tz=tz_designator)
+
+
+def parse_presets_file(presets_file):
+    '''Load a `presets_file` as XML-tree and interpret the "OP_Mode" of this `Composition`.
+    
+    The tricky thing is, that any OP_Mode may or may not override previous settings!
+    Therefore, it depends on the order of modes in this Composition to be able to assign
+    each OP_Mode its actual dictionary of set_values.
+    
+    Note, that the preset file uses its own naming convention that cannot neccessarily be
+    translated into standard parID-names. You may choose whatever you like to do with it.
+    '''
+    import xml.etree.ElementTree as ET
+    from collections import namedtuple, defaultdict
+    
+    _key = namedtuple('preset_item', ['name', 'ads_path', 'dtype'])        
+    _parse_value = {
+        "FLOAT": float,
+        "BOOL":  bool,
+        "BYTE":  int,
+        "ENUM":  int,
+    }        
+    tree = ET.parse(presets_file)
+    root = tree.getroot()
+
+    preset_names = {}
+    preset_items = defaultdict(dict)
+    for index, preset in enumerate(root.iterfind('preset')):
+        preset_names[index] = preset.find('name').text.strip()
+        
+        if preset.find('WritePrimIon').text.upper() == "TRUE":
+            val = preset.find('IndexPrimIon').text
+            preset_items[index][_key('PrimionIdx', '', 'INT')] = int(val)
+
+        if preset.find('WriteTransmission').text.upper() == "TRUE":
+            val = preset.find('IndexTransmission').text
+            preset_items[index][_key('TransmissionIdx', '', 'INT')] = int(val)
+            
+        for item in preset.iterfind('item'):
+            if item.find('Write').text.upper() == "TRUE":
+            #   device_index = item.find('DeviceIndex').text
+                ads_path     = item.find('AdsPath').text
+                data_type    = item.find('DataType').text
+            #   page_name    = item.find('PageName').text
+                name         = item.find('Name').text
+                value_text   = item.find('Value').text
+                
+                key = _key(name, ads_path, data_type)
+                val = _parse_value[data_type](value_text)                    
+                preset_items[index][key] = val
+
+    return {index: (preset_names[index], preset_items[index]) for index in preset_names.keys()}
+
+
+def setup_measurement_dir(config_dir=None, data_root_dir='D:/Data', suffix='',
+        date_fmt = "%Y_%m_%d__%H_%M_%S"):
+    """Create a new directory for saving the measurement and set it up.
+
+    Optional: copy all files from the given config-directory.
+
+    data_root_dir: the base folder for storing new measurement-directories
+    suffix: will be appended to directory and data-file
+    date_fmt: format for the source-folder and -file to be timestamped
+    """
+    import os
+    import glob
+    import shutil
+    from collections import namedtuple
+    from datetime import datetime
+    from itertools import chain
+
+    recipe = namedtuple('recipe', ['dirname', 'h5_file', 'pt_file', 'alarms_file'])
+    _pt_formats = ['*.ionipt']
+    _al_formats = ['*.alm']
+    # make directory with current timestamp:
+    now = datetime.now()
+    new_h5_file = os.path.abspath(os.path.join(
+        data_root_dir,
+        now.strftime(date_fmt) + suffix,
+        now.strftime(date_fmt) + suffix + '.h5',
+    ))
+    new_recipe_dir = os.path.dirname(new_h5_file)
+    os.makedirs(new_recipe_dir, exist_ok=False)  # may throw!
+    if not config_dir:
+        # we're done here..
+        return recipe(new_recipe_dir, new_h5_file, '', '')
+
+    # find the *first* matching file or an empty string if no match...
+    new_pt_file = next(chain.from_iterable(glob.iglob(config_dir + "/" + g) for g in _pt_formats), '')
+    new_al_file = next(chain.from_iterable(glob.iglob(config_dir + "/" + g) for g in _al_formats), '')
+    # ...and copy all files from the master-recipe-dir:
+    files2copy = glob.glob(config_dir + "/*")
+    for file in files2copy:
+        new_file = shutil.copy(file, new_recipe_dir)
+        try:  # remove write permission (a.k.a. make files read-only)
+            mode = os.stat(file).st_mode
+            os.chmod(new_file, mode & ~stat.S_IWRITE)
+        except Exception as exc:
+            # well, we can't set write permission
+            pass
+
+    return recipe(new_recipe_dir, new_h5_file, new_pt_file, new_al_file)
 

pytrms/peaktable.py

@@ -35,7 +35,7 @@ other custom formats.
 >>> pt
 <PeakTable (1) [21.0u]>
 >>> pt[0]
-<Peak [H3O+] @ 21.0219>
+<Peak @ 21.0219+0.0000 [H3O+]>
 
 Peaks may be modified and the PeakTable exported in the same format:
 >>> pt[0].formula = 'H3O'
@@ -56,7 +56,9 @@ Peaks may be modified and the PeakTable exported in the same format:
       "parent": "?",
       "isotopic_abundance": 0.678,
       "k_rate": 2.1,
-      "multiplier": 488
+      "multiplier": 488.0,
+      "resolution": 1000.0,
+      "shift": 0.0
     }
   ]
 }
@@ -144,14 +146,14 @@ class Peak:
         return self.center == round(float(other), Peak._exact_decimals)
 
     def __hash__(self):
-        return hash(str(self.center))  # + self.label)
+        return hash(str(self.center) + self.label)
 
     def __float__(self):
         return self.center
 
     def __repr__(self):
-        return '<%s [%s <~ %s] @ %.4f+%.4f>' % (self.__class__.__name__,
-                self.label, self.parent, self.center, self.shift)
+        return '<%s @ %.4f+%.4f [%s]>' % (self.__class__.__name__,
+                self.center, self.shift, self.label)
 
 
 class PeakTable:

pytrms/readers/ionitof_reader.py

@@ -7,19 +7,10 @@ import numpy as np
 import pandas as pd
 
 from .._base import itype
+from ..helpers import convert_labview_to_posix
 
 __all__ = ['IoniTOFReader', 'GroupNotFoundError']
 
-def convert_labview_to_posix(lv_time_utc, utc_offset_sec):
-    '''Create a `pandas.Timestamp` from LabView time.'''
-    # change epoch from 01.01.1904 to 01.01.1970:
-    posix_time = lv_time_utc - 2082844800
-    # the tz must be specified in isoformat like '+02:30'..
-    tz_sec = int(utc_offset_sec)
-    tz_designator = '{0}{1:02d}:{2:02d}'.format(
-            '+' if tz_sec >= 0 else '-', tz_sec // 3600, tz_sec % 3600 // 60)
-
-    return pd.Timestamp(posix_time, unit='s', tz=tz_designator)
 
 class GroupNotFoundError(KeyError):
     pass

{pytrms-0.9.0.dist-info → pytrms-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytrms
-Version: 0.9.0
+Version: 0.9.1
 Summary: Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS).
 License: GPL-2.0
 Author: Moritz Koenemann
@@ -15,5 +15,5 @@ Requires-Dist: h5py (>=3.12.1,<4.0.0)
 Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
 Requires-Dist: paho-mqtt (>=1.6.1,<1.7.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
-Requires-Dist: pyModbusTCP (>=0.3.0,<0.4.0)
+Requires-Dist: pyModbusTCP (>=0.1.9)
 Requires-Dist: requests (>=2.32.3,<3.0.0)

pytrms-0.9.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+pytrms/__init__.py,sha256=bEgQmBOD5ftYjdwWCsZALJzhodK8CsOxI24V8Dm9Vcg,925
+pytrms/_base/__init__.py,sha256=GBALqAy1kUPMc0CWnWRmn_Cg_HGKGCeE-V2rdZEmN8A,836
+pytrms/_base/ioniclient.py,sha256=f4xWW3PL0p1gP7pczBaDEva3WUUb_J73n7yTIY5pW4s,826
+pytrms/_base/mqttclient.py,sha256=iua-AK7S_3rH1hsuLepqIjf7ivF5Ihb6T9OJNafJXXE,4233
+pytrms/_version.py,sha256=fXD69jGmDocNcc-uipbNIhjWxC7EuyhPUQ6BrBvK0Wg,854
+pytrms/clients/__init__.py,sha256=RejfXqq7zSKLMZbUHdxtBvLiyeshLX-JQzgthmpYeMw,1404
+pytrms/clients/db_api.py,sha256=wEEhPUsdbqSH8TsYRICeYxAfBzdyNekM-rYe4xlCXkM,7248
+pytrms/clients/ioniclient.py,sha256=pHGzaNtKuVrjZ2O2nTmZYJObNMDkxNwLcNerlFit1vA,2477
+pytrms/clients/modbus.py,sha256=BbluHm8iYQY4V2Wbxd4eSiWJtIORyxRWRjhJo1_1JzQ,20585
+pytrms/clients/mqtt.py,sha256=H8uRBGcB4j4MaIlN7Hk_DcRnINJ7hxSxSA6sw4YJKAM,31041
+pytrms/clients/ssevent.py,sha256=umNeWMEYS65qLjmD9zawHTqzatnMDphFDALaxOgCKao,2731
+pytrms/compose/__init__.py,sha256=gRkwGezTsuiMLA4jr5hhQsY7XX_FonBeWcvDfDuMFnY,30
+pytrms/compose/composition.py,sha256=hlV8g6n6HaLLLKileSh7sk8EtwPvaIQjOFXCEKLDKJ0,12161
+pytrms/data/IoniTofPrefs.ini,sha256=e1nU7Hyuh0efpgfN-G5-ERAFC6ZeehUiotsM4VtZIT0,1999
+pytrms/data/ParaIDs.csv,sha256=eWQxmHFfeTSxFfMcFpqloiZWDyK4VLZaV9zCnzLHNYs,27996
+pytrms/helpers.py,sha256=QfJgdQ6b0RcyiAuNHbDGGfuRfeZIs20dPF5flZVR12o,4979
+pytrms/instrument.py,sha256=OIFTbS6fuhos6oYMsrA_qdgvs_7T-H-sOSl1a0qpxZ8,3977
+pytrms/measurement.py,sha256=RqACqedT0JQDkv5cmKxcXVSgl1n0Fbp1mQj81aOsZkg,5507
+pytrms/peaktable.py,sha256=Ms0_dyHg8e6Oc8mwSTk8rD70EPjosX92pDXstf4f6Tk,17572
+pytrms/plotting/__init__.py,sha256=vp5mAa3npo4kP5wvXXNDxKnryFK693P4PSwC-BxEUH8,66
+pytrms/plotting/plotting.py,sha256=t7RXUhjOwXchtYXVgb0rJPD_9aVMDCT6DCAGu8TZQfE,702
+pytrms/readers/__init__.py,sha256=F1ZX4Jv7NcY8nuSWnIbwjYnNFC2JsTnEp0BnfBHUMSM,76
+pytrms/readers/ionitof_reader.py,sha256=zWKIdkeueRMDMxknUGOu68kUrPJz0rjVu4D_aoZUQQ4,18128
+pytrms-0.9.1.dist-info/LICENSE,sha256=GJsa-V1mEVHgVM6hDJGz11Tk3k0_7PsHTB-ylHb3Fns,18431
+pytrms-0.9.1.dist-info/METADATA,sha256=hmNvBCwFj49gPdStWhw5DrWneupksW5DQuPsX64on7Q,763
+pytrms-0.9.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pytrms-0.9.1.dist-info/RECORD,,

pytrms/clients/dirigent.py

@@ -1,169 +0,0 @@
-import os
-import json
-from contextlib import contextmanager
-import logging
-
-import requests
-
-from . import ionitof_url
-
-log = logging.getLogger()
-
-
-class Template:
-    '''A template for uploading a collection item.
-
-    >>> t = Template()
-    >>> t.template == Template.default_template
-    True
-
-    >>> t.render('AME_FooNumber', 42)
-    '{"template": {"data": [{"name": "ParaID", "value": "AME_FooNumber", "prompt": "the
-        parameter ID"}, {"name": "ValAsString", "value": "42", "prompt": "the new value"}]}}'
-
-    '''
-
-    default_template = {
-            "data": [
-                 {"name": "ParaID", "value": "AME_RunNumber", "prompt": "the parameter ID"},
-                 {"name": "ValAsString", "value": "5.000000", "prompt": "the new value"},
-                 {"name": "DataType", "value": "", "prompt": "datatype (int, float, string)"},
-             ]
-         }
-
-    @staticmethod
-    def download(url=ionitof_url, endpoint='/api/schedule'):
-        r = requests.get(url + endpoint, headers={'accept': 'application/vnd.collection+json'})
-        r.raise_for_status()
-        j = r.json()
-
-        return Template(j["collection"]["template"])
-
-    def __init__(self, template=None):
-        if template is None:
-            template = Template.default_template
-        self.template = dict(template)
-
-        self._inserts = dict()  # cache data-items sorted by semantic meaning..
-        for insert in self.template["data"]:
-            if 'ID' in insert["name"] or 'parameter' in insert["prompt"]:
-                self._inserts["parID"] = insert
-            if 'set' in insert["name"].lower() or 'value' in insert["prompt"]:
-                self._inserts["value"] = insert
-            if 'typ' in insert["name"].lower() or 'datatype' in insert["prompt"]:
-                self._inserts["dtype"] = insert
-
-        assert len(self._inserts) == 3, "missing or unknown name in template"
-
-    def render(self, parID, value):
-        """Prepare a request for uploading."""
-        dtype = 'float'
-        if isinstance(value, int): dtype = 'int'
-        if isinstance(value, str): dtype = 'string'
-
-        parID_insert = dict(self._inserts["parID"])
-        value_insert = dict(self._inserts["value"])
-        dtype_insert = dict(self._inserts["dtype"])
-
-        parID_insert.update(value=str(parID)),
-        value_insert.update(value=str(value)),
-        dtype_insert.update(value=str(dtype)),
-
-        return json.dumps({
-            "template": dict(data=[
-                parID_insert,
-                value_insert,
-                dtype_insert,
-            ])}
-        )
-
-    def render_many(self, new_values):
-        for key, value in new_values.items():
-            yield self.render(key, value)
-
-
-class Dirigent:
-
-    def __init__(self, url=ionitof_url, template=None):
-        if template is None:
-            template = Template.download(url)
-
-        self.url = url
-        self.template = template
-        self._session = None  # TODO :: ?
-
-    def push(self, parID, new_value, future_cycle):
-        uri = self.url + '/api/schedule/' + str(int(future_cycle))
-        payload = self.template.render(parID, new_value)
-        r = self._make_request('PUT', uri, payload=payload)
-
-        return r.status_code
-
-    def push_filename(self, path, future_cycle):
-        return self.push('ACQ_SRV_SetFullStorageFile', path.replace('/', '\\'), future_cycle - 2)
-
-    def find_scheduled(self, parID):
-        uri = self.url + '/api/schedule/search'
-        r = self._make_request('GET', uri, params={'name': str(parID)})
-        j = r.json()
-
-        return [item['href'].split('/')[-1] for item in j['collection']['items']]
-
-    def _make_request(self, method, uri, params=None, payload=None):
-        if self._session is None:
-            session = requests  # not using a session..
-        else:
-            session = self._session
-
-        try:
-            r = session.request(method, uri, params=params, data=payload, headers={
-                'content-type': 'application/vnd.collection+json'
-            })
-        except requests.exceptions.ConnectionError as exc:
-            # Note: the LabVIEW-webservice seems to implement a weird HTTP:
-            #  we may get a [85] Custom Error (Bad status line) from urllib3
-            #  even though we just mis-spelled a parameter-ID ?!
-            log.error(exc)
-            raise KeyError(str(params, payload))
-
-        log.debug(f"request to <{uri}> returned [{r.status_code}]")
-        if not r.ok and payload:
-            log.error(payload)
-        r.raise_for_status()
-
-        return r
-
-    def wait_until(self, future_cycle):
-        if self._session is None:
-            session = requests  # not using a session..
-        else:
-            session = self._session
-
-        r = session.get(self.url + '/api/timing/' + str(int(future_cycle)))
-        # ...
-        if r.status_code == 410:
-            # 410 Client Error: Gone 
-            log.warning("we're late, better return immediately!")
-            return r.status_code
-    
-        r.raise_for_status()
-        log.debug(f"waited until {r.json()['TimeCycle']}")
-
-        return r.status_code
-
-    @contextmanager
-    def open_session(self):
-        '''open a session for faster upload (to be used as a contextmanager).'''
-        if self._session is None:
-            self._session = requests.Session()
-        try:
-            yield self
-        finally:
-            self._session.close()
-            self._session = None
-
-
-if __name__ == '__main__':
-    import doctest
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS)
-

pytrms/tracebuffer.py

@@ -1,108 +0,0 @@
-import time
-import json
-import queue
-from itertools import chain
-from enum import Enum
-from threading import Thread, Condition
-
-import pandas as pd
-
-from .helpers import convert_labview_to_posix, PTRConnectionError
-
-
-def parse(response, trace='raw'):
-    jsonized = json.loads(response)
-    info = jsonized['TimeCycle']
-    ts = convert_labview_to_posix(info['AbsTime'])
-
-    data = [list(info.values())] + [a['Data'] for a in jsonized['AddData']] + [jsonized[trace]]
-    desc = [list(info.keys())] + [a['Desc'] for a in jsonized['AddData']] + [jsonized['masses']]
-    chained_data = chain(*data)
-    chained_desc = chain(*desc)
-
-    return pd.Series(data=chained_data, index=chained_desc, name=ts)
-
-
-class TraceBuffer(Thread):
-
-    poll = 0.2  # seconds
-
-    class State(Enum):
-        CONNECTING = -1
-        IDLE = 0
-        ACTIVE = 1
-
-    def __init__(self, client):
-        """'client' must provide a `.get_traces()` method that returns raw json data.
-        """
-        Thread.__init__(self)
-        self.daemon = True
-        self.client = client
-        self.queue = queue.Queue()
-        self.state = TraceBuffer.State.CONNECTING
-        self._cond = Condition()
-
-    def is_connected(self):
-        return self.state != TraceBuffer.State.CONNECTING
-
-    def is_idle(self):
-        return self.state == TraceBuffer.State.IDLE
-
-    def wait_for_connection(self, timeout=5):
-        '''
-        will raise a PTRConnectionError if not connected after `timeout` 
-        '''
-        waited = 0
-        dt = 0.01
-        while not self.is_connected():
-            waited += dt
-            if waited > timeout:
-                raise PTRConnectionError('no connection to instrument')
-            time.sleep(dt)
-
-    def run(self):
-        last = -753  # the year Rome was founded is never a valid cycle
-        while True:
-            #TODO :: das kann ja gar nicht funktionieren!?!?
-            #if not self.is_connected():
-            #    time.sleep(self.poll)
-            #    continue
-
-            time.sleep(self.poll)
-
-            with self._cond:  # .acquire()`s the underlying lock
-                raw = self.client.get_traces()
-                #try:
-                #except PTRConnectionError as exc:
-                #    print(exc)
-                #    break
-                if not len(raw):
-                    continue
-
-                jsonized = json.loads(raw)
-                ts = jsonized['TimeCycle']['AbsTime']
-                oc = jsonized['TimeCycle']['OverallCycle']
-                # the client returns the "current", i.e. last known trace data, even if
-                # the machine is currently stopped. we want to definitely reflect this
-                # idle state of the (actual) machine in our Python objects!
-                # TODO :: *ideally*, the state is returned by a webAPI-call.. but as long
-                # as this doesn't work perfectly, let's just do the next best thing and
-                # watch the current cycle:
-                if last < 0: last = oc
-
-                if oc > last:
-                    pd_series = parse(raw)
-                    self.queue.put(pd_series)
-                    self.state = TraceBuffer.State.ACTIVE
-                else:
-                    self.state = TraceBuffer.State.IDLE
-                last = oc
-
-                # This method releases the underlying lock, and then blocks until it is
-                # awakened by a notify() or notify_all() call for the same condition variable
-                # in another thread, or until the optional timeout occurs. Once awakened or
-                # timed out, it re-acquires the lock and returns.  The return value is True
-                # unless a given timeout expired, in which case it is False.
-                if self._cond.wait(self.poll):
-                    break
-

pytrms-0.9.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-pytrms/__init__.py,sha256=U4ixhTjfFkiVlLXV4JXcRq-eLFkdKlGlU4e52Zlbpsg,970
-pytrms/_base/__init__.py,sha256=GBALqAy1kUPMc0CWnWRmn_Cg_HGKGCeE-V2rdZEmN8A,836
-pytrms/_base/ioniclient.py,sha256=f4xWW3PL0p1gP7pczBaDEva3WUUb_J73n7yTIY5pW4s,826
-pytrms/_base/mqttclient.py,sha256=iua-AK7S_3rH1hsuLepqIjf7ivF5Ihb6T9OJNafJXXE,4233
-pytrms/_version.py,sha256=fXD69jGmDocNcc-uipbNIhjWxC7EuyhPUQ6BrBvK0Wg,854
-pytrms/clients/__init__.py,sha256=RejfXqq7zSKLMZbUHdxtBvLiyeshLX-JQzgthmpYeMw,1404
-pytrms/clients/db_api.py,sha256=exgE4iUHdACprztYYs330NzYI88f6TwF8PjtBzohgjk,6658
-pytrms/clients/dirigent.py,sha256=9WZPfqXxLmFCcT2RC8wxm7uixe4n-Y8vbsdpzc61tsI,5742
-pytrms/clients/ioniclient.py,sha256=5s3GPDr6AKH4Ia0Jix6UI8Xie_t3muKxr218MNRk2Yw,2853
-pytrms/clients/modbus.py,sha256=E1IfoHJm2gVHo-GcKDWba359ii5e0Ymaplv-DO88FqM,19223
-pytrms/clients/mqtt.py,sha256=QRJgC10GWFKzT3r4yNGOafXshgHlA5poGEzouEporEU,30231
-pytrms/clients/ssevent.py,sha256=OziYX9amJunVzTN0MiQmLg2mICHdnVC0LXT5o_ZcwcE,2546
-pytrms/compose/__init__.py,sha256=gRkwGezTsuiMLA4jr5hhQsY7XX_FonBeWcvDfDuMFnY,30
-pytrms/compose/composition.py,sha256=c3ae3PgQg0b741RhRU6oQMAiM7B2xRvbweGp0tCZatc,7906
-pytrms/data/IoniTofPrefs.ini,sha256=e1nU7Hyuh0efpgfN-G5-ERAFC6ZeehUiotsM4VtZIT0,1999
-pytrms/data/ParaIDs.csv,sha256=eWQxmHFfeTSxFfMcFpqloiZWDyK4VLZaV9zCnzLHNYs,27996
-pytrms/helpers.py,sha256=pNLYWlHM1n7vOkCi2vwESMG5baIJ5v2OD4z94XpXU1k,108
-pytrms/instrument.py,sha256=OIFTbS6fuhos6oYMsrA_qdgvs_7T-H-sOSl1a0qpxZ8,3977
-pytrms/measurement.py,sha256=RqACqedT0JQDkv5cmKxcXVSgl1n0Fbp1mQj81aOsZkg,5507
-pytrms/peaktable.py,sha256=b3KkILn5DctEfTi1-tOC9LZv1yrRcoH23VaE5JEqyk4,17536
-pytrms/plotting/__init__.py,sha256=vp5mAa3npo4kP5wvXXNDxKnryFK693P4PSwC-BxEUH8,66
-pytrms/plotting/plotting.py,sha256=t7RXUhjOwXchtYXVgb0rJPD_9aVMDCT6DCAGu8TZQfE,702
-pytrms/readers/__init__.py,sha256=F1ZX4Jv7NcY8nuSWnIbwjYnNFC2JsTnEp0BnfBHUMSM,76
-pytrms/readers/ionitof_reader.py,sha256=vhwVfhJ-ly8I_02okpgxoVqnB0QRDuqkufGZY21vFi4,18583
-pytrms/tracebuffer.py,sha256=30HfMJtxZ4Dnf4mPeyinXqESOA-0Xpu9FR4jaBvb_nA,3912
-pytrms-0.9.0.dist-info/LICENSE,sha256=GJsa-V1mEVHgVM6hDJGz11Tk3k0_7PsHTB-ylHb3Fns,18431
-pytrms-0.9.0.dist-info/METADATA,sha256=sTHS7ZvxCdgcaTj_hCI_Vb8erA1nIUBCs4JMGb06mRg,770
-pytrms-0.9.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pytrms-0.9.0.dist-info/RECORD,,