Add equality methods to Visibilities and VisMeta.

xrayvision/tests/test_visibility.py

@@ -2,7 +2,9 @@
 
 import astropy.units as apu
 import pytest
+from astropy.coordinates import get_body
 from astropy.tests.helper import assert_quantity_allclose
+from astropy.time import Time
 
 import xrayvision.visibility as vm
 
@@ -14,14 +16,22 @@ def test_data_dir():
 
 
 @pytest.fixture
-def visibilities():
+def vis_meta():
+    return vm.VisMeta({"observer_coordinate": get_body("Earth", Time("2000-01-01 00:00:00")),
+                       "energy_range": [6, 10] * apu.keV,
+                       "time_range": Time(["2000-01-01 00:00:00", "2000-01-01 00:00:01"]),
+                       "vis_labels": ["3a", "10b"],
+                       "instrument": "stix"})
+
+
+@pytest.fixture
+def visibilities(vis_meta):
     visibilities = [1 + 2 * 1j, 3 + 3 * 1j] * apu.ct
     u = [0.023, -0.08] * 1 / apu.arcsec
     v = [-0.0013, 0.013] * 1 / apu.arcsec
     phase_center = [0, 0] * apu.arcsec
     unc = [0.01, 0.15] * apu.ct
-    meta = vm.VisMeta({"vis_labels": ["3a", "10b"]})
-    return vm.Visibilities(visibilities, u, v, phase_center, uncertainty=unc, meta=meta)
+    return vm.Visibilities(visibilities, u, v, phase_center, uncertainty=unc, meta=vis_meta)
 
 
 def test_vis_u(visibilities):
@@ -70,3 +80,15 @@ def test_vis_phase_uncertainty(visibilities):
     expected_phase_uncertainty = [0.22918312, 1.4323945] * apu.deg
 
     assert_quantity_allclose(output_phase_uncertainty, expected_phase_uncertainty)
+
+
+def test_vis_eq(visibilities):
+    vis = visibilities
+    assert vis == vis
+
+
+def test_meta_eq(vis_meta):
+    meta = vis_meta
+    assert meta == meta
+    meta = vm.VisMeta(dict())
+    assert meta == meta

xrayvision/visibility.py

@@ -352,6 +352,35 @@ def __repr__(self):
         """
         return f"{self.__class__.__name__}< {self.u.size}, {self.visibilities}>"
 
+    def __eq__(self, other):
+        """
+        Checks whether two VisMeta objects are equal.
+
+        Does not check whether their metas are equal.
+        """
+        if not apu.quantity.allclose(self.visibilities, other.visibilities):
+            return False
+        if not apu.quantity.allclose(self.u, other.u):
+            return False
+        if not apu.quantity.allclose(self.v, other.v):
+            return False
+        if not apu.quantity.allclose(self.phase_center, other.phase_center):
+            return False
+        if not apu.quantity.allclose(self.amplitude, other.amplitude):
+            return False
+        if not apu.quantity.allclose(self.phase, other.phase):
+            return False
+
+        uncerts = ((self.uncertainty, other.uncertainty),
+                   (self.amplitude_uncertainty, other.amplitude_uncertainty),
+                   (self.phase_uncertainty, other.phase_uncertainty))
+        for (self_uncert, other_uncert) in uncerts:
+            if (not _attrs_both_none_or_neither(self_uncert, other_uncert)
+                or (self_uncert is not None and not apu.quantity.allclose(self_uncert, other_uncert))):
+                return False
+
+        return True
+
 
 class VisMeta(VisMetaABC, dict):
     """
@@ -406,6 +435,47 @@ def instrument(self):
             i += 1
         return instr
 
+    @property
+    def __eq__(self, other):
+        if not _attrs_both_none_or_neither(self.observer_coordinate, other.observer_coordinate):
+            return False
+        if hasattr(self.observer_coordinate, "__len__"):
+            if not hasattr(other.observer_coordinate, "__len__"):
+                if all(self.observer_coordinate == other.observer_coordinate):
+                    return False
+            else:
+                return False
+        elif hasattr(other.observer_coordinate, "__len__"):
+            return False
+        elif self.observer_coordinate != other.observer_coordinate:
+            return False
+
+        if (not _attrs_both_none_or_neither(self.vis_labels, other.vis_labels)
+            or tuple(self.vis_labels) != tuple(other.vis_labels)):
+            return False
+
+        if (not _attrs_both_none_or_neither(self.instrument, other.instrument)
+            or tuple(self.instrument) != tuple(other.instrument)):
+            return False
+
+        if not (_attrs_both_none_or_neither(self.spectral_range, other.spectral_range)
+                and apu.quantity.allclose(self.spectral_range, other.spectral_range)):
+            return False
+
+        if not (_attrs_both_none_or_neither(self.time_range, other.time_range)
+                and np.allclose(self.time_range.mjd == other.time_range.mjd)):
+            return False
+        return True
+
+
+def _attrs_both_none_or_neither(attr1, attr2):
+    if attr1 is None:
+        if attr2 is not None:
+            return False
+    elif attr2 is None:
+        return False
+    return True
+
 
 class BaseVisibility:
     r"""