pyForceDAQ 2.0.0.dev0__tar.gz → 2.0.1__tar.gz

{pyforcedaq-2.0.0.dev0 → pyforcedaq-2.0.1}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.3
 Name: pyForceDAQ
-Version: 2.0.0.dev0
+Version: 2.0.1
 Summary: A Python package for data acquisition and analysis in force-based experiments.
 Author: Oliver Lindemann
 Author-email: Oliver Lindemann <lindemann@essb.eur.nl>
 Requires-Dist: atiiaftt>=0.1.1
 Requires-Dist: expyriment>=1.0.1
-Requires-Dist: freesimplegui>=5.2.0.post1
 Requires-Dist: icecream>=2.2.0
 Requires-Dist: nidaqmx>=1.5.0
 Requires-Dist: numpy>=2.4.4
 Requires-Dist: psutil>=7.2.2
 Requires-Dist: pydaqmx>=1.4.7
 Requires-Dist: pylsl>=1.18.2
+Requires-Dist: pysimplegui>=6.0
 Requires-Dist: pyxdf>=1.17.4
 Requires-Dist: tomlkit>=0.15.0
 Requires-Python: >=3.12, <3.14

{pyforcedaq-2.0.0.dev0 → pyforcedaq-2.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyForceDAQ"
-version = "2.0.0-dev0"
+version = "2.0.1"
 description = "A Python package for data acquisition and analysis in force-based experiments."
 authors = [
     { name = "Oliver Lindemann", email = "lindemann@essb.eur.nl" },
@@ -9,13 +9,13 @@ requires-python = ">=3.12, <3.14"
 dependencies = [
     "atiiaftt>=0.1.1",
     "expyriment>=1.0.1",
-    "freesimplegui>=5.2.0.post1",
     "icecream>=2.2.0",
     "nidaqmx>=1.5.0",
     "numpy>=2.4.4",
     "psutil>=7.2.2",
     "pydaqmx>=1.4.7",
     "pylsl>=1.18.2",
+    "pysimplegui>=6.0",
     "pyxdf>=1.17.4",
     "tomlkit>=0.15.0",
 ]

{pyforcedaq-2.0.0.dev0 → pyforcedaq-2.0.1}/src/pyforcedaq/__init__.py

@@ -7,7 +7,7 @@ launch the GUI force from your Python program:
 ``
     from pyforcedaq import gui
 
-    gui.run_with_options(remote_control=False,
+    gui.run(remote_control=False,
               ask_filename=True,
                calibration_file="FT_sensor1.cal")
 ``

{pyforcedaq-2.0.0.dev0 → pyforcedaq-2.0.1}/src/pyforcedaq/__main__.py

@@ -24,9 +24,16 @@ def cli():
         help="Run with launcher GUI to edit settings and start recording",
     )
 
+    parser.add_argument(
+        "-o", "--omit-launcher",
+        action="store_true",
+        default=False,
+        help="Omit launcher GUI and start recording directly",
+    )
+
     args = parser.parse_args()
 
-    if args.launcher:
+    if not args.omit_launcher:
         if len(args.SETTINGS_FILE) > 0:
             print("Can't use launcher and settings file")
             exit()
@@ -34,9 +41,9 @@ def cli():
         from .gui import launcher
         return launcher.run()
     else:
-        gui.run(args.SETTINGS_FILE)
+        gui.run_settings(args.SETTINGS_FILE)
 
 
 
 if __name__ == "__main__": # required because of threading
-    cli() # gui.run(), gui.run_with_options()
+    cli()

{pyforcedaq-2.0.0.dev0/src/pyforcedaq/force → pyforcedaq-2.0.1/src/pyforcedaq/_lib}/_log.py

@@ -1,6 +1,7 @@
+import logging
 import os
 import sys
-import logging
+
 
 def set_logging(data_directory, log_file):
     base_dir = os.path.split(sys.argv[0])[0]

pyforcedaq-2.0.1/src/pyforcedaq/_lib/clock.py

@@ -0,0 +1,40 @@
+"""A high-resolution monotonic timer based on LSL's local_clock() function.
+"""
+
+
+from time import sleep
+
+from pylsl import local_clock
+
+
+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.
+    """
+    start = local_clock_ms()
+    if waiting_time > looptime:
+        sleep((waiting_time - looptime) / 1000)
+    while local_clock_ms() < start + waiting_time:
+        pass
+
+class StopWatch(object):#
+    """A simple timer"""
+
+    def __init__(self):
+        self._init_time = local_clock()
+
+    def reset_stopwatch(self):
+        """Reset the stopwatch time to zero.
+        """
+        self._init_time = local_clock()
+
+    @property
+    def time(self) -> float:
+        return local_clock() - self._init_time
+
+    @property
+    def time_ms(self) -> float:
+        return self.time * 1000

{pyforcedaq-2.0.0.dev0/src/pyforcedaq/force → pyforcedaq-2.0.1/src/pyforcedaq/_lib}/data_recorder.py

@@ -7,16 +7,16 @@ __author__ = "Oliver Lindemann"
 import atexit
 import gzip
 import logging
-import os
-import sys
+from pathlib import Path
 from time import asctime, localtime, strftime
 
-from pyforcedaq._lib import timer
-
 from .. import __version__ as forceDAQVersion
-from .._lib.process_priority_manager import ProcessPriorityManager
-from .._lib.timer import app_clock
-from .._lib.types import (
+from . import _log
+from .clock import wait_ms
+from .process_priority_manager import ProcessPriorityManager
+from .sensor import SensorSettings
+from .sensor_process import SensorProcess
+from .types import (
     TAG_COMMENTS,
     TAG_DAQEVENT,
     TAG_UDPDATA,
@@ -25,10 +25,10 @@ from .._lib.types import (
     PollingPriority,
     UDPData,
 )
-from .._lib.types import GUIRemoteControlCommands as RemoteCmd
-from .._lib.udp_connection import UDPConnectionProcess
-from .sensor import SensorSettings
-from .sensor_process import SensorProcess
+from .types import GUIRemoteControlCommands as RemoteCmd
+from .udp_connection import UDPConnectionProcess
+
+_log.set_logging(data_directory="data", log_file="recording.log")
 
 NEWLINE = "\n"
 
@@ -38,7 +38,7 @@ class DataRecorder(object):
     def __init__(self, force_sensor_settings:SensorSettings | list,
                  poll_udp_connection=False,
                  write_deviceid = False,
-                 polling_priority=None):
+                 polling_priority:str | None = None):
 
 
         """queue_data will be saved
@@ -82,18 +82,18 @@ class DataRecorder(object):
         self._proc_manager.add_subprocess(self.udp)
         self._proc_manager.add_subprocess(self._force_sensor_processes)
         if polling_priority is not None:
-            self._proc_manager.set_subprocess_priorities(
-                level=PollingPriority.get_priority(polling_priority),
-                disable_gc=False)
+           level = PollingPriority.NORMAL
+        else:
+            level = PollingPriority.get_priority(polling_priority)
+        self._proc_manager.set_subprocess_priorities(level=level, disable_gc=False)
 
-        logging.info("Main process priority: {}".format(
-            self._proc_manager.get_main_priority()))
+        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
         self._daq_event = []
-        self.filename = None
+        self.filename: str | None = None
         atexit.register(self.quit)
 
 
@@ -102,7 +102,7 @@ class DataRecorder(object):
         """Property indicates whether the recording processes are alive"""
         try:
             return self._force_sensor_processes[0].is_alive()
-        except:
+        except Exception:
             return False
 
     @property
@@ -119,7 +119,7 @@ class DataRecorder(object):
         return list(map(lambda x:x.sensor_settings,
                         self._force_sensor_processes))
 
-    def quit(self):
+    def quit(self) -> list | None:
         """Stop all recording processes, close data file and quit recording
 
         Notes
@@ -145,7 +145,7 @@ class DataRecorder(object):
 
         return buffer
 
-    def process_and_write_udp_events(self):
+    def process_and_write_udp_events(self) -> list:
         """process udp events and return them"""
         buffer = []
         while True:
@@ -159,9 +159,9 @@ class DataRecorder(object):
             self._save_data(buffer)
         return buffer
 
-    def _save_data(self, data_buffer,
+    def _save_data(self, data_buffer: list,
                    recording_screen=None,
-                   float_decimal_places=4):
+                   float_decimal_places: int = 4) -> None:
         """ writes data to disk and set counters
 
         ignores UDP remote control commands
@@ -199,21 +199,19 @@ class DataRecorder(object):
                     "Writing {0} of {1} blocks".format(c//BLOCKSIZE,
                                                        buffer_len//BLOCKSIZE)).present()
 
-    def _file_write(self, str):
-        self._file.write(str.encode())
+    def _file_write(self, s: str) -> None:
+        self._file.write(s.encode())
 
-    def save_daq_event(self, code, time=None):
+    def save_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
 
         """
-        if time is None:
-            time = app_clock.time
         self._daq_event.append(DAQEvents(time = time, code = code))
 
 
-    def start_recording(self, determine_bias=False):
+    def start_recording(self, determine_bias: bool = False) -> None:
         """Start polling process and record
 
         See Also
@@ -233,7 +231,7 @@ class DataRecorder(object):
         list(map(lambda x:x.start_polling(), self._force_sensor_processes))
         self._is_recording = True
 
-    def pause_recording(self, recording_screen=None):
+    def pause_recording(self, recording_screen=None) -> list:
         """Pauses all polling processes and process data
 
         returns
@@ -251,7 +249,7 @@ class DataRecorder(object):
         for fsp in self._force_sensor_processes:
             fsp.pause_polling()
 
-        timer.wait(500)
+        wait_ms(500)
 
         # get data
         for fsp in self._force_sensor_processes:
@@ -268,7 +266,7 @@ class DataRecorder(object):
         self._daq_event = []
         return data
 
-    def determine_biases(self, n_samples):
+    def determine_biases(self, n_samples: int) -> None:
         """Record n data samples (n_samples) to determine bias.
         Afterwards recording is in pause mode
 
@@ -289,12 +287,12 @@ class DataRecorder(object):
         for x in self._force_sensor_processes:
             x.event_bias_is_available.wait()
 
-    def open_data_file(self, filename,
-                       subdirectory="data",
-                       time_stamp_filename=False,
-                       varnames = True,
-                       comment_line="",
-                       zipped=False):
+    def open_data_file(self, filename: str,
+                       subdirectory: str = "data",
+                       time_stamp_filename: bool = False,
+                       varnames: bool = True,
+                       comment_line: str = "",
+                       zipped: bool = False) -> Path:
         """Create a data file
 
         Only if data file has been opened, data will be saved!
@@ -322,11 +320,8 @@ class DataRecorder(object):
                 full path the actually used file (incl. timestamp)
 
         """
-
-        base_dir = os.path.split(sys.argv[0])[0]
-        data_dir = os.path.join(base_dir, subdirectory)
-        if not os.path.isdir(data_dir):
-            os.mkdir(data_dir)
+        data_dir = Path.cwd() / subdirectory
+        data_dir.mkdir(exist_ok=True)
         self.close_data_file()
 
         if filename is None or len(filename) == 0:
@@ -352,8 +347,8 @@ class DataRecorder(object):
             else:
                 self.filename = flname + suffix
 
-            full_path_file = os.path.join(data_dir, self.filename)
-            if os.path.isfile(full_path_file):
+            full_path_file = data_dir / self.filename
+            if full_path_file.is_file():
                 # print "data file already exists, adding counter"
                 cnt += 1
             else:
@@ -388,7 +383,7 @@ class DataRecorder(object):
 
         return full_path_file
 
-    def close_data_file(self):
+    def close_data_file(self) -> None:
         """Close the data file
 
         Afterwards data will not be saved anymore.

pyforcedaq-2.0.1/src/pyforcedaq/_lib/lsl.py

@@ -0,0 +1,75 @@
+from pylsl import (
+    StreamInfo,
+    StreamOutlet,
+    cf_double64,
+    cf_float32,
+    cf_int8,
+    cf_int16,
+    cf_int32,
+    cf_int64,
+    cf_string,
+    cf_undefined,
+)
+
+
+class LSLSream():
+
+    def __init__(self):
+        self.outlet = None
+        self._is_init = False
+
+    @property
+    def is_init(self):
+        return self._is_init
+
+    def init(self,
+        name: str,
+        n_channels: int,
+        stream_id: str,
+        freq: int,
+        channel_format: int,
+        metadata: dict | None = None,
+    ):
+        """
+        Initialise a LSL stream
+
+        Args:
+            name: name of the stream
+            n_channels: number of channels per sample
+            channel_format: format/type of each channel (ex: string, int, ...)
+                            same format for each channel
+            stream_id: unique identifier of the stream
+            content_type: content type of stream. By convention LSL uses the content
+                types defined in the XDF file format specification where
+                applicable
+            freq: sampling rate in Hz
+
+        Return:
+            outlet: StreamOulet to push samples with LSL
+        """
+        if self._is_init:
+            return
+
+        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:
+            # Get xml object of the stream created earlier
+            xml_info = info.desc()
+            # Add meta data to xml object
+            for key, data in metadata.items():
+                xml_info.append_child_value(key, str(data))
+
+        self._is_init = True
+        self.outlet = StreamOutlet(info)
+
+    def push_sample(self, sample: list):
+        """Push a sample to the LSL stream if it is initialized."""
+        if not self._is_init:
+            # Don't do anything
+            return
+        self.outlet.push_sample(sample)  # type: ignore

{pyforcedaq-2.0.0.dev0 → pyforcedaq-2.0.1}/src/pyforcedaq/_lib/misc.py

@@ -1,6 +1,4 @@
-from os import listdir, path
-
-from .timer import get_time_ms
+from .clock import local_clock_ms
 
 
 def N2g(N):
@@ -9,9 +7,9 @@ def N2g(N):
 
 class MinMaxDetector(object):
 
-    def __init__(self, start_value, duration):
+    def __init__(self, start_value, duration_ms):
         self._minmax = [start_value, start_value]
-        self._duration = duration
+        self._duration_ms = duration_ms
         self._level_change_time = None
 
     def process(self, value):
@@ -19,7 +17,7 @@ class MinMaxDetector(object):
         level change has occurred, otherwise None"""
 
         if self._level_change_time is not None:
-            if (get_time_ms() - self._level_change_time) >= self._duration:
+            if (local_clock_ms() - self._level_change_time) >= self._duration_ms:
                 return tuple(self._minmax)
 
             if value > self._minmax[1]:
@@ -28,7 +26,7 @@ class MinMaxDetector(object):
                 self._minmax[0] = value
 
         elif self._minmax[0] != value: # level change just occurred
-            self._level_change_time = get_time_ms()
+            self._level_change_time = local_clock_ms()
             return self.process(value)
 
         return None
@@ -37,22 +35,33 @@ class MinMaxDetector(object):
     def is_sampling_for_minmax(self):
         """true true if currently sampling for minmax"""
         return (self._level_change_time is not None) and \
-               (get_time_ms() - self._level_change_time) < self._duration
-
-def find_calibration_file(calibration_folder, sensor_name,
-                          calibration_suffix=".cal"):
-
-    needle = 'Serial="{0}"'.format(sensor_name)
-    for x in listdir(path.abspath(calibration_folder)):
-        filename = path.join(calibration_folder, x)
-        if path.isfile(filename) and filename.endswith(calibration_suffix):
-            with open(filename, "r") as fl:
-                for l in fl:
-                    if l.find(needle)>0:
-                        return filename
-    raise RuntimeError("Can't find calibration file for sensor '{0}' : {1}.".format(
-        sensor_name, filename))
-
+               (local_clock_ms() - self._level_change_time) < self._duration_ms
+
+# def find_calibration_file(calibration_folder: str, sensor_name: str,
+#                           calibration_suffix=".cal") -> str:
+
+#     needle = 'Serial="{0}"'.format(sensor_name)
+#     calibration_files = []
+#     for x in listdir(path.abspath(calibration_folder)):
+#         filename = path.join(calibration_folder, x)
+#         if path.isfile(filename) and filename.endswith(calibration_suffix):
+#             with open(filename, "r") as fl:
+#                 for l in fl:
+#                     if l.find(needle)>0:
+#                         print("Found calibration file for sensor '{0}' : {1}.".format(
+#                             sensor_name, filename))
+#                         calibration_files.append(filename)
+
+#     if len(calibration_files) == 1:
+#         return calibration_files[0]
+#     elif len(calibration_files) > 1:
+#         print("Multiple calibration files found for sensor '{0}'".format(sensor_name))
+#         for f in calibration_files:
+#             print("  - {0}".format(f))
+#         print("Please ensure that only one calibration file exists for each sensor")
+#     else:
+#         print("No calibration file found for sensor '{0}'.".format(sensor_name))
+#     exit()
 
 #Sensor History with moving average filtering and distance, velocity
 class SensorHistory(object):

{pyforcedaq-2.0.0.dev0 → pyforcedaq-2.0.1}/src/pyforcedaq/_lib/polling_time_profile.py

@@ -1,26 +1,28 @@
 import numpy as np
 
-from .timer import get_time_ms
+from .clock import local_clock
 
 
 class PollingTimeProfile(object):
 
-    def __init__(self, timing_range=10):
+    def __init__(self, timing_range_ms=10):
         self._last = None
-        self._timing_range = 10
+        self._timing_range_ms = 10
         self._zero_cnt = 0
 
         #self._zero_time_polling_frequency = {}
-        self.profile_frequency = np.array([0] * (timing_range + 1))
+        self.profile_frequency = np.array([0] * (timing_range_ms + 1))
 
     def stop(self):
         self._last = None
 
-    def update(self, time_ms):
+    def update(self, time: float):
+
+        time_ms = int(time * 1000)
         if self._last is not None:
             d = time_ms - self._last
-            if d > self._timing_range:
-                d = self._timing_range
+            if d > self._timing_range_ms:
+                d = self._timing_range_ms
             self.profile_frequency[d] += 1
 
             #if d == 0:
@@ -35,7 +37,7 @@ class PollingTimeProfile(object):
         self._last = time_ms
 
     def tick(self):
-        self.update(get_time_ms())
+        self.update(local_clock())
 
     @property
     def profile_percent(self):