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

pytrms/helpers.py

@@ -1,120 +1,126 @@
-"""@file helpers.py
-
-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)
-
+"""@file helpers.py
+
+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", exclude=r".*\.REPLAY"):
+    """Create a new directory for saving the measurement and set it up.
+
+    Optional: copy all files from the given config-directory.
+
+    config_dir - where to copy from
+    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
+    exclude - a regular expression to exclude files from copying
+    """
+    import os
+    import re
+    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:
+        if exclude and re.match(exclude, file):
+            continue
+
+        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

@@ -1,119 +1,119 @@
-import os.path
-import time
-from abc import abstractmethod, ABC
-
-from .measurement import *
-
-
-class Instrument(ABC):
-    '''
-    Class for controlling the PTR instrument remotely.
-
-    This class reflects the states of the actual instrument, which can be currently idle
-    or running a measurement. An idle instrument can start a measurement. A running
-    instrument can be stopped. But trying to start a measurement twice will raise an
-    exception (RuntimeError).
-
-    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):
-        # Note: we get ourselves a nifty little state-machine :)
-        self.__class__ = newstate
-
-    def __new__(cls, backend):
-        # make this class a singleton..
-        if cls._Instrument__instance is not None:
-            # quick reminder: If __new__() does not return an instance of cls, then the
-            # new instance’s __init__() method will *not* be invoked:
-            return cls._Instrument__instance
-
-        # ..that is synchronized with the PTR-instrument state:
-        if backend.is_running:
-            cls = RunningInstrument
-        else:
-            cls = IdleInstrument
-
-        inst = object.__new__(cls)
-        Instrument._Instrument__instance = inst
-
-        return inst
-
-    def __init__(self, backend):
-        # dispatch all blocking calls to the client
-        self.backend = backend
-
-    @property
-    def is_local(self):
-        """Returns True if files are written to the local machine."""
-        host = str(self.backend.host)
-        return 'localhost' in host or '127.0.0.1' in host
-
-    def get(self, varname):
-        """Get the current value of a setting."""
-        # TODO :: this is not an interface implementation
-        raw = self.backend.get(varname)
-        if not isinstance(self.backend, MqttClient):
-            import json
-            jobj = json.loads(raw)
-
-            return jobj[0]['Act']['Real']
-
-        ## how it should be:
-        return raw
-
-    def set(self, varname, value, unit='-'):
-        """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__)
-
-    def stop_measurement(self):
-        # this method must be implemented by each state
-        raise RuntimeError("can't stop %s" % self.__class__)
-
-
-class IdleInstrument(Instrument):
-
-    def start_measurement(self, filename=''):
-        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)
-
-
-class RunningInstrument(Instrument):
-
-    def stop_measurement(self):
-        self.backend.stop_measurement()
-        self._new_state(IdleInstrument)
-
-        # TODO :: this catches only one sourcefile.. it'll do for simple cases:
-        return FinishedMeasurement(_current_sourcefile)
-
+import os.path
+import time
+from abc import abstractmethod, ABC
+
+from .measurement import *
+
+
+class Instrument(ABC):
+    '''
+    Class for controlling the PTR instrument remotely.
+
+    This class reflects the states of the actual instrument, which can be currently idle
+    or running a measurement. An idle instrument can start a measurement. A running
+    instrument can be stopped. But trying to start a measurement twice will raise an
+    exception (RuntimeError).
+
+    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):
+        # Note: we get ourselves a nifty little state-machine :)
+        self.__class__ = newstate
+
+    def __new__(cls, backend):
+        # make this class a singleton..
+        if cls._Instrument__instance is not None:
+            # quick reminder: If __new__() does not return an instance of cls, then the
+            # new instance’s __init__() method will *not* be invoked:
+            return cls._Instrument__instance
+
+        # ..that is synchronized with the PTR-instrument state:
+        if backend.is_running:
+            cls = RunningInstrument
+        else:
+            cls = IdleInstrument
+
+        inst = object.__new__(cls)
+        Instrument._Instrument__instance = inst
+
+        return inst
+
+    def __init__(self, backend):
+        # dispatch all blocking calls to the client
+        self.backend = backend
+
+    @property
+    def is_local(self):
+        """Returns True if files are written to the local machine."""
+        host = str(self.backend.host)
+        return 'localhost' in host or '127.0.0.1' in host
+
+    def get(self, varname):
+        """Get the current value of a setting."""
+        # TODO :: this is not an interface implementation
+        raw = self.backend.get(varname)
+        if not isinstance(self.backend, MqttClient):
+            import json
+            jobj = json.loads(raw)
+
+            return jobj[0]['Act']['Real']
+
+        ## how it should be:
+        return raw
+
+    def set(self, varname, value, unit='-'):
+        """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__)
+
+    def stop_measurement(self):
+        # this method must be implemented by each state
+        raise RuntimeError("can't stop %s" % self.__class__)
+
+
+class IdleInstrument(Instrument):
+
+    def start_measurement(self, filename=''):
+        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)
+
+
+class RunningInstrument(Instrument):
+
+    def stop_measurement(self):
+        self.backend.stop_measurement()
+        self._new_state(IdleInstrument)
+
+        # TODO :: this catches only one sourcefile.. it'll do for simple cases:
+        return FinishedMeasurement(_current_sourcefile)
+