Merge branch 'main' into MichaelClerx-patch-1

Author: MichaelClerx

.flake8

@@ -9,9 +9,9 @@ ignore =
     W504,
     # missing whitespace around arithmetic operator
     E226,
-    # Import sorting
-    I201
-    I100
+    # Allow I, l and O as variable names
+    E741,
+
 
 exclude=
     .git,

.github/workflows/pytest.yml

@@ -4,9 +4,11 @@ on: [push]
 jobs:
   build:
     runs-on: ubuntu-latest
+    if: github.event.pull_request.draft == false
     strategy:
       matrix:
-        python-version: [3.8, 3.9, '3.10', 3.11, 3.12, 3.13]
+        python-version: ['3.10', 3.11, 3.12, 3.13, 3.14]
+        
     steps:
     - name: Checkout repository
       uses: actions/checkout@v4
@@ -52,5 +54,5 @@ jobs:
     - uses: codecov/codecov-action@v4
       with:
         token: ${{ secrets.CODECOV_TOKEN }} # not required for public repos
-      if: success() && matrix.python-version == 3.13
+      if: success() && matrix.python-version == 3.14
 

.github/workflows/todo.yml

@@ -5,7 +5,7 @@ This repository contains a python package and scripts for handling time-series d
 The package has been tested with data from a SyncroPatch 384, but may be adapted to work with data in other formats.
 It can also be used to perform quality control (QC) as described in [Lei et al. (2019)](https://doi.org/10.1016%2Fj.bpj.2019.07.029).
 
-This package is tested on Ubuntu with Python 3.8, 3.9, 3.10, 3.11, 3.12 and 3.13.
+This package is tested on Ubuntu with Python 3.10, 3.11, 3.12, 3.13 and 3.14.
 
 ## Getting Started
 

README.md

@@ -0,0 +1,63 @@
+import datetime
+import os
+import sys
+
+from ._version import __commit_id__, __version__
+
+
+def get_git_revision_hash():
+    """
+    Get the hash for the git commit currently being used.
+
+    @return The most recent commit hash or a suitable message
+
+    """
+
+    return __commit_id__
+
+
+def get_build_type():
+    if "dev" in __version__:
+        return "Develop"
+    else:
+        return "Release"
+
+
+def setup_output_directory(dirname: str = None, subdir_name: str = None):
+    """
+    Create an output directory if one doesn't already exist. Place an info
+    file in this directory which lists the date/time created, the version of
+    pcpostprocess, the command-line arguments provided, and the most recent git
+    commit. The two parameters allow for a user specified top-level directory and
+    a script-defined name for a subdirectory.
+
+    @param Optional directory name
+    @param Optional subdirectory name
+
+    @return The path to the created file directory (String)
+    """
+
+    if dirname is None:
+        if subdir_name:
+            dirname = os.path.join("output", f"{subdir_name}")
+        else:
+            dirname = os.path.join("output", "output")
+
+    if subdir_name is not None:
+        dirname = os.path.join(dirname, subdir_name)
+    if not os.path.exists(dirname):
+        os.makedirs(dirname)
+
+    with open(os.path.join(dirname, "pcpostprocess_info.txt"), "w") as description_fout:
+        git_hash = get_git_revision_hash()
+        datetimestr = str(datetime.datetime.now())
+        description_fout.write("pcpostprocess output "
+                               "https://github.com/CardiacModelling/pcpostprocess\n")
+        description_fout.write(f"Date: {datetimestr}\n")
+        description_fout.write(f"Version: {__version__}\n")
+        description_fout.write(f"Build type: {get_build_type()}\n")
+        description_fout.write(f"Commit: {git_hash}\n")
+        command = " ".join(sys.argv)
+        description_fout.write(f"Command: {command}\n")
+    return dirname
+

pcpostprocess/directory_builder.py

@@ -5,41 +5,55 @@
 import numpy as np
 import numpy.polynomial.polynomial as poly
 
+from .detect_ramp_bounds import detect_ramp_bounds
 
-def infer_reversal_potential(current, times, voltage_segments, voltages,
-                             ax=None, output_path=None, plot=None,
-                             known_Erev=None, figsize=(5, 3)):
-
-    if output_path:
-        dirname = os.path.dirname(output_path)
-        if not os.path.exists(dirname):
-            os.makedirs(dirname)
-
-    if (ax or output_path) and plot is not False:
-        plot = True
-
-    # Find indices of observations during the reversal ramp
-    ramps = [line for line in voltage_segments if line[2] != line[3]]
 
-    # Assume the last ramp is the reversal ramp (convert to ms)
-    tstart, tend = np.array(ramps)[-1, :2]
+def infer_reversal_potential(current, times, voltage_segments, voltages,
+                             output_path=None, known_Erev=None,
+                             figsize=(5, 3)):
+    """
+    Infers a reversal potential in a time series, based on a reversal ramp.
+
+    The data is denoised by fitting a 4-th order polynomial through the ramp
+    data, from which a reversal potential is then detected. If no polynomial
+    can be fit or the resulting zero-crossing is outside of
+    ``min(voltages), max(voltages)``, then ``np.nan`` is returned.
+
+    @param current: The currents that make up a time series with ``times``
+    @param times: The sampled times
+    @param voltage_segments: A list of tuples (tstart, tend, vstart, vend)
+    describing voltage steps or ramps. It is assumed the final ramp is the
+    reversal ramp.
+    @param voltages: The sampled voltages
+    @param output_path: An optional path to store a plot at
+    @param known_Erev: A known reversal potential to include in the plot
+    @param figsize: A size for the plot.
+
+    @return: The inferred reversal potential
+    """
+
+    # Get ramp bounds, assuming final ramp is the reversal ramp
+    tstart, tend = detect_ramp_bounds(times, voltage_segments, -1)
 
     istart = np.argmax(times > tstart)
     iend = np.argmax(times > tend)
 
-    times = times[istart:iend]
     current = current[istart:iend]
     voltages = voltages[istart:iend]
 
+    # Fit a 4-th order polynomial
     try:
         fitted_poly = poly.Polynomial.fit(voltages, current, 4)
     except ValueError as exc:
         logging.warning(str(exc))
         return np.nan
 
+    # Try extracting the polynomial's roots, accepting only ones that are
+    # within the range of sampled voltages (so not using ramp info here!)
     try:
+        vmin, vmax = np.min(voltages), np.max(voltages)
         roots = np.unique([np.real(root) for root in fitted_poly.roots()
-                           if root > np.min(voltages) and root < np.max(voltages)])
+                           if root > vmin and root < vmax])
     except np.linalg.LinAlgError as exc:
         logging.warning(str(exc))
         return np.nan
@@ -50,33 +64,30 @@ def infer_reversal_potential(current, times, voltage_segments, voltages,
 
     if len(roots) == 0:
         return np.nan
+    erev = roots[-1]
 
-    if plot:
-        created_fig = False
-        if ax is None and output_path is not None:
-
-            created_fig = True
-            fig = plt.figure(figsize=figsize)
-            ax = fig.subplots()
+    # Optional plot
+    if output_path is not None:
+        dirname = os.path.dirname(output_path)
+        if not os.path.exists(dirname):
+            os.makedirs(dirname)
 
-        ax.set_xlabel('$V$ (mV)')
+        fig = plt.figure(figsize=figsize)
+        ax = fig.subplots()
+        ax.set_xlabel('$V$ (mV)')  # Assuming mV here
         ax.set_ylabel('$I$ (nA)')
 
         # Now plot current vs voltage
         ax.plot(voltages, current, 'x', markersize=2, color='grey', alpha=.5)
-        ax.axvline(roots[-1], linestyle='--', color='grey', label=r'$E_\mathrm{obs}$')
+        ax.axvline(erev, linestyle='--', color='grey', label=r'$E_\mathrm{obs}$')
         if known_Erev:
             ax.axvline(known_Erev, linestyle='--', color='orange',
                        label="Calculated $E_{Kr}$")
         ax.axhline(0, linestyle='--', color='grey')
         ax.plot(*fitted_poly.linspace())
         ax.legend()
 
-        if output_path is not None:
-            fig = ax.figure
-            fig.savefig(output_path)
-
-        if created_fig:
-            plt.close(fig)
+        fig.savefig(output_path)
+        plt.close(fig)
 
-    return roots[-1]
+    return erev