gwpy 3.0.8__py3-none-any.whl → 3.0.10__py3-none-any.whl

gwpy/timeseries/io/cache.py

@@ -19,22 +19,34 @@
 """I/O utilities for reading `TimeSeries` from a `list` of file paths.
 """
 
-from ...io.cache import (FILE_LIKE, read_cache, file_segment, sieve)
+from io import BytesIO
+from math import inf
+from os import PathLike
+
+from ...io.cache import (
+    FILE_LIKE,
+    file_segment,
+    read_cache,
+    write_cache,
+)
 from ...segments import Segment
 
 __author__ = "Duncan Macleod <duncan.macleod@ligo.org>"
 
 
-def preformat_cache(cache, start=None, end=None):
+def preformat_cache(cache, start=None, end=None, sort=file_segment):
     """Preprocess a `list` of file paths for reading.
 
-    - read the cache from the file (if necessary)
-    - sieve the cache to only include data we need
+    This function does the following:
+
+    - read the list of paths cache file (if necessary),
+    - sort the cache in time order (if possible),
+    - sieve the cache to only include data we need.
 
     Parameters
     ----------
-    cache : `list`, `str`
-        List of file paths, or path to a LAL-format cache file on disk.
+    cache : `list`, `str`, `pathlib.Path`
+        List of file paths, or path to a cache file.
 
     start : `~gwpy.time.LIGOTimeGPS`, `float`, `str`, optional
         GPS start time of required data, defaults to start of data found;
@@ -44,31 +56,37 @@ def preformat_cache(cache, start=None, end=None):
         GPS end time of required data, defaults to end of data found;
         any input parseable by `~gwpy.time.to_gps` is fine.
 
+    sort : `callable`, optional
+        A callable key function by which to sort the file paths.
+
     Returns
     -------
     modcache : `list`
         A parsed, sieved list of paths based on the input arguments.
+
+    See also
+    --------
+    gwpy.io.cache.read_cache
+        For details of how the sorting and sieving is implemented
     """
-    # open cache file
-    if isinstance(cache, (str,) + FILE_LIKE):
-        return read_cache(cache, sort=file_segment,
-                          segment=Segment(start, end))
-
-    # format existing cache file
-    cache = type(cache)(cache)  # copy cache
-
-    # sort cache
-    try:
-        cache.sort(key=file_segment)  # sort
-    except ValueError:
-        # if this failed, then the sieving will also fail, but lets proceed
-        # anyway, since the user didn't actually ask us to do this (but
-        # its a very good idea)
-        return cache
-
-    # sieve cache
-    if start is None:  # start time of earliest file
-        start = file_segment(cache[0])[0]
-    if end is None:  # end time of latest file
-        end = file_segment(cache[-1])[-1]
-    return sieve(cache, segment=Segment(start, end))
+    # if given a list of paths, write it to a file-like structure
+    # so that we can use read_cache to do all the work
+    if not isinstance(cache, (str, PathLike) + FILE_LIKE):
+        cachef = BytesIO()
+        write_cache(cache, cachef)
+        cachef.seek(0)
+        cache = cachef
+
+    # need start and end times to sieve the cache
+    if start is None:
+        start = -inf
+    if end is None:
+        end = +inf
+
+    # read the cache
+    return read_cache(
+        cache,
+        coltype=type(start),
+        sort=sort,
+        segment=Segment(start, end),
+    )

gwpy/timeseries/io/gwf/lalframe.py

@@ -149,6 +149,14 @@ def read(source, channels, start=None, end=None, series_class=TimeSeries,
         end = epoch + streamdur
     end = min(epoch + streamdur, lalutils.to_lal_ligotimegps(end))
     duration = float(end - start)
+    if start >= (epoch + streamdur):
+        raise ValueError(
+            "cannot read data starting after stream ends",
+        )
+    if duration < 0:
+        raise ValueError(
+            "cannot read data with negative duration",
+        )
 
     # read data
     out = series_class.DictClass()

gwpy/timeseries/statevector.py

@@ -184,8 +184,10 @@ class StateTimeSeries(TimeSeriesBase):
     def unit(self):
         return units.dimensionless_unscaled
 
-    def override_unit(self, unit, parse_strict='raise'):
-        return NotImplemented
+    def override_unit(self, *args, **kwargs):
+        raise NotImplementedError(
+            f"overriding units is not supported for {type(self).__name__}",
+        )
 
     def _to_own_unit(self, value, check_precision=True):
         if isinstance(value, units.Quantity) and value.unit != self.unit:

gwpy/timeseries/tests/test_core.py

@@ -53,7 +53,8 @@ class TestTimeSeriesBase(_TestSeries):
     def test_new(self):
         """Test `gwpy.timeseries.TimeSeriesBase` constructor
         """
-        array = super().test_new()
+        array = self.create()
+        super().test_new()
 
         # check time-domain metadata
         assert array.epoch == GPS_EPOCH
@@ -145,7 +146,7 @@ class TestTimeSeriesBase(_TestSeries):
     def test_sample_rate_ghz(self, array):
         """Test that very large sample rates don't get rounded to dt=0.
 
-        Regression: https://github.com/gwpy/gwpy/issues/1646
+        Regression: https://gitlab.com/gwpy/gwpy/-/issues/1646
         """
         array.sample_rate = 1e9
         assert array.dt.value > 0.
@@ -400,20 +401,13 @@ class TestTimeSeriesBaseDict(object):
 
     def test_resample(self, instance):
         if self.ENTRY_CLASS is TimeSeriesBase:  # currently only for subclasses
-            return NotImplemented
+            pytest.skip(f"not implemented for {type(instance).__name__}")
+
+        # for all subclasses
         a = instance.resample(.5)
         for key in a:
             assert a[key].dx == 1/.5 * a[key].xunit
 
-    def test_fetch(self):
-        return NotImplemented
-
-    def test_find(self):
-        return NotImplemented
-
-    def test_get(self):
-        return NotImplemented
-
     @pytest.mark.requires("nds2")
     def test_from_nds2_buffers(self):
         buffers = [
@@ -445,7 +439,7 @@ class TestTimeSeriesBaseDict(object):
     def test_plot_separate(self, instance):
         """Test plotting `TimeSeriesDict` on separate axes.
 
-        See https://github.com/gwpy/gwpy/issues/1609
+        See https://gitlab.com/gwpy/gwpy/-/issues/1609
         """
         with rc_context(rc={'text.usetex': False}):
             plot = instance.plot(separate=True)

gwpy/timeseries/tests/test_io_cache.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) Cardiff University 2023
+#
+# This file is part of GWpy.
+#
+# GWpy is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# GWpy is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GWpy.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for :mod:`gwpy.timeseries.io.cache`
+"""
+
+import pytest
+
+from ...io.cache import write_cache
+from ..io import cache as ts_io_cache
+
+
+@pytest.fixture
+def cache():
+    """List of files over which to test sorting/sieving.
+    """
+    return [
+        "/tmp/A-TEST-0-10.tmp",
+        "/tmp/A-TEST-10-10.tmp",
+        "/tmp/A-TEST-20-10.tmp",
+        "/tmp/A-TEST-30-5.tmp",
+        "/tmp/A-TEST-35-15.tmp",
+    ]
+
+
+@pytest.fixture
+def cache_file(tmp_path, cache):
+    """File version of `cache()`.
+    """
+    path = tmp_path / "cache.txt"
+    write_cache(cache, path)
+    return path
+
+
+@pytest.mark.parametrize("source", ("cache", "cache_file"))
+@pytest.mark.parametrize(("start", "end", "idx"), [
+    # use everything in the cache
+    (None, None, slice(None)),
+    # use only GPS time '25' onwards, which is cache[2:]
+    (25, None, slice(2, None)),
+    # use only up to GPS time '25', which is cache[:3]
+    (None, 25, slice(None, 3)),
+    # use interval [10, 35), which needs cache[1:4]
+    (10, 35, slice(1, 4)),
+])
+def test_preformat_cache(request, cache, source, start, end, idx):
+    """Test that `gwpy.timeseries.io.cache.preformat_cache` works properly.
+
+    Here `[start, end)` is a GPS segment, and `idx` the corresponding slice
+    needed to restrict the cache object.
+
+    Loops over a variety of input arguments, using `request` to dynamically
+    loop over `cache` or `cache_file` as the input.
+    """
+    assert ts_io_cache.preformat_cache(
+        request.getfixturevalue(source),  # cache or cache_file
+        start=start,
+        end=end,
+    ) == cache[idx]

gwpy/timeseries/tests/test_io_gwf_framecpp.py

@@ -63,7 +63,7 @@ def test_read_scaled_type_change(int32ts, tmp_path):
 
 
 def test_read_write_frvect_name(tmp_path):
-    """Test against regression of https://github.com/gwpy/gwpy/issues/1206
+    """Test against regression of https://gitlab.com/gwpy/gwpy/-/issues/1206
     """
     data = TimeSeries(
         numpy.random.random(10),

gwpy/timeseries/tests/test_statevector.py

@@ -144,29 +144,39 @@ class TestStateTimeSeries(_TestTimeSeriesBase):
         assert flag.label == 'Label'
         assert flag.description == 'Description'
 
-    def test_override_unit(self):
-        return NotImplemented
+    def test_override_unit(self, array):
+        with pytest.raises(NotImplementedError):
+            super().test_override_unit(array)
 
     def test_is_compatible_error_unit(self):
-        return NotImplemented
+        pytest.skip(f"not implemented for {self.TEST_CLASS.__name__}")
 
     def test_to_from_pycbc(self):
-        return NotImplemented
+        pytest.skip(f"not implemented for {self.TEST_CLASS.__name__}")
 
-    def test_to_from_lal(self):
-        return NotImplemented
+    def test_to_from_lal(self, array):
+        with pytest.raises(NotImplementedError):
+            super().test_to_from_lal(array)
 
-    def test_to_from_lal_no_copy(self):
-        return NotImplemented
+    @pytest.mark.parametrize("copy", (False, True))
+    def test_to_from_lal_no_copy(self, array, copy):
+        with pytest.raises(NotImplementedError):
+            super().test_to_from_lal_no_copy(array, copy)
 
-    def test_to_from_lal_pow10_units(self):
-        return NotImplemented
+    @pytest.mark.requires("lal")
+    def test_to_from_lal_pow10_units(self, array):
+        with pytest.raises(NotImplementedError):
+            super().test_to_from_lal_pow10_units(array)
 
-    def test_to_from_lal_scaled_units(self):
-        return NotImplemented
+    @pytest.mark.requires("lal")
+    def test_to_from_lal_scaled_units(self, array):
+        with pytest.raises(NotImplementedError):
+            super().test_to_from_lal_scaled_units(array)
 
-    def test_to_from_lal_unrecognised_units(self):
-        return NotImplemented
+    @pytest.mark.requires("lal")
+    def test_to_from_lal_unrecognised_units(self, array):
+        with pytest.raises(NotImplementedError):
+            super().test_to_from_lal_unrecognised_units(array)
 
 
 # -- StateTimeSeriesDict ------------------------------------------------------
@@ -176,8 +186,8 @@ class TestStateTimeSeriesDict(_TestTimeSeriesBaseDict):
     ENTRY_CLASS = StateTimeSeries
     DTYPE = 'bool'
 
-    def test_resample(self):
-        return NotImplemented
+    def test_resample(self, instance):
+        pytest.skip(f"not implemented for {type(instance).__name__}")
 
 
 # -- Bits ---------------------------------------------------------------------
@@ -326,7 +336,9 @@ class TestStateVector(_TestTimeSeriesBase):
             array.resample(array.sample_rate * 1.5)
 
     def test_to_from_lal_scaled_units(self):
-        return NotImplemented
+        pytest.skip(
+            f"not implemented for {self.TEST_CLASS.__name__}",
+        )
 
     # -- data access ----------------------------
 

gwpy/timeseries/tests/test_timeseries.py

@@ -201,7 +201,7 @@ class TestTimeSeries(_TestTimeSeriesBase):
     def test_read_ascii_header(self, tmpdir):
         """Check that ASCII files with headers are read without extra options
 
-        [regression: https://github.com/gwpy/gwpy/issues/1473]
+        [regression: https://gitlab.com/gwpy/gwpy/-/issues/1473]
         """
         txt = tmpdir / "text.txt"
         txt.write_text(
@@ -253,28 +253,29 @@ class TestTimeSeries(_TestTimeSeriesBase):
                                         exclude=['channel'])
 
     @pytest.mark.parametrize('api', GWF_APIS)
-    def test_read_write_gwf_gps_errors(self, tmp_path, api):
+    def test_read_gwf_end_error(self, api):
+        """Test that reading past the end of available data fails.
+        """
         fmt = "gwf" if api is None else "gwf." + api
-        array = self.create(name='TEST')
-        tmp = tmp_path / "test.gwf"
-        array.write(tmp, format=fmt)
-
-        # check that reading past the end of the array fails
-        with pytest.raises((ValueError, RuntimeError)):
+        with pytest.raises(ValueError):
             self.TEST_CLASS.read(
-                tmp,
-                array.name,
+                utils.TEST_GWF_FILE,
+                "L1:LDAS-STRAIN",
                 format=fmt,
-                start=array.span[1],
+                start=utils.TEST_GWF_SPAN[1],
             )
 
-        # check that reading before the start of the array also fails
-        with pytest.raises((ValueError, RuntimeError)):
+    @pytest.mark.parametrize('api', GWF_APIS)
+    def test_read_gwf_negative_duration_error(self, api):
+        """Test that reading a negative duration fails.
+        """
+        fmt = "gwf" if api is None else "gwf." + api
+        with pytest.raises(ValueError):
             self.TEST_CLASS.read(
-                tmp,
-                array.name,
+                utils.TEST_GWF_FILE,
+                "L1:LDAS-STRAIN",
                 format=fmt,
-                end=array.span[0]-1,
+                end=utils.TEST_GWF_SPAN[0]-1,
             )
 
     @pytest.mark.parametrize('api', GWF_APIS)
@@ -283,7 +284,7 @@ class TestTimeSeries(_TestTimeSeriesBase):
         """Check that each GWF API can read a series of files, either in
         a single process, or in multiple processes
 
-        Regression: https://github.com/gwpy/gwpy/issues/1486
+        Regression: https://gitlab.com/gwpy/gwpy/-/issues/1486
         """
         fmt = "gwf" if api is None else "gwf." + api
         a1 = self.create(name='TEST')
@@ -511,7 +512,7 @@ class TestTimeSeries(_TestTimeSeriesBase):
         """Check that `TimeSeries.read` with `gap='raise'` actually
         raises appropriately.
 
-        [regression: https://github.com/gwpy/gwpy/issues/1211]
+        [regression: https://gitlab.com/gwpy/gwpy/-/issues/1211]
         """
         from gwpy.io.cache import file_segment
         span = file_segment(utils.TEST_HDF5_FILE)
@@ -845,9 +846,7 @@ class TestTimeSeries(_TestTimeSeriesBase):
             gw150914.psd(abs(gw150914.span), method='lal_median_mean')
 
         # odd number of segments should warn
-        # pytest hides the second DeprecationWarning that should have been
-        # triggered here, for some reason
-        with pytest.warns(UserWarning):
+        with pytest.warns(UserWarning), pytest.deprecated_call():
             gw150914.psd(1, .5, method='lal_median_mean')
 
     @pytest.mark.parametrize('method', ('welch', 'bartlett', 'median'))
@@ -1021,18 +1020,16 @@ class TestTimeSeries(_TestTimeSeriesBase):
         pytest.param('pycbc', marks=pytest.mark.requires("pycbc.psd")),
     ])
     def test_spectrogram_median_mean(self, gw150914, library):
-        method = '{0}-median-mean'.format(library)
+        method = f"{library}-median-mean"
 
-        # median-mean warn on LAL if not given the correct data for an
-        # even number of FFTs.
-        # pytest only asserts a single warning, and UserWarning will take
-        # precedence apparently, so check that for lal
+        # the LAL implementation of median-mean warns if not given the
+        # correct amount of data for an even number of FFTs.
         if library == 'lal':
-            warn_ctx = pytest.warns(UserWarning)
+            lal_warn_ctx = pytest.warns(UserWarning)
         else:
-            warn_ctx = pytest.deprecated_call()
+            lal_warn_ctx = nullcontext()
 
-        with warn_ctx:
+        with pytest.deprecated_call(), lal_warn_ctx:
             sg = gw150914.spectrogram(
                 1.5,
                 fftlength=.5,
@@ -1073,18 +1070,22 @@ class TestTimeSeries(_TestTimeSeriesBase):
         fgram = gw150914.fftgram(1)
         fs = int(gw150914.sample_rate.value)
         f, t, sxx = signal.spectrogram(
-            gw150914, fs,
+            gw150914,
+            fs,
             window='hann',
             nperseg=fs,
             mode='complex',
         )
         utils.assert_array_equal(gw150914.t0.value + t, fgram.xindex.value)
         utils.assert_array_equal(f, fgram.yindex.value)
-        utils.assert_array_equal(sxx.T, fgram)
+        utils.assert_array_equal(sxx.T, fgram.value)
 
+    def test_fftgram_overlap(self, gw150914):
         fgram = gw150914.fftgram(1, overlap=0.5)
+        fs = int(gw150914.sample_rate.value)
         f, t, sxx = signal.spectrogram(
-            gw150914, fs,
+            gw150914,
+            fs,
             window='hann',
             nperseg=fs,
             noverlap=fs//2,
@@ -1092,7 +1093,7 @@ class TestTimeSeries(_TestTimeSeriesBase):
         )
         utils.assert_array_equal(gw150914.t0.value + t, fgram.xindex.value)
         utils.assert_array_equal(f, fgram.yindex.value)
-        utils.assert_array_equal(sxx.T, fgram)
+        utils.assert_array_equal(sxx.T, fgram.value)
 
     def test_spectral_variance(self, gw150914):
         variance = gw150914.spectral_variance(.5, method="median")
@@ -1381,7 +1382,9 @@ class TestTimeSeries(_TestTimeSeriesBase):
 
     def test_convolve(self):
         data = self.TEST_CLASS(
-            signal.hann(1024), sample_rate=512, epoch=-1
+            signal.get_window("hann", 1024),
+            sample_rate=512,
+            epoch=-1,
         )
         filt = numpy.array([1, 0])
 

gwpy/types/array.py

@@ -34,6 +34,11 @@ from math import modf
 import numpy
 
 from astropy.units import Quantity
+try:
+    from astropy.utils.compat.numpycompat import COPY_IF_NEEDED
+except ImportError:  # astropy < 6.1
+    from astropy.utils import minversion
+    COPY_IF_NEEDED = None if minversion(numpy, "2.0.0.dev") else False
 
 from ..detector import Channel
 from ..detector.units import parse_unit
@@ -119,8 +124,16 @@ class Array(Quantity):
             unit = parse_unit(unit, parse_strict='warn')
 
         # create new array
-        new = super().__new__(cls, value, unit=unit, dtype=dtype, copy=False,
-                              order=order, subok=subok, ndmin=ndmin)
+        new = super().__new__(
+            cls,
+            value,
+            unit=unit,
+            dtype=dtype,
+            copy=COPY_IF_NEEDED,
+            order=order,
+            subok=subok,
+            ndmin=ndmin,
+        )
 
         # explicitly copy here to get ownership of the data,
         # see (astropy/astropy#7244)
@@ -397,7 +410,7 @@ class Array(Quantity):
         out = super().__array_ufunc__(function, method, *inputs, **kwargs)
         # if a ufunc returns a scalar, return a Quantity
         if not out.ndim:
-            return Quantity(out, copy=False)
+            return Quantity(out, copy=COPY_IF_NEEDED)
         # otherwise return an array
         return out
 

gwpy/types/index.py

@@ -23,6 +23,8 @@ import numpy
 
 from astropy.units import Quantity
 
+from .array import COPY_IF_NEEDED
+
 
 class Index(Quantity):
     """1-D `~astropy.units.Quantity` array for indexing a `Series`
@@ -57,11 +59,11 @@ class Index(Quantity):
         """
         if dtype is None:
             dtype = max(
-                numpy.array(start, subok=True, copy=False).dtype,
-                numpy.array(step, subok=True, copy=False).dtype,
+                numpy.array(start, subok=True, copy=COPY_IF_NEEDED).dtype,
+                numpy.array(step, subok=True, copy=COPY_IF_NEEDED).dtype,
             )
-        start = Quantity(start, dtype=dtype, copy=False)
-        step = Quantity(step, dtype=dtype, copy=False).to(start.unit)
+        start = Quantity(start, dtype=dtype, copy=COPY_IF_NEEDED)
+        step = Quantity(step, dtype=dtype, copy=COPY_IF_NEEDED).to(start.unit)
         stop = start + step * num
         return cls(
             numpy.arange(
@@ -71,7 +73,7 @@ class Index(Quantity):
                 dtype=dtype,
             )[:num],
             unit=start.unit,
-            copy=False,
+            copy=COPY_IF_NEEDED,
         )
 
     @property

gwpy/types/tests/test_array.py

@@ -88,23 +88,25 @@ class TestArray(object):
 
     # -- test basic construction ----------------
 
-    def test_new(self):
-        """Test Array creation
+    def assert_new(self, array):
+        """Run basic assertions for a new instance of the type under test.
         """
-        # test basic empty contructor
-        with pytest.raises(TypeError):
-            self.TEST_CLASS()
-
-        # test with some data
-        array = self.create()
         utils.assert_array_equal(array.value, self.data)
 
         # test that copy=True ensures owndata
         assert self.create(copy=False).flags.owndata is False
         assert self.create(copy=True).flags.owndata is True
 
-        # return array for subclasses to use
-        return array
+    def test_new_empty(self):
+        """Test that `Array()` raises an exception.
+        """
+        with pytest.raises(TypeError):
+            self.TEST_CLASS()
+
+    def test_new(self):
+        """Test Array creation.
+        """
+        self.assert_new(self.create())
 
     def test_unit(self, array):
         # test default unit is dimensionless

gwpy/types/tests/test_array2d.py

@@ -198,7 +198,7 @@ class TestArray2D(_TestSeries):
 
         But still represent the output as an `Array2D` with `Index` arrays.
 
-        This tests regression of https://github.com/gwpy/gwpy/issues/1504.
+        This tests regression of https://gitlab.com/gwpy/gwpy/-/issues/1504.
         """
         # create an array with indices
         a = self.create()
@@ -239,18 +239,14 @@ class TestArray2D(_TestSeries):
         with pytest.raises(IndexError):
             array.value_at(1.6, 4.8)
 
-    @pytest.mark.skip("not implemented for >1D arrays")
     def test_pad(self):
-        return NotImplemented
+        pytest.skip("not implemented for >1D arrays")
 
-    @pytest.mark.skip("not implemented for >1D arrays")
     def test_pad_index(self):
-        return NotImplemented
+        pytest.skip("not implemented for >1D arrays")
 
-    @pytest.mark.skip("not implemented for >1D arrays")
     def test_pad_asymmetric(self):
-        return NotImplemented
+        pytest.skip("not implemented for >1D arrays")
 
-    @pytest.mark.skip("not applicable for >1D arrays")
     def test_single_getitem_not_created(self):
-        return NotImplemented
+        pytest.skip("not implemented for >1D arrays")