Version 0.17.12

.github/workflows/build_publish.yml

@@ -39,12 +39,13 @@ jobs:
       - name: Build wheels
         uses: pypa/cibuildwheel@v3.4.0
         env:
-          CIBW_SKIP: pp* cp36-* cp37-* cp38-* cp39-* cp310-* *musllinux*
+          CIBW_SKIP: pp* cp38-* cp39-* cp310-* *musllinux*
           CIBW_ARCHS_MACOS: auto64
           CIBW_ARCHS_LINUX: auto64
           CIBW_ARCHS_WINDOWS: auto64
           CIBW_BEFORE_BUILD_WINDOWS: "pip install delvewheel"
           CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: "delvewheel repair -w {dest_dir} {wheel}"
+          MACOSX_DEPLOYMENT_TARGET: 15.0
         with:
           output-dir: wheelhouse
           config-file: "{package}/pyproject.toml"
@@ -69,6 +70,7 @@ jobs:
           path: dist/*.tar.gz
 
   upload_pypi:
+    if: ${{ github.event_name != 'workflow_dispatch' }}
     needs: [build_wheels, build_sdist]
     runs-on: ubuntu-latest
     steps:

.readthedocs.yml

@@ -25,9 +25,9 @@ python:
       extra_requirements:
         - docs
 build:
-  os: ubuntu-20.04
+  os: ubuntu-lts-latest
   tools:
-    python: "3.10"
+    python: "3.13"
   jobs:
     pre_install:
       - echo "\n\n[tool.meson-python.args]\nsetup = [\"-Dis_not_rtd_build=false\"]" >> pyproject.toml

meson.build

@@ -1,7 +1,7 @@
 project(
     'scikit-digital-health',
     'c',
-    version: '0.17.11',
+    version: '0.17.12',
     license: 'MIT',
     meson_version: '>=1.1',
 )

src/skdh/activity/core.py

@@ -209,6 +209,10 @@ def __init__(
         self.wake_endpoints = [
             ept.IntensityGradient(state="wake"),
             ept.MaxAcceleration(self.max_acc_lens, state="wake"),
+            # M5hr, M10hr
+            ept.MaxAcceleration([300, 600], required_points=0.5, state="wake"),
+            # L5hr
+            ept.MinAcceleration([300], required_points=0.5, state="wake"),
         ]
         self.wake_endpoints += [
             ept.TotalIntensityTime(lvl, self.wlen, self.cutpoints, state="wake")

src/skdh/activity/endpoints.py

@@ -11,7 +11,9 @@
     zeros,
     full,
     max,
+    min,
     nanmax,
+    nanmin,
     histogram,
     log,
     nan,
@@ -43,6 +45,7 @@
     "ActivityEndpoint",
     "IntensityGradient",
     "MaxAcceleration",
+    "MinAcceleration",
     "TotalIntensityTime",
     "BoutIntensityTime",
     "FragmentationEndpoints",
@@ -394,17 +397,23 @@ class MaxAcceleration(ActivityEndpoint):
     ----------
     window_lengths : {list, int}
         List of window lengths, or a single window length.
+    required_points : int, float, optional
+        Number of points required in the window to compute the endpoint. If float, 
+        should be between 0 and 1 and will be interpreted as a fraction of the total 
+        number of points in the window. Default is 1.0, meaning all points in the 
+        window must be present.
     state : {'wake', 'sleep}
         State during which the endpoint is being computed.
     """
 
-    def __init__(self, window_lengths, state="wake"):
+    def __init__(self, window_lengths, required_points=1.0, state="wake"):
         if isinstance(window_lengths, int):
             window_lengths = [window_lengths]
 
         super().__init__([f"max acc {i}min [g]" for i in window_lengths], state)
 
         self.wlens = window_lengths
+        self.required_points = required_points
 
     def predict(
         self,
@@ -445,14 +454,87 @@ def predict(
             # skipping more samples would introduce bias by random chance of
             # where the windows start and stop
             try:
-                tmp_max = max(moving_mean(accel_metric, n, 1))
+                tmp_max = max(moving_mean(accel_metric, n, 1, req_points=self.required_points))
             except ValueError:
                 return  # if the window length is too long for this block of data
 
             # check that we don't have a larger result already for this day
             results[name][i] = nanmax([tmp_max, results[name][i]])
 
 
+class MinAcceleration(ActivityEndpoint):
+    """
+    Compute the minimum acceleration over windows of the specified length.
+
+    Parameters
+    ----------
+    window_lengths : {list, int}
+        List of window lengths, or a single window length.
+    required_points : int, float, optional
+        Number of points required in the window to compute the endpoint. If float, 
+        should be between 0 and 1 and will be interpreted as a fraction of the total 
+        number of points in the window. Default is 1.0, meaning all points in the 
+        window must be present.
+    state : {'wake', 'sleep}
+        State during which the endpoint is being computed.
+    """
+
+    def __init__(self, window_lengths, required_points=1.0, state="wake"):
+        if isinstance(window_lengths, int):
+            window_lengths = [window_lengths]
+
+        super().__init__([f"min acc {i}min [g]" for i in window_lengths], state)
+
+        self.wlens = window_lengths
+        self.required_points = required_points
+
+    def predict(
+        self,
+        results,
+        i,
+        accel_metric,
+        accel_metric_60,
+        epoch_s,
+        epochs_per_min,
+        **kwargs,
+    ):
+        """
+        Compute the minimum acceleration during this set of data, and compare it
+        to the previous smallest detected value.
+
+        Parameters
+        ----------
+        results : dict
+            Dictionary containing the initialized results arrays. Keys in `results`
+            are taken from the names of endpoints.
+        i : int
+            Index of the day, used to index into individual result arrays, e.g.
+            `results[self.name][i] = 5.0`
+        accel_metric : numpy.ndarray
+            Computed acceleration metric (e.g. ENMO).
+        accel_metric_60 : numpy.ndarray
+            Computed acceleration metric for a 60 second window.
+        epoch_s : int
+            Duration in seconds of each sample of `accel_metric`.
+        epochs_per_min : int
+            Number of epochs per minute.
+        """
+        super(MinAcceleration, self).predict()
+
+        for wlen, name in zip(self.wlens, self.name):
+            n = wlen * epochs_per_min
+            # skip 1 sample because we want the window with the smallest acceleration
+            # skipping more samples would introduce bias by random chance of
+            # where the windows start and stop
+            try:
+                tmp_min = min(moving_mean(accel_metric, n, 1, req_points=self.required_points))
+            except ValueError:
+                return  # if the window length is too long for this block of data
+
+            # check that we don't have a smaller result already for this day
+            results[name][i] = nanmin([tmp_min, results[name][i]])
+
+
 class TotalIntensityTime(ActivityEndpoint):
     """
     Compute the total time spent in an intensity level.

src/skdh/features/lib/extensions/_utility.c

@@ -7,18 +7,18 @@
 #include <stdlib.h>
 #include <math.h>
 
-extern void mean_sd_1d(long *, double *, double *, double *);
-extern void unique(long *, double *, double *, long *, long *);
-extern void gmean(long *, double *, double *);
-extern void embed_sort(long *, long *, double *, long *, long *, long *);
-extern void hist(long *, double *, long *, double *, double *, long *);
-extern void histogram(long *, long *, double *, double *, long *);
+extern void mean_sd_1d(Py_ssize_t *, double *, double *, double *);
+extern void unique(Py_ssize_t *, double *, double *, long *, long *);
+extern void gmean(Py_ssize_t *, double *, double *);
+extern void embed_sort(Py_ssize_t *, long *, double *, long *, long *, long *);
+extern void hist(Py_ssize_t *, double *, Py_ssize_t *, double *, double *, long *);
+extern void histogram(Py_ssize_t *, Py_ssize_t *, double *, double *, long *);
 
 extern void insertion_sort_2d(long *, long *, double *, long *);
 extern void quick_argsort_(long *, double *, long *);
 extern void quick_sort_(long *, double *);
 
-extern void f_rfft(long *, double *, long *, double *);
+extern void f_rfft(Py_ssize_t *, double *, long *, double *);
 extern void destroy_plan(void);
 
 
@@ -194,10 +194,10 @@ PyObject * cf_embed_sort(PyObject *NPY_UNUSED(self), PyObject *args){
 
 PyObject * cf_hist(PyObject *NPY_UNUSED(self), PyObject *args){
     PyObject *x_;
-    long ncells = 1;
+    npy_intp ncells = 1;
     double min_val = 0., max_val = 100.;
 
-    if (!PyArg_ParseTuple(args, "Oldd:cf_hist", &x_, &ncells, &min_val, &max_val)) return NULL;
+    if (!PyArg_ParseTuple(args, "Ondd:cf_hist", &x_, &ncells, &min_val, &max_val)) return NULL;
 
     PyArrayObject *data = (PyArrayObject *)PyArray_FromAny(
         x_, PyArray_DescrFromType(NPY_DOUBLE), 1, 0,
@@ -261,8 +261,8 @@ PyObject * cf_histogram(PyObject *NPY_UNUSED(self), PyObject *args){
 
     npy_intp n_elem = PyArray_SIZE(data);
 
-    long n3 = 3;
-    long ncells = (long)ceil(sqrt(n_elem));
+    npy_intp n3 = 3;
+    npy_intp ncells = (npy_intp)ceil(sqrt(n_elem));
 
     PyArrayObject *d = (PyArrayObject *)PyArray_EMPTY(1, &n3, NPY_DOUBLE, 0);
     PyArrayObject *counts = (PyArrayObject *)PyArray_ZEROS(1, &ncells, NPY_LONG, 0);

src/skdh/features/lib/extensions/entropy.c

@@ -6,9 +6,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-extern void signal_entropy_1d(long *, double *, double *);
-extern void sample_entropy_1d(long *, double *, long *, double *, double *);
-extern void permutation_entropy_1d(long *, double *, long *, long *, int *, double *);
+extern void signal_entropy_1d(Py_ssize_t *, double *, double *);
+extern void sample_entropy_1d(Py_ssize_t *, double *, long *, double *, double *);
+extern void permutation_entropy_1d(Py_ssize_t *, double *, long *, long *, int *, double *);
 
 
 PyObject * signal_entropy(PyObject *NPY_UNUSED(self), PyObject *args){
@@ -48,7 +48,7 @@ PyObject * signal_entropy(PyObject *NPY_UNUSED(self), PyObject *args){
         double *dptr = (double *)PyArray_DATA(data);
         double *rptr = (double *)PyArray_DATA(res);
 
-        long stride = ddims[ndim-1];
+        npy_intp stride = ddims[ndim-1];
         int nrepeats = PyArray_SIZE(data) / stride;
 
         for (int i = 0; i < nrepeats; ++i){
@@ -107,7 +107,7 @@ PyObject * sample_entropy(PyObject *NPY_UNUSED(self), PyObject *args){
         double *dptr = (double *)PyArray_DATA(data);
         double *rptr = (double *)PyArray_DATA(res);
 
-        long stride = ddims[ndim-1];
+        npy_intp stride = ddims[ndim-1];
         int nrepeats = PyArray_SIZE(data) / stride;
 
         for (int i = 0; i < nrepeats; ++i){
@@ -168,7 +168,7 @@ PyObject * permutation_entropy(PyObject *NPY_UNUSED(self), PyObject *args){
         double *dptr = (double *)PyArray_DATA(data);
         double *rptr = (double *)PyArray_DATA(res);
 
-        long stride = ddims[ndim-1];
+        npy_intp stride = ddims[ndim-1];
         int nrepeats = PyArray_SIZE(data) / stride;
 
         for (int i = 0; i < nrepeats; ++i){

src/skdh/features/lib/extensions/f_rfft.f95

@@ -6,7 +6,8 @@ subroutine f_rfft(n, x, nfft, F) bind(C, name="f_rfft")
     use, intrinsic :: iso_c_binding
     use real_fft, only : execute_real_forward
     implicit none
-    integer(c_long), intent(in) :: n, nfft
+    integer(c_size_t), intent(in) :: n
+    integer(c_long), intent(in) :: nfft
     real(c_double), intent(in) :: x(n)
     real(c_double), intent(out) :: F(2 * nfft + 2)
     ! local