spikesafe-python 1.13.5__tar.gz → 1.15.8__tar.gz

{spikesafe_python-1.13.5/spikesafe_python.egg-info → spikesafe_python-1.15.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spikesafe-python
-Version: 1.13.5
+Version: 1.15.8
 Summary: SpikeSafe Python Library
 Author-email: Vektrex <support@vektrex.com>
 Classifier: Programming Language :: Python :: 3

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spikesafe-python"
-version = "1.13.5"
+version = "1.15.8"
 authors = [
   { name="Vektrex", email="support@vektrex.com" },
 ]

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/Compensation.py

@@ -3,6 +3,7 @@ import jsonschema
 from jsonschema import validate
 import logging
 import os
+from ._deprecation import deprecated
 from .SpikeSafeEnums import LoadImpedance, RiseTime
 
 log = logging.getLogger(__name__)
@@ -551,6 +552,10 @@ class Compensation:
             #           f"for device_type: {device_type}, max current: {max_current}")
 
 
+@deprecated(
+    "get_optimum_compensation is deprecated; "
+    "use Compensation.get_optimum_compensation() instead."
+    )
 def get_optimum_compensation(
     spikesafe_model_max_current_amps: float,
     set_current_amps: float,
@@ -558,10 +563,14 @@ def get_optimum_compensation(
     enable_logging: bool = False
 ) -> tuple[LoadImpedance, RiseTime]:
     """
-    Obsolete: Use Compensation.get_optimum_compensation() instead.
+    Deprecated: Use Compensation.get_optimum_compensation() instead.
     """
     return Compensation.get_optimum_compensation(spikesafe_model_max_current_amps, set_current_amps, pulse_on_time_seconds, enable_logging)
 
+@deprecated(
+    "get_custom_compensation is deprecated; "
+    "use Compensation.get_custom_compensation() instead."
+    )
 def get_custom_compensation(
     spikesafe_model_max_current_amps: float,
     set_current_amps: float,
@@ -571,18 +580,26 @@ def get_custom_compensation(
     enable_logging: bool = False
 ) -> tuple[LoadImpedance, RiseTime]:
     """
-    Obsolete: Use Compensation.get_custom_compensation() instead.
+    Deprecated: Use Compensation.get_custom_compensation() instead.
     """
     return Compensation.get_custom_compensation(spikesafe_model_max_current_amps, set_current_amps, device_type, custom_compensation_table, pulse_on_time_seconds, enable_logging)
 
+@deprecated(
+    "load_custom_compensation_table is deprecated; "
+    "use Compensation.load_custom_compensation_table() instead."
+    )
 def load_custom_compensation_table(file_path: str) -> list[dict]:
     """
-    Obsolete: Use Compensation.load_custom_compensation_table() instead.
+    Deprecated: Use Compensation.load_custom_compensation_table() instead.
     """
     return Compensation.load_custom_compensation_table(file_path)
 
+@deprecated(
+    "load_custom_compensation_unique_device_types is deprecated; "
+    "use Compensation.load_custom_compensation_unique_device_types() instead."
+    )
 def load_custom_compensation_unique_device_types(custom_compensation_table: list[dict]) -> list[str]:
     """
-    Obsolete: Use Compensation.load_custom_compensation_unique_device_types() instead.
+    Deprecated: Use Compensation.load_custom_compensation_unique_device_types() instead.
     """
     return Compensation.load_custom_compensation_unique_device_types(custom_compensation_table)

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/DigitizerDataFetch.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 import sys
 import logging
 import time
+from ._deprecation import deprecated
 from .DigitizerData import DigitizerData
 from .DigitizerEnums import TimeSamplingMode, SamplingMode
 from .DigitizerVfCustomSequence import DigitizerVfCustomSequence
@@ -31,8 +32,8 @@ class DigitizerDataFetch:
         Returns an array of voltage readings using custom sampling mode from the digitizer obtained through a fetch query.
     wait_for_new_voltage_data(spike_safe_socket: TcpSocket, wait_time: float = 0.0, enable_logging: bool | None = None, timeout: float | None = None, digitizer_number: int | None = None) -> None
         Queries the SpikeSafe PSMU digitizer until it responds that it has acquired new data.
-    get_new_voltage_data_estimated_complete_time(aperture_microseconds: int, reading_count: int, hardware_trigger_count: int | None = None, hardware_trigger_delay_microseconds: int | None = None) -> float
-        Returns the estimated minimum possible time in seconds it will take for the SpikeSafe PSMU digitizer to acquire new voltage readings. If hardware triggering is used, this does not take into account the pulse period, so the actual time may be longer.
+    get_new_voltage_data_estimated_complete_time(aperture_microseconds: int, reading_count: int, hardware_trigger_count: int | None = None, hardware_trigger_delay_microseconds: int | None = None, pulse_period_seconds: float | None = None) -> float
+        Returns the estimated minimum possible time in seconds it will take for the SpikeSafe PSMU digitizer to acquire new voltage readings.
     """
     @staticmethod
     def fetch_voltage_data(
@@ -355,10 +356,11 @@ class DigitizerDataFetch:
         aperture_microseconds: int,
         reading_count: int,
         hardware_trigger_count: int | None = None,
-        hardware_trigger_delay_microseconds: int | None = None
+        hardware_trigger_delay_microseconds: int | None = None,
+        pulse_period_seconds: float | None = None
     ) -> float:
         """
-        Returns the estimated minimum possible time it will take for the SpikeSafe PSMU digitizer to acquire new voltage readings. If hardware triggering is used, this does not take into account the pulse period, so the actual time may be longer.
+        Returns the estimated minimum possible time it will take for the SpikeSafe PSMU digitizer to acquire new voltage readings.
 
         Parameters
         ----------
@@ -374,6 +376,9 @@ class DigitizerDataFetch:
         hardware_trigger_delay_microseconds : int, optional
             Delay in microseconds between each hardware trigger
 
+        pulse_period_seconds : float, optional
+            Pulse period in seconds. If not provided, the Digitizer minimum retrigger time of 600us is used for multiple hardware triggers.
+
         Returns
         -------
         float
@@ -390,13 +395,20 @@ class DigitizerDataFetch:
         if hardware_trigger_delay_microseconds is None:
             hardware_trigger_delay_microseconds = 0  # Default value if not provided
 
+        trigger_delay_seconds = hardware_trigger_delay_microseconds / 1_000_000.0
+        acquisition_time_seconds = (aperture_microseconds * reading_count) / 1_000_000.0
+
         if hardware_trigger_count == 1:
-            # 𝑀𝑖𝑛𝑖𝑚𝑢𝑚 𝑇𝑜𝑡𝑎𝑙 𝐴𝑐𝑞𝑢𝑖𝑠𝑖𝑡𝑖𝑜𝑛 𝑇𝑖𝑚𝑒 = 𝑇𝑟𝑖𝑔𝑔𝑒𝑟 𝐶𝑜𝑢𝑛𝑡 (𝑇𝑟𝑖𝑔𝑔𝑒𝑟 𝐷𝑒𝑙𝑎𝑦+𝐴𝑝𝑒𝑟𝑡𝑢𝑟𝑒 𝑇𝑖𝑚𝑒×𝑅𝑒𝑎𝑑𝑖𝑛𝑔 𝐶𝑜𝑢𝑛𝑡)
-            estimated_complete_time_seconds = (hardware_trigger_count * (hardware_trigger_delay_microseconds + aperture_microseconds * reading_count)) / 1_000_000.0
+            estimated_complete_time_seconds = trigger_delay_seconds + acquisition_time_seconds
         else:
-            retrigger_time_microseconds = 600
-            # 𝑀𝑖𝑛𝑖𝑚𝑢𝑚 𝑇𝑜𝑡𝑎𝑙 𝐴𝑐𝑞𝑢𝑖𝑠𝑖𝑡𝑖𝑜𝑛 𝑇𝑖𝑚𝑒 = 𝑇𝑟𝑖𝑔𝑔𝑒𝑟 𝐶𝑜𝑢𝑛𝑡 (𝑇𝑟𝑖𝑔𝑔𝑒𝑟 𝐷𝑒𝑙𝑎𝑦 + Retrigger Time + 𝐴𝑝𝑒𝑟𝑡𝑢𝑟𝑒 𝑇𝑖𝑚𝑒 × 𝑅𝑒𝑎𝑑𝑖𝑛𝑔 𝐶𝑜𝑢𝑛𝑡) - Retrigger Time (ignore time last trigger)
-            estimated_complete_time_seconds = (hardware_trigger_count * (hardware_trigger_delay_microseconds + retrigger_time_microseconds + aperture_microseconds * reading_count) - retrigger_time_microseconds) / 1_000_000.0
+            digitizer_minimum_retrigger_time_seconds = 0.000600
+            effective_trigger_spacing_seconds = digitizer_minimum_retrigger_time_seconds
+            if pulse_period_seconds is not None and pulse_period_seconds > digitizer_minimum_retrigger_time_seconds:
+                effective_trigger_spacing_seconds = pulse_period_seconds
+
+            # Do not add trigger spacing after the final trigger.
+            estimated_complete_time_seconds = hardware_trigger_count * (trigger_delay_seconds + effective_trigger_spacing_seconds + acquisition_time_seconds) - effective_trigger_spacing_seconds
+
         # wait time cannot be less than 0s
         estimated_complete_time_seconds = max(estimated_complete_time_seconds, 0)
 
@@ -550,17 +562,24 @@ class DigitizerDataFetch:
                 # Regular sample
                 return accumulated_time_since_start + aperture
             
-
+@deprecated(
+    "fetch_voltage_data is deprecated; "
+    "use DigitizerDataFetch.fetch_voltage_data() instead."
+    )
 def fetch_voltage_data(
     spike_safe_socket: TcpSocket,
     enable_logging: bool | None = None,
     digitizer_number: int | None = None
 ) -> list[DigitizerData]:
     """
-    Obsolete: Use DigitizerDataFetch.fetch_voltage_data() instead.
+    Deprecated: Use DigitizerDataFetch.fetch_voltage_data() instead.
     """
     return DigitizerDataFetch.fetch_voltage_data(spike_safe_socket, enable_logging, digitizer_number=digitizer_number)
 
+@deprecated(
+    "fetch_voltage_data_sampling_mode_linear is deprecated; "
+    "use DigitizerDataFetch.fetch_voltage_data_sampling_mode_linear() instead."
+    )
 def fetch_voltage_data_sampling_mode_linear(
     spike_safe_socket: TcpSocket,
     time_sampling_mode: TimeSamplingMode,
@@ -572,10 +591,14 @@ def fetch_voltage_data_sampling_mode_linear(
     digitizer_number: int | None = None
 ) -> list[DigitizerData]:
     """
-    Obsolete: Use DigitizerDataFetch.fetch_voltage_data_sampling_mode_linear() instead.
+    Deprecated: Use DigitizerDataFetch.fetch_voltage_data_sampling_mode_linear() instead.
     """
     return DigitizerDataFetch.fetch_voltage_data_sampling_mode_linear(spike_safe_socket, time_sampling_mode, aperture_microseconds, reading_count, hardware_trigger_delay_microseconds, pulse_period_seconds, enable_logging, digitizer_number=digitizer_number)
 
+@deprecated(
+    "fetch_voltage_data_sampling_mode_logarithmic is deprecated; "
+    "use DigitizerDataFetch.fetch_voltage_data_sampling_mode_logarithmic() instead."
+    )
 def fetch_voltage_data_sampling_mode_logarithmic(
     spike_safe_socket: TcpSocket,
     time_sampling_mode: TimeSamplingMode,
@@ -585,10 +608,14 @@ def fetch_voltage_data_sampling_mode_logarithmic(
     digitizer_number: int | None = None
 ) -> list[DigitizerData]:
     """
-    Obsolete: Use DigitizerDataFetch.fetch_voltage_data_sampling_mode_logarithmic() instead.
+    Deprecated: Use DigitizerDataFetch.fetch_voltage_data_sampling_mode_logarithmic() instead.
     """
     return DigitizerDataFetch.fetch_voltage_data_sampling_mode_logarithmic(spike_safe_socket, time_sampling_mode, sampling_mode, hardware_trigger_delay_microseconds, enable_logging, digitizer_number=digitizer_number)
 
+@deprecated(
+    "fetch_voltage_data_sampling_mode_custom is deprecated; "
+    "use DigitizerDataFetch.fetch_voltage_data_sampling_mode_custom() instead."
+    )
 def fetch_voltage_data_sampling_mode_custom(
     spike_safe_socket: TcpSocket,
     time_sampling_mode: TimeSamplingMode,
@@ -598,21 +625,30 @@ def fetch_voltage_data_sampling_mode_custom(
     digitizer_number: int | None = None
 ) -> list[DigitizerData]:
     """
-    Obsolete: Use DigitizerDataFetch.fetch_voltage_data_sampling_mode_custom() instead.
+    Deprecated: Use DigitizerDataFetch.fetch_voltage_data_sampling_mode_custom() instead.
     """
     return DigitizerDataFetch.fetch_voltage_data_sampling_mode_custom(spike_safe_socket, time_sampling_mode, custom_sequence, hardware_trigger_delay_microseconds, enable_logging, digitizer_number=digitizer_number)
 
+@deprecated(
+    "get_new_voltage_data_estimated_complete_time is deprecated; "
+    "use DigitizerDataFetch.get_new_voltage_data_estimated_complete_time() instead."
+    )
 def get_new_voltage_data_estimated_complete_time(
     aperture_microseconds: int,
     reading_count: int,
     hardware_trigger_count: int | None = None,
-    hardware_trigger_delay_microseconds: int | None = None
+    hardware_trigger_delay_microseconds: int | None = None,
+    pulse_period_seconds: float | None = None
 ) -> float:
     """
-    Obsolete: Use DigitizerDataFetch.get_new_voltage_data_estimated_complete_time() instead.
+    Deprecated: Use DigitizerDataFetch.get_new_voltage_data_estimated_complete_time() instead.
     """
-    return DigitizerDataFetch.get_new_voltage_data_estimated_complete_time(aperture_microseconds, reading_count, hardware_trigger_count, hardware_trigger_delay_microseconds)
+    return DigitizerDataFetch.get_new_voltage_data_estimated_complete_time(aperture_microseconds, reading_count, hardware_trigger_count, hardware_trigger_delay_microseconds, pulse_period_seconds)
 
+@deprecated(
+    "wait_for_new_voltage_data is deprecated; "
+    "use DigitizerDataFetch.wait_for_new_voltage_data() instead."
+    )
 def wait_for_new_voltage_data(
     spike_safe_socket: TcpSocket,
     wait_time: float = 0.010,
@@ -621,6 +657,6 @@ def wait_for_new_voltage_data(
     digitizer_number: int | None = None
 ) -> None:
     """
-    Obsolete: Use DigitizerDataFetch.wait_for_new_voltage_data() instead.
+    Deprecated: Use DigitizerDataFetch.wait_for_new_voltage_data() instead.
     """
     return DigitizerDataFetch.wait_for_new_voltage_data(spike_safe_socket, wait_time, enable_logging, timeout, digitizer_number=digitizer_number)

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/Discharge.py

@@ -1,4 +1,6 @@
 import time
+
+from ._deprecation import deprecated
 from .SpikeSafeInfo import SpikeSafeInfo
 from .TcpSocket import TcpSocket
 from .Threading import wait
@@ -97,9 +99,13 @@ class Discharge:
             # when Discharge Complete query is not supported, use a calculated wait time
             wait_time = Discharge.get_spikesafe_channel_discharge_time(compliance_voltage + 35) # 35V gives extra time, some windows pcs return early from wait function
             wait(wait_time)
-
+            
+@deprecated(
+    "get_spikesafe_channel_discharge_time is deprecated; "
+    "use Discharge.get_spikesafe_channel_discharge_time() instead."
+    )
 def get_spikesafe_channel_discharge_time(compliance_voltage: float) -> float:
     """
-    Obsolete: use Discharge.get_spikesafe_channel_discharge_time instead
+    Deprecated: use Discharge.get_spikesafe_channel_discharge_time instead
     """
     return Discharge.get_spikesafe_channel_discharge_time(compliance_voltage)

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/MemoryTableReadData.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 import logging
 import math
+from ._deprecation import deprecated
 from .ChannelData import ChannelData
 from .TcpSocket import TcpSocket
 from .TemperatureData import TemperatureData
@@ -203,8 +204,12 @@ class MemoryTableReadData:
         data = spike_safe_socket.read_data()                # read SpikeSafe memory table
         log.info(data)
 
+@deprecated(
+    "log_memory_table_read is deprecated; "
+    "use MemoryTableReadData.log_memory_table_read() instead."
+    )
 def log_memory_table_read(spike_safe_socket: TcpSocket) -> None:
     """
-    Obsolete: Use MemoryTableReadData.log_memory_table_read(spike_safe_socket) instead.
+    Deprecated: Use MemoryTableReadData.log_memory_table_read(spike_safe_socket) instead.
     """
     return MemoryTableReadData.log_memory_table_read(spike_safe_socket)

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/Precision.py

@@ -1,5 +1,6 @@
 
 from __future__ import annotations
+from ._deprecation import deprecated
 
 class Precision:
     """
@@ -203,63 +204,102 @@ class Precision:
         else:
             return f'{current_amps:.4f}'
         
-
+@deprecated(
+    "get_precise_compliance_voltage_command_argument is deprecated; "
+    "use Precision.get_precise_compliance_voltage_command_argument() instead."
+    )
 def get_precise_compliance_voltage_command_argument(compliance_voltage: float) -> str:
     """
-    Obsolete: use Precision.get_precise_compliance_voltage_command_argument instead.
+    Deprecated: use Precision.get_precise_compliance_voltage_command_argument instead.
     """
     return Precision.get_precise_compliance_voltage_command_argument(compliance_voltage)
 
+@deprecated(
+    "get_precise_voltage_protection_ramp_dv_command_argument is deprecated; "
+    "use Precision.get_precise_voltage_protection_ramp_dv_command_argument() instead."
+    )
 def get_precise_voltage_protection_ramp_dv_command_argument(voltage_protection_ramp_dv: float) -> str:
     """
-    Obsolete: use Precision.get_precise_voltage_protection_ramp_dv_command_argument instead.
+    Deprecated: use Precision.get_precise_voltage_protection_ramp_dv_command_argument instead.
     """
     return Precision.get_precise_voltage_protection_ramp_dv_command_argument(voltage_protection_ramp_dv)
 
+@deprecated(
+    "get_precise_voltage_protection_ramp_dt_command_argument is deprecated; "
+    "use Precision.get_precise_voltage_protection_ramp_dt_command_argument() instead."
+    )
 def get_precise_voltage_protection_ramp_dt_command_argument(voltage_protection_ramp_dt: float) -> str:
     """
-    Obsolete: use Precision.get_precise_voltage_protection_ramp_dt_command_argument instead.
+    Deprecated: use Precision.get_precise_voltage_protection_ramp_dt_command_argument instead.
     """
     return Precision.get_precise_voltage_protection_ramp_dt_command_argument(voltage_protection_ramp_dt)
 
+@deprecated(
+    "get_precise_pulse_width_offset_command_argument is deprecated; "
+    "use Precision.get_precise_pulse_width_offset_command_argument() instead."
+    )
 def get_precise_pulse_width_offset_command_argument(pulse_width_offset: float) -> str:
     """
-    Obsolete: use Precision.get_precise_pulse_width_offset_command_argument instead.
+    Deprecated: use Precision.get_precise_pulse_width_offset_command_argument instead.
     """
     return Precision.get_precise_pulse_width_offset_command_argument(pulse_width_offset)
 
+@deprecated(
+    "get_precise_pulse_width_correction_command_argument is deprecated; "
+    "use Precision.get_precise_pulse_width_correction_command_argument() instead."
+    )
 def get_precise_pulse_width_correction_command_argument(pulse_width_correction: float) -> str:
     """
-    Obsolete: use Precision.get_precise_pulse_width_correction_command_argument instead.
+    Deprecated: use Precision.get_precise_pulse_width_correction_command_argument instead.
     """
     return Precision.get_precise_pulse_width_correction_command_argument(pulse_width_correction)
 
+@deprecated(
+    "get_precise_duty_cycle_command_argument is deprecated; "
+    "use Precision.get_precise_duty_cycle_command_argument() instead."
+    )
 def get_precise_duty_cycle_command_argument(duty_cycle: float) -> str:
     """
-    Obsolete: use Precision.get_precise_duty_cycle_command_argument instead.
+    Deprecated: use Precision.get_precise_duty_cycle_command_argument instead.
     """
     return Precision.get_precise_duty_cycle_command_argument(duty_cycle)
 
+@deprecated(
+    "get_precise_time_command_argument is deprecated; "
+    "use Precision.get_precise_time_command_argument() instead."
+    )
 def get_precise_time_command_argument(time_seconds: float) -> str:
     """
-    Obsolete: use Precision.get_precise_time_command_argument instead.
+    Deprecated: use Precision.get_precise_time_command_argument instead.
     """
     return Precision.get_precise_time_command_argument(time_seconds)
 
+@deprecated(
+    "get_precise_time_milliseconds_command_argument is deprecated; "
+    "use Precision.get_precise_time_milliseconds_command_argument() instead."
+    )
 def get_precise_time_milliseconds_command_argument(time_milliseconds: float) -> str:
     """
-    Obsolete: use Precision.get_precise_time_milliseconds_command_argument instead.
+    Deprecated: use Precision.get_precise_time_milliseconds_command_argument instead.
     """
     return Precision.get_precise_time_milliseconds_command_argument(time_milliseconds)
 
+@deprecated(
+    "get_precise_time_microseconds_command_argument is deprecated; "
+    "use Precision.get_precise_time_microseconds_command_argument() instead."
+    )
 def get_precise_time_microseconds_command_argument(time_microseconds: float) -> str:
     """
-    Obsolete: use Precision.get_precise_time_microseconds_command_argument instead.
+    Deprecated: use Precision.get_precise_time_microseconds_command_argument instead.
     """
     return Precision.get_precise_time_microseconds_command_argument(time_microseconds)
 
+@deprecated(
+    "get_precise_current_command_argument is deprecated; "
+    "use Precision.get_precise_current_command_argument() instead."
+    )
 def get_precise_current_command_argument(current_amps: float) -> str:
     """
-    Obsolete: use Precision.get_precise_current_command_argument instead.
+    Deprecated: use Precision.get_precise_current_command_argument instead.
     """
     return Precision.get_precise_current_command_argument(current_amps)

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/PulseWidthCorrection.py

@@ -1,3 +1,5 @@
+from ._deprecation import deprecated
+
 from .SpikeSafeEnums import LoadImpedance, RiseTime
 from .SpikeSafeInfo import SpikeSafeInfo
 
@@ -2617,7 +2619,11 @@ class PulseWidthCorrection:
         }
 
         return table
-    
+
+@deprecated(
+    "get_optimum_pulse_width_correction is deprecated; "
+    "use PulseWidthCorrection.get_optimum_pulse_width_correction() instead."
+    )
 def get_optimum_pulse_width_correction(
     spikesafe_model_max_current_amps: float,
     set_current_amps: float,
@@ -2625,7 +2631,7 @@ def get_optimum_pulse_width_correction(
     rise_time: RiseTime
 ) -> str:
     """
-    Obsolete: use PulseWidthCorrection.get_optimum_pulse_width_correction() instead
+    Deprecated: use PulseWidthCorrection.get_optimum_pulse_width_correction() instead.
     """
     spikesafe_info = SpikeSafeInfo()
     spikesafe_info.maximum_pulse_width_correction_override = 9

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/ReadAllEvents.py

@@ -8,6 +8,8 @@
 from __future__ import annotations
 import logging
 import time
+
+from ._deprecation import deprecated
 from .EventData import EventData
 from .SpikeSafeError import SpikeSafeError
 from .TcpSocket import TcpSocket
@@ -179,8 +181,15 @@ class ReadAllEvents:
             raise
 
     @staticmethod
+    @deprecated(
+    "ReadAllEvents.log_all_events is deprecated; "
+    "use ReadAllEvents.read_all_events(spike_safe_socket, enable_logging=True) instead."
+    )
     def log_all_events(spike_safe_socket: TcpSocket) -> None:
-        """Reads all SpikeSafe events from event queue and prints them to the log file
+        """
+        Deprecated: Use ReadAllEvents.read_all_events(spike_safe_socket, enable_logging=True) instead.
+
+        Reads all SpikeSafe events from event queue and prints them to the log file
 
         Parameters
         ----------
@@ -193,29 +202,41 @@ class ReadAllEvents:
         """
         event_data = ReadAllEvents.read_all_events(spike_safe_socket)   # read all events in SpikeSafe event queue and store in list
         for event in event_data:                        # print all SpikeSafe events to the log file
-            log.info(event.event)                                                                             
+            log.info(event.event)
 
+@deprecated(
+    "ReadAllEvents.read_all_events is deprecated; "
+    "use ReadAllEvents.read_all_events(spike_safe_socket, enable_logging) instead."
+    )
 def read_all_events(
         spike_safe_socket: TcpSocket,
         enable_logging: bool | None = None
     ) -> list[EventData]:
     """
-    Obsolete: Use ReadAllEvents.read_all_events instead.
+    Deprecated: Use ReadAllEvents.read_all_events(spike_safe_socket, enable_logging) instead.
     """
     return ReadAllEvents.read_all_events(spike_safe_socket, enable_logging)
 
+@deprecated(
+    "ReadAllEvents.read_until_event is deprecated; "
+    "use ReadAllEvents.read_until_event(spike_safe_socket, code, enable_logging, timeout) instead."
+    )
 def read_until_event(
         spike_safe_socket: TcpSocket,
         code: int,
         enable_logging: bool | None = None
     ) -> list[EventData]:
     """
-    Obsolete: Use ReadAllEvents.read_until_event instead.
+    Deprecated: Use ReadAllEvents.read_until_event(spike_safe_socket, code, enable_logging, timeout) instead.
     """
     return ReadAllEvents.read_until_event(spike_safe_socket, code, enable_logging)
 
+@deprecated(
+    "ReadAllEvents.log_all_events is deprecated; "
+    "use ReadAllEvents.read_all_events(spike_safe_socket, enable_logging=True) instead."
+    )
 def log_all_events(spike_safe_socket: TcpSocket) -> None:
     """
-    Obsolete: Use ReadAllEvents.log_all_events instead.
+    Deprecated: Use ReadAllEvents.read_all_events(spike_safe_socket, enable_logging=True) instead.
     """
     ReadAllEvents.log_all_events(spike_safe_socket)

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/ScpiFormatter.py

@@ -1,3 +1,5 @@
+from ._deprecation import deprecated
+
 class ScpiFormatter:
     """
     Class for formatting SCPI command arguments.
@@ -49,15 +51,23 @@ class ScpiFormatter:
             return 'ON'
         else:
             return 'OFF'
-            
+
+@deprecated(
+    "get_scpi_format_integer_for_bool is deprecated; "
+    "use ScpiFormatter.get_scpi_format_integer_for_bool() instead."
+    )         
 def get_scpi_format_integer_for_bool(bool_value: bool) -> int:
     """
-    Obsolete: Use ScpiFormatter.get_scpi_format_integer_for_bool() instead.
+    Deprecated: Use ScpiFormatter.get_scpi_format_integer_for_bool() instead.
     """
     return ScpiFormatter.get_scpi_format_integer_for_bool(bool_value)
-     
+
+@deprecated(
+    "get_scpi_format_on_state_for_bool is deprecated; "
+    "use ScpiFormatter.get_scpi_format_on_state_for_bool() instead."
+    )        
 def get_scpi_format_on_state_for_bool(bool_value: bool) -> str:
     """
-    Obsolete: Use ScpiFormatter.get_scpi_format_on_state_for_bool() instead.
+    Deprecated: Use ScpiFormatter.get_scpi_format_on_state_for_bool() instead.
     """
     return ScpiFormatter.get_scpi_format_on_state_for_bool(bool_value)

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/SpikeSafeEvents.py

@@ -185,3 +185,6 @@ class SpikeSafeEvents(IntEnum):
     INVALID_VOLTAGE_PROTECTION_MODE = 600
     INVALID_STAIRCASE_SWEEP_ON_TIME = 602
     INVALID_STAIRCASE_SWEEP_STEP_COUNT = 603
+    INVALID_CURRENT_RAMP_RATE_SETTINGS = 604
+    BIAS_CURRENT_SETTING_IS_ONLY_ALLOWED_IN_BIAS_MODE_ON_CHANNEL_1 = 605
+    INVALID_PULSE_TIME_WITH_PULSE_CORRECTION_VALUE = 606

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/SpikeSafeInfoParser.py

@@ -1,3 +1,4 @@
+from ._deprecation import deprecated
 from .DigitizerInfo import DigitizerInfo
 from .SpikeSafeInfo import SpikeSafeInfo
 from .TcpSocket import TcpSocket
@@ -58,12 +59,11 @@ class SpikeSafeInfoParser:
         # Requires Release 3.12.9 (or Ethernet Processor must be 3.0.11.10 or later) to support Multiple digitizers, else:
         supports_multiple_digitizers = SpikeSafeInfoParser.compare_rev_version(spikesafe_info.version, "3.0.11.10")
         if supports_multiple_digitizers:
-            spike_safe_socket.send_scpi_command('DIGI:FUNC:CARD:NUMB?')
-            digitizer_functioning_card_number_list = spike_safe_socket.read_data(enable_logging)
-            digitizer_functioning_card_number_list = digitizer_functioning_card_number_list.split(",")
+            digitizer_functioning_card_number_list = SpikeSafeInfoParser._query_int_list(spike_safe_socket, 'DIGI:FUNC:CARD:NUMB?', enable_logging)
+            digitizer_functioning_card_number_list = [card_number for card_number in digitizer_functioning_card_number_list if card_number > 0]
 
             for digitizer_functioning_card_number in digitizer_functioning_card_number_list:
-                SpikeSafeInfoParser._fetch_digitizer_info(spike_safe_socket, spikesafe_info, digitizer_functioning_card_number, enable_logging)
+                SpikeSafeInfoParser._fetch_digitizer_info(spike_safe_socket, spikesafe_info, str(digitizer_functioning_card_number), enable_logging)
 
             spikesafe_info.has_digitizer = len(spikesafe_info.digitizer_infos) > 0
         else: 
@@ -361,8 +361,12 @@ class SpikeSafeInfoParser:
         ref_parts = list(map(int, ref_version.split('.')))
         return rev_parts >= ref_parts
 
+@deprecated(
+    "parse_spikesafe_info is deprecated; "
+    "use SpikeSafeInfoParser.parse_spikesafe_info() instead."
+    )
 def parse_spikesafe_info(spike_safe_socket: TcpSocket, enable_logging: bool | None = None) -> SpikeSafeInfo:
     """
-    Obsolete: use SpikeSafeInfoParser.parse_spikesafe_info() instead
+    Deprecated: use SpikeSafeInfoParser.parse_spikesafe_info() instead
     """
-    return SpikeSafeInfoParser.parse_spikesafe_info(spike_safe_socket, enable_logging)
+    return SpikeSafeInfoParser.parse_spikesafe_info(spike_safe_socket, enable_logging)

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/TcpSocket.py

@@ -67,11 +67,14 @@ class TcpSocket:
             self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)          
             self.tcp_socket.settimeout(2)
             self.tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 512)
+            
+            # disable nagel to reduce ACK calls and improve overall script timing
+            self.tcp_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
 
             if (self.enable_logging):
                 log.log(self.default_log_level, self.__get_formatted_log_message__('Connecting...'))
 
-            self.tcp_socket.connect((ip_address, port_number))                           
+            self.tcp_socket.connect((ip_address, port_number))
         except Exception as err:
             # print any error to the log file and raise error to function caller
             log.error('Error connecting to socket at {}: {}'.format(ip_address, err))   

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python/Threading.py

@@ -1,4 +1,5 @@
 import time
+from ._deprecation import deprecated
 
 class Threading:
     """
@@ -14,7 +15,7 @@ class Threading:
     def wait(
         wait_time: float,
         os_timer_resolution_offset_time: float = 0,
-        current_time: float = time.perf_counter()
+        current_time: float | None = None
     ) -> None:
         """
         Suspends the current thread for a specified amount of time.
@@ -25,20 +26,27 @@ class Threading:
             Wait time in seconds to suspend the current thread.
         os_timer_resolution_offset_time: float, optional
             The offset time in seconds to add to wait_time due to the operating system timer resolution limit. Default is 0.
-        current_time: float, optional
-            The current time in seconds. Default is time.perf_counter(), which is the result from a high resolution clock
+        current_time: float | None, optional
+            The current time in seconds. If None, time.perf_counter() is used, which is the result from a high resolution clock.
         """
-        now = current_time
-        end = now + wait_time + os_timer_resolution_offset_time
-        while now < end:
-            now = time.perf_counter()
+        if current_time is None:
+            current_time = time.perf_counter()
 
+        end = current_time + wait_time + os_timer_resolution_offset_time
+
+        while time.perf_counter() < end:
+            pass
+
+@deprecated(
+    "wait is deprecated; "
+    "use Threading.wait() instead."
+    )
 def wait(
     wait_time: float,
     os_timer_resolution_offset_time: float = 0,
-    current_time: float = time.perf_counter()
+    current_time: float | None = None
 ) -> None:
     """
-    Obsolete: use Threading.wait() instead
+    Deprecated: use Threading.wait() instead
     """
     return Threading.wait(wait_time, os_timer_resolution_offset_time, current_time)

spikesafe_python-1.15.8/spikesafe_python/_deprecation.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from functools import wraps
+from typing import ParamSpec, TypeVar
+import warnings
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def deprecated(message: str) -> Callable[[Callable[P, T]], Callable[P, T]]:
+    def decorator(func: Callable[P, T]) -> Callable[P, T]:
+        @wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8/spikesafe_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spikesafe-python
-Version: 1.13.5
+Version: 1.15.8
 Summary: SpikeSafe Python Library
 Author-email: Vektrex <support@vektrex.com>
 Classifier: Programming Language :: Python :: 3

{spikesafe_python-1.13.5 → spikesafe_python-1.15.8}/spikesafe_python.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ spikesafe_python/TcpSocket.py
 spikesafe_python/TemperatureData.py
 spikesafe_python/Threading.py
 spikesafe_python/__init__.py
+spikesafe_python/_deprecation.py
 spikesafe_python.egg-info/PKG-INFO
 spikesafe_python.egg-info/SOURCES.txt
 spikesafe_python.egg-info/dependency_links.txt
@@ -43,4 +44,5 @@ tests/test_optimum_compensation.py
 tests/test_optimum_compensation_old.py
 tests/test_optimum_pulse_width_correction.py
 tests/test_optimum_pulse_width_correction_old.py
-tests/test_spikesafe_info_compare_rev_version.py
+tests/test_spikesafe_info_compare_rev_version.py
+tests/test_spikesafe_info_parser.py

spikesafe_python-1.15.8/tests/test_get_new_voltage_data_estimated_complete_time.py

@@ -0,0 +1,59 @@
+import pytest
+from spikesafe_python.DigitizerDataFetch import DigitizerDataFetch
+
+@pytest.mark.parametrize(
+    "aperture_microseconds, reading_count, hardware_trigger_count, hardware_trigger_delay_microseconds, expected",
+    [
+        # 488us aperture, 1 reading, 1 hardware trigger, 200us delay
+        (488, 1, 1, 200, 0.000688),        
+        # 500us aperture, 1 reading, 1 hardware trigger, 150us delay
+        (500, 1, 1, 150, 0.00065),
+        # 694us aperture, 1 reading, 1 hardware trigger, 0us delay
+        (694, 1, 1, 0, 0.000694),
+        # 25ms aperture, 1 reading, 1 hardware trigger, 3ms delay
+        (25000, 1, 1, 3000, 0.028),
+    ]
+)
+def test_get_new_voltage_data_estimated_complete_time(
+    aperture_microseconds, reading_count, hardware_trigger_count, hardware_trigger_delay_microseconds, expected
+):
+    result = DigitizerDataFetch.get_new_voltage_data_estimated_complete_time(
+        aperture_microseconds,
+        reading_count,
+        hardware_trigger_count,
+        hardware_trigger_delay_microseconds
+    )
+    assert pytest.approx(result, rel=1e-6) == expected
+
+@pytest.mark.parametrize(
+    "pulse_period_seconds, expected",
+    [
+        # No pulse period uses the Digitizer minimum retrigger time of 600us
+        (None, 0.003),
+        # Pulse periods below 600us are clamped to the Digitizer minimum retrigger time
+        (0.0005, 0.003),
+        # Pulse periods above 600us are used as the effective trigger spacing time
+        (0.001, 0.0038),
+    ]
+)
+def test_get_new_voltage_data_estimated_complete_time_with_multiple_triggers_and_pulse_period(
+    pulse_period_seconds, expected
+):
+    result = DigitizerDataFetch.get_new_voltage_data_estimated_complete_time(
+        aperture_microseconds=400,
+        reading_count=1,
+        hardware_trigger_count=3,
+        hardware_trigger_delay_microseconds=200,
+        pulse_period_seconds=pulse_period_seconds
+    )
+    assert pytest.approx(result, rel=1e-6) == expected
+
+def test_get_new_voltage_data_estimated_complete_time_ignores_pulse_period_for_single_trigger():
+    result = DigitizerDataFetch.get_new_voltage_data_estimated_complete_time(
+        aperture_microseconds=400,
+        reading_count=1,
+        hardware_trigger_count=1,
+        hardware_trigger_delay_microseconds=200,
+        pulse_period_seconds=0.001
+    )
+    assert pytest.approx(result, rel=1e-6) == 0.0006

spikesafe_python-1.15.8/tests/test_spikesafe_info_parser.py

@@ -0,0 +1,54 @@
+from unittest.mock import patch
+
+from spikesafe_python.SpikeSafeInfoParser import SpikeSafeInfoParser
+
+
+class FakeSpikeSafeSocket:
+    def __init__(self, digitizer_card_numbers: str) -> None:
+        self.socket_ip_address = "127.0.0.1"
+        self.digitizer_card_numbers = digitizer_card_numbers
+        self.last_command = None
+        self.sent_commands = []
+
+    def send_scpi_command(self, command, enable_logging=None):
+        self.last_command = command
+        self.sent_commands.append(command)
+
+    def read_data(self, enable_logging=None):
+        responses = {
+            "*IDN?": "Vektrex, SpikeSafe 400, Rev 3.0.11.10; SN:1234, HwRev:1, CPLD 1; DSP 1, Last Cal Date:2024-01-01, ModelNum:ZIN644",
+            "SOUR0:CURR? MAX": "10",
+            "SOUR0:CURR? MIN": "0",
+            "SOUR0:VOLT? MAX": "100",
+            "SOUR0:VOLT? MIN": "0",
+            "SOUR0:PULS:TON? MIN": "1",
+            "SOUR0:PULS:TON? MAX": "100",
+            "SOUR0:PULS:OFFS? MIN": "0",
+            "SOUR0:PULS:OFFS? MAX": "10",
+            "MEM:DATA ZINNUM?": "ZIN644",
+            "DIGI:FUNC:CARD:NUMB?": self.digitizer_card_numbers,
+            "MEM:DATA CONNAVAIL?": "FALSE",
+            "SOUR0:FUNC:SHAP? LIST": "PULSED",
+        }
+        return responses[self.last_command]
+
+
+def test_parse_spikesafe_info_does_not_fetch_digitizer_info_when_card_number_is_zero():
+    socket = FakeSpikeSafeSocket("0")
+
+    with patch.object(SpikeSafeInfoParser, "_fetch_digitizer_info") as fetch_digitizer_info:
+        spikesafe_info = SpikeSafeInfoParser.parse_spikesafe_info(socket)
+
+    fetch_digitizer_info.assert_not_called()
+    assert spikesafe_info.has_digitizer is False
+    assert spikesafe_info.digitizer_infos == []
+
+
+def test_parse_spikesafe_info_only_fetches_positive_digitizer_card_numbers():
+    socket = FakeSpikeSafeSocket("1,2")
+
+    with patch.object(SpikeSafeInfoParser, "_fetch_digitizer_info") as fetch_digitizer_info:
+        spikesafe_info = SpikeSafeInfoParser.parse_spikesafe_info(socket)
+
+    assert [call.args[2] for call in fetch_digitizer_info.call_args_list] == ["1", "2"]
+    assert spikesafe_info.has_digitizer is False

spikesafe_python-1.13.5/tests/test_get_new_voltage_data_estimated_complete_time.py

@@ -1,26 +0,0 @@
-import pytest
-from spikesafe_python.DigitizerDataFetch import DigitizerDataFetch
-
-@pytest.mark.parametrize(
-    "aperture_microseconds, reading_count, hardware_trigger_count, hardware_trigger_delay_microseconds, expected",
-    [
-        # 488us aperture, 1 reading, 1 hardware trigger, 200us delay
-        (488, 1, 1, 200, 0.000688),        
-        # 500us aperture, 1 reading, 1 hardware trigger, 150us delay
-        (500, 1, 1, 150, 0.00065),
-        # 694us aperture, 1 reading, 1 hardware trigger, 0us delay
-        (694, 1, 1, 0, 0.000694),
-        # 25ms aperture, 1 reading, 1 hardware trigger, 3ms delay
-        (25000, 1, 1, 3000, 0.028),
-    ]
-)
-def test_get_new_voltage_data_estimated_complete_time(
-    aperture_microseconds, reading_count, hardware_trigger_count, hardware_trigger_delay_microseconds, expected
-):
-    result = DigitizerDataFetch.get_new_voltage_data_estimated_complete_time(
-        aperture_microseconds,
-        reading_count,
-        hardware_trigger_count,
-        hardware_trigger_delay_microseconds
-    )
-    assert pytest.approx(result, rel=1e-6) == expected