pytrms 0.9.9__tar.gz → 0.9.10__tar.gz

{pytrms-0.9.9 → pytrms-0.9.10}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pytrms
-Version: 0.9.9
+Version: 0.9.10
 Summary: Python bundle for proton-transfer reaction mass-spectrometry (PTR-MS).
 License: GPL-2.0
+License-File: LICENSE
 Author: Moritz Koenemann
 Author-email: moritz.koenemann@ionicon.com
 Requires-Python: >=3.10,<4.0
@@ -12,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 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,<3.0)

{pytrms-0.9.9 → pytrms-0.9.10}/pyproject.toml

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

{pytrms-0.9.9 → pytrms-0.9.10}/pytrms/__init__.py

@@ -1,4 +1,4 @@
-_version = '0.9.9'
+_version = '0.9.10'
 
 import logging
 from functools import wraps

{pytrms-0.9.9 → pytrms-0.9.10}/pytrms/_base/mqttclient.py

@@ -33,6 +33,30 @@ def _on_publish(client, self, mid):
     log.debug(f"[{self}] published {mid = }")
 
 
+def _exception_safe(callback_fun):
+    # rest assured, that we never throw inside callbacks!
+
+    cb_name = callback_fun.__code__.co_name
+    cb_argc = callback_fun.__code__.co_argcount
+    short_payload = lambda s: s[:50] + ('...' if len(s) > 50 else '')
+
+    assert cb_argc == 3, "subscriber callback must have arguments (client, obj, msg)"
+
+    def exception_safe_callback_wrapper(client, data, msg):
+        try:
+            callback_fun(client, data, msg)
+        except Exception as exc:
+            log.warning(f"unhandled {exc.__class__.__name__}: {exc} "
+                      + f"in callback {cb_name}({msg.topic}, <obj>, {short_payload(msg.payload)})")
+            pass
+        except:
+            log.warning(f"exception unhandled "
+                      + f"in callback {cb_name}({msg.topic}, <obj>, {short_payload(msg.payload)})")
+            pass
+
+    return exception_safe_callback_wrapper
+
+
 class MqttClientBase:
     """Mix-in class that supplies basic MQTT-callback functions.
 
@@ -88,7 +112,7 @@ class MqttClientBase:
         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)
+                self.client.message_callback_add(topic, _exception_safe(subscriber))
         # ...pass this instance to each callback...
         self.client.user_data_set(self)
         # ...and connect to the server:

{pytrms-0.9.9 → pytrms-0.9.10}/pytrms/clients/db_api.py

@@ -67,22 +67,17 @@ class IoniConnect(_IoniClientBase):
         self.session = requests.sessions.Session()
         self.session.mount('http://',  self._http_adapter)
         self.session.mount('https://', self._http_adapter)
-        started_at = time.monotonic()
-        while timeout_s is None or time.monotonic() < started_at + timeout_s:
-            try:
-                self.current_meas_loc = self.get_location("/api/measurements/current")
-                break
-            except requests.exceptions.HTTPError:
+        try:
+            self.current_meas_loc = self.get_location("/api/measurements/current")
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 410:  # Gone
                 # OK, no measurement running..
                 self.current_meas_loc = ''
-                break
-            except Exception:
-                pass
-
-            time.sleep(10e-1)
-        else:
+                return
+        except requests.exceptions.ConnectionError as e:
             self.session = self.current_meas_loc = None
-            raise TimeoutError(f"no connection to '{self.url}'");
+            log.error(type(e).__name__, str(e))
+            raise
 
     def disconnect(self):
         if self.session is not None:
@@ -124,7 +119,7 @@ class IoniConnect(_IoniClientBase):
         self.current_meas_loc = None
         try:
             self.connect(timeout_s=3.3)
-        except TimeoutError:
+        except requests.exceptions.ConnectionError:
             log.warning("no connection! make sure the DB-API is running and try again")
 
     def get(self, endpoint, **kwargs):
@@ -402,6 +397,8 @@ class IoniConnect(_IoniClientBase):
          stream-implementation), unless the server sends a keep-alive at regular
          intervals (as every well-behaved server should be doing)!
         """
-        yield from SSEventListener(event_re, host_url=self.url, endpoint="/api/events",
-                session=self.session)
+        # Note: DO NOT inject our `requests.session` with the 'session' kw-arg!!
+        #  For some unknown reason this didn't work. Maybe in combination with
+        #  the new _http_adapter? Who knows.. let the listener use its own session:
+        yield from SSEventListener(event_re, host_url=self.url, endpoint="/api/events")
 

{pytrms-0.9.9 → pytrms-0.9.10}/pytrms/clients/mqtt.py

@@ -376,12 +376,6 @@ def follow_act_set_values(client, self, msg):
             self.act_values[parID] = _parse_data_element(payload["DataElement"])
         if kind == "Set":
             self.set_values[parID] = _parse_data_element(payload["DataElement"])
-    except json.decoder.JSONDecodeError as exc:
-        log.error(f"{exc.__class__.__name__}: {exc} :: while processing [{msg.topic}] ({msg.payload})")
-        raise
-    except KeyError as exc:
-        log.error(f"{exc.__class__.__name__}: {exc} :: while processing [{msg.topic}] ({msg.payload})")
-        pass
     except ParsingError as exc:
         log.error(f"while parsing [{parID}] :: {str(exc)}")
         pass

{pytrms-0.9.9 → pytrms-0.9.10}/pytrms/clients/ssevent.py

@@ -106,6 +106,6 @@ class SSEventListener(Iterable):
 
     def __iter__(self):
         g = self.follow_events(timeout_s=None, prime=True)
-        assert next(g).event == 'new connection', "invalid program: pseude-event expected"
+        assert next(g).event == 'new connection', "invalid program: pseudo-event expected"
         yield from g
 

{pytrms-0.9.9 → pytrms-0.9.10}/pytrms/measurement.py

@@ -218,6 +218,9 @@ class FinishedMeasurement(Measurement):
         """
         return pd.concat(sf.read_all(kind, index, force_original) for sf in self._readers)
 
+    get_traces = read_traces
+    get_traces.__doc__ = read_traces.__doc__ + "\nAlias: 'get_traces'."
+
     def __iter__(self):
         for reader in self._readers:
             for specdata in reader.iter_specdata():

{pytrms-0.9.9 → pytrms-0.9.10}/pytrms/peaktable.py

@@ -114,10 +114,16 @@ class Peak:
             label = 'm{:.4f}'.format(self.center)
         self.label = str(label)
         self.formula = formula
-        if parent is not None and not isinstance(parent, Peak):
-            raise ValueError(parent)
+        # check parent and use its borders:
+        if parent is not None:
+            if not isinstance(parent, Peak):
+                raise ValueError(parent)
+
+            borders = parent.borders
+            self.parent = parent
+        else:
+            self.parent = None
 
-        self.parent = parent
         self._borders = tuple(map(lambda x: round(float(x), ndigits=4), borders))
         self.isotopic_abundance = float(isotopic_abundance)
         self.k_rate = float(k_rate)
@@ -194,7 +200,7 @@ class PeakTable:
         peaks = []
         for row in table.itertuples(index=False):
             borders = row.BorderLow, row.BorderHigh
-            peaks.append(Peak(center=row.MassCenters, label=row.Descriptions,
+            peaks.append(Peak(center=row.MassCenters, label=row.Descriptions.strip(),
                               borders=borders, k_rate=row.kRates,
                               multiplier=row.Multipliers))
 
@@ -327,6 +333,46 @@ class PeakTable:
                        indent=2)
         fp.write(s)
 
+    def _write_ionipt(self, fp, fileversion='1.0'):
+        # modes:
+        IGNORE    = 0b00
+        INTEGRATE = 0b01
+        FIT_PEAKS = 0b10
+        BOTH      = 0b11
+
+        # Note (Warning): We can only deduce BOTH and INTEGRATE, because all parents
+        #  with children are always fitted in our context. The IGNORE and FIT_PEAKS
+        #  modes will be lost when saving in .ionipt format!
+
+        render_borderpeak = lambda bp: {
+                "name": bp.label,
+                "center": bp.center,
+                "ion": "",
+                "ionic_isotope": bp.formula,
+                "parent": "",  # not used!
+                "isotopic_abundance": bp.isotopic_abundance,
+                "k_rate": bp.k_rate,
+                "multiplier": bp.multiplier,
+                "resolution": bp.resolution
+            }
+        parent2children = self.group()
+        s = json.dumps([
+                {
+                    "border_peak": render_borderpeak(parent),
+                    "low": parent.borders[0],
+                    "high": parent.borders[1],
+                    "peak": [
+                        render_borderpeak(child)
+                        for child in parent2children[parent]
+                    ],
+                    "mode": int(BOTH if len(parent2children[parent]) else INTEGRATE),
+                    "shift": parent.shift,
+                }
+                for parent in self.nominal
+            ],
+            indent=4)
+        fp.write(s)
+
     def _write_ipt(self, fp, fileversion='1.0'):
         if fileversion not in ['1.0', '1.1']:
             raise NotImplementedError("Can't write .ipt version %s!" % fileversion)
@@ -426,6 +472,16 @@ class PeakTable:
 
         raise KeyError("No such peak at %s!" % str(exact_mass))
 
+    def find_by_label(self, label):
+        """Return the peak with the given `label`.
+
+        Raises KeyError if not found.
+        """
+        try:
+            return next((peak for peak in self.peaks if peak.label == label))
+        except StopIteration:
+            raise KeyError("No such peak at %s!" % str(label))
+
     def group(self):
         groups = defaultdict(list)
         for peak in self:
@@ -443,6 +499,8 @@ class PeakTable:
             writer = partial(self._write_ipt, fileversion='1.0')
         elif ext == '.ipta':
             writer = partial(self._write_ipta, fileversion='1.0')
+        elif ext == '.ionipt':
+            writer = partial(self._write_ionipt, fileversion='1.0')
         else:
             raise NotImplementedError("can't export with file extension <%s>!" % ext)
 

{pytrms-0.9.9 → pytrms-0.9.10}/pytrms/readers/ionitof_reader.py

@@ -206,13 +206,13 @@ class IoniTOFReader:
         except KeyError as exc:
             msg = "Unknown index-type! `kind` must be one of {0}.".format(', '.join(lut.keys()))
             raise KeyError(msg) from exc
-    
+
         return convert2iterator(self.hf['SPECdata/Times'][:, _N])
 
     @lru_cache
     def make_index(self, kind='abs_cycle'):
         return pd.Index(self.iter_index(kind))
-    
+
     def __len__(self):
         return self.hf['SPECdata/Intensities'].shape[0]
 
@@ -249,11 +249,11 @@ class IoniTOFReader:
         self.hf.visit(lambda obj_name: obj_names.add(obj_name))
 
         return sorted(obj_names)
-    
+
     def list_addtrace_groups(self):
         """Lists the recorded additional trace-groups."""
         return sorted(self._locate_datainfo())
-    
+
     def __repr__(self):
         return "<%s (%s) [no. %s] %s>" % (self.__class__.__name__,
                 self.inst_type, self.serial_nr, self.hf.filename)
@@ -263,7 +263,7 @@ class IoniTOFReader:
         """Lookup groups with data-info traces."""
         dataloc = set()
         infoloc = set()
-    
+
         def func(object_name):
             nonlocal dataloc
             nonlocal infoloc
@@ -272,13 +272,13 @@ class IoniTOFReader:
             if object_name.endswith('/Info'):
                 infoloc |= {object_name[:-5], }
             return None
-    
+
         # use the above 'visit'-function that appends matched sections...
         self.hf.visit(func)
-    
+
         # ...and return only groups with both /Data and /Info datasets:
         return dataloc.intersection(infoloc)
-    
+
     def traces(self):
         """Returns a  'pandas.DataFrame' with all traces concatenated."""
         return self.read_all(kind='conc', index='abs_cycle', force_original=False)
@@ -292,7 +292,7 @@ class IoniTOFReader:
     #   |__ wird dann bei bedarf ge-populated
     # 
     # das sourcefile / measurement soll sich wie ein pd.DataFrame "anfuehlen":
-        
+
     # das loest das Problem, aus einer "Matrix2 gezielt eine Zeile oder eine "Spalte" 
     #  oder alles (d.h. iterieren ueber Zeilen) zu selektieren und zwar intuitiv!!
 
@@ -304,7 +304,7 @@ class IoniTOFReader:
     # 3. _column_getter
     # 4. _row_getter
     # 5. parID_resolver ~> keys() aus ParID.txt zu addtrace-group + column!
-    
+
     ###################################################################################
     #                                                                                 #
     # ENDZIEL: times u. Automation fuer die "letzte" Zeile an die Datenbank schicken! #
@@ -341,7 +341,7 @@ class IoniTOFReader:
         dset_name, column = lut[key]  # may raise KeyError
 
         return self.hf[dset_name][:,column]
-    
+
     def loc(self, label):
         if isinstance(label, int):
             return self.iloc[self.make_index('abs_cycle')[label]]
@@ -374,7 +374,7 @@ class IoniTOFReader:
 
         if hasattr(labels[0], 'decode'):
             labels = [b.decode('latin1') for b in labels]
-    
+
         # TODO :: wir haben hier diese doesigen Set/Act werte drin, was wollen wir??
         # if keys[0].endswith('[Set]'):
         #     rv = {key[:-5]: (value, unit)
@@ -414,10 +414,10 @@ class IoniTOFReader:
         #    act_values.columns = [col.replace('_Act', '') for col in act_values.columns]
         #
         #    return _trace(set_values, act_values)
-    
-    
+
+
         return pd.DataFrame(data, columns=labels)
-    
+
     def _read_processed_traces(self, kind, index):
         # error conditions:
         # 1) 'kind' is not recognized -> ValueError
@@ -444,11 +444,12 @@ class IoniTOFReader:
         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, inplace=True)
+        # Note [#3433]: the .h5 'ConcentrationsInfo' is what *should* label the
+        #  columns, but it is ambiguous, because it rounds to 3 decimal places
+        #  (for whatever reason...)! Just overwrite it with the 'PeakTableInfo':
+        data.columns = [b.decode('latin1') for b in pt['label']]
         data.index = list(self.iter_index(index))
-        
+
         return data
 
     def _read_original_traces(self, kind, index):
@@ -464,9 +465,9 @@ class IoniTOFReader:
         except KeyError as exc:
             msg = ("Unknown trace-type! `kind` must be one of 'raw', 'corrected' or 'concentration'.")
             raise ValueError(msg) from exc
-    
+
         info = self.hf['TRACEdata/TraceInfo']
         labels = [b.decode('latin1') for b in info[1,:]]
-    
+
         return pd.DataFrame(data, columns=labels, index=list(self.iter_index(index)))