pyForceDAQ 2.0.1.dev1__tar.gz → 2.0.2__tar.gz

{pyforcedaq-2.0.1.dev1 → pyforcedaq-2.0.2}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.3
 Name: pyForceDAQ
-Version: 2.0.1.dev1
+Version: 2.0.2
 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.1.dev1 → pyforcedaq-2.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyForceDAQ"
-version = "2.0.1-dev1"
+version = "2.0.2"
 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.1.dev1 → pyforcedaq-2.0.2}/src/pyforcedaq/__init__.py

@@ -7,9 +7,8 @@ launch the GUI force from your Python program:
 ``
     from pyforcedaq import gui
 
-    gui.run(remote_control=False,
-              ask_filename=True,
-               calibration_file="FT_sensor1.cal")
+    gui.run(ask_filename=True,
+               calibration_file="FT_sensor1.cal") TODO
 ``
 
 
@@ -18,10 +17,6 @@ import relevant stuff to program your own force:
     from pyforcedaq import force
 ``
 
-import relevant stuff for remote control of the GUI force:
-``
-    from pyforcedaq import remote_control
-``
 
 For function to support data handling see the folder pyForceDAQ/analysis
 
@@ -35,8 +30,6 @@ __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(

{pyforcedaq-2.0.1.dev1 → pyforcedaq-2.0.2}/src/pyforcedaq/__main__.py

@@ -1,7 +1,6 @@
-
 import argparse
 
-from . import __author__, __version__, gui
+from . import __author__, __version__
 
 
 def cli():
@@ -24,17 +23,28 @@ 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",
+    )
+    print("+" + "-" * 23 + "+")
+    print(f"| pyforceDAQ {__version__}".ljust(24) + "|")
+    print("+" + "-" * 23 + "+")
+
     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()
 
-        from .gui import launcher
-        return launcher.run()
+        from .launcher import run_launcher
+        return run_launcher()
     else:
-        gui.run_settings(args.SETTINGS_FILE)
+        from .gui import run_settings_file
+        run_settings_file(args.SETTINGS_FILE)
 
 
 

{pyforcedaq-2.0.1.dev1/src/pyforcedaq/force → pyforcedaq-2.0.2/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.2/src/pyforcedaq/_lib/clock.py

@@ -0,0 +1,38 @@
+"""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.2/src/pyforcedaq/_lib/constants.py

@@ -0,0 +1,9 @@
+USE_MOCK_SENSOR = False # <-- change for usage in lab to False
+USE_PYDAQMX = False # <-- change to True to use pyDAQmx instead of nidaqmx, requires pyDAQmx installation
+USE_ATI_DLL = False # <-- change to True to use ATI DLL for calibration conversion, otherwise use atiiaftt
+
+SETTINGS_FILE_EXTENSION = ".settings.toml"
+DEFAULT_SETTINGS_FILE = "pyForceDAQ" + SETTINGS_FILE_EXTENSION
+DEFAULT_OUTPUT_FILENAME = None
+CALIBRATION_FOLDER = "calibration"
+DATA_FOLDER = "data"

{pyforcedaq-2.0.1.dev1/src/pyforcedaq/force → pyforcedaq-2.0.2/src/pyforcedaq/_lib}/data_recorder.py

@@ -7,15 +7,18 @@ __author__ = "Oliver Lindemann"
 import atexit
 import gzip
 import logging
+from io import TextIOWrapper
 from pathlib import Path
 from time import asctime, localtime, strftime
-
-from pyforcedaq._lib import timer
+from typing import List
 
 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_process import SensorProcess
+from .settings import RecordingSettings, SensorSettings
+from .types import (
     TAG_COMMENTS,
     TAG_DAQEVENT,
     TAG_UDPDATA,
@@ -24,20 +27,19 @@ 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 .udp_connection import UDPConnectionProcess
+
+_log.set_logging(data_directory="data", log_file="recording.log")
 
 NEWLINE = "\n"
 
 class DataRecorder(object):
     """handles multiple sensors and udp connection"""
 
-    def __init__(self, force_sensor_settings:SensorSettings | list,
-                 poll_udp_connection=False,
-                 write_deviceid = False,
-                 polling_priority:str | None = None):
+    def __init__(self,
+                 recording_settings: RecordingSettings,
+                 force_sensor_settings:SensorSettings | List[SensorSettings],
+                 poll_udp_connection: bool = False):
 
 
         """queue_data will be saved
@@ -47,13 +49,10 @@ class DataRecorder(object):
         {REALTIME} or {NORMAL} or None
         """
 
-        self._write_deviceid = write_deviceid
-
         if not isinstance(force_sensor_settings, list):
             force_sensor_settings = [force_sensor_settings]
-        # write forces and triggers as define in sensor1
-        self._write_forces = force_sensor_settings[0].array_write_forces()
-        self._write_trigger = force_sensor_settings[0].array_write_trigger()
+
+        self.recording_settings = recording_settings
 
         # create sensor processes
         self._force_sensor_processes =[]
@@ -62,7 +61,8 @@ class DataRecorder(object):
             if not isinstance(fs, SensorSettings):
                 raise RuntimeError("Recorder needs a list of Force Sensor Settings!")
             else:
-                fst = SensorProcess(settings = fs,
+                fst = SensorProcess(sensor_settings = fs,
+                                    recording_settings=recording_settings,
                                     pipe_buffered_data_after_pause=True)
                 fst.start()
                 event_trigger.append(fst.event_trigger)
@@ -70,20 +70,19 @@ class DataRecorder(object):
 
         # create udp connection process
         if poll_udp_connection:
-            self.udp = UDPConnectionProcess(event_trigger=event_trigger,
-                                            event_ignore_tag = RemoteCmd.COMMAND_STR)
+            self.udp = UDPConnectionProcess(event_trigger=event_trigger)
             self.udp.start()
         else:
             self.udp = None
 
-        # process managing
+        # process managing FIYME needed?
         self._proc_manager = ProcessPriorityManager()
         self._proc_manager.add_subprocess(self.udp)
         self._proc_manager.add_subprocess(self._force_sensor_processes)
-        if polling_priority is not None:
+        if self.recording_settings.priority is not None:
            level = PollingPriority.NORMAL
         else:
-            level = PollingPriority.get_priority(polling_priority)
+            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())
@@ -92,9 +91,13 @@ class DataRecorder(object):
         self._is_recording = False
         self._file = None
         self._daq_event = []
-        self.filename: str | None = None
+        self.path_open_file = Path("")
         atexit.register(self.quit)
 
+    @property
+    def is_saving_data(self):
+        """Property indicates whether a data file is open"""
+        return self._file is not None
 
     @property
     def is_alive(self):
@@ -149,16 +152,16 @@ class DataRecorder(object):
         buffer = []
         while True:
             try:
-                data = self.udp.receive_queue.get_nowait()
-            except:
+                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:
-            self._save_data(buffer)
+            self._write_data(buffer)
         return buffer
 
-    def _save_data(self, data_buffer: list,
+    def _write_data(self, data_buffer: list,
                    recording_screen=None,
                    float_decimal_places: int = 4) -> None:
         """ writes data to disk and set counters
@@ -168,18 +171,20 @@ class DataRecorder(object):
         #DOC output format
 
         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
         float_format = "{0:." + str(float_decimal_places) + "f},"
         buffer_len = len(data_buffer)
         for c, d in enumerate(data_buffer):
             if self._file is not None:
                 if isinstance(d, ForceSensorData):
                     line = f"{d.time}, {d.acquisition_delay},"
-                    if self._write_deviceid:
-                        line += f"{d.device_id},"
-                    for x in d.selected_forces(select=self._write_forces):
+                    if write_deviceid:
+                        line += f"{d.sensor_id},"
+                    for x in d.selected_forces(select=write_forces):
                         line += float_format.format(x)
-                    for x in d.selected_trigger(select=self._write_trigger):
+                    for x in d.selected_trigger(select=write_trigger):
                         if isinstance(x, int):
                             line += f"{x},"
                         else:
@@ -190,25 +195,27 @@ class DataRecorder(object):
                     self._file_write(f"{TAG_DAQEVENT},{d.time},{str(d.code)}" + NEWLINE)
 
                 elif isinstance(d, UDPData):
-                    if not d.is_remote_control_command:
-                        self._file_write(f"{TAG_UDPDATA},{d.time},{d.unicode}" + NEWLINE)
+                    self._file_write(f"{TAG_UDPDATA},{d.time},{d.unicode}" + NEWLINE)
 
             if recording_screen is not None and c % BLOCKSIZE == 0:
                 recording_screen.stimulus(
-                    "Writing {0} of {1} blocks".format(c//BLOCKSIZE,
+                    "Saving {0} of {1} blocks".format(c//BLOCKSIZE,
                                                        buffer_len//BLOCKSIZE)).present()
 
     def _file_write(self, s: str) -> None:
-        self._file.write(s.encode())
 
-    def save_daq_event(self, code, time: float | None = None) -> None:
+        if isinstance(self._file, gzip.GzipFile):
+            self._file.write(s.encode("utf-8"))
+        elif isinstance(self._file, TextIOWrapper):
+            self._file.write(s)
+
+
+    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
 
         """
-        if time is None:
-            time = app_clock.time
         self._daq_event.append(DAQEvents(time = time, code = code))
 
 
@@ -244,25 +251,31 @@ class DataRecorder(object):
 
         data = []
         if recording_screen is not None:
-            recording_screen.stimulus("writing data ...").present()
+            recording_screen.stimulus("").present()
 
         #pause polling
         for fsp in self._force_sensor_processes:
             fsp.pause_polling()
 
-        timer.wait(500)
+        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()
-            self._save_data(buffer, recording_screen)
+            self._write_data(buffer, recording_screen)
             data.extend(buffer)
 
         # udp event
         data.extend(self.process_and_write_udp_events())
 
         # soft trigger
-        self._save_data(self._daq_event)
+        self._write_data(self._daq_event)
         data.extend(self._daq_event)
         self._daq_event = []
         return data
@@ -288,12 +301,11 @@ class DataRecorder(object):
         for x in self._force_sensor_processes:
             x.event_bias_is_available.wait()
 
-    def open_data_file(self, filename: str,
+    def open_data_file(self,
+                       filename: str | Path,
                        subdirectory: str = "data",
-                       time_stamp_filename: bool = False,
                        varnames: bool = True,
-                       comment_line: str = "",
-                       zipped: bool = False) -> Path:
+                       comment_line: str = "") -> Path:
         """Create a data file
 
         Only if data file has been opened, data will be saved!
@@ -311,9 +323,6 @@ class DataRecorder(object):
             write variable names in first line of data output
         comment_line : string, optional
             add some comments at the beginning of the data output file
-        zippers : boolean, optional
-            are the data zipped or not. Note: Saving zipped data after pause
-            takes much longer.
 
         Returns
         -------
@@ -321,68 +330,57 @@ class DataRecorder(object):
                 full path the actually used file (incl. timestamp)
 
         """
-        data_dir = Path.cwd() / subdirectory
-        data_dir.mkdir(exist_ok=True)
         self.close_data_file()
 
-        if filename is None or len(filename) == 0:
-            filename = "daq_recording.csv"
-
-        if zipped:
-            suffix = ".gz"
+        # create filename
+        data_dir = Path.cwd() / subdirectory
+        data_dir.mkdir(exist_ok=True)
+        if self.recording_settings.zip_data:
+            filename = Path(filename).with_suffix(".csv.gz")
         else:
-            suffix = ""
+            filename = Path(filename).with_suffix(".csv")
 
-        cnt = 0
         while True:
-            flname = filename
-            if cnt>0:
-                x = flname.find(".")
-                if x<0:
-                    x = len(flname)
-                flname = flname[:x] + "_{0}".format(cnt) + flname[x:]
-
-            if time_stamp_filename:
-                self.filename = flname + "_" + \
-                        strftime("%Y%m%d%H%M", localtime()) + suffix
-            else:
-                self.filename = flname + suffix
-
-            full_path_file = data_dir / self.filename
-            if full_path_file.is_file():
+            self.path_open_file = data_dir / filename
+            if self.path_open_file.is_file():
                 # print "data file already exists, adding counter"
-                cnt += 1
+                filename = Path(filename.stem + "_" + strftime("%m%d%H%M", localtime()) + \
+                                filename.suffix)
             else:
                 break
 
-        if zipped:
-            self._file = gzip.open(full_path_file, 'w+')
+        if self.recording_settings.zip_data:
+            self._file = gzip.open(self.path_open_file, 'w')
         else:
-            self._file = open(full_path_file, 'w+')
-        print("Data file: {}".format(full_path_file))
+            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))
-        logging.info("new file: {}".format(filename))
+        logging.info("new file: {}".format(self.path_open_file))
 
         for s in self.sensor_settings_list:
-            txt = " Sensor: id={0}, name={1}, cal-file={2}\n".format(s.device_id,
-                                s.sensor_name, s.calibration_file)
+            txt = f" Sensor: label={s.device_label}, cal-file={s.calibration_file}\n"
             self._file_write(TAG_COMMENTS + txt)
 
         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
             line = "time,delay,"
-            if self._write_deviceid: line += "device_tag,"
+            if write_deviceid:
+                line += "device_tag,"
             for x in range(6):
-                if self._write_forces[x]:
+                if write_forces[x]:
                     line += ForceSensorData.forces_names[x] + ","
-            if self._write_trigger[0]: line += "trigger1,"
-            if self._write_trigger[1]: line += "trigger2,"
+            if write_trigger[0]: line += "trigger1,"
+            if write_trigger[1]: line += "trigger2,"
             self._file_write(line[:-1] + NEWLINE)
 
-        return full_path_file
+        return self.path_open_file
 
     def close_data_file(self) -> None:
         """Close the data file
@@ -394,3 +392,4 @@ class DataRecorder(object):
         if self._file is not None:
             self._file.close()
             self._file = None
+            self.path_open_file = Path("")

pyforcedaq-2.0.2/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