pytrms 0.2.2__tar.gz → 0.9.1__tar.gz

pytrms-0.9.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: pytrms
+Version: 0.9.1
+Summary: Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS).
+License: GPL-2.0
+Author: Moritz Koenemann
+Author-email: moritz.koenemann@ionicon.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+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.1.9)
+Requires-Dist: requests (>=2.32.3,<3.0.0)

{pytrms-0.2.2 → pytrms-0.9.1}/pyproject.toml

@@ -1,26 +1,31 @@
 [tool.poetry]
 name = "pytrms"
-version = "0.2.2"
+version = "0.9.1"
 description = "Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS)."
 authors = ["Moritz Koenemann <moritz.koenemann@ionicon.com>"]
 license = "GPL-2.0"
 include = [
-    "par_ID_list.txt",
+    "pytrms/data/ParaIDs.csv",
     "pytrms/data/IoniTofPrefs.ini",
 ]
 
 [tool.poetry.dependencies]
-python = "^3.8"
-h5py = "^3.6.0"
-requests = "^2.27.1"
-pandas = "^1.4.0"
-pyModbusTCP = "^0.2.0"
+python = "^3.10"
+h5py = "^3.12.1"
+matplotlib = "^3.9.2"
+requests = "^2.32.3"
+pandas = "^2.2.3"
+pyModbusTCP = ">=0.1.9"
+paho-mqtt = "~1.6.1"
+
+[tool.poetry.group.test.dependencies]
+pytest = "^8.3.0"
 
 [tool.poetry.group.dev.dependencies]
-ipykernel = "^6.13.1"
-matplotlib = "^3.5.2"
-Sphinx = "^5.3.0"
+Sphinx = "^8.0.0"
+ipykernel = "^6.29.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
+

pytrms-0.9.1/pytrms/__init__.py

@@ -0,0 +1,36 @@
+_version = '0.9.1'
+
+__all__ = ['load', 'connect']
+
+
+def load(path):
+    '''Open a datafile for post-analysis or batch processing.
+
+    returns a `Measurement`.
+    '''
+    from .measurement import OfflineMeasurement
+    from .readers import IoniTOFReader
+
+    reader = IoniTOFReader(path)
+
+    return OfflineMeasurement(reader)
+
+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))
+

pytrms-0.9.1/pytrms/_base/__init__.py

@@ -0,0 +1,24 @@
+from collections import namedtuple
+
+from .mqttclient import MqttClientBase
+from .ioniclient import IoniClientBase
+
+class itype:
+
+    table_setting_t = namedtuple('mass_mapping', ['name', 'mass2value'])
+    timecycle_t     = namedtuple('timecycle',  ['rel_cycle','abs_cycle','abs_time','rel_time'])
+    masscal_t       = namedtuple('masscal',    ['mode', 'masses', 'timebins', 'cal_pars', 'cal_segs'])
+    add_data_item_t = namedtuple('add_data',   ['value', 'name', 'unit', 'view'])
+    fullcycle_t     = namedtuple('fullcycle',  ['timecycle', 'intensity', 'mass_cal', 'add_data'])
+
+    AME_RUN    = 8
+    AME_STEP   = 7
+    AME_ACTION = 5
+    USE_MEAN   = 2  # (only in AUTO_UseMean)
+
+    REACT_Udrift = 0
+    REACT_pDrift = 1
+    REACT_Tdrift = 2
+    REACT_PI_Idx = 4  # skipping E/N = 3
+    REACT_TM_Idx = 5
+

pytrms-0.9.1/pytrms/_base/ioniclient.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+
+class IoniClientBase(ABC):
+
+    @property
+    @abstractmethod
+    def is_connected(self):
+        '''Returns `True` if connection to IoniTOF could be established.'''
+        pass
+
+    @property
+    @abstractmethod
+    def is_running(self):
+        '''Returns `True` if IoniTOF is currently acquiring data.'''
+        pass
+
+    @abstractmethod
+    def connect(self, timeout_s):
+        pass
+
+    @abstractmethod
+    def disconnect(self):
+        pass
+
+    def __init__(self, host, port):
+        # Note: circumvent (potentially sluggish) Windows DNS lookup:
+        self.host = '127.0.0.1' if host == 'localhost' else str(host)
+        self.port = int(port)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} @ {self.host}[:{self.port}]>"
+

pytrms-0.9.1/pytrms/_base/mqttclient.py

@@ -0,0 +1,106 @@
+import os
+import time
+import logging
+import json
+from collections import deque
+from itertools import cycle
+from threading import Condition, RLock
+from datetime import datetime as dt
+from abc import ABC, abstractmethod
+
+import paho.mqtt.client as mqtt
+
+from .ioniclient import IoniClientBase
+
+log = logging.getLogger(__name__)
+
+__all__ = ['MqttClientBase']
+
+
+def _on_connect(client, self, flags, rc):
+    # Note: ensure subscription after re-connecting,
+    #  wildcards are '+' (one level), '#' (all levels):
+    default_QoS = 2
+    topics = set()
+    for subscriber in self._subscriber_functions:
+        topics.update(set(getattr(subscriber, "topics", [])))
+    subs = sorted(zip(topics, cycle([default_QoS])))
+    log.debug(f"[{self}] " + "\n   --> ".join(["subscribing to"] + list(map(str, subs))))
+    rv = client.subscribe(subs)
+    log.info(f"[{self}] successfully connected with {rv = }")
+
+def _on_subscribe(client, self, mid, granted_qos):
+    log.info(f"[{self}] successfully subscribed with {mid = } | {granted_qos = }")
+
+def _on_publish(client, self, mid):
+    log.debug(f"[{self}] published {mid = }")
+
+
+class MqttClientBase(IoniClientBase):
+
+    @property
+    @abstractmethod
+    def is_connected(self):
+        '''Returns `True` if connected to the server.
+
+        Note: this property will be polled on initialization and should
+         return `True` if a connection could be established!
+        '''
+        return (True
+            and self.client.is_connected())
+
+    def __init__(self, host, subscriber_functions,
+            on_connect, on_subscribe, on_publish, 
+            connect_timeout_s=10):
+        super().__init__(host, port=1883)
+        # configure connection...
+        self.client = mqtt.Client(clean_session=True)
+        # clean_session is a boolean that determines the client type. If True,
+        # the broker will remove all information about this client when it
+        # disconnects. If False, the client is a persistent client and
+        # subscription information and queued messages will be retained when the
+        # client disconnects.
+        # The clean_session argument only applies to MQTT versions v3.1.1 and v3.1.
+        # It is not accepted if the MQTT version is v5.0 - use the clean_start
+        # argument on connect() instead.
+        self.client.on_connect   = on_connect    if on_connect   is not None else _on_connect
+        self.client.on_subscribe = on_subscribe  if on_subscribe is not None else _on_subscribe
+        self.client.on_publish   = on_publish    if on_publish   is not None else _on_publish
+        # ...subscribe to topics...
+        self._subscriber_functions = list(subscriber_functions)
+        for subscriber in self._subscriber_functions:
+            for topic in getattr(subscriber, "topics", []):
+                self.client.message_callback_add(topic, subscriber)
+        # ...pass this instance to each callback...
+        self.client.user_data_set(self)
+        # ...and connect to the server:
+        try:
+            self.connect(connect_timeout_s)
+        except TimeoutError as exc:
+            log.warn(f"{exc} (retry connecting when the Instrument is set up)")
+
+    def connect(self, timeout_s=10):
+        log.info(f"[{self}] connecting to MQTT broker...")
+        self.client.connect(self.host, self.port, timeout_s)
+        self.client.loop_start()  # runs in a background thread
+        started_at = time.monotonic()
+        while time.monotonic() < started_at + timeout_s:
+            if self.is_connected:
+                break
+
+            time.sleep(10e-3)
+        else:
+            self.disconnect()
+            raise TimeoutError(f"[{self}] no connection to IoniTOF")
+
+    def publish_with_ack(self, *args, timeout_s=10, **kwargs):
+        # Note: this is important when publishing just before exiting the application
+        #  to ensure that all messages get through (timeout_s is set on `.__init__()`)
+        msg = self.client.publish(*args, **kwargs)
+        msg.wait_for_publish(timeout=timeout_s)
+        return msg
+
+    def disconnect(self):
+        self.client.loop_stop()
+        self.client.disconnect()
+

pytrms-0.9.1/pytrms/clients/__init__.py

@@ -0,0 +1,33 @@
+import os
+
+_root = os.path.dirname(__file__)
+_par_id_file = os.path.abspath(os.path.join(_root, '..', 'data', 'ParaIDs.csv'))
+assert os.path.exists(_par_id_file), "par-id file not found: please re-install PyTRMS package"
+
+
+import logging as _logging
+
+_logging.TRACE = 0  # overwrites logging.NOTSET
+
+def enable_extended_logging(log_level=_logging.DEBUG):
+    '''make output of http-requests more talkative.
+    
+    set 'log_level=logging.TRACE' (defined as 0 in pytrms.__init__) for highest verbosity!
+    '''
+    if log_level <= _logging.DEBUG:
+        # enable logging of http request urls on the library, that is
+        #  underlying the 'requests'-package:
+        _logging.warn(f"enabling logging-output on 'urllib3' ({log_level = })")
+        requests_log = _logging.getLogger("urllib3")
+        requests_log.setLevel(log_level)
+        requests_log.propagate = True
+    
+    if log_level == _logging.TRACE:
+        # Enabling debugging at http.client level (requests->urllib3->http.client)
+        # you will see the REQUEST, including HEADERS and DATA, and RESPONSE with
+        # HEADERS but without DATA. the only thing missing will be the response.body,
+        # which is not logged.
+        _logging.warn(f"enabling logging-output on 'HTTPConnection' ({log_level = })")
+        from http.client import HTTPConnection
+        HTTPConnection.debuglevel = 1
+

pytrms-0.9.1/pytrms/clients/db_api.py

@@ -0,0 +1,178 @@
+import os
+import json
+
+import requests
+
+from . import _logging
+from .ssevent import SSEventListener
+from .._base import IoniClientBase
+
+log = _logging.getLogger(__name__)
+
+# TODO :: sowas waer auch ganz cool: die DBAPI bietes sich geradezu an,
+#  da mehr object-oriented zu arbeiten:
+#   currentVariable = get_component(currentComponentNameAction, ds)
+#   currentVariable.save_value({'value': currentValue})
+
+class IoniConnect(IoniClientBase):
+
+    @property
+    def is_connected(self):
+        '''Returns `True` if connection to IoniTOF could be established.'''
+        try:
+            self.get("/api/status")
+            return True
+        except:
+            return False
+
+    @property
+    def is_running(self):
+        '''Returns `True` if IoniTOF is currently acquiring data.'''
+        raise NotImplementedError("is_running")
+
+    def connect(self, timeout_s):
+        pass
+
+    def disconnect(self):
+        pass
+
+    def __init__(self, host='127.0.0.1', port=5066, session=None):
+        super().__init__(host, port)
+        self.url = f"http://{self.host}:{self.port}"
+        if session is None:
+            session = requests.sessions.Session()
+        self.session = session
+        # ??
+        self.current_avg_endpoint = None
+        self.comp_dict = dict()
+
+    def get(self, endpoint, **kwargs):
+        return self._get_object(endpoint, **kwargs).json()
+
+    def post(self, endpoint, data, **kwargs):
+        return self._create_object(endpoint, data, 'post', **kwargs).headers.get('Location')
+
+    def put(self, endpoint, data, **kwargs):
+        return self._create_object(endpoint, data, 'put', **kwargs).headers.get('Location')
+
+    def upload(self, endpoint, filename):
+        if not endpoint.startswith('/'):
+            endpoint = '/' + endpoint
+        with open(filename) as f:
+            # Note (important!): this is a "form-data" entry, where the server
+            #  expects the "name" to be 'file' and rejects it otherwise:
+            name = 'file'
+            r = self.session.post(self.url + endpoint, files=[(name, (filename, f, ''))])
+            r.raise_for_status()
+
+        return r
+
+    def _get_object(self, endpoint, **kwargs):
+        if not endpoint.startswith('/'):
+            endpoint = '/' + endpoint
+        if 'headers' not in kwargs:
+            kwargs['headers'] = {'content-type': 'application/hal+json'}
+        elif 'content-type' not in (k.lower() for k in kwargs['headers']):
+            kwargs['headers'].update({'content-type': 'application/hal+json'})
+        r = self.session.request('get', self.url + endpoint, **kwargs)
+        r.raise_for_status()
+        
+        return r
+
+    def _create_object(self, endpoint, data, method='post', **kwargs):
+        if not endpoint.startswith('/'):
+            endpoint = '/' + endpoint
+        if not isinstance(data, str):
+            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']):
+            kwargs['headers'].update({'content-type': 'application/hal+json'})
+        r = self.session.request(method, self.url + endpoint, data=data, **kwargs)
+        if not r.ok:
+            log.error(f"POST {endpoint}\n{data}\n\nreturned [{r.status_code}]: {r.content}")
+            r.raise_for_status()
+
+        return r
+
+    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'),
+        }
+        # 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
+
+            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,
+        }
+
+    def iter_events(self, event_re=r".*"):
+        """Follow the server-sent-events (SSE) on the DB-API.
+
+        `event_re`  a regular expression to filter events (default: matches everything)
+        """
+        yield from SSEventListener(event_re, host_url=self.url, endpoint="/api/events",
+                session=self.session)
+

{pytrms-0.2.2 → pytrms-0.9.1}/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>]
-              """)
-