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

gwpy/spectrogram/tests/test_spectrogram.py

@@ -175,11 +175,11 @@ class TestSpectrogram(_TestArray2D):
 
         # test simple filter
         a2 = array.filter(*zpk)
-        utils.assert_array_equal(array * fresp, a2)
+        utils.assert_quantity_sub_equal(array * fresp, a2)
 
         # test inplace filtering
         array.filter(lti, inplace=True)
-        utils.assert_array_equal(array, a2)
+        utils.assert_quantity_sub_equal(array, a2)
 
         # test errors
         with pytest.raises(TypeError):

gwpy/testing/fixtures.py

@@ -30,7 +30,7 @@ import numpy
 
 from matplotlib import rc_context
 
-from ..plot.tex import HAS_TEX
+from ..plot.tex import has_tex
 from ..timeseries import TimeSeries
 from ..utils.decorators import deprecated_function
 from .utils import TemporaryFilename
@@ -52,25 +52,8 @@ def tmpfile():
 
 # -- plotting -----------------------------------------------------------------
 
-def _test_usetex():
-    """Return `True` if we can render figures using `text.usetex`.
-    """
-    from matplotlib import pyplot
-    with rc_context(rc={'text.usetex': True}):
-        fig = pyplot.figure()
-        fig.gca()
-        try:
-            fig.canvas.draw()
-        except RuntimeError:
-            return False
-        else:
-            return True
-        finally:
-            pyplot.close(fig)
-
-
 SKIP_TEX = pytest.mark.skipif(
-    not HAS_TEX or not _test_usetex(),
+    not has_tex(),
     reason='TeX is not available',
 )
 

gwpy/testing/utils.py

@@ -23,7 +23,6 @@ import os.path
 import subprocess
 import tempfile
 from contextlib import contextmanager
-from distutils.version import LooseVersion
 from importlib import import_module
 from itertools import zip_longest
 from pathlib import Path
@@ -35,12 +34,14 @@ from numpy.testing import (assert_array_equal, assert_allclose)
 
 from astropy.time import Time
 
-from ..utils.decorators import deprecated_function
+from gwpy.io.cache import file_segment
+from gwpy.utils.decorators import deprecated_function
 
 # -- useful constants ---------------------------------------------------------
 
 TEST_DATA_DIR = os.path.join(os.path.dirname(__file__), 'data')
 TEST_GWF_FILE = os.path.join(TEST_DATA_DIR, 'HLV-HW100916-968654552-1.gwf')
+TEST_GWF_SPAN = file_segment(TEST_GWF_FILE)
 TEST_HDF5_FILE = os.path.join(TEST_DATA_DIR, 'HLV-HW100916-968654552-1.hdf')
 
 
@@ -83,8 +84,9 @@ def skip_missing_dependency(module):  # pragma: no cover
     "be removed in GWpy 3.1.0",
 ))
 def module_older_than(module, minversion):  # pragma: no cover
+    from packaging.version import Version
     mod = import_module(module)
-    return LooseVersion(mod.__version__) < LooseVersion(minversion)
+    return Version(mod.__version__) < Version(minversion)
 
 
 @deprecated_function(message=(
@@ -148,26 +150,42 @@ def _assert_quantity(q1, q2, array_assertion=assert_array_equal):
     array_assertion(q1.value, q2.value)
 
 
-def assert_quantity_sub_equal(a, b, *attrs, **kwargs):
-    """Assert that two `~gwpy.types.Array` objects are the same (or almost)
+def assert_quantity_sub_equal(
+    a,
+    b,
+    *attrs,
+    almost_equal=False,
+    exclude=None,
+    **kwargs,
+):
+    """Assert that two `~gwpy.types.Array` objects are the same (or almost).
 
     Parameters
     ----------
     a, b : `~gwpy.types.Array`
-        the arrays two be tested (can be subclasses)
+        The arrays to be tested (can be subclasses).
 
     *attrs
-        the list of attributes to test, defaults to all
+        The list of attributes to test, defaults to all.
 
     almost_equal : `bool`, optional
-        allow the numpy array's to be 'almost' equal, default: `False`,
-        i.e. require exact matches
+        Allow the numpy array's to be 'almost' equal, default: `False`,
+        i.e. require exact matches.
 
     exclude : `list`, optional
-        a list of attributes to exclude from the test
+        A list of attributes to exclude from the test.
+
+    kwargs
+        Other keyword arguments are passed to the array comparison operator
+        `numpy.testing.assert_array_equal` or `numpy.testing.assert_allclose`.
+
+    See also
+    --------
+    numpy.testing.assert_array_equal
+    numpy.testing.assert_allclose
     """
     # get value test method
-    if kwargs.pop('almost_equal', False):
+    if almost_equal:
         assert_array = assert_allclose
     else:
         assert_array = assert_array_equal
@@ -175,8 +193,7 @@ def assert_quantity_sub_equal(a, b, *attrs, **kwargs):
     # parse attributes to be tested
     if not attrs:
         attrs = a._metadata_slots
-    exclude = kwargs.pop('exclude', [])
-    attrs = [attr for attr in attrs if attr not in exclude]
+    attrs = [attr for attr in attrs if attr not in (exclude or [])]
 
     # don't assert indexes that don't exist for both
     def _check_index(dim):
@@ -193,7 +210,7 @@ def assert_quantity_sub_equal(a, b, *attrs, **kwargs):
 
     # test data
     assert_attributes(a, b, *attrs)
-    assert_array(a.value, b.value)
+    assert_array(a.value, b.value, **kwargs)
 
 
 def assert_attributes(a, b, *attrs):
@@ -313,11 +330,18 @@ def TemporaryFilename(*args, **kwargs):  # pylint: disable=invalid-name
             os.remove(name)
 
 
-def test_read_write(data, format,
-                    extension=None, autoidentify=True,
-                    read_args=[], read_kw={},
-                    write_args=[], write_kw={},
-                    assert_equal=assert_array_equal, assert_kw={}):
+def test_read_write(
+    data,
+    format,
+    extension=None,
+    autoidentify=True,
+    read_args=[],
+    read_kw={},
+    write_args=[],
+    write_kw={},
+    assert_equal=assert_quantity_sub_equal,
+    assert_kw={},
+):
     """Test that data can be written to and read from a file in some format
 
     Parameters

gwpy/time/_tconvert.py

@@ -23,14 +23,13 @@ Peter Shawhan.
 """
 
 import datetime
-import warnings
 from decimal import Decimal
 from numbers import Number
 
-from dateutil.parser import parse as parse_datestr
-
 from astropy.units import Quantity
 
+from dateparser import parse as dateparser_parse
+
 from . import (Time, LIGOTimeGPS)
 
 __author__ = 'Duncan Macleod <duncan.macleod@ligo.org>'
@@ -224,7 +223,11 @@ def from_gps(gps):
 # special case strings
 
 def _now():
-    return datetime.datetime.utcnow().replace(microsecond=0)
+    try:
+        now = datetime.datetime.now(datetime.UTC)
+    except AttributeError:  # python < 3.11
+        now = datetime.datetime.utcnow()
+    return now.replace(microsecond=0)
 
 
 def _today():
@@ -260,35 +263,18 @@ def _str_to_datetime(datestr):
     except KeyError:  # any other string
         pass
 
-    # use maya
-    try:
-        import maya
-    except ImportError:
-        MAYA_ERROR = None
-    else:
-        try:
-            return maya.when(datestr).datetime()
-        except Exception as exc1:
-            MAYA_ERROR = exc1
-
-    # use dateutil.parse
-    with warnings.catch_warnings():
-        # don't allow lazy passing of time-zones
-        warnings.simplefilter("error", RuntimeWarning)
-        try:
-            return parse_datestr(datestr)
-        except RuntimeWarning as exc:
-            if MAYA_ERROR:
-                raise exc from MAYA_ERROR
-            exc.args = (
-                f"{str(exc).rstrip('.')}. Try installing 'maya' which can "
-                "handle more complex date strings.",
-            )
-            raise
-        except (ValueError, TypeError) as exc:  # improve error reporting
-            exc.args = ("Cannot parse date string {0!r}: {1}".format(
-                datestr, exc.args[0]),)
-            raise
+    result = dateparser_parse(
+        datestr,
+        settings={
+            "TIMEZONE": "UTC",
+            "RETURN_AS_TIMEZONE_AWARE": True,
+            "TO_TIMEZONE": "UTC",
+            "PREFER_DATES_FROM": "current_period",
+        }
+    )
+    if result is None:
+        raise ValueError("failed to parse '{datestr}' as datetime")
+    return result
 
 
 def _datetime_to_time(dtm):

gwpy/time/tests/test_time.py

@@ -19,11 +19,9 @@
 """Tests for :mod:`gwpy.time`
 """
 
-from contextlib import nullcontext
 from datetime import datetime
 from decimal import Decimal
 from operator import attrgetter
-from unittest import mock
 
 import pytest
 
@@ -55,10 +53,6 @@ YESTERDAY = 1126137617
 
 
 @pytest.mark.freeze_time(FREEZE)
-@pytest.mark.parametrize("use_maya", (
-    False,
-    pytest.param(True, marks=pytest.mark.requires("maya")),
-))
 @pytest.mark.parametrize(("in_", "out"), [
     (1126259462, int(GW150914)),
     (1235635623.7500002, LIGOTimeGPS(1235635623, 750000200)),
@@ -66,6 +60,7 @@ YESTERDAY = 1126137617
     ('0', 0),
     ('Jan 1 2017', 1167264018),
     ('Sep 14 2015 09:50:45.391', GW150914),
+    ('Oct 30 2016 12:34 CST', 1161887657),
     ((2017, 1, 1), 1167264018),
     (datetime(2017, 1, 1), 1167264018),
     (Time(57754, format='mjd'), 1167264018),
@@ -83,30 +78,15 @@ YESTERDAY = 1126137617
     ('tomorrow', TOMORROW),
     ('yesterday', YESTERDAY),
 ])
-def test_to_gps(in_, out, use_maya):
-    """Test that :func:`to_gps` works with and without maya.
-    """
-    if use_maya:  # do nothing
-        ctx = nullcontext()
-    else:  # force 'install maya' to error to use dateutil
-        ctx = mock.patch.dict("sys.modules", {"maya": None})
-    with ctx:
-        assert time.to_gps(in_) == out
-
-
-@pytest.mark.requires("maya")
-@pytest.mark.parametrize(("in_", "out"), [
-    ('Oct 30 2016 12:34 CST', 1161887657),
-])
-def test_to_gps_maya(in_, out):
-    """Test that :func:`gwpy.time.to_gps` works with maya.
+def test_to_gps(in_, out):
+    """Test that :func:`to_gps` works.
     """
     assert time.to_gps(in_) == out
 
 
 @pytest.mark.parametrize(("in_", "err"), [
     (Quantity(1, 'm'), UnitConversionError),
-    ('random string', (ValueError, TypeError)),
+    ('random string', ValueError),
 ])
 def test_to_gps_error(in_, err):
     """Test that :func:`gwpy.time.to_gps` errors when it should.
@@ -115,27 +95,6 @@ def test_to_gps_error(in_, err):
         time.to_gps(in_)
 
 
-@mock.patch.dict("sys.modules", {"maya": None})
-def test_to_gps_dateparser_error_propagation_nomaya():
-    with pytest.raises(
-        RuntimeWarning,
-        match=(
-            "tzname CST identified but not understood.(.*) "
-            "Try installing 'maya' (.*)"
-        ),
-    ):
-        time.to_gps("Oct 30 2016 12:34 CST")
-
-
-@pytest.mark.requires("maya")
-@mock.patch("maya.when", side_effect=ValueError("test chain"))
-def test_to_gps_dateparser_error_propagation_maya(_):
-    with pytest.raises(RuntimeWarning) as exc:
-        time.to_gps("Oct 30 2016 12:34 CST")
-    # validate that the maya exception was chained to the dateutil one
-    assert str(exc.value.__cause__) == "test chain"
-
-
 @pytest.mark.parametrize('in_, out', [
     (1167264018, datetime(2017, 1, 1)),
     ('1167264018', datetime(2017, 1, 1)),

gwpy/timeseries/core.py

@@ -1288,16 +1288,18 @@ class TimeSeriesBaseDict(OrderedDict):
             # find observatory for this group
             if observatory is None:
                 try:
-                    observatory = ''.join(
+                    obs = ''.join(
                         sorted(set(c.ifo[0] for c in channellist)))
                 except TypeError as exc:
                     raise ValueError(
                         "Cannot parse list of IFOs from channel names",
                     ) from exc
 
+            else:
+                obs = observatory
             # find frames
             cache = io_datafind.find_urls(
-                observatory,
+                obs,
                 frametype,
                 start,
                 end,

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

@@ -401,6 +401,7 @@ def read_frvect(vect, epoch, start, end, name=None, series_class=TimeSeries):
     dim = vect.GetDim(0)
     dx = dim.dx
     x0 = dim.startX
+    xunit = dim.GetUnitX() or None
 
     # start and end GPS times of this FrVect
     dimstart = epoch + x0
@@ -428,8 +429,16 @@ def read_frvect(vect, epoch, start, end, name=None, series_class=TimeSeries):
     unit = vect.GetUnitY() or None
 
     # create array
-    series = series_class(arr, t0=dimstart+nxstart*dx, dt=dx, name=name,
-                          channel=name, unit=unit, copy=False)
+    series = series_class(
+        arr,
+        t0=dimstart+nxstart*dx,
+        dt=dx,
+        name=name,
+        channel=name,
+        xunit=xunit,
+        unit=unit,
+        copy=False,
+    )
 
     # add information to channel
     series.channel.sample_rate = series.sample_rate.value

gwpy/timeseries/io/gwf/lalframe.py

@@ -149,12 +149,33 @@ 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()
     for name in channels:
         ts = _read_channel(stream, str(name), start=start, duration=duration)
         out[name] = series_class.from_lal(ts, copy=False)
+        tsend = ts.epoch + getattr(ts.data.data, "size", 0) * ts.deltaT
+        if (end - tsend) >= ts.deltaT:  # one (probably) sample missing
+            # if the available data simply didn't go all the way to the end
+            # lalframe would have errored (and we protect against that above),
+            # so we know there is data missing.
+            # see https://git.ligo.org/lscsoft/lalsuite/-/issues/710
+            ts = _read_channel(
+                stream,
+                str(name),
+                start=tsend,
+                duration=float(end - tsend),
+            )
+            out[name] = out[name].append(ts.data.data, inplace=False)
         lalframe.FrStreamSeek(stream, epoch)
     return out
 

gwpy/timeseries/io/losc.py

@@ -35,7 +35,10 @@ from gwosc.locate import get_urls
 
 from .. import (StateVector, TimeSeries)
 from ...io import (gwf as io_gwf, hdf5 as io_hdf5)
-from ...io.cache import file_segment
+from ...io.cache import (
+    file_segment,
+    sieve as sieve_cache,
+)
 from ...io.utils import file_path
 from ...detector.units import parse_unit
 from ...segments import Segment
@@ -149,7 +152,10 @@ def fetch_gwosc_data(detector, start, end, cls=TimeSeries, **kwargs):
               key in kwargs}
     if 'sample_rate' in url_kw:  # format as Hertz
         url_kw['sample_rate'] = Quantity(url_kw['sample_rate'], 'Hz').value
-    cache = get_urls(detector, int(start), int(ceil(end)), **url_kw)
+    cache = sieve_cache(
+        get_urls(detector, int(start), int(ceil(end)), **url_kw),
+        segment=span,
+    )
     # if event dataset, pick shortest file that covers the request
     # -- this is a bit hacky, and presumes that only an event dataset
     # -- would be produced with overlapping files.

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_lalframe.py

@@ -28,6 +28,7 @@ import numpy
 from gwdatafind.utils import file_segment
 
 from ...io.cache import write_cache
+from ...segments import Segment
 from ...testing.utils import (
     assert_dict_equal,
     assert_quantity_sub_equal,
@@ -184,3 +185,19 @@ def test_write_no_ifo(tmp_path, data):
         {None: data},
         tmp
     )
+
+
+def test_read_missing_sample():
+    """Check that giving non-sampled start time doesn't result in missing data.
+
+    See https://git.ligo.org/computing/helpdesk/-/issues/4774 and
+    https://git.ligo.org/lscsoft/lalsuite/-/issues/710.
+    """
+    data = TimeSeries.read(
+        TEST_GWF_PATH,
+        "H1:LDAS-STRAIN",
+        start=968654552.6709,
+        end=968654553,
+        format="gwf.lalframe",
+    )
+    assert data.span == Segment(968654552.670898432, 968654553.0)