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

pytrms/clients/ssevent.py

@@ -1,82 +1,82 @@
 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(__name__)
 
+_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):
             line += bite
             if bite == '\n':
-                yield line
+                yield line.strip()
                 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...
-            if not line.strip():
-                continue
+        event = msg = ''
+        for line in self._line_stream(self._connect_response):  # blocks...
+            if not line:
+                # an empty line concludes an event
+                if event and any(re.match(sub, event) for sub in self.subscriptions):
+                    yield _event_rv(event, msg)
 
-            key, msg = line.split(':', maxsplit=1)
-            msg = msg.strip()
-            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
+                # Note: any further empty lines are ignored (may be used as keep-alive),
+                #  but in either case clear event and msg to rearm for the next event:
+                event = msg = ''
+                continue
 
+            key, val = line.split(':', maxsplit=1)
+            if not key:
+                # this is a comment, starting with a colon ':' ...
+                log.log(_logging.TRACE, "sse:" + val)
+            elif key == 'event':
+                event = val.lstrip()
             elif key == 'data':
-                yield msg
-
+                msg += val.lstrip()
             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/instrument.py

@@ -17,7 +17,6 @@ class Instrument(ABC):
     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):
@@ -69,38 +68,41 @@ class Instrument(ABC):
         """Set a variable to a new value."""
         return self.backend.set(varname, value, unit='-')
 
+    _current_sourcefile = ''
+
     def start_measurement(self, filename=''):
         # this method must be implemented by each state
         raise RuntimeError("can't start %s" % self.__class__)
 
-    start_measurement.__doc__ = Measurement.start.__doc__
-
     def stop_measurement(self):
         # this method must be implemented by each state
         raise RuntimeError("can't stop %s" % self.__class__)
 
-    stop_measurement.__doc__ = Measurement.stop.__doc__
-
 
 class IdleInstrument(Instrument):
 
     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 filename and self.is_local:
-            home = os.path.dirname(filename)
-            os.makedirs(home, exist_ok=True)
-            base = os.path.basename(filename)
-            if not base:
-                base = '%Y-%m-%d_%H-%M-%S.h5'
-            base = time.strftime(base)
-            filename = os.path.join(home, base)
+        dirname = os.path.dirname(filename)
+        if dirname and self.is_local:
+            # Note: 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:
+            os.makedirs(dirname, exist_ok=True)
+
+        if filename:
+            basename = os.path.basename(filename)
+            # this may very well be a directory to record a filename into:
+            if not basename:
+                basename = '%Y-%m-%d_%H-%M-%S.h5'
+                filename = os.path.join(dirname, basename)
+            # finally, pass everything through strftime...
+            filename = time.strftime(filename)
             if os.path.exists(filename):
                 raise RuntimeError(f'filename exists and cannot be overwritten')
 
         self.backend.start_measurement(filename)
+        self._current_sourcefile = filename
         self._new_state(RunningInstrument)
 
         return RunningMeasurement(self)
@@ -112,3 +114,6 @@ class RunningInstrument(Instrument):
         self.backend.stop_measurement()
         self._new_state(IdleInstrument)
 
+        # TODO :: this catches only one sourcefile.. it'll do for simple cases:
+        return FinishedMeasurement(_current_sourcefile)
+

pytrms/measurement.py

@@ -1,9 +1,10 @@
 import time
-from glob import glob
 from operator import attrgetter
 from itertools import chain
 from abc import abstractmethod, ABC
 
+import pandas as pd
+
 from .readers import IoniTOFReader
 
 __all__ = ['Measurement', 'PreparingMeasurement', 'RunningMeasurement', 'FinishedMeasurement']
@@ -145,16 +146,14 @@ class FinishedMeasurement(Measurement):
     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)
+    def __init__(self, *filenames, _reader=IoniTOFReader):
         if not len(filenames):
-            raise ValueError("file not found or empty glob expression")
+            raise ValueError("no filename given")
 
         self.sourcefiles = sorted((_reader(f) for f in filenames), key=attrgetter('time_of_file'))
         self._check(self.sourcefiles)
 
-    def iter_traces(self, kind='raw', index='abs_cycle', force_original=False):
+    def read_traces(self, kind='conc', 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
@@ -164,8 +163,11 @@ class FinishedMeasurement(Measurement):
         'abs_time' or 'rel_time'.
 
         """
-        return chain.from_iterable(sf.get_all(kind, index, force_original) for sf in self.sourcefiles)
+        return pd.concat(sf.read_all(kind, index, force_original) for sf in self.sourcefiles)
+
+    def __iter__(self):
+        return iter(self.sourcefiles)
 
     def __len__(self):
-        return sum(len(sf) for sf in self.sourcefiles)
+        return len(self.sourcefiles)
 

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: