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

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
@@ -79,7 +70,7 @@ class IoniTOFReader:
             # well it didn't work..
             pass
         finally:
-            self.hf = h5py.File(path, 'r', swmr=True)
+            self.hf = h5py.File(path, 'r', swmr=False)
 
     @property
     def number_of_timebins(self):
@@ -106,7 +97,7 @@ class IoniTOFReader:
         return float(self.hf.attrs.get('Single Spec Duration (ms)'))
 
     def __init__(self, path):
-        self.hf = h5py.File(path, 'r', swmr=True)
+        self.hf = h5py.File(path, 'r', swmr=False)
         self.filename = os.path.abspath(self.hf.filename)
 
     table_locs = {
@@ -448,14 +439,14 @@ class IoniTOFReader:
             raise ValueError(msg) from exc
 
         try:
-            data = self._read_datainfo(tracedata, prefix=prefix)  # may raise KeyError
-            pt = self._read_datainfo(tracedata, prefix='PeakTable')  # may raise KeyError
-            labels = [b.decode('latin1') for b in pt['label']]
+            data = self._read_datainfo(tracedata, prefix=prefix)
+            pt = self._read_datainfo(tracedata, prefix='PeakTable')
         except KeyError as exc:
             raise KeyError(f'unknown group {exc}. filetype is not supported yet.') from exc
 
+        labels = [b.decode('latin1') for b in pt['label']]
         mapper = dict(zip(data.columns, labels))
-        data.rename(columns=mapper)
+        data.rename(columns=mapper, inplace=True)
         data.index = list(self.iter_index(index))
         
         return data

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytrms
-Version: 0.9.0
+Version: 0.9.2
 Summary: Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS).
 License: GPL-2.0
 Author: Moritz Koenemann
@@ -13,7 +13,7 @@ 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: paho-mqtt (>=1.6.1,<3.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.2.dist-info/RECORD

@@ -0,0 +1,27 @@
+pytrms/__init__.py,sha256=e7CfZbs2LclwfPeL74K17jqM4xgnc6q4xLsJ9meXlgw,973
+pytrms/_base/__init__.py,sha256=GBALqAy1kUPMc0CWnWRmn_Cg_HGKGCeE-V2rdZEmN8A,836
+pytrms/_base/ioniclient.py,sha256=f4xWW3PL0p1gP7pczBaDEva3WUUb_J73n7yTIY5pW4s,826
+pytrms/_base/mqttclient.py,sha256=taO-pHfsqTDTiTV306ehY6G5fpq86RA5YaJZrRrHbsc,5157
+pytrms/_version.py,sha256=fXD69jGmDocNcc-uipbNIhjWxC7EuyhPUQ6BrBvK0Wg,854
+pytrms/clients/__init__.py,sha256=7q-mRjyf0xH01ohU1pPVvMgm2Gj4Q0eWf3BT50CewhM,1415
+pytrms/clients/db_api.py,sha256=pfMmfOlDCRmPCpsawwf-Rh4rix2sp3gHTF-afhXXMAQ,7556
+pytrms/clients/ioniclient.py,sha256=pHGzaNtKuVrjZ2O2nTmZYJObNMDkxNwLcNerlFit1vA,2477
+pytrms/clients/modbus.py,sha256=BbluHm8iYQY4V2Wbxd4eSiWJtIORyxRWRjhJo1_1JzQ,20585
+pytrms/clients/mqtt.py,sha256=BJ4CESjR4DTrggL3gWCr54c9Xm1_SSZ_FCKWduPPgEk,31217
+pytrms/clients/ssevent.py,sha256=zYS7MM4pkplC8wAj9ZY2Cb3fG3e-HtkyLt1qOosx-bk,3028
+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=BVQLFac5466PgppipmaBDInakau6lxztijQgQueDz1U,4289
+pytrms/measurement.py,sha256=yjTAskKKwXPzkW3I-Y4GawJxmJpLNxA7GQB8j1RDb8g,5445
+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=9O_enLxLYWgwRlpjZdK8wcX5rMCzt2B6PkgHJM9bPzw,18096
+pytrms-0.9.2.dist-info/LICENSE,sha256=GJsa-V1mEVHgVM6hDJGz11Tk3k0_7PsHTB-ylHb3Fns,18431
+pytrms-0.9.2.dist-info/METADATA,sha256=tPXvyFroNSiZAKAFwA4Krsd_I2o7BGvA1pH7iouqszM,761
+pytrms-0.9.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pytrms-0.9.2.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,,