gwpy 3.0.7__py3-none-any.whl → 3.0.9__py3-none-any.whl

gwpy/timeseries/tests/test_timeseries.py

@@ -91,6 +91,7 @@ NDS2_GW150914_CHANNEL = "L1:DCS-CALIB_STRAIN_C02"
 GWOSC_GW150914_FRAMETYPE = "L1_LOSC_16_V1"
 GWOSC_GW150914 = 1126259462
 GWOSC_GW150914_SEGMENT = Segment(GWOSC_GW150914-2, GWOSC_GW150914+2)
+GWOSC_GW150914_SEGMENT_32 = Segment(GWOSC_GW150914-16, GWOSC_GW150914+16)
 GWOSC_GW150914_DQ_BITS = {
     'hdf5': [
         'data present',
@@ -153,6 +154,22 @@ class TestTimeSeries(_TestTimeSeriesBase):
             sample_rate=16384,
         )
 
+    @pytest.fixture(scope="class")
+    @pytest_skip_network_error
+    def gw150914_h1_32(self):
+        return self.TEST_CLASS.fetch_open_data(
+            "H1",
+            *GWOSC_GW150914_SEGMENT_32,
+        )
+
+    @pytest.fixture(scope="class")
+    @pytest_skip_network_error
+    def gw150914_l1_32(self):
+        return self.TEST_CLASS.fetch_open_data(
+            "L1",
+            *GWOSC_GW150914_SEGMENT_32,
+        )
+
     # -- test class functionality ---------------
 
     def test_ligotimegps(self):
@@ -236,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)
@@ -784,6 +802,22 @@ class TestTimeSeries(_TestTimeSeriesBase):
         assert fs.size == 129
         assert fs.dx == gw150914.sample_rate / 256
 
+    @pytest.mark.parametrize("data", [
+        [1., 0., -1., 0.],
+        [1., 2., 3., 2., 1., 0.],
+        numpy.arange(10),
+        numpy.random.random(100),
+    ])
+    def test_fft_ifft(self, data):
+        a = self.TEST_CLASS(data)
+        utils.assert_quantity_sub_equal(
+            a,
+            a.fft().ifft(),
+            almost_equal=True,
+            rtol=1e-7,
+            atol=1e-10,
+        )
+
     def test_average_fft(self, gw150914):
         # test all defaults
         fs = gw150914.average_fft()
@@ -1040,18 +1074,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,
@@ -1059,7 +1097,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")
@@ -1348,7 +1386,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])
 
@@ -1498,28 +1538,30 @@ class TestTimeSeries(_TestTimeSeriesBase):
         assert comp.name == '%s >= 2.0' % (array.name)
         assert (array == array).name == '{0} == {0}'.format(array.name)
 
-    @pytest_skip_network_error
-    def test_transfer_function(self):
-        tsh = TimeSeries.fetch_open_data('H1', 1126259446, 1126259478)
-        tsl = TimeSeries.fetch_open_data('L1', 1126259446, 1126259478)
-        tf = tsh.transfer_function(tsl, fftlength=1.0, overlap=0.5)
+    def test_transfer_function(self, gw150914_h1_32, gw150914_l1_32):
+        tf = gw150914_h1_32.transfer_function(
+            gw150914_l1_32,
+            fftlength=1.0,
+            overlap=0.5,
+        )
         assert tf.df == 1 * units.Hz
         assert tf.frequencies[abs(tf).argmax()] == 516 * units.Hz
 
-    @pytest_skip_network_error
-    def test_coherence(self):
-        tsh = TimeSeries.fetch_open_data('H1', 1126259446, 1126259478)
-        tsl = TimeSeries.fetch_open_data('L1', 1126259446, 1126259478)
-        coh = tsh.coherence(tsl, fftlength=1.0)
+    def test_coherence(self, gw150914_h1_32, gw150914_l1_32):
+        coh = gw150914_h1_32.coherence(
+            gw150914_l1_32,
+            fftlength=1.0,
+        )
         assert coh.df == 1 * units.Hz
         assert coh.frequencies[coh.argmax()] == 60 * units.Hz
 
-    @pytest_skip_network_error
-    def test_coherence_spectrogram(self):
-        tsh = TimeSeries.fetch_open_data('H1', 1126259446, 1126259478)
-        tsl = TimeSeries.fetch_open_data('L1', 1126259446, 1126259478)
-        cohsg = tsh.coherence_spectrogram(tsl, 4, fftlength=1.0)
-        assert cohsg.t0 == tsh.t0
+    def test_coherence_spectrogram(self, gw150914_h1_32, gw150914_l1_32):
+        cohsg = gw150914_h1_32.coherence_spectrogram(
+            gw150914_l1_32,
+            4,
+            fftlength=1.0,
+        )
+        assert cohsg.t0 == gw150914_h1_32.t0
         assert cohsg.dt == 4 * units.second
         assert cohsg.df == 1 * units.Hz
         tmax, fmax = numpy.unravel_index(cohsg.argmax(), cohsg.shape)

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/sliceutils.py

@@ -107,7 +107,11 @@ def null_slice(slice_):
     except TypeError:
         return False
 
-    if isinstance(slice_, numpy.ndarray) and numpy.all(slice_):
+    if (
+        isinstance(slice_, numpy.ndarray)
+        and slice_.dtype == bool
+        and slice_.all()
+    ):
         return True
     if isinstance(slice_, slice) and slice_ in (
             slice(None, None, None), slice(0, None, 1)

gwpy/types/tests/test_array2d.py

@@ -250,3 +250,7 @@ class TestArray2D(_TestSeries):
     @pytest.mark.skip("not implemented for >1D arrays")
     def test_pad_asymmetric(self):
         return NotImplemented
+
+    @pytest.mark.skip("not applicable for >1D arrays")
+    def test_single_getitem_not_created(self):
+        return NotImplemented

gwpy/types/tests/test_series.py

@@ -163,6 +163,32 @@ class TestSeries(_TestArray):
                 name=array.name, epoch=array.epoch, unit=array.unit),
             )
 
+    def test_getitem_index(self, array):
+        """Test that __getitem__ also applies to an xindex.
+
+        When subsetting a Series with an iterable of integer indices,
+        make sure that the xindex, if it exists, is also subsetted. Tests
+        regression against https://github.com/gwpy/gwpy/issues/1680.
+        """
+        array.xindex  # create xindex
+        indices = numpy.array([0, 1, len(array)-1])
+        newarray = array[indices]
+
+        assert len(newarray) == 3
+        assert len(newarray) == len(newarray.value)
+        assert len(newarray.value) == len(newarray.xindex)
+
+    def test_single_getitem_not_created(self, array):
+        """Test that array[i] does not return an object with a new _xindex."""
+
+        # check that there is no xindex when a single value is accessed
+        with pytest.raises(AttributeError):
+            array[0].xindex
+
+        # we don't need this, we don't want it accidentally injected
+        with pytest.raises(AttributeError):
+            array[0]._xindex
+
     def test_empty_slice(self, array):
         """Check that we can slice a `Series` into nothing
 

gwpy/utils/shell.py

@@ -20,7 +20,6 @@
 """
 
 import warnings
-from distutils.spawn import find_executable
 from subprocess import (Popen, PIPE, CalledProcessError)
 
 from .decorators import deprecated_function
@@ -52,7 +51,8 @@ def which(program):
     ValueError
         if not executable program is found
     """
-    exe = find_executable(program)
+    from shutil import which
+    exe = which(program)
     if exe is None:
         raise ValueError("No executable '%s' found in PATH" % program)
     return exe

gwpy/utils/sphinx/zenodo.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) Duncan Macleod (2018-2020)
+# Copyright (C) Cardiff University (2018-2023)
 #
 # This file is part of GWpy.
 #
@@ -17,89 +17,146 @@
 # along with GWpy.  If not, see <http://www.gnu.org/licenses/>.
 
 import argparse
-import requests
 import sys
 
+import requests
 
-def parse_command_line():
-    parser = argparse.ArgumentParser(
-        description=__doc__,
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument('id', type=int, help='Zenodo ID for package')
-    parser.add_argument('-u', '--url', default='https://zenodo.org/',
-                        help='%(metavar)s to query')
-    parser.add_argument('-n', '--hits', default=10, type=int,
-                        help='number of versions to display')
-    parser.add_argument('-p', '--tag-prefix', default='v',
-                        help='prefix for git version tags')
-    parser.add_argument('-o', '--output-file', help='output file path')
-
-    if len(sys.argv) == 1:  # print --help message for no arguments
-        parser.print_help()
-        sys.exit(0)
-
-    return parser.parse_args()
+DEFAULT_ZENODO_URL = "https://zenodo.org"
+DEFAULT_HITS = 10
 
 
-def format_citations(zid, url='https://zenodo.org/', hits=10, tag_prefix='v'):
-    """Query and format a citations page from Zenodo entries
+def format_citations(
+    zid,
+    url=DEFAULT_ZENODO_URL,
+    hits=10,
+    tag_prefix="v",
+):
+    """Query and format a citations page from Zenodo entries.
 
     Parameters
     ----------
     zid : `int`, `str`
-        the Zenodo ID of the target record
+        The Zenodo ID (``conceptrecid``) of the parent target record.
 
     url : `str`, optional
-        the base URL of the Zenodo host, defaults to ``https://zenodo.org``
+        The base URL of the Zenodo host, defaults to ``https://zenodo.org``.
 
-    hist : `int`, optional
-        the maximum number of hits to show, default: ``10``
+    hits : `int`, optional
+        The maximum number of results to show, default: ``10``.
 
     tag_prefix : `str`, optional
-        the prefix for git tags. This is removed to generate the section
-        headers in the output RST
+        The prefix for git tags. This is removed to generate the section
+        headers in the output RST.
 
     Returns
     -------
     rst : `str`
-        an RST-formatted string of DOI badges with URLs
+        An RST-formatted string of DOI badges with URLs.
     """
     # query for metadata
-    url = ('{url}/api/records/?'
-           'page=1&'
-           'size={hits}&'
-           'q=conceptrecid:"{id}"&'
-           'sort=-version&'
-           'all_versions=True'.format(id=zid, url=url, hits=hits))
-    resp = requests.get(url)  # make the request
+    apiurl = f"{url.rstrip('/')}/api/records"
+    params = {
+        "q": f"conceptrecid:{zid}",
+        "allversions": True,
+        "sort": "version",
+        "page": 1,
+        "size": int(hits),
+    }
+    resp = requests.get(apiurl, params)  # make the request
     resp.raise_for_status()  # make sure it worked
-    metadata = resp.json()  # parse the response
+    records = resp.json()  # parse the response
 
     lines = []
-    for i, hit in enumerate(metadata['hits']['hits']):
-        version = hit['metadata']['version'][len(tag_prefix):]
-        lines.append('-' * len(version))
-        lines.append(version)
-        lines.append('-' * len(version))
-        lines.append('')
-        lines.append('.. image:: {badge}\n'
-                     '   :target: {doi}'.format(**hit['links']))
-        if i < hits - 1:
-            lines.append('')
-
-    return '\n'.join(lines)
-
-
-if __name__ == '__main__':
-    args = parse_command_line()
-
-    if args.output_file:
-        f = open(args.output_file, 'w')
-    else:
+    for i, rec in enumerate(records["hits"]["hits"]):
+        # print RST-format header
+        version = str(rec['metadata']['version'])[len(tag_prefix):]
+        head = "-" * len(version)
+        lines.extend([
+            head,
+            version,
+            head,
+            "",
+        ])
+
+        # add DOI badge
+        badge = f"{url}/badge/doi/{rec['doi']}.svg"
+        lines.extend([
+            f".. image:: {badge}",
+            f"    :alt: {rec['title']} Zenodo DOI badge",
+            f"    :target: {rec['doi_url']}",
+        ])
+
+        # add break before next record
+        lines.append("")
+
+    return '\n'.join(lines).strip()
+
+
+# -- command-line usage ---------------
+
+def create_parser():
+    """Create an `argparse.ArgumentParser` for this tool.
+    """
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "id",
+        type=int,
+        help="Zenodo concept ID for package",
+    )
+    parser.add_argument(
+        "-u",
+        "--url",
+        default=DEFAULT_ZENODO_URL,
+        help="Base URL of API to query",
+    )
+    parser.add_argument(
+        "-n",
+        "--hits",
+        default=DEFAULT_HITS,
+        type=int,
+        help="Number of versions to display",
+    )
+    parser.add_argument(
+        "-p",
+        "--tag-prefix",
+        default="v",
+        help="Prefix for version tags",
+    )
+    parser.add_argument(
+        "-o",
+        "--output-file",
+        default="stdout",
+        help="Output file path",
+    )
+    return parser
+
+
+def main(args=None):
+    """Run this tool as a command-line script.
+    """
+    # parse arguments
+    parser = create_parser()
+    opts = parser.parse_args(args=args)
+
+    # generate RST
+    citing = format_citations(
+        opts.id,
+        url=opts.url,
+        hits=opts.hits,
+        tag_prefix=opts.tag_prefix,
+    )
+
+    # print
+    if opts.output_file in {None, "stdout"}:
         f = sys.stdout
-
-    citing = format_citations(args.id, url=args.url, hits=args.hits,
-                              tag_prefix=args.tag_prefix)
-
+    else:
+        f = open(opts.output_file, 'w')
     with f:
         print(citing, file=f)
+
+
+if __name__ == '__main__':
+    sys.exit(main())

gwpy/utils/tests/test_shell.py

@@ -20,9 +20,9 @@
 """
 
 import platform
+import shutil
 import subprocess
 import sys
-from distutils.spawn import find_executable
 
 import pytest
 
@@ -72,6 +72,6 @@ def test_shell_call_error_warn():
 
 def test_which():
     with pytest.warns(DeprecationWarning):
-        assert shell.which('python') == find_executable('python')
+        assert shell.which('python') == shutil.which('python')
     with pytest.raises(ValueError), pytest.warns(DeprecationWarning):
         shell.which('gwpy-no-executable')