ibl-neuropixel 1.9.2__py3-none-any.whl → 1.10.0__py3-none-any.whl

{ibl_neuropixel-1.9.2.dist-info → ibl_neuropixel-1.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibl-neuropixel
-Version: 1.9.2
+Version: 1.10.0
 Summary: Collection of tools for Neuropixel 1.0 and 2.0 probes data
 Home-page: https://github.com/int-brain-lab/ibl-neuropixel
 Author: The International Brain Laboratory
@@ -36,7 +36,7 @@ Collection of tools to handle Neuropixel 1.0 and 2.0 data
 
 ## Installation
 Minimum Python version supported is 3.10
-`pip install ibl-neuropixel`
+`uv pip install ibl-neuropixel`
 
 
 ## Destriping

ibl_neuropixel-1.10.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+neuropixel.py,sha256=Fp5J09CBtWtyyl4kuuJf3UE9KxS5YYbGMskfEck4A7M,39850
+spikeglx.py,sha256=iyw-Gxqhi_ioVHqEhZmQgCSFiW1ysEkhwPxQmP70bPg,41939
+ibl_neuropixel-1.10.0.dist-info/licenses/LICENSE,sha256=JJCjBeS78UPiX7TZpE-FnMjNNpCyrFb4s8VDGG2wD10,1087
+ibldsp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ibldsp/cadzow.py,sha256=pAtxDxBwoNhoxFNc2R5WLwUrmKsq4rQuaglRNgW2Lj8,7251
+ibldsp/cuda_tools.py,sha256=6LpVhYOCuOXEEg8kJ3aOCE4hzA1Yq1dojsbbBQmQCF4,2387
+ibldsp/destripe_gpu.py,sha256=I5jzFocpsYw36kMMd533YThbrQaZix5e1sHqsUjHvO4,2824
+ibldsp/filter_gpu.py,sha256=DPrPBLRXeCh_6BcJWJnPFaxS9Q6kX4nPENZg-c2q5rc,5789
+ibldsp/fourier.py,sha256=mKg9Inv7N1vi-IxAArlwNOCHsuX7Dre02664K5Uy4ws,10648
+ibldsp/icsd.py,sha256=y9NWOXBB4Nfb5A1fQMKlOu0PdVDVOZ39v2pwk2zzB84,44923
+ibldsp/plots.py,sha256=XmYC4yca_seZYNEmC5hE5wBiJAl_fi_KU00DbNcM6jI,4577
+ibldsp/raw_metrics.py,sha256=Ie4b7unuFc-XiFc9-tpTsUkph29G-20NvM7iJ25jAPI,5198
+ibldsp/smooth.py,sha256=m_mByXHG_JyFErnYsZ27gXjcqpfwCEuWa6eOb9eFuyg,8033
+ibldsp/spiketrains.py,sha256=lYP1PD4l6T-4KhFu8ZXlbnUUnEQLOriGxN1szacolPY,6878
+ibldsp/sync.py,sha256=wBZgHVS3y3ih7zRcHy1KavITwV1VQz1F62Dy9iiehUQ,5210
+ibldsp/utils.py,sha256=1-K7J7zzJtyYntwUylDTQmzzxpAQTQque9TAuIVYmVQ,17062
+ibldsp/voltage.py,sha256=aSTl8v1gApkE7CCWjxdlHAuA_LK0M-tDkTMAffYPgMA,52622
+ibldsp/waveform_extraction.py,sha256=yKrldgHqpwQ_Dq6xdoSCceKkfrL9FUXnpwKJUM3R41M,26570
+ibldsp/waveforms.py,sha256=XKWO0sSEhZR1mBsXCdGpVU3ga96HX3CViXIgpl3bml8,35280
+neurowaveforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neurowaveforms/model.py,sha256=YOPWMMNNS_Op5TyK4Br1i9_Ni41jLSqHie5r1vb5VjY,6729
+tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/integration/csd_experiments.py,sha256=bddMl2SCzeEM_QnBrZGypUYMKxFVDc6qderyUyX-iew,3158
+tests/integration/test_destripe.py,sha256=ZV7gasuFib2AbVb63WczgQvc13PbIX9t4pQgamBMgRY,6161
+tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/test_cadzow.py,sha256=Ky16lMe0guSQznlA1w76wSqQJ52P7LeYl7catAIb3Pg,681
+tests/unit/test_ephys_np2.py,sha256=dFPe53Btqxc0n2lScEUQ0gR-S0vkwnaH1YOsdA5zaG8,14198
+tests/unit/test_neuropixel.py,sha256=c27B_jHhOH9vk8Rk-rAA7vGdeaw93SrS3YtmezrwTnU,3903
+tests/unit/test_plots.py,sha256=PhCxrEN1Zd1jTgmiwd16_dEghcI7kwmHT3AQmAPpzkA,850
+tests/unit/test_spikeglx.py,sha256=BQ8dgCe-DczCmsa_xI0R7H-b33k49SWcucXiFWcSgEw,35110
+tests/unit/test_sync.py,sha256=ak282Ela5SRRT3gohjOvj8xQQvttSvNuGcYQCUH2ABE,3779
+tests/unit/test_utils.py,sha256=H2PSS5Y31-ZSJC-7n_PK6kOuJ9zdHZ_qIVTT4fM3K_o,20071
+tests/unit/test_voltage.py,sha256=Za9bpHmpHrTyQz4KrUcstPOtQ5_tre9jgpJzQPIcChE,11469
+tests/unit/test_waveforms.py,sha256=VnFvUi1pteROwwbC5Ebp2lqSxF3a8a7eXHpD8OUeuTg,16237
+ibl_neuropixel-1.10.0.dist-info/METADATA,sha256=bdbrWgWJM0h3VjqDvF2ipPD88w7dpMPRjcIkjFgaKSQ,3750
+ibl_neuropixel-1.10.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ibl_neuropixel-1.10.0.dist-info/top_level.txt,sha256=WtVcEUptnwU6BT72cgGmrWYFGM9d9qCEqe3LwR9FIw4,48
+ibl_neuropixel-1.10.0.dist-info/RECORD,,

{ibl_neuropixel-1.9.2.dist-info → ibl_neuropixel-1.10.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ibldsp/cadzow.py

@@ -17,8 +17,6 @@ for N-spatial dimensions.
 }
 """
 
-from functools import lru_cache
-
 import numpy as np
 import scipy.fft
 from iblutil.numerical import ismember2d
@@ -48,7 +46,6 @@ def traj_matrix_indices(n):
     return itraj
 
 
-@lru_cache(maxsize=24)
 def trajectory(x, y, dtype=np.complex128):
     """
     Computes the 2 spatial dimensions block-Toeplitz indices from x and y trace coordinates.

ibldsp/fourier.py

@@ -224,6 +224,8 @@ def fshift(w, s, axis=-1, ns=None):
     :return: w
     """
     # create a vector that contains a 1 sample shift on the axis
+    if np.all(s == 0):
+        return w
     ns = ns or w.shape[axis]
     shape = np.array(w.shape) * 0 + 1
     shape[axis] = ns

ibldsp/sync.py

@@ -0,0 +1,147 @@
+from pathlib import Path
+import uuid
+
+import numpy as np
+import scipy.interpolate
+
+import one.alf.io as alfio
+
+import spikeglx
+import ibldsp.utils
+
+
+def extract_spikeglx_sync(raw_ephys_apfile, output_path=None, save=False, parts=""):
+    """
+    Extracts sync.times, sync.channels and sync.polarities from binary ephys dataset
+
+    :param raw_ephys_apfile: bin file containing ephys data or spike
+    :param output_path: output directory
+    :param save: bool write to disk only if True
+    :param parts: string or list of strings that will be appended to the filename before extension
+    :return:
+    """
+    # handles input argument: support ibllib.io.spikeglx.Reader, str and pathlib.Path
+    if isinstance(raw_ephys_apfile, spikeglx.Reader):
+        sr = raw_ephys_apfile
+    else:
+        raw_ephys_apfile = Path(raw_ephys_apfile)
+        sr = spikeglx.Reader(raw_ephys_apfile)
+
+    SYNC_BATCH_SIZE_SECS = 100
+
+    if not (opened := sr.is_open):
+        sr.open()
+    # if no output, need a temp folder to swap for big files
+    if output_path is None:
+        output_path = sr.file_bin.parent
+    file_ftcp = Path(output_path).joinpath(
+        f"fronts_times_channel_polarity{uuid.uuid4()}.bin"
+    )
+
+    # loop over chunks of the raw ephys file
+    wg = ibldsp.utils.WindowGenerator(
+        sr.ns, int(SYNC_BATCH_SIZE_SECS * sr.fs), overlap=1
+    )
+    fid_ftcp = open(file_ftcp, "wb")
+    for sl in wg.slice:
+        ss = sr.read_sync(sl)
+        ind, fronts = ibldsp.utils.fronts(ss, axis=0)
+        # a = sr.read_sync_analog(sl)
+        sav = np.c_[(ind[0, :] + sl.start) / sr.fs, ind[1, :], fronts.astype(np.double)]
+        sav.tofile(fid_ftcp)
+    # close temp file, read from it and delete
+    fid_ftcp.close()
+    tim_chan_pol = np.fromfile(str(file_ftcp))
+    tim_chan_pol = tim_chan_pol.reshape((int(tim_chan_pol.size / 3), 3))
+    file_ftcp.unlink()
+    sync = {
+        "times": tim_chan_pol[:, 0],
+        "channels": tim_chan_pol[:, 1],
+        "polarities": tim_chan_pol[:, 2],
+    }
+    # If opened Reader was passed into function, leave open
+    if not opened:
+        sr.close()
+    if save:
+        out_files = alfio.save_object_npy(
+            output_path, sync, "sync", namespace="spikeglx", parts=parts
+        )
+        return sync, out_files
+    else:
+        return sync
+
+
+def sync_timestamps(tsa, tsb, tbin=0.1, return_indices=False, linear=False):
+    """
+    Sync two arrays of time stamps
+    :param tsa: vector of timestamps
+    :param tsb: vector of timestamps
+    :param tbin: time bin length
+    :param return_indices (bool), if True returns 2 sets of indices for tsa and tsb with
+    :param linear: (bool) if True, restricts the fit to linear
+    identified matches
+    :return:
+     function: interpolation function such as fnc(tsa) = tsb
+     float: drift in ppm
+     numpy array: of indices ia
+     numpy array: of indices ib
+    """
+
+    def _interp_fcn(tsa, tsb, ib, linear=linear):
+        # now compute the bpod/fpga drift and precise time shift
+        ab = np.polyfit(tsa[ib >= 0], tsb[ib[ib >= 0]] - tsa[ib >= 0], 1)
+        drift_ppm = ab[0] * 1e6
+        if linear:
+            fcn_a2b = lambda x: x * (1 + ab[0]) + ab[1]  # noqa
+        else:
+            fcn_a2b = scipy.interpolate.interp1d(
+                tsa[ib >= 0], tsb[ib[ib >= 0]], fill_value="extrapolate"
+            )
+        return fcn_a2b, drift_ppm
+
+    # assert sorted inputs
+    tmin = np.min([np.min(tsa), np.min(tsb)])
+    tmax = np.max([np.max(tsa), np.max(tsb)])
+    # brute force correlation to get an estimate of the delta_t between series
+    x = np.zeros(int(np.ceil(tmax - tmin) / tbin))
+    y = np.zeros_like(x)
+    x[np.int32(np.floor((tsa - tmin) / tbin))] = 1
+    y[np.int32(np.floor((tsb - tmin) / tbin))] = 1
+    delta_t = (
+        ibldsp.utils.parabolic_max(scipy.signal.correlate(x, y, mode="full"))[0]
+        - x.shape[0]
+        + 1
+    ) * tbin
+    # do a first assignment at a DT threshold
+    ib = np.zeros(tsa.shape, dtype=np.int32) - 1
+    threshold = tbin
+    for m in np.arange(tsa.shape[0]):
+        dt = np.abs(tsa[m] - delta_t - tsb)
+        inds = np.where(dt < threshold)[0]
+        if inds.size == 1:
+            ib[m] = inds[0]
+        elif inds.size > 1:
+            candidates = inds[~np.isin(inds, ib[:m])]
+            if candidates.size == 1:
+                ib[m] = candidates[0]
+            elif candidates.size > 1:
+                ib[m] = inds[np.argmin(dt[inds])]
+
+    fcn_a2b, _ = _interp_fcn(tsa, tsb, ib)
+    # do a second assignment - this time a full matrix of candidate matches is computed
+    # the most obvious matches are assigned first and then one by one
+    iamiss = np.where(ib < 0)[0]
+    ibmiss = np.setxor1d(np.arange(tsb.size), ib[ib >= 0])
+    dt = np.abs(fcn_a2b(tsa[iamiss]) - tsb[ibmiss][:, np.newaxis])
+    dt[dt > tbin] = np.nan
+    while ~np.all(np.isnan(dt)):
+        _b, _a = np.unravel_index(np.nanargmin(dt), dt.shape)
+        ib[iamiss[_a]] = ibmiss[_b]
+        dt[:, _a] = np.nan
+        dt[_b, :] = np.nan
+    fcn_a2b, drift_ppm = _interp_fcn(tsa, tsb, ib, linear=linear)
+
+    if return_indices:
+        return fcn_a2b, drift_ppm, np.where(ib >= 0)[0], ib[ib >= 0]
+    else:
+        return fcn_a2b, drift_ppm

ibldsp/utils.py

@@ -2,13 +2,21 @@
 Window generator, front detections, rms
 """
 
+import warnings
+
 import numpy as np
 import scipy
 
 
 def sync_timestamps(tsa, tsb, tbin=0.1, return_indices=False, linear=False):
     """
+    .. deprecated:: X.Y.Z
+        `sync_timestamps` has been moved to `ibldsp.sync` module.
+        Use `from ibldsp.sync import sync_timestamps` instead.
+        This function will be removed in version X.Y.Z.
+
     Sync two arrays of time stamps
+
     :param tsa: vector of timestamps
     :param tsb: vector of timestamps
     :param tbin: time bin length
@@ -18,66 +26,23 @@ def sync_timestamps(tsa, tsb, tbin=0.1, return_indices=False, linear=False):
     :return:
      function: interpolation function such as fnc(tsa) = tsb
      float: drift in ppm
-     numpy array: of indices ia
-     numpy array: of indices ib
+     numpy array: of indices ia (if return_indices=True)
+     numpy array: of indices ib (if return_indices=True)
     """
+    warnings.warn(
+        "sync_timestamps has been moved to ibldsp.sync module and will be removed "
+        "from ibldsp.utils in version X.Y.Z. "
+        "Please use 'from ibldsp.sync import sync_timestamps' instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
 
-    def _interp_fcn(tsa, tsb, ib, linear=linear):
-        # now compute the bpod/fpga drift and precise time shift
-        ab = np.polyfit(tsa[ib >= 0], tsb[ib[ib >= 0]] - tsa[ib >= 0], 1)
-        drift_ppm = ab[0] * 1e6
-        if linear:
-            fcn_a2b = lambda x: x * (1 + ab[0]) + ab[1]  # noqa
-        else:
-            fcn_a2b = scipy.interpolate.interp1d(
-                tsa[ib >= 0], tsb[ib[ib >= 0]], fill_value="extrapolate"
-            )
-        return fcn_a2b, drift_ppm
-
-    # assert sorted inputs
-    tmin = np.min([np.min(tsa), np.min(tsb)])
-    tmax = np.max([np.max(tsa), np.max(tsb)])
-    # brute force correlation to get an estimate of the delta_t between series
-    x = np.zeros(int(np.ceil(tmax - tmin) / tbin))
-    y = np.zeros_like(x)
-    x[np.int32(np.floor((tsa - tmin) / tbin))] = 1
-    y[np.int32(np.floor((tsb - tmin) / tbin))] = 1
-    delta_t = (
-        parabolic_max(scipy.signal.correlate(x, y, mode="full"))[0] - x.shape[0] + 1
-    ) * tbin
-    # do a first assignment at a DT threshold
-    ib = np.zeros(tsa.shape, dtype=np.int32) - 1
-    threshold = tbin
-    for m in np.arange(tsa.shape[0]):
-        dt = np.abs(tsa[m] - delta_t - tsb)
-        inds = np.where(dt < threshold)[0]
-        if inds.size == 1:
-            ib[m] = inds[0]
-        elif inds.size > 1:
-            candidates = inds[~np.isin(inds, ib[:m])]
-            if candidates.size == 1:
-                ib[m] = candidates[0]
-            elif candidates.size > 1:
-                ib[m] = inds[np.argmin(dt[inds])]
-
-    fcn_a2b, _ = _interp_fcn(tsa, tsb, ib)
-    # do a second assignment - this time a full matrix of candidate matches is computed
-    # the most obvious matches are assigned first and then one by one
-    iamiss = np.where(ib < 0)[0]
-    ibmiss = np.setxor1d(np.arange(tsb.size), ib[ib >= 0])
-    dt = np.abs(fcn_a2b(tsa[iamiss]) - tsb[ibmiss][:, np.newaxis])
-    dt[dt > tbin] = np.nan
-    while ~np.all(np.isnan(dt)):
-        _b, _a = np.unravel_index(np.nanargmin(dt), dt.shape)
-        ib[iamiss[_a]] = ibmiss[_b]
-        dt[:, _a] = np.nan
-        dt[_b, :] = np.nan
-    fcn_a2b, drift_ppm = _interp_fcn(tsa, tsb, ib, linear=linear)
-
-    if return_indices:
-        return fcn_a2b, drift_ppm, np.where(ib >= 0)[0], ib[ib >= 0]
-    else:
-        return fcn_a2b, drift_ppm
+    # Import and delegate to the new location
+    from ibldsp.sync import sync_timestamps as _sync_timestamps
+
+    return _sync_timestamps(
+        tsa, tsb, tbin=tbin, return_indices=return_indices, linear=linear
+    )
 
 
 def parabolic_max(x):