xarray-behave 0.35.5__tar.gz → 0.35.8__tar.gz

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/.github/workflows/publish.yaml

@@ -19,11 +19,8 @@ jobs:
     strategy:
       fail-fast: False
       matrix:
-        python-version: ['3.10']
-        os: [ubuntu-latest, windows-latest, macOS-13, macOS-14]
-        include:
-        - python-version: 3.9
-          os: windows-latest
+        python-version: ['3.10', '3.11', '3.12']
+        os: [ubuntu-latest, windows-latest, macOS-14]
     defaults:  # https://github.com/marketplace/actions/setup-miniconda#use-a-default-shell
       run:
         shell: bash -l {0}
@@ -33,21 +30,26 @@ jobs:
       uses: conda-incubator/setup-miniconda@v3
       with:
         auto-update-conda: true
-        miniforge-variant: Mambaforge
-        miniforge-version: latest
-        channels: conda-forge,ncb,anaconda,defaults
-        python-version: 3.11
-        mamba-version: "*"
+        channels: conda-forge,ncb
+        python-version: 3.12
         auto-activate-base: false
         activate-environment: anaconda-client-env
         environment-file: build_env.yml
         condarc-file: condarc.yml
-        use-mamba: true
-        use-only-tar-bz2: true  # IMPORTANT: This needs to be set for caching to work properly!
-    - name: Build and upload to anaconda
+    - name: Build
       run: |
-        conda mambabuild conda/xarray-behave -c conda-forge -c ncb -c anaconda --python ${{ matrix.python-version }} --user ncb --token $ANACONDA_TOKEN
+        mkdir ./build
+        conda build conda/xarray-behave --no-test --no-anaconda-upload --python ${{ matrix.python-version }} --output-folder ./build
+    - name: Test
+      run: |
+        conda deactivate
+        conda create -n xb_test python=${{ matrix.python-version }} xarray-behave -c ./build -c local -c conda-forge -c ncb -y
+        conda activate xb_test
+        python -c "import xarray_behave; print(xarray_behave.__version__)"
+        python -c "import xarray_behave.gui.app"
+        # xb --help  
+    - name: Upload
+      run: |
+        conda build conda/xarray-behave --no-test --python ${{ matrix.python-version }} --output-folder ./build --user ncb --token ${{ secrets.ANACONDA_TOKEN }}
       env:
         ANACONDA_TOKEN: ${{ secrets.ANACONDA_TOKEN }}
-        
- 

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xarray-behave
-Version: 0.35.5
+Version: 0.35.8
 Summary: xarray tools for behavioral data.
 Author-email: Jan Clemens <clemensjan@googlemail.com>
 Requires-Python: >3.6
@@ -15,7 +15,6 @@ Requires-Dist: flammkuchen
 Requires-Dist: rich
 Requires-Dist: dask
 Requires-Dist: toolz
-Requires-Dist: samplestamps
 Requires-Dist: pysoundfile
 Requires-Dist: opencv-python-headless
 Requires-Dist: pyside6 ; extra == "gui"
@@ -38,8 +37,7 @@ Provides-Extra: gui
 Install a working conda installation (see [here](https://docs.conda.io/en/latest/miniconda.html)). 
 
 ```shell
-conda install mamba -c conda-forge -n base -y
-mamba create -c conda-forge -c anaconda -c ncb -n xb python=3.9 xarray-behave
+conda create -c conda-forge -c ncb -n xb python=3.12 xarray-behave
 ```
 
 See `demo.ipynb` for usage examples.

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/README.md

@@ -3,8 +3,7 @@
 Install a working conda installation (see [here](https://docs.conda.io/en/latest/miniconda.html)). 
 
 ```shell
-conda install mamba -c conda-forge -n base -y
-mamba create -c conda-forge -c anaconda -c ncb -n xb python=3.9 xarray-behave
+conda create -c conda-forge -c ncb -n xb python=3.12 xarray-behave
 ```
 
 See `demo.ipynb` for usage examples.

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/build_env.yml

@@ -1,15 +1,9 @@
 name: anaconda-client-env
 channels:
   - conda-forge
-  - anaconda
-  - ncb
-  - defaults
 dependencies:
   - conda
-  - mamba
   - anaconda-client
-  - boa
   - conda-build
-  - conda-verify
   - pip
   - git

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/conda/xarray-behave/meta.yaml

@@ -16,46 +16,33 @@ requirements:
   host:
     - python {{ python }}
     - pip
-    - numpy=1.23
   run:
     - python {{ python }}
     - defopt=6.3
     - rich
     - flammkuchen
     - h5py
-    - librosa>0.8
-    - matplotlib
-    - pandas
-    - scipy>=1.9
-    - peakutils
     - pyyaml
-    - scikit-learn
     - zarr
     - numba
     - xarray
     - dask
-    - conda-forge::pyside2
-    # - conda-forge::pyside2 # [linux or osx or arm64]
-    # - conda-forge::pyside6 # [win and py>39]
-    # - conda-forge::pyside2 # [osx or arm64]
-    # - pyside2 # [win and py==39]
+    - librosa>0.8
+    - pysoundfile
+    - python-sounddevice
+    - matplotlib
+    - colorcet
+    - pandas
+    - scipy>=1.9
+    - scikit-image
+    - scikit-learn
+    - peakutils
+    - pyside6
     - pyqtgraph>0.12
     - qtpy
     - superqt
-    - rich
-    - colorcet
-    - python-sounddevice
-    - scikit-image
     - ffmpeg
     - pyvideoreader
-    - samplestamps>=0.6
-    - pysoundfile
-
-test:
-  imports:
-    - xarray_behave
-  commands:
-    - xb --help [ not win ]
 
 about:
   home: "http://github.com/janclemenslab/xarray-behave"

xarray-behave-0.35.8/condarc.yml

@@ -0,0 +1,9 @@
+anaconda_upload: yes
+always_yes: yes
+changeps1: no
+channel_priority: flexible 
+channels:
+- conda-forge
+- ncb
+conda-build:
+   pkg_format: 2

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/pyproject.toml

@@ -11,7 +11,7 @@ classifiers = ["License :: OSI Approved :: MIT License"]
 dynamic = ["version", "description"]
 requires-python = ">3.6"
 dependencies = ['numpy', 'scipy', 'xarray', 'h5py', 'zarr', 'flammkuchen', 'rich',
-                'dask', 'toolz', 'samplestamps', 'pysoundfile', 'opencv-python-headless']
+                'dask', 'toolz', 'pysoundfile', 'opencv-python-headless']
 readme = "README.md"
 
 [project.optional-dependencies]

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/src/xarray_behave/__init__.py

@@ -1,6 +1,6 @@
 """xarray tools for behavioral data."""
 
-__version__ = "0.35.5"
+__version__ = "0.35.8"
 
 from .xarray_behave import assemble, assemble_metrics, load, save
 import os

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/src/xarray_behave/annot.py

@@ -87,7 +87,7 @@ class Events(UserDict):
     ):
         if possible_event_names is None:
             possible_event_names = []
-        unique_names = list(set(names))
+        unique_names = list(np.unique(names))  # use `np.unique` instead of `set` to have reproducible order of names for now
         unique_names.extend(possible_event_names)
         dct = {name: [] for name in unique_names}
 
@@ -548,6 +548,18 @@ class Events(UserDict):
         self[name] = np.delete(self[name], indices, axis=0)
         return indices
 
+    def sort(self, names: Optional[List[str]] = None):
+        """Sort annotations by start time.
+
+        Args:
+            names (Optional[List[str]], optional): _description_. Defaults to None.
+        """
+        if names is None:
+            names = self.names
+
+        for name in names:
+            self[name] = self[name][np.argsort(self[name][:, 0]), :]
+
     def find_next(self, t: float, names: Optional[List[str]] = None):
         """Find event starting after `t` of type in names.
 
@@ -564,7 +576,9 @@ class Events(UserDict):
             names = self.names
 
         nxt = []
+
         for name in names:
+            self.sort([name])
             cmp = self[name][:, 0] > t
             if np.any(cmp):
                 nxt.append(self[name][np.argmax(cmp), 0])
@@ -588,6 +602,7 @@ class Events(UserDict):
 
         nxt = []
         for name in names:
+            self.sort([name])
             cmp = self[name][:, 1] < t
             if np.any(cmp):
                 nxt.append(self[name][np.argmin(cmp) - 1, 0])

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/src/xarray_behave/gui/app.py

@@ -2084,24 +2084,26 @@ class PSV(MainWindow):
             self.update_frame()
 
     def set_prev_cuepoint(self, qt_keycode):
-        if self.edit_only_current_events:  # of the currently active type
-            names = [self.current_event_name]
-        else:  # of any type
-            names = self.event_times.names
-
+        # if self.edit_only_current_events:  # of the currently active type
+        #     names = [self.current_event_name]
+        # else:  # of any type
+        #     names = self.event_times.names
+        names = [self.current_event_name]
         t = (self.t0 - 1) / self.fs_song
         nxt = self.event_times.find_prev(t, names)
+
         if nxt is not None:
             self.t0 = nxt * self.fs_song
 
     def set_next_cuepoint(self, qt_keycode):
-        if self.edit_only_current_events:  # of the currently active type
-            names = [self.current_event_name]
-        else:  # of any type
-            names = self.event_times.names
-
+        # if self.edit_only_current_events:  # of the currently active type
+        #     names = [self.current_event_name]
+        # else:  # of any type
+        #     names = self.event_times.names
+        names = [self.current_event_name]
         t = (self.t0 + 1) / self.fs_song
         nxt = self.event_times.find_next(t, names)
+
         if nxt is not None:
             self.t0 = nxt * self.fs_song
 

xarray-behave-0.35.8/src/xarray_behave/io/samplestamps/__init__.py

@@ -0,0 +1,6 @@
+"""For converting between timestamps."""
+
+__version__ = "0.6.0"
+
+
+from .samplestamps import *

xarray-behave-0.35.8/src/xarray_behave/io/samplestamps/samplestamps.py

@@ -0,0 +1,114 @@
+"""Tools for converting between samples and time stamps.
+
+glossary:
+    densely stamped - each sample is consecutively time stamped
+    sparsely stamped - only selected samples are time stamped - need to provide sample numbers
+"""
+
+from . import utils
+
+
+class SampStamp:
+    """Converts between frames and samples."""
+
+    def __init__(
+        self,
+        sample_times,
+        frame_times=None,
+        sample_numbers=None,
+        frame_numbers=None,
+        frame_samples=None,
+        sample_times_offset=0,
+        frame_times_offset=0,
+        auto_monotonize=True,
+    ):
+        """Get converter.
+
+        Args:
+            sample_times(np.ndarray)
+            frame_times(np.ndarray)
+            sample_number(np.ndarray)
+            frame_number(np.ndarray)
+            frame_samples
+            sample_times_offset(float)
+            frame_times_offset(float)
+            auto_monotonize(bool)
+        """
+        # we want:
+        # samples -> frames
+        # samples -> times
+        # frames -> samples
+        # frames -> times
+
+        # we need:
+        # (samples, times) from DAQ, (frames, times) from video timestamps
+        # (samples, times) from DAQ, (samples, frames) from movieframes
+        # (samples, frames) from movieframes, (frames, times) from video timestamps (ignore edge case)
+
+        # generate dense x_number arrays
+        if sample_numbers is None and sample_times is not None:
+            sample_numbers = range(sample_times.shape[0])
+        if frame_numbers is None and frame_times is not None:
+            frame_numbers = range(frame_times.shape[0])
+
+        # correct for offsets
+        sample_times += sample_times_offset
+        if frame_times is not None:
+            frame_times += frame_times_offset
+
+        if auto_monotonize:
+            if sample_times is not None:
+                sample_times = utils.monotonize(sample_times)
+                sample_numbers = sample_numbers[: sample_times.shape[0]]
+            if frame_times is not None:
+                frame_times = utils.monotonize(frame_times)
+                frame_numbers = frame_numbers[: frame_times.shape[0]]
+            if frame_samples is not None:
+                frame_samples = utils.monotonize(frame_samples)
+                # frame_numbers = frame_numbers[:frame_times.shape[0]]
+
+        # get all interpolators for re-use
+        if sample_numbers is not None and sample_times is not None:
+            self.samples2times = utils.interpolator(sample_numbers, sample_times)
+        if frame_times is None and frame_samples is not None:
+            frame_times = self.samples2times(frame_samples)
+            # self.frame_times = self.samples2times(frame_samples)
+
+        if frame_numbers is not None and frame_times is not None:
+            self.frames2times = utils.interpolator(frame_numbers, frame_times)
+        if frame_times is not None and sample_numbers is not None:
+            self.times2samples = utils.interpolator(sample_times, sample_numbers)
+        if frame_times is not None and frame_numbers is not None:
+            self.times2frames = utils.interpolator(frame_times, frame_numbers)
+
+        if frame_samples is not None:
+            self.samples2frames = utils.interpolator(frame_samples, frame_numbers, fill_value="extrapolate")
+
+    def frame(self, sample):
+        """Get frame number from sample number."""
+        return self.times2frames(self.sample_time(sample))
+
+    def sample(self, frame):
+        """Get sample number from frame number."""
+        return self.times2samples(self.frame_time(frame))
+
+    def frame_time(self, frame):
+        """Get time of frame number."""
+        return self.frames2times(frame)
+
+    def sample_time(self, sample):
+        """Get time of sample number."""
+        return self.samples2times(sample)
+
+
+class SimpleStamp(SampStamp):
+    """If all you need is conversion between sampling rates."""
+
+    def __init__(self, sampling_rate: float):
+
+        self.sampling_rate = sampling_rate
+        self.samples2times = utils.SampleInterpolator(self.sampling_rate)
+        self.times2samples = utils.SampleInterpolator(1 / self.sampling_rate)
+
+        self.frames2times = self.samples2times
+        self.times2frames = self.times2samples

xarray-behave-0.35.8/src/xarray_behave/io/samplestamps/utils.py

@@ -0,0 +1,181 @@
+import numpy as np
+import operator as op
+from datetime import datetime
+import scipy.interpolate
+
+
+def ismonotonous(x, direction="increasing", strict=True):
+    """Check if vector is monotonous.
+
+    Args:
+        x(np.ndarray)
+        direction(str): 'increasing' or 'decreasing'
+        strict(bool): defaults to True
+    Returns:
+        (bool)
+    """
+    allowed_directions = ["increasing", "decreasing"]
+    if direction not in allowed_directions:
+        raise ValueError(f'Direction "{direction}" must be in {allowed_directions}.')
+
+    if direction == "decreasing":
+        x = -x
+
+    if strict:
+        comp_op = op.gt  # >
+    else:
+        comp_op = op.ge  # >=
+
+    return np.all(comp_op(x[1:], x[:-1]))
+
+
+def monotonize(x, direction="increasing", strict=True):
+    """Cut trailing non-monotonous values.
+
+    Args:
+        x
+        direction - montonously 'increasing' (default) or 'decreasing'
+        strict - strictly (default) or non-strictly monotonous
+    Returns:
+        truncated array
+    """
+    allowed_directions = ["increasing", "decreasing"]
+    if direction not in allowed_directions:
+        raise ValueError(f'Direction "{direction}" must be in {allowed_directions}.')
+
+    if strict:
+        comp_op = op.le  # >=
+    else:
+        comp_op = op.lt  # >
+
+    if direction == "decreasing":
+        comp = comp_op(x[:-1], x[1:])
+    else:
+        comp = comp_op(x[1:], x[:-1])
+
+    if np.all(~comp):
+        last_idx = len(comp) + 1
+    else:
+        last_idx = np.argmax(comp) + 1
+
+    return x[:last_idx]
+
+
+def interpolator(x, y, fill_value="extrapolate"):
+    return scipy.interpolate.interp1d(x, y, fill_value=fill_value)
+
+
+class SampleInterpolator:
+    """For samples on a regular grid"""
+
+    def __init__(self, sampling_rate: float):
+        self.sampling_rate = float(sampling_rate)
+        # dummy values for compatibililty with Interpolators from scipy.interpolate
+        self.x = np.array([0.0, 1.0])
+        self.y = self.x / self.sampling_rate
+
+    def __call__(self, sample_numbers):
+        return np.asarray(sample_numbers) / self.sampling_rate
+
+
+def time_from_log(logfilename, line_number=1):
+    """Parse time stamp from a specified lines in a log file.
+
+    Args:
+        logfilename(str)
+        line_number(int): line in the log file from which parse the time stamp (defaults to 1 - will read the first line (not 0-indexed!))
+    Returns:
+        (datetime) time stamp
+    """
+    with open(logfilename, "r") as f:
+        for _ in range(line_number):
+            current_line = f.readline()
+
+    current_line_parts = current_line.partition(" ")[0]
+    return datetime.strptime(current_line_parts, "%Y-%m-%d,%H:%M:%S.%f")
+
+
+def samplenumber_from_timestamps(target_time, timestamps, sample_at_timestamps=None):
+    """Gets samplenumber from timestamps given time.
+
+    Args:
+        target_time (numpy.ndarrary): time of desired sample
+        timestamps (numpy.ndarrary): list of timestamps
+        sample_at_timestamps: can be provided for sparsely stamped data, the sample number for each timestamp
+    Returns:
+        samplenumber at target time (as an index, starts at 0, can be <0 if target is before first timestamps) (np.intp)
+    """
+    if not ismonotonous(timestamps, strict=True):
+        raise ValueError(f"Timestamps must increase strictly monotonously.")
+
+    if sample_at_timestamps is None:
+        sample_at_timestamps = range(timestamps.shape[0])
+
+    f = interpolator(timestamps, sample_at_timestamps)
+    samplenumber = np.intp(np.round(f(target_time)))
+
+    return samplenumber
+
+
+def samplerange_from_timestamps(target_epoch, timestamps, sample_at_timestamps=None):
+    """Gets range of samples from timestamps given a epoch defined by start and stop time.
+
+    Args:
+        target_epoch (numpy.ndarrary): start and stop time
+        timestamps (numpy.ndarrary): list of timestamps
+        sample_at_timestamps: can be provided for sparsely stamped data, the sample number for each timestamp
+    Returns:
+        range of samples spanning epoch (as an indices, starts at 0, can be <0 if targets extends to before first timestamps)
+    """
+    samplenumber_start = samplenumber_from_timestamps(target_epoch[0], timestamps, sample_at_timestamps)
+    samplenumber_end = samplenumber_from_timestamps(target_epoch[1], timestamps, sample_at_timestamps)
+    return range(samplenumber_start, samplenumber_end)
+
+
+def timestamp_from_samplenumber(samplenumber, timestamps, sample_at_timestamps=None):
+    """Gets samplenumber from timestamps given time.
+
+    Args:
+        samplenumber (numpy.ndarrary): sample number for which we want the time stamp
+        timestamps (numpy.ndarrary): list of timestamps
+        sample_at_timestamps: can be provided for sparsely stamped data, the sample number for each timestamp
+    Returns:
+        time stamp for that sample (float)
+    """
+    if not ismonotonous(timestamps, strict=True):
+        raise ValueError(f"Timestamps must increase strictly monotonously.")
+
+    if sample_at_timestamps is None:
+        sample_at_timestamps = range(timestamps.shape[0])
+
+    f = interpolator(sample_at_timestamps, timestamps)
+    timestamp = f(samplenumber)
+
+    return timestamp
+
+
+def samples_from_samples(sample_in, in_stamps, in_samplenumber=None, out_stamps=None, out_samplenumber=None):
+    """Convert between different sampling grids via a common clock.
+    Args:
+        sample_in: sample number in INPUT sampling grid
+        in_stamps: time stamps of samples numbers `in_samplenumber` in OUTPUT sampling grid
+        in_samplenumber: sample numbers for INPUT timestamps (defaults to None for densely stamped data)
+        out_stamps: time stamps of samples numbers `out_samplenumber` in OUTPUT sampling grid
+        out_samplenumber: sample numbers for INPUT timestamps (defaults to None for densely stamped data)
+    Returns:
+        sample number in the OUTPUT sampling grid corresponding to sample_in
+    """
+    time_in = timestamp_from_samplenumber(sample_in, in_stamps, in_samplenumber)
+    sample_out = samplenumber_from_timestamps(time_in, out_stamps, out_samplenumber)
+    return sample_out
+
+
+def timestamp_from_cycles(cycleOffset, cycleSecs):
+    times = cycleOffset + cycleSecs / 8000
+    # correct counter overflows
+    overflows = np.cumsum((np.diff(times) <= 0).astype(np.uint))
+    overflows = np.insert(overflows, 0, 0)
+    times = times + overflows * 128
+    # offset such that first time is zero
+    times = times - np.min(times)
+    return times

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/src/xarray_behave/loaders.py

@@ -7,7 +7,7 @@ import scipy.ndimage
 import scipy.signal
 import scipy.stats
 from scipy.ndimage import maximum_filter1d
-from samplestamps import SampStamp
+from .io.samplestamps import SampStamp
 from . import io
 
 

{xarray-behave-0.35.5 → xarray-behave-0.35.8}/src/xarray_behave/xarray_behave.py

@@ -1,7 +1,7 @@
 """Create self-documenting xarray dataset from behavioral recordings and annotations."""
 
 import numpy as np
-from samplestamps.samplestamps import SampStamp, SimpleStamp
+from .io.samplestamps import SampStamp, SimpleStamp
 import scipy.interpolate
 import scipy.stats
 import xarray as xr
@@ -145,7 +145,11 @@ def assemble(
         else:
             basename = filepath_daq
 
-        audio_loader = io.get_loader(kind="audio", basename=basename, basename_is_full_name=filepath_daq_is_custom)
+        audio_loader = io.get_loader(
+            kind="audio",
+            basename=basename,
+            basename_is_full_name=filepath_daq_is_custom,
+        )
         if not audio_loader and filepath_daq_is_custom:
             audio_loader = io.audio.AudioFile(basename)
 
@@ -177,6 +181,7 @@ def assemble(
         ss_ball, last_sample_number_ball, sampling_rate_ball = ld.load_times(filepath_timestamps_ball, filepath_daq)
 
     filepath_timestamps_movie = Path(root, res_path, datename, f"{datename}_movieframes.csv")
+    ss_movie = None
     if os.path.exists(filepath_daq) and os.path.exists(filepath_timestamps_movie):
         ss_movie, last_sample_number_movie, sampling_rate_movie = ld.load_movietimes(filepath_timestamps_movie, filepath_daq)
 
@@ -284,20 +289,31 @@ def assemble(
     with_movieparams = False
     if include_movieparams:
         logger.info("Loading movie params:")
-        movieparams_loader = io.get_loader(kind="movieparams", basename=os.path.join(root, dat_path, datename, datename))
-        if movieparams_loader:
-            try:
-                xr_movieparams = movieparams_loader.make(movieparams_loader.path)
-                xr_movieparams = add_time(xr_movieparams, ss_movie, dim="frame_number_movie", suffix="_movie")
-
-                logger.info(f"   {movieparams_loader.path} loaded.")
-                with_movieparams = True
-            except Exception as e:
-                logger.info(f"   Loading {movieparams_loader.path} failed.")
-                logger.exception(e)
+        if ss_movie is None:
+            logger.warning("   Failed loading movie params - no ss_movie")
         else:
-            logger.info("   Found no movie params data.")
-        logger.info("Done.")
+            movieparams_loader = io.get_loader(
+                kind="movieparams",
+                basename=os.path.join(root, dat_path, datename, datename),
+            )
+            if movieparams_loader:
+                try:
+                    xr_movieparams = movieparams_loader.make(movieparams_loader.path)
+                    xr_movieparams = add_time(
+                        xr_movieparams,
+                        ss_movie,
+                        dim="frame_number_movie",
+                        suffix="_movie",
+                    )
+
+                    logger.info(f"   {movieparams_loader.path} loaded.")
+                    with_movieparams = True
+                except Exception as e:
+                    logger.info(f"   Loading {movieparams_loader.path} failed.")
+                    logger.exception(e)
+            else:
+                logger.warning("   Found no movie params data.")
+            logger.info("Done.")
 
     # Init empty and event data
     auto_event_seconds: Dict[str, Any] = {}
@@ -352,7 +368,9 @@ def assemble(
         # load MANUAL SONG ANNOTATIONS
         logger.info("Loading manual annotations:")
         manual_annot_loader = io.get_loader(
-            kind="annotations_manual", basename=filepath_annotations, basename_is_full_name=custom_filepath_annotations
+            kind="annotations_manual",
+            basename=filepath_annotations,
+            basename_is_full_name=custom_filepath_annotations,
         )
         if manual_annot_loader:
             try:
@@ -377,7 +395,9 @@ def assemble(
             )  # or construct form audio file name - .ext + _definitions.csv
 
         definitions_loader = io.get_loader(
-            kind="definitions_manual", basename=filepath_definitions, basename_is_full_name=custom_filepath_definitions
+            kind="definitions_manual",
+            basename=filepath_definitions,
+            basename_is_full_name=custom_filepath_definitions,
         )
         if definitions_loader:
             try:
@@ -404,14 +424,20 @@ def assemble(
             else:
                 basename = filepath_daq
 
-            audio_loader = io.get_loader(kind="audio", basename=basename, basename_is_full_name=filepath_daq_is_custom)
+            audio_loader = io.get_loader(
+                kind="audio",
+                basename=basename,
+                basename_is_full_name=filepath_daq_is_custom,
+            )
             if not audio_loader and filepath_daq_is_custom:
                 audio_loader = io.audio.AudioFile(basename)
 
             if audio_loader:
                 try:
                     song_raw, non_song_raw, samplerate = audio_loader.load(
-                        audio_loader.path, return_nonsong_channels=True, lazy=lazy_load_song
+                        audio_loader.path,
+                        return_nonsong_channels=True,
+                        lazy=lazy_load_song,
                     )
                     logger.info(f"   {audio_loader.path} with shape {song_raw.shape} loaded using {audio_loader.NAME}.")
                 except Exception as e:
@@ -441,7 +467,10 @@ def assemble(
             f"No tracks - setting first/last tracked frame numbers to those of the first/last sample in the recording ({first_tracked_frame}, {last_tracked_frame})."
         )
     else:
-        first_tracked_frame, last_tracked_frame = int(xr_tracks.frame_number[0]), int(xr_tracks.frame_number[-1])
+        first_tracked_frame, last_tracked_frame = (
+            int(xr_tracks.frame_number[0]),
+            int(xr_tracks.frame_number[-1]),
+        )
         logger.info(f"Tracked frame {first_tracked_frame} to {last_tracked_frame}.")
 
     # construct desired sample grid for data
@@ -544,7 +573,14 @@ def assemble(
 
     if with_tracks:
         logger.info("   Tracking")
-        xr_tracks = align_time(xr_tracks, ss, target_samples, ref_time=ref_time, target_time=time, extrapolate=True)
+        xr_tracks = align_time(
+            xr_tracks,
+            ss,
+            target_samples,
+            ref_time=ref_time,
+            target_time=time,
+            extrapolate=True,
+        )
         xr_tracks.attrs.update(
             {
                 "description": 'coords are "allocentric" - rel. to the full frame',
@@ -595,7 +631,13 @@ def assemble(
     if with_balltracker:
         logger.info("   Balltracker")
         xr_balltracks = align_time(
-            xr_balltracks, ss_ball, target_samples, target_time=time, dim="frame_number_ball", suffix="_ball", ref_time=ref_time
+            xr_balltracks,
+            ss_ball,
+            target_samples,
+            target_time=time,
+            dim="frame_number_ball",
+            suffix="_ball",
+            ref_time=ref_time,
         )
         xr_balltracks.attrs.update(
             {
@@ -639,10 +681,17 @@ def assemble(
     if "sampletime" not in dataset:
         dataset.coords["sampletime"] = time
     if "nearest_frame" not in dataset:
-        dataset.coords["nearest_frame"] = (("time"), (ss.times2frames(dataset["time"] + ref_time).astype(np.intp)))
+        dataset.coords["nearest_frame"] = (
+            ("time"),
+            (ss.times2frames(dataset["time"] + ref_time).astype(np.intp)),
+        )
 
     # convert spatial units to mm using info in attrs
-    dataset = convert_spatial_units(dataset, to_units="mm", names=["body_positions", "pose_positions", "pose_positions_allo"])
+    dataset = convert_spatial_units(
+        dataset,
+        to_units="mm",
+        names=["body_positions", "pose_positions", "pose_positions_allo"],
+    )
 
     # save command line args
     dataset.attrs = {
@@ -688,7 +737,12 @@ def _interp(ds, dim, target_frames_float, interp_kwargs={}):
     # but now the first dim is size 1 - so we need to fix this
     coords = ds_new.coords
     # maps for the too short dims: dim name - ref dim
-    coords_map = {"flies": "flies", "chambers": "flies", "data_ball": "data_ball", "params_movie": "params_movie"}
+    coords_map = {
+        "flies": "flies",
+        "chambers": "flies",
+        "data_ball": "data_ball",
+        "params_movie": "params_movie",
+    }
     new_coords = {}
     for key in coords_map.keys():
         if key in coords:
@@ -710,7 +764,12 @@ def _interp(ds, dim, target_frames_float, interp_kwargs={}):
     # now interp all remaining dims
     for fly in range(1, new_shape[1]):
         interpolator = scipy.interpolate.interp1d(
-            ds[dim].data, ds.data[:, fly, ...], axis=0, bounds_error=False, assume_sorted=True, **interp_kwargs
+            ds[dim].data,
+            ds.data[:, fly, ...],
+            axis=0,
+            bounds_error=False,
+            assume_sorted=True,
+            **interp_kwargs,
         )
         ds_x.data[:, fly, ...] = interpolator(target_frames_float)
 
@@ -736,12 +795,23 @@ def align_time(
     ds = _interp(ds, dim, target_frames_float, interp_kwargs)
     # ds = ds.interp({dim: target_frames_float}, assume_sorted=True, kwargs=interp_kwargs)
 
-    ds = ds.drop_vars(["frame_number" + suffix, "frame_times" + suffix, "frame_samples" + suffix], errors="Ignore")
+    ds = ds.drop_vars(
+        ["frame_number" + suffix, "frame_times" + suffix, "frame_samples" + suffix],
+        errors="Ignore",
+    )
 
     # time_new = ds['frametimes' + suffix] - ref_time
     ds = ds.assign_coords({"time": ((dim), target_time)})
     ds = ds.swap_dims({dim: "time"})
-    ds = ds.assign_coords({"nearest_frame" + suffix: (("time"), np.round(target_frames_float).astype(np.intp))})
+    ds = ds.assign_coords(
+        {
+            "nearest_frame"
+            + suffix: (
+                ("time"),
+                np.round(target_frames_float).astype(np.intp),
+            )
+        }
+    )
 
     fps = 1 / np.nanmean(np.diff(ds["frametimes" + suffix]))
     ds.attrs.update({"video_fps": fps})
@@ -802,7 +872,12 @@ def assemble_metrics(
     time = dataset.time.data
     nearest_frame = dataset.nearest_frame.data
 
-    pose_names = {"thorax": "thorax", "head": "head", "left_wing": "left_wing", "right_wing": "right_wing"}
+    pose_names = {
+        "thorax": "thorax",
+        "head": "head",
+        "left_wing": "left_wing",
+        "right_wing": "right_wing",
+    }
     if custom_pose_names is not None:
         pose_names.update(custom_pose_names)
 
@@ -912,7 +987,11 @@ def assemble_metrics(
         ds_dict["abs_features"] = xr.DataArray(
             data=absolute.data,
             dims=["time", "flies", "absolute_features"],
-            coords={"time": time, "absolute_features": abs_feature_names, "nearest_frame": (("time"), nearest_frame)},
+            coords={
+                "time": time,
+                "absolute_features": abs_feature_names,
+                "nearest_frame": (("time"), nearest_frame),
+            },
             attrs={
                 "description": 'coords are "egocentric" - rel. to box',
                 "sampling_rate_Hz": sampling_rate,
@@ -932,7 +1011,14 @@ def assemble_metrics(
         )
         rel_velocities_mag = np.sqrt(rel_velocities_forward**2 + rel_velocities_lateral**2)
 
-        list_relative = [dis, rel_angles, rel_orientation, rel_velocities_mag, rel_velocities_forward, rel_velocities_lateral]
+        list_relative = [
+            dis,
+            rel_angles,
+            rel_orientation,
+            rel_velocities_mag,
+            rel_velocities_forward,
+            rel_velocities_lateral,
+        ]
 
         rel_feature_names = [
             "distance",
@@ -947,7 +1033,11 @@ def assemble_metrics(
         ds_dict["rel_features"] = xr.DataArray(
             data=relative.data,
             dims=["time", "flies", "relative_flies", "relative_features"],
-            coords={"time": time, "relative_features": rel_feature_names, "nearest_frame": (("time"), nearest_frame)},
+            coords={
+                "time": time,
+                "relative_features": rel_feature_names,
+                "nearest_frame": (("time"), nearest_frame),
+            },
             attrs={
                 "description": 'coords are "egocentric" - rel. to box',
                 "sampling_rate_Hz": sampling_rate,

xarray-behave-0.35.5/conda/xarray-behave/conda_build_config.yaml

@@ -1,4 +0,0 @@
-# python:
-#   - 3.8
-# numpy:
-#   - 1.19

xarray-behave-0.35.5/condarc.yml

@@ -1,3 +0,0 @@
-anaconda_upload: yes
-always_yes: yes
-changeps1: no