pyForceDAQ 2.0.2.dev0__py3-none-any.whl → 2.0.3.dev1__py3-none-any.whl

pyforcedaq/__init__.py

@@ -30,11 +30,11 @@ __author__ = "Oliver Lindemann"
 
 import sys as _sys
 
-USE_MOCK_SENSOR = False # <-- change for usage in lab to False
-
-if _sys.version_info[0] != 3 or _sys.version_info[1]<12:
-    raise RuntimeError("pyForceDAQ {0} ".format(__version__) +
-                      "is not compatible with Python {0}.{1}. ".format(
-                                                    _sys.version_info[0],
-                                                    _sys.version_info[1]) +
-                       "Please use Python 3.12+.")
+if _sys.version_info[0] != 3 or _sys.version_info[1] < 12:
+    raise RuntimeError(
+        "pyForceDAQ {0} ".format(__version__)
+        + "is not compatible with Python {0}.{1}. ".format(
+            _sys.version_info[0], _sys.version_info[1]
+        )
+        + "Please use Python 3.12+."
+    )

pyforcedaq/__main__.py

@@ -1,7 +1,6 @@
-
 import argparse
 
-from . import __author__, __version__, gui
+from . import __author__, __version__
 
 
 def cli():
@@ -18,18 +17,23 @@ def cli():
     parser.add_argument("SETTINGS_FILE", nargs="?", default="", help="settings file")
 
     parser.add_argument(
-        "-l", "--launcher",
+        "-l",
+        "--launcher",
         action="store_true",
         default=False,
         help="Run with launcher GUI to edit settings and start recording",
     )
 
     parser.add_argument(
-        "-o", "--omit-launcher",
+        "-o",
+        "--omit-launcher",
         action="store_true",
         default=False,
         help="Omit launcher GUI and start recording directly",
     )
+    print("+" + "-" * 23 + "+")
+    print(f"| pyforceDAQ {__version__}".ljust(24) + "|")
+    print("+" + "-" * 23 + "+")
 
     args = parser.parse_args()
 
@@ -38,12 +42,14 @@ def cli():
             print("Can't use launcher and settings file")
             exit()
 
-        from .gui import launcher
-        return launcher.run_launcher()
+        from .launcher import run_launcher
+
+        return run_launcher()
     else:
-        gui.run_settings_file(args.SETTINGS_FILE)
+        from .gui import run_settings_file
 
+        run_settings_file(args.SETTINGS_FILE)
 
 
-if __name__ == "__main__": # required because of threading
+if __name__ == "__main__":  # required because of threading
     cli()

pyforcedaq/_lib/clock.py

@@ -1,6 +1,4 @@
-"""A high-resolution monotonic timer based on LSL's local_clock() function.
-"""
-
+"""A high-resolution monotonic timer based on LSL's local_clock() function."""
 
 from time import sleep
 
@@ -11,24 +9,24 @@ def local_clock_ms():
     """Returns the current time in milliseconds, based on LSL's local_clock()"""
     return local_clock() * 1000
 
-def wait_ms(waiting_time: int | float, looptime : int = 200) -> None:
-    """Wait for a certain amount of milliseconds.
-    """
+
+def wait_ms(waiting_time: int | float, looptime: int = 200) -> None:
+    """Wait for a certain amount of milliseconds."""
     start = local_clock_ms()
     if waiting_time > looptime:
         sleep((waiting_time - looptime) / 1000)
     while local_clock_ms() < start + waiting_time:
         pass
 
-class StopWatch(object):#
+
+class StopWatch(object):  #
     """A simple timer"""
 
     def __init__(self):
         self._init_time = local_clock()
 
     def reset_stopwatch(self):
-        """Reset the stopwatch time to zero.
-        """
+        """Reset the stopwatch time to zero."""
         self._init_time = local_clock()
 
     @property
@@ -37,4 +35,4 @@ class StopWatch(object):#
 
     @property
     def time_ms(self) -> float:
-        return self.time * 1000
+        return self.time * 1000

pyforcedaq/_lib/data_recorder.py

@@ -2,22 +2,20 @@
 
 See COPYING file distributed along with the pyForceDAQ copyright and license terms.
 """
+
 __author__ = "Oliver Lindemann"
 
 import atexit
 import gzip
 import logging
-from fileinput import filename
 from io import TextIOWrapper
 from pathlib import Path
 from time import asctime, localtime, strftime
 from typing import List
 
-from icecream import ic
-
 from .. import __version__ as forceDAQVersion
-from . import _log
 from .clock import wait_ms
+from .misc import set_logging
 from .process_priority_manager import ProcessPriorityManager
 from .sensor_process import SensorProcess
 from .settings import RecordingSettings, SensorSettings
@@ -32,19 +30,20 @@ from .types import (
 )
 from .udp_connection import UDPConnectionProcess
 
-_log.set_logging(data_directory="data", log_file="recording.log")
+set_logging(data_directory="data", log_file="recording.log")
 
 NEWLINE = "\n"
 
+
 class DataRecorder(object):
     """handles multiple sensors and udp connection"""
 
-    def __init__(self,
-                 recording_settings: RecordingSettings,
-                 force_sensor_settings:SensorSettings | List[SensorSettings],
-                 poll_udp_connection: bool = False):
-
-
+    def __init__(
+        self,
+        recording_settings: RecordingSettings,
+        force_sensor_settings: SensorSettings | List[SensorSettings],
+        poll_udp_connection: bool = False,
+    ):
         """queue_data will be saved
         see sensorprocess.__init__
 
@@ -58,15 +57,17 @@ class DataRecorder(object):
         self.recording_settings = recording_settings
 
         # create sensor processes
-        self._force_sensor_processes =[]
+        self._force_sensor_processes = []
         event_trigger = []
         for fs in force_sensor_settings:
             if not isinstance(fs, SensorSettings):
                 raise RuntimeError("Recorder needs a list of Force Sensor Settings!")
             else:
-                fst = SensorProcess(sensor_settings = fs,
-                                    recording_settings=recording_settings,
-                                    pipe_buffered_data_after_pause=True)
+                fst = SensorProcess(
+                    sensor_settings=fs,
+                    recording_settings=recording_settings,
+                    pipe_buffered_data_after_pause=True,
+                )
                 fst.start()
                 event_trigger.append(fst.event_trigger)
                 self._force_sensor_processes.append(fst)
@@ -83,13 +84,15 @@ class DataRecorder(object):
         self._proc_manager.add_subprocess(self.udp)
         self._proc_manager.add_subprocess(self._force_sensor_processes)
         if self.recording_settings.priority is not None:
-           level = PollingPriority.NORMAL
+            level = PollingPriority.NORMAL
         else:
             level = PollingPriority.get_priority(self.recording_settings.priority)
         self._proc_manager.set_subprocess_priorities(level=level, disable_gc=False)
 
-        logging.info("Main process priority: %s", self._proc_manager.get_main_priority())
-        #logging.info("Subprocess priorities: {}".format(self._proc_manager.get_subprocess_priorities()))
+        logging.info(
+            "Main process priority: %s", self._proc_manager.get_main_priority()
+        )
+        # logging.info("Subprocess priorities: {}".format(self._proc_manager.get_subprocess_priorities()))
 
         self._is_recording = False
         self._file = None
@@ -121,8 +124,7 @@ class DataRecorder(object):
 
     @property
     def sensor_settings_list(self):
-        return list(map(lambda x:x.sensor_settings,
-                        self._force_sensor_processes))
+        return list(map(lambda x: x.sensor_settings, self._force_sensor_processes))
 
     def quit(self) -> list | None:
         """Stop all recording processes, close data file and quit recording
@@ -155,28 +157,28 @@ class DataRecorder(object):
         buffer = []
         while True:
             try:
-                data = self.udp.receive_queue.get_nowait() # type: ignore
+                data = self.udp.receive_queue.get_nowait()  # type: ignore
             except AttributeError:
                 # until queue empty or no udp connection
                 break
             buffer.append(data)
-        if len(buffer)>0:
+        if len(buffer) > 0:
             self._write_data(buffer)
         return buffer
 
-    def _write_data(self, data_buffer: list,
-                   recording_screen=None,
-                   float_decimal_places: int = 4) -> None:
-        """ writes data to disk and set counters
+    def _write_data(
+        self, data_buffer: list, recording_screen=None, float_decimal_places: int = 4
+    ) -> None:
+        """writes data to disk and set counters
 
         ignores UDP remote control commands
         """
-        #DOC output format
+        # DOC output format
 
-        BLOCKSIZE = 10000 # for recording screen feedback only
+        BLOCKSIZE = 10000  # for recording screen feedback only
         write_forces = self.recording_settings.array_write_forces()
         write_trigger = self.recording_settings.array_write_trigger()
-        write_deviceid = len(self.recording_settings.device_labels)>1
+        write_deviceid = len(self.recording_settings.device_labels) > 1
         float_format = "{0:." + str(float_decimal_places) + "f},"
         buffer_len = len(data_buffer)
         for c, d in enumerate(data_buffer):
@@ -185,9 +187,9 @@ class DataRecorder(object):
                     line = f"{d.time}, {d.acquisition_delay},"
                     if write_deviceid:
                         line += f"{d.sensor_id},"
-                    for x in d.selected_forces(select=write_forces):
+                    for x in d.forces[write_forces]:
                         line += float_format.format(x)
-                    for x in d.selected_trigger(select=write_trigger):
+                    for x in d.trigger[write_trigger]:
                         if isinstance(x, int):
                             line += f"{x},"
                         else:
@@ -202,8 +204,10 @@ class DataRecorder(object):
 
             if recording_screen is not None and c % BLOCKSIZE == 0:
                 recording_screen.stimulus(
-                    "Writing {0} of {1} blocks".format(c//BLOCKSIZE,
-                                                       buffer_len//BLOCKSIZE)).present()
+                    "Saving {0} of {1} blocks".format(
+                        c // BLOCKSIZE, buffer_len // BLOCKSIZE
+                    )
+                ).present()
 
     def _file_write(self, s: str) -> None:
 
@@ -212,15 +216,15 @@ class DataRecorder(object):
         elif isinstance(self._file, TextIOWrapper):
             self._file.write(s)
 
-
-    def store_daq_event(self, code: str | int | float, time: float | None = None) -> None:
+    def store_daq_event(
+        self, code: str | int | float, time: float | None = None
+    ) -> None:
         """Set marker code in file
 
         DAQEvent will be timestamps and occur in the data output
 
         """
-        self._daq_event.append(DAQEvents(time = time, code = code))
-
+        self._daq_event.append(DAQEvents(time=time, code=code))
 
     def start_recording(self, determine_bias: bool = False) -> None:
         """Start polling process and record
@@ -234,12 +238,20 @@ class DataRecorder(object):
         if determine_bias:
             self.determine_biases(n_samples=1000)
 
-        if len(list(filter(lambda x:x.event_bias_is_available.is_set(),
-                   self._force_sensor_processes))) != len(self._force_sensor_processes):
-            raise RuntimeError("Sensors can't be started before bias has been determined.")
+        if len(
+            list(
+                filter(
+                    lambda x: x.event_bias_is_available.is_set(),
+                    self._force_sensor_processes,
+                )
+            )
+        ) != len(self._force_sensor_processes):
+            raise RuntimeError(
+                "Sensors can't be started before bias has been determined."
+            )
 
         # start polling
-        list(map(lambda x:x.start_polling(), self._force_sensor_processes))
+        list(map(lambda x: x.start_polling(), self._force_sensor_processes))
         self._is_recording = True
 
     def pause_recording(self, recording_screen=None) -> list:
@@ -254,14 +266,20 @@ class DataRecorder(object):
 
         data = []
         if recording_screen is not None:
-            recording_screen.stimulus("writing data ...").present()
+            recording_screen.stimulus("").present()
 
-        #pause polling
+        # pause polling
         for fsp in self._force_sensor_processes:
             fsp.pause_polling()
 
         wait_ms(500)
 
+        if recording_screen is not None:
+            if self.is_saving_data:
+                recording_screen.stimulus("saving data ...").present()
+            else:
+                recording_screen.stimulus("pause recording").present()
+
         # get data
         for fsp in self._force_sensor_processes:
             buffer = fsp.get_buffer()
@@ -298,11 +316,13 @@ class DataRecorder(object):
         for x in self._force_sensor_processes:
             x.event_bias_is_available.wait()
 
-    def open_data_file(self,
-                       filename: str | Path,
-                       subdirectory: str = "data",
-                       varnames: bool = True,
-                       comment_line: str = "") -> Path:
+    def open_data_file(
+        self,
+        filename: str | Path,
+        subdirectory: str = "data",
+        varnames: bool = True,
+        comment_line: str = "",
+    ) -> Path:
         """Create a data file
 
         Only if data file has been opened, data will be saved!
@@ -341,40 +361,50 @@ class DataRecorder(object):
             self.path_open_file = data_dir / filename
             if self.path_open_file.is_file():
                 # print "data file already exists, adding counter"
-                filename = Path(filename.stem + "_" + strftime("%m%d%H%M", localtime()) + \
-                                filename.suffix)
+                filename = Path(
+                    filename.stem
+                    + "_"
+                    + strftime("%m%d%H%M", localtime())
+                    + filename.suffix
+                )
             else:
                 break
 
         if self.recording_settings.zip_data:
-            self._file = gzip.open(self.path_open_file, 'w')
+            self._file = gzip.open(self.path_open_file, "w")
         else:
-            self._file = open(self.path_open_file, 'w')
+            self._file = open(self.path_open_file, "w")
         print("Data file: {}".format(self.path_open_file))
 
-        self._file_write(TAG_COMMENTS + "Recorded at {0} with pyForceDAQ {1}\n".format(
-            asctime(localtime()), forceDAQVersion))
+        self._file_write(
+            TAG_COMMENTS
+            + "Recorded at {0} with pyForceDAQ {1}\n".format(
+                asctime(localtime()), forceDAQVersion
+            )
+        )
         logging.info("new file: {}".format(self.path_open_file))
 
         for s in self.sensor_settings_list:
             txt = f" Sensor: label={s.device_label}, cal-file={s.calibration_file}\n"
             self._file_write(TAG_COMMENTS + txt)
 
-        if len(comment_line)>0:
+        if len(comment_line) > 0:
             self._file_write(TAG_COMMENTS + comment_line + "\n")
 
         if varnames:
             write_forces = self.recording_settings.array_write_forces()
             write_trigger = self.recording_settings.array_write_trigger()
-            write_deviceid = len(self.recording_settings.device_labels)>1
+            write_deviceid = len(self.recording_settings.device_labels) > 1
             line = "time,delay,"
             if write_deviceid:
                 line += "device_tag,"
             for x in range(6):
                 if write_forces[x]:
                     line += ForceSensorData.forces_names[x] + ","
-            if write_trigger[0]: line += "trigger1,"
-            if write_trigger[1]: line += "trigger2,"
+            if write_trigger[0]:
+                line += "trigger1,"
+            if write_trigger[1]:
+                line += "trigger2,"
             self._file_write(line[:-1] + NEWLINE)
 
         return self.path_open_file

pyforcedaq/_lib/lsl.py

@@ -12,8 +12,7 @@ from pylsl import (
 )
 
 
-class LSLSream():
-
+class LSLSream:
     def __init__(self):
         self.outlet = None
         self._is_init = False
@@ -22,7 +21,8 @@ class LSLSream():
     def is_init(self):
         return self._is_init
 
-    def init(self,
+    def init(
+        self,
         name: str,
         n_channels: int,
         stream_id: str,
@@ -50,11 +50,14 @@ class LSLSream():
         if self._is_init:
             return
 
-        info = StreamInfo(name, "force",
-                        channel_count=n_channels,
-                        nominal_srate=freq,
-                        channel_format=channel_format,
-                        source_id=stream_id)
+        info = StreamInfo(
+            name,
+            "force",
+            channel_count=n_channels,
+            nominal_srate=freq,
+            channel_format=channel_format,
+            source_id=stream_id,
+        )
 
         # Check if there is metadata to add to the lsl stream
         if metadata:

pyforcedaq/_lib/misc.py

@@ -1,12 +1,41 @@
+import logging
+import os
+import sys
+from pathlib import Path
+
+from ..constants import SETTINGS_FILE_EXTENSION
 from .clock import local_clock_ms
 
 
+def set_logging(data_directory, log_file):
+    base_dir = os.path.split(sys.argv[0])[0]
+    log_dir = os.path.join(base_dir, data_directory)
+    try:
+        os.mkdir(log_dir)
+    except:
+        pass
+    log_file = os.path.abspath(os.path.join(log_dir, log_file))
+    logging.basicConfig(
+        level=logging.INFO,
+        format="[%(asctime)s] %(message)s",
+        datefmt="%m-%d %H:%M:%S",
+        filename=log_file,
+        filemode="a",
+    )
+    return log_file
+
+
+def list_settings_files():
+    """Returns a list of all settings files in the current directory."""
+    return [f.name for f in Path(".").glob(f"*{SETTINGS_FILE_EXTENSION}")]
+
+
 def N2g(N):
-    kg = N/9.81
-    return kg*1000
+    kg = N / 9.81
+    return kg * 1000
 
-class MinMaxDetector(object):
 
+class MinMaxDetector(object):
     def __init__(self, start_value, duration_ms):
         self._minmax = [start_value, start_value]
         self._duration_ms = duration_ms
@@ -25,7 +54,7 @@ class MinMaxDetector(object):
             elif value < self._minmax[0]:
                 self._minmax[0] = value
 
-        elif self._minmax[0] != value: # level change just occurred
+        elif self._minmax[0] != value:  # level change just occurred
             self._level_change_time = local_clock_ms()
             return self.process(value)
 
@@ -34,8 +63,10 @@ class MinMaxDetector(object):
     @property
     def is_sampling_for_minmax(self):
         """true true if currently sampling for minmax"""
-        return (self._level_change_time is not None) and \
-               (local_clock_ms() - self._level_change_time) < self._duration_ms
+        return (self._level_change_time is not None) and (
+            local_clock_ms() - self._level_change_time
+        ) < self._duration_ms
+
 
 # def find_calibration_file(calibration_folder: str, device_label: str,
 #                           calibration_suffix=".cal") -> str:
@@ -63,7 +94,8 @@ class MinMaxDetector(object):
 #         print("No calibration file found for sensor '{0}'.".format(device_label))
 #     exit()
 
-#Sensor History with moving average filtering and distance, velocity
+
+# Sensor History with moving average filtering and distance, velocity
 class SensorHistory(object):
     """The Sensory History keeps track of the last n recorded sample and
     calculates online the moving average (running mean).
@@ -101,10 +133,12 @@ class SensorHistory(object):
             self.moving_average = self.calc_history_average()
         else:
             self._correction_cnt += 1
-            self.moving_average = list(map(
-                lambda x: x[0] + (float(x[1] - x[2]) / len(self.history)),
-                zip(self.moving_average, values, pop)))
-
+            self.moving_average = list(
+                map(
+                    lambda x: x[0] + (float(x[1] - x[2]) / len(self.history)),
+                    zip(self.moving_average, values, pop),
+                )
+            )
 
     def calc_history_average(self):
         """Calculate history averages for all sensor parameter.
@@ -120,7 +154,6 @@ class SensorHistory(object):
             s = list(map(lambda x: x[0] + x[1], zip(s, t)))
         return list(map(lambda x: x / len(self.history), s))
 
-
     @property
     def history_size(self):
         return len(self.history)
@@ -132,4 +165,3 @@ class SensorHistory(object):
     @property
     def previous_moving_average(self):
         return self._previous_moving_average
-

pyforcedaq/_lib/polling_time_profile.py

@@ -4,13 +4,12 @@ from .clock import local_clock
 
 
 class PollingTimeProfile(object):
-
     def __init__(self, timing_range_ms=10):
         self._last = None
         self._timing_range_ms = 10
         self._zero_cnt = 0
 
-        #self._zero_time_polling_frequency = {}
+        # self._zero_time_polling_frequency = {}
         self.profile_frequency = np.array([0] * (timing_range_ms + 1))
 
     def stop(self):
@@ -25,9 +24,9 @@ class PollingTimeProfile(object):
                 d = self._timing_range_ms
             self.profile_frequency[d] += 1
 
-            #if d == 0:
+            # if d == 0:
             #    self._zero_cnt += 1
-            #elif self._zero_cnt > 0:
+            # elif self._zero_cnt > 0:
             #    try:
             #        self._zero_time_polling_frequency[self._zero_cnt] += 1
             #    except:
@@ -45,10 +44,14 @@ class PollingTimeProfile(object):
         return self.profile_frequency / n
 
     def get_profile_str(self):
-        rtn = str(list(self.profile_frequency)
-                  ).replace("[", "").replace("]", "").replace(" ", "")
+        rtn = (
+            str(list(self.profile_frequency))
+            .replace("[", "")
+            .replace("]", "")
+            .replace(" ", "")
+        )
         return "polling profile [{}]".format(rtn)
 
-    #@property
-    #def zero_time_polling_frequency(self):
-    #    return np.array(list(self._zero_time_polling_frequency.items()))
+    # @property
+    # def zero_time_polling_frequency(self):
+    #    return np.array(list(self._zero_time_polling_frequency.items()))