xradio 0.0.41__py3-none-any.whl → 0.0.42__py3-none-any.whl

xradio/_utils/common.py

@@ -1,101 +0,0 @@
-import numpy as np
-
-_deg_to_rad = np.pi / 180
-
-
-def cast_to_str(x):
-    if isinstance(x, list):
-        return x[0]
-    else:
-        return x
-
-
-def get_pad_value(col_dtype: np.dtype) -> object:
-    """
-    Produce a padding/missing/nan value appropriate for a casacore data column
-    (for when we need to pad data vars coming from columns with rows of
-    variable size array values)
-
-    Parameters
-    ----------
-    col_dtype : dtype
-        dtype of data being loaded from a table column
-
-    Returns
-    -------
-    object
-        pad value ("missing" / "fill") for the type given
-    """
-    # Fill values for missing/NaN data in integer variables, based on usual
-    # numpy fill values. See https://github.com/numpy/numpy/issues/21166,
-    # https://github.com/casangi/xradio/issues/219, https://github.com/casangi/xradio/pull/177
-    fill_value_int32 = np.int32(-2147483648)
-    fill_value_int64 = np.int64(-9223372036854775808)
-
-    if col_dtype == np.int32:
-        return fill_value_int32
-    elif col_dtype == np.int64 or col_dtype == "int":
-        return fill_value_int64
-    elif np.issubdtype(col_dtype, np.floating):
-        return np.nan
-    elif np.issubdtype(col_dtype, np.complexfloating):
-        return complex(np.nan, np.nan)
-    elif np.issubdtype(col_dtype, np.bool_):
-        return False
-    elif np.issubdtype(col_dtype, str):
-        return ""
-    else:
-        raise RuntimeError(
-            "Padding / missing value not defined for the type requested: "
-            f"{col_dtype} (of type: {type(col_dtype)})"
-        )
-
-
-def convert_to_si_units(xds):
-    for data_var in xds.data_vars:
-        if "units" in xds[data_var].attrs:
-            for u_i, u in enumerate(xds[data_var].attrs["units"]):
-                if u == "km":
-                    xds[data_var][..., u_i] = xds[data_var][..., u_i] * 1e3
-                    xds[data_var].attrs["units"][u_i] = "m"
-                if u == "km/s":
-                    xds[data_var][..., u_i] = xds[data_var][..., u_i] * 1e3
-                    xds[data_var].attrs["units"][u_i] = "m/s"
-                if u == "deg":
-                    xds[data_var][..., u_i] = xds[data_var][..., u_i] * np.pi / 180
-                    xds[data_var].attrs["units"][u_i] = "rad"
-                if u == "Au" or u == "AU":
-                    xds[data_var][..., u_i] = xds[data_var][..., u_i] * 149597870700
-                    xds[data_var].attrs["units"][u_i] = "m"
-                if u == "Au/d" or u == "AU/d":
-                    xds[data_var][..., u_i] = (
-                        xds[data_var][..., u_i] * 149597870700 / 86400
-                    )
-                    xds[data_var].attrs["units"][u_i] = "m/s"
-                if u == "arcsec":
-                    xds[data_var][..., u_i] = xds[data_var][..., u_i] * np.pi / 648000
-                    xds[data_var].attrs["units"][u_i] = "rad"
-    return xds
-
-
-def add_position_offsets(dv_1, dv_2):
-    # Fun with angles: We are adding angles together. We need to make sure that the results are between -pi and pi.
-    new_pos = dv_1 + dv_2
-
-    while np.any(new_pos[:, 0] > np.pi) or np.any(new_pos[:, 0] < -np.pi):
-        new_pos[:, 0] = np.where(
-            new_pos[:, 0] > np.pi, new_pos[:, 0] - 2 * np.pi, new_pos[:, 0]
-        )
-        new_pos[:, 0] = np.where(
-            new_pos[:, 0] < -np.pi, new_pos[:, 0] + 2 * np.pi, new_pos[:, 0]
-        )
-
-    while np.any(new_pos[:, 1] > np.pi / 2) or np.any(new_pos[:, 1] < -np.pi / 2):
-        new_pos[:, 1] = np.where(
-            new_pos[:, 1] > np.pi / 2, new_pos[:, 1] - np.pi, new_pos[:, 1]
-        )
-        new_pos[:, 1] = np.where(
-            new_pos[:, 1] < -np.pi / 2, new_pos[:, 1] + np.pi, new_pos[:, 1]
-        )
-
-    return new_pos

xradio/correlated_data/_utils/__init__.py

@@ -1,5 +0,0 @@
-from . import ms
-from . import zarr
-from . import _utils
-
-__all__ = ["ms", "zarr", "_utils"]

xradio/correlated_data/correlated_xds.py

@@ -1,13 +0,0 @@
-import pandas as pd
-from xradio._utils.list_and_array import to_list
-import xarray as xr
-import numbers
-
-
-class CorrelatedXds(xr.Dataset):
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def to_zarr():
-        pass

xradio/correlated_data/processing_set.py

@@ -1,301 +0,0 @@
-import pandas as pd
-from xradio._utils.list_and_array import to_list
-import numbers
-
-
-class ProcessingSet(dict):
-    """
-    A dictionary subclass representing a Processing Set (PS) that is a set of Measurement Sets v4 (MS).
-
-    This class extends the built-in `dict` class and provides additional methods for manipulating and selecting subsets of the Processing Set.
-
-    Attributes:
-        meta (dict): A dictionary containing metadata information about the Processing Set.
-
-    Methods:
-        summary(data_group="base"): Returns a summary of the Processing Set as a Pandas table.
-        get_ps_max_dims(): Returns the maximum dimension of all the MSs in the Processing Set.
-        get_ps_freq_axis(): Combines the frequency axis of all MSs.
-        sel(query:str=None, **kwargs): Selects a subset of the Processing Set based on column names and values or a Pandas query.
-        ms_sel(**kwargs): Selects a subset of the Processing Set by applying the `sel` method to each individual MS.
-        ms_isel(**kwargs): Selects a subset of the Processing Set by applying the `isel` method to each individual MS.
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.meta = {"summary": {}}
-
-    def summary(self, data_group="base"):
-        """
-        Returns a summary of the Processing Set as a Pandas table.
-
-        Args:
-            data_group (str): The data group to summarize. Default is "base".
-
-        Returns:
-            pandas.DataFrame: A DataFrame containing the summary information.
-        """
-        if data_group in self.meta["summary"]:
-            return self.meta["summary"][data_group]
-        else:
-            self.meta["summary"][data_group] = self._summary(data_group).sort_values(
-                by=["name"], ascending=True
-            )
-            return self.meta["summary"][data_group]
-
-    def get_ps_max_dims(self):
-        """
-        Returns the maximum dimension of all the MSs in the Processing Set.
-
-        For example, if the Processing Set contains two MSs with dimensions (50, 20, 30) and (10, 30, 40), the maximum dimensions will be (50, 30, 40).
-
-        Returns:
-            dict: A dictionary containing the maximum dimensions of the Processing Set.
-        """
-        if "max_dims" in self.meta:
-            return self.meta["max_dims"]
-        else:
-            self.meta["max_dims"] = self._get_ps_max_dims()
-            return self.meta["max_dims"]
-
-    def get_ps_freq_axis(self):
-        """
-        Combines the frequency axis of all MSs.
-
-        Returns:
-            xarray.DataArray: The frequency axis of the Processing Set.
-        """
-        if "freq_axis" in self.meta:
-            return self.meta["freq_axis"]
-        else:
-            self.meta["freq_axis"] = self._get_ps_freq_axis()
-            return self.meta["freq_axis"]
-
-    def _summary(self, data_group="base"):
-        summary_data = {
-            "name": [],
-            "intents": [],
-            "shape": [],
-            "polarization": [],
-            "scan_number": [],
-            "spw_name": [],
-            # "field_id": [],
-            "field_name": [],
-            # "source_id": [],
-            "source_name": [],
-            # "num_lines": [],
-            "line_name": [],
-            "field_coords": [],
-            "start_frequency": [],
-            "end_frequency": [],
-        }
-        from astropy.coordinates import SkyCoord
-        import astropy.units as u
-
-        for key, value in self.items():
-            summary_data["name"].append(key)
-            summary_data["intents"].append(value.attrs["partition_info"]["intents"])
-            summary_data["spw_name"].append(
-                value.attrs["partition_info"]["spectral_window_name"]
-            )
-            summary_data["polarization"].append(value.polarization.values)
-            summary_data["scan_number"].append(
-                value.attrs["partition_info"]["scan_number"]
-            )
-            data_name = value.attrs["data_groups"][data_group]["correlated_data"]
-
-            if "VISIBILITY" in data_name:
-                center_name = "FIELD_PHASE_CENTER"
-
-            if "SPECTRUM" in data_name:
-                center_name = "FIELD_REFERENCE_CENTER"
-
-            summary_data["shape"].append(value[data_name].shape)
-
-            # summary_data["field_id"].append(value.attrs["partition_info"]["field_id"])
-            # summary_data["source_id"].append(value.attrs["partition_info"]["source_id"])
-
-            summary_data["field_name"].append(
-                value.attrs["partition_info"]["field_name"]
-            )
-            summary_data["source_name"].append(
-                value.attrs["partition_info"]["source_name"]
-            )
-
-            summary_data["line_name"].append(value.attrs["partition_info"]["line_name"])
-
-            # summary_data["num_lines"].append(value.attrs["partition_info"]["num_lines"])
-            summary_data["start_frequency"].append(
-                to_list(value["frequency"].values)[0]
-            )
-            summary_data["end_frequency"].append(to_list(value["frequency"].values)[-1])
-
-            if value[data_name].attrs["field_and_source_xds"].is_ephemeris:
-                summary_data["field_coords"].append("Ephemeris")
-            elif (
-                "time"
-                in value[data_name].attrs["field_and_source_xds"][center_name].coords
-            ):
-                summary_data["field_coords"].append("Multi-Phase-Center")
-            else:
-                ra_dec_rad = (
-                    value[data_name].attrs["field_and_source_xds"][center_name].values
-                )
-                frame = (
-                    value[data_name]
-                    .attrs["field_and_source_xds"][center_name]
-                    .attrs["frame"]
-                    .lower()
-                )
-
-                coord = SkyCoord(
-                    ra=ra_dec_rad[0] * u.rad, dec=ra_dec_rad[1] * u.rad, frame=frame
-                )
-
-                summary_data["field_coords"].append(
-                    [
-                        frame,
-                        coord.ra.to_string(unit=u.hour, precision=2),
-                        coord.dec.to_string(unit=u.deg, precision=2),
-                    ]
-                )
-
-        summary_df = pd.DataFrame(summary_data)
-        return summary_df
-
-    def _get_ps_freq_axis(self):
-        import xarray as xr
-
-        spw_ids = []
-        freq_axis_list = []
-        frame = self.get(0).frequency.attrs["frame"]
-        for ms_xds in self.values():
-            assert (
-                frame == ms_xds.frequency.attrs["frame"]
-            ), "Frequency reference frame not consistent in Processing Set."
-            if ms_xds.frequency.attrs["spectral_window_id"] not in spw_ids:
-                spw_ids.append(ms_xds.frequency.attrs["spectral_window_id"])
-                freq_axis_list.append(ms_xds.frequency)
-
-        freq_axis = xr.concat(freq_axis_list, dim="frequency").sortby("frequency")
-        return freq_axis
-
-    def _get_ps_max_dims(self):
-        max_dims = None
-        for ms_xds in self.values():
-            if max_dims is None:
-                max_dims = dict(ms_xds.sizes)
-            else:
-                for dim_name, size in ms_xds.sizes.items():
-                    if dim_name in max_dims:
-                        if max_dims[dim_name] < size:
-                            max_dims[dim_name] = size
-                    else:
-                        max_dims[dim_name] = size
-        return max_dims
-
-    def get(self, id):
-        return self[list(self.keys())[id]]
-
-    def sel(self, string_exact_match: bool = True, query: str = None, **kwargs):
-        """
-        Selects a subset of the Processing Set based on column names and values or a Pandas query.
-
-        The following columns are supported: name, intents, polarization, spw_name, field_name, source_name, field_coords, start_frequency, end_frequency.
-
-        This function will not apply any selection on the MS data so data will not be dropped for example if a MS has field_name=['field_0','field_10','field_08'] and ps.sel(field_name='field_0') is done the resulting MS will still have field_name=['field_0','field_10','field_08'].
-
-        Examples:
-            ps.sel(intents='OBSERVE_TARGET#ON_SOURCE', polarization=['RR', 'LL']) # Select all MSs with intents 'OBSERVE_TARGET#ON_SOURCE' and polarization 'RR' or 'LL'.
-            ps.sel(query='start_frequency > 100e9 AND end_frequency < 200e9') # Select all MSs with start_frequency greater than 100 GHz and less than 200 GHz.
-
-        Args:
-            query (str): A Pandas query string. Default is None.
-            string_exact_match (bool): If True, the selection will be an exact match for string and string list columns. Default is True.
-            **kwargs: Keyword arguments representing column names and values to filter the Processing Set.
-
-        Returns:
-            processing_set: The subset of the Processing Set.
-        """
-        import numpy as np
-
-        # def select_rows(df, col, input_strings):
-        #     return df[df[col].apply(lambda x: any(i in x for i in input_strings))]
-
-        # def select_rows(df, col, sel, string_exact_match):
-        #     def check_selection(row_val):
-        #         if isinstance(row_val, numbers.Number) or string_exact_match:
-        #             return any(i == row_val for i in sel) #If values are numbers
-        #         return any(i in row_val for i in sel) #If values are strings
-        #     return df[df[col].apply(check_selection)]
-
-        def select_rows(df, col, sel_vals, string_exact_match):
-            def check_selection(row_val):
-                row_val = to_list(
-                    row_val
-                )  # make sure that it is a list so that we can iterate over it.
-
-                for rw in row_val:
-                    for s in sel_vals:
-                        if string_exact_match:
-                            if rw == s:
-                                return True
-                        else:
-                            if s in rw:
-                                return True
-                return False
-
-            return df[df[col].apply(check_selection)]
-
-        summary_table = self.summary()
-        for key, value in kwargs.items():
-            value = to_list(value)  # make sure value is a list.
-
-            if len(value) == 1 and isinstance(value[0], slice):
-                summary_table = summary_table[
-                    summary_table[key].between(value[0].start, value[0].stop)
-                ]
-            else:
-                summary_table = select_rows(
-                    summary_table, key, value, string_exact_match
-                )
-
-        if query is not None:
-            summary_table = summary_table.query(query)
-
-        sub_ps = ProcessingSet()
-        for key, val in self.items():
-            if key in summary_table["name"].values:
-                sub_ps[key] = val
-
-        return sub_ps
-
-    def ms_sel(self, **kwargs):
-        """
-        Selects a subset of the Processing Set by applying the `sel` method to each MS.
-
-        Args:
-            **kwargs: Keyword arguments representing column names and values to filter the Processing Set.
-
-        Returns:
-            processing_set: The subset of the Processing Set.
-        """
-        sub_ps = ProcessingSet()
-        for key, val in self.items():
-            sub_ps[key] = val.sel(kwargs)
-        return sub_ps
-
-    def ms_isel(self, **kwargs):
-        """
-        Selects a subset of the Processing Set by applying the `isel` method to each MS.
-
-        Args:
-            **kwargs: Keyword arguments representing dimension names and indices to select from the Processing Set.
-
-        Returns:
-            processing_set: The subset of the Processing Set.
-        """
-        sub_ps = ProcessingSet()
-        for key, val in self.items():
-            sub_ps[key] = val.isel(kwargs)
-        return sub_ps

xradio/correlated_data/test__processing_set.py

@@ -1,74 +0,0 @@
-import unittest
-from xradio.src.xradio.correlated_data.processing_set import processing_set
-
-
-class TestProcessingSet(unittest.TestCase):
-
-    def setUp(self):
-        # Create a sample processing set
-        self.ps = processing_set()
-        self.ps["ms1"] = {
-            "partition_info": {
-                "obs_mode": "OBSERVE_TARGET#ON_SOURCE",
-                "spectral_window_name": "spw1",
-            },
-            "polarization": ["RR", "LL"],
-            "visibility": "vis1",
-            "frequency": [1e9, 2e9],
-        }
-        self.ps["ms2"] = {
-            "partition_info": {
-                "obs_mode": "OBSERVE_TARGET#CALIBRATE_POLARIZATION",
-                "spectral_window_name": "spw2",
-            },
-            "polarization": ["RR"],
-            "spectrum": "spec1",
-            "frequency": [2e9, 3e9],
-        }
-        self.ps["ms3"] = {
-            "partition_info": {
-                "obs_mode": "OBSERVE_TARGET#ON_SOURCE",
-                "spectral_window_name": "spw1",
-            },
-            "polarization": ["LL"],
-            "visibility": "vis2",
-            "frequency": [3e9, 4e9],
-        }
-
-    def test_summary(self):
-        # Test the summary method
-        summary = self.ps.summary()
-        self.assertEqual(
-            len(summary), 3
-        )  # Check the number of rows in the summary table
-
-    def test_get_ps_max_dims(self):
-        # Test the get_ps_max_dims method
-        max_dims = self.ps.get_ps_max_dims()
-        self.assertEqual(max_dims, {"frequency": 2, "polarization": 2})
-
-    def test_get_ps_freq_axis(self):
-        # Test the get_ps_freq_axis method
-        freq_axis = self.ps.get_ps_freq_axis()
-        self.assertEqual(len(freq_axis), 4)  # Check the length of the frequency axis
-
-    def test_sel(self):
-        # Test the sel method
-        subset = self.ps.sel(
-            obs_mode="OBSERVE_TARGET#ON_SOURCE", polarization=["RR", "LL"]
-        )
-        self.assertEqual(len(subset), 2)  # Check the number of MSs in the subset
-
-    def test_ms_sel(self):
-        # Test the ms_sel method
-        subset = self.ps.ms_sel(obs_mode="OBSERVE_TARGET#ON_SOURCE", polarization="RR")
-        self.assertEqual(len(subset), 1)  # Check the number of MSs in the subset
-
-    def test_ms_isel(self):
-        # Test the ms_isel method
-        subset = self.ps.ms_isel(obs_mode="OBSERVE_TARGET#ON_SOURCE", polarization="LL")
-        self.assertEqual(len(subset), 1)  # Check the number of MSs in the subset
-
-
-if __name__ == "__main__":
-    unittest.main()

xradio-0.0.41.dist-info/RECORD

@@ -1,75 +0,0 @@
-xradio/__init__.py,sha256=WHBhQWQie3YQqfIxQBL3LKiKuUcN7ZL7sPMEcdWOp5E,382
-xradio/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xradio/_utils/common.py,sha256=GY_fjet9wLhnx9XUINTq6ONBoceyLWRXHXlrNla3j3o,3726
-xradio/_utils/list_and_array.py,sha256=_wznOiHra1pHrWNdtQPXhk-TAXJ8qb9fTGE0czQNpIo,2802
-xradio/_utils/schema.py,sha256=tdGyvQTd-rQivtkzmH9-1f7KMIB9KeSf57EN2v7Mw_o,6855
-xradio/_utils/_casacore/tables.py,sha256=aq6E_4RRAHdTBCwMKrVil1cWhFU2O980DNH9IlRKXLw,1280
-xradio/_utils/zarr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xradio/_utils/zarr/common.py,sha256=egj3Zma0BUK0msOBDozMa-62rHrcxrjCNE5XkkZUq70,5332
-xradio/correlated_data/__init__.py,sha256=2oVnsJL4afv17FYpuHLH_bxspcJNWCWiT3wYCOn5jLk,423
-xradio/correlated_data/convert_msv2_to_processing_set.py,sha256=Hae-NOHSyxydlMEssiH3DpkYSJorDHTslsp3Dl8Dq08,6422
-xradio/correlated_data/correlated_xds.py,sha256=Q_qlQyAYC-9jhxvvR3wgGjPLy2tBctu2bvaD212BtVY,256
-xradio/correlated_data/load_processing_set.py,sha256=Sn8WQ6kdpnzngsGaW9o2fd6xOqOn2wM7yIKj45SXobQ,5526
-xradio/correlated_data/open_processing_set.py,sha256=BcW03m7ZoKcrdZsugczK6sbyu1YmPgoh2WZY5FYsrz8,4002
-xradio/correlated_data/processing_set.py,sha256=DXh34lr_-15kwy_ZkL3Ee25ptqcEwpQ9gbfJwU14zPI,11951
-xradio/correlated_data/schema.py,sha256=pJuWi0qwQoiJkGnb541f3Iq-YjiB6EsjDbbfW8Tc85c,59247
-xradio/correlated_data/test__processing_set.py,sha256=zWyUfCGr_FwxUqYZInNi3bYAH-ctmE_xB9ORSRaT4fs,2527
-xradio/correlated_data/_utils/__init__.py,sha256=Scu6rKJ2SpO8aG7F-xdTZcYfyWx0viV8gFh8E8ur_gI,93
-xradio/correlated_data/_utils/ms.py,sha256=m7cYGZGbdCD3uSPe1BldgRurZ4Y-K3vJr6aePUVyGjE,4310
-xradio/correlated_data/_utils/zarr.py,sha256=ehXlu0Xh_UZ5Xm2RnHCxESsRZ26c3DQAO5rqMK5MwTk,3947
-xradio/correlated_data/_utils/_ms/chunks.py,sha256=JTPk3il6fk570BjWZMoOAtsbvnLmqPcBv9EPY6A2yOs,2964
-xradio/correlated_data/_utils/_ms/conversion.py,sha256=Gz5_7vu0rUMrLxZJEMyCaCJ9UC9dKvVOemabVM67JCw,40940
-xradio/correlated_data/_utils/_ms/create_antenna_xds.py,sha256=w5yjNV4Ow1mL0zev9avLn7jfRfcBP-wmkpS0rGBGE4Y,17686
-xradio/correlated_data/_utils/_ms/create_field_and_source_xds.py,sha256=IPYbLx4580UGd2ibe2KtTThCCY4Ckz86reIL6s_8u4I,30881
-xradio/correlated_data/_utils/_ms/descr.py,sha256=dYK8mhXxODIh-dfqaOm-YZb7kmoN1N2golX_RFncO94,5215
-xradio/correlated_data/_utils/_ms/msv2_msv3.py,sha256=9AKs2HWly7Ivv_Cjr11dIPGmm33_rtSBoGF9wN5ZwEQ,116
-xradio/correlated_data/_utils/_ms/msv2_to_msv4_meta.py,sha256=gk9gU7g2Lk7dmaiLW8qecOEt574pRtGsCHnUnHXM3D0,1614
-xradio/correlated_data/_utils/_ms/msv4_info_dicts.py,sha256=kQpKNvgIki_ZIpC-lbKRqCKah7aLBoy5Q_NH1Q2vz3g,6895
-xradio/correlated_data/_utils/_ms/msv4_sub_xdss.py,sha256=qZUq6edNe5F9rLPrIEMXAPYehkk60WnVIq42MTqVho0,18440
-xradio/correlated_data/_utils/_ms/optimised_functions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xradio/correlated_data/_utils/_ms/partition_queries.py,sha256=hEe3VAzGqtEPg3X4GUhvHaxyesjS6WVy5et421qSdZg,14573
-xradio/correlated_data/_utils/_ms/partitions.py,sha256=_KhRq8bSx2QxuWp9K57fLoLxcU6kvJ35e6wvJ-THbwc,12979
-xradio/correlated_data/_utils/_ms/subtables.py,sha256=_mpOOtHexqhiqEKt7S4LVqImJoNMJKSY18vNVw83r_U,3945
-xradio/correlated_data/_utils/_ms/_tables/load.py,sha256=IR3fdKlq8rgH4bHmB1JTtB5gSGuITIvErJEVjUA8rWM,1799
-xradio/correlated_data/_utils/_ms/_tables/load_main_table.py,sha256=npy30aRt_qtd8vfgGWYQgHRj1YON-ZYjfQi7zzLtToM,14806
-xradio/correlated_data/_utils/_ms/_tables/read.py,sha256=JLhn_8W2spLJy_3MjZ1mdMPKe7GPTq3VwuLeY-DiCjk,42937
-xradio/correlated_data/_utils/_ms/_tables/read_main_table.py,sha256=8AbNt-AxrhPK3EPRa7xqJXffxzIgfVsv1BDfoVJEXLU,26056
-xradio/correlated_data/_utils/_ms/_tables/read_subtables.py,sha256=JM6pGUQtjQR881u9VqakmbJjppEFq-EVKnEZ14JqnAw,12438
-xradio/correlated_data/_utils/_ms/_tables/table_query.py,sha256=q8EGFf_zIwHcHnvFJOn8hPh8zFZQ3f7BGbXvL3bHad4,555
-xradio/correlated_data/_utils/_ms/_tables/write.py,sha256=43XQ-tHhbhex0eUTRknNpPEEOnNR-w1lGCox9WZ9NHE,9540
-xradio/correlated_data/_utils/_ms/_tables/write_exp_api.py,sha256=GDEll8nMwkQGc6vosu4UddFL5_ld7WurRgF9hYFTRmU,15511
-xradio/correlated_data/_utils/_utils/cds.py,sha256=OpvKowSheIthUbcPEv2AoKmxlEt3DqJZS5C1AYh5z10,1179
-xradio/correlated_data/_utils/_utils/partition_attrs.py,sha256=JaePHts_A0EbB4K-0a_uC98RZ2EmfjB9pDSEI11oAwk,3401
-xradio/correlated_data/_utils/_utils/stokes_types.py,sha256=DMa8TmmS7BQ99Xm8c7ZjcRapMtLbrKVxrt4f0qUIOvg,561
-xradio/correlated_data/_utils/_utils/xds_helper.py,sha256=jZWR55e574j9NJ4Yf5HdHD7J7QtKdXbXStbblQ66WdE,13218
-xradio/correlated_data/_utils/_zarr/encoding.py,sha256=GENIlThV6a9CUCL6gIGlu9c6NR3OFWNos6mpxZjMwDc,536
-xradio/correlated_data/_utils/_zarr/read.py,sha256=O9DiwD2Gn8WiatQ-Q6WGGSwjsXwFktG4f81lM-mgcSg,7596
-xradio/correlated_data/_utils/_zarr/write.py,sha256=k5IfqtI44Dm4KBDiKFGhL5hN7kwNOulvVHmeP5Mi7N4,10043
-xradio/image/__init__.py,sha256=HAD0GfopIbhdxOYckyW6S9US_dSWmZrwIl3FHUzZwrE,435
-xradio/image/image.py,sha256=QoJ_BTLoMfeXJzU1yvtidBIhaMmjNA5_-6C3FWJRUeI,15635
-xradio/image/_util/__init__.py,sha256=M9lxD1Gc7kv0ucDEDbjLRuIEuESev-IG8j9EaCKUAkA,77
-xradio/image/_util/casacore.py,sha256=DmBTHUQ6870N5ARuFnYSfjZSLniJYgsjrsICUlCREYM,4234
-xradio/image/_util/common.py,sha256=vQs7Du9FSkb_D64Syt3IkiWkb_GmG9xhDPdgbpgP9Ok,9031
-xradio/image/_util/fits.py,sha256=gyGm06fuCKqVGK7uv-ObvQNfFawUDsIOa_nQyklM3Aw,329
-xradio/image/_util/image_factory.py,sha256=6tPzs20FTm2wEshHc1xqtTV7D0TbKxGLUKAVtvOc68I,10506
-xradio/image/_util/zarr.py,sha256=lhQqVRC1GEWClG3zRbuDr2IlQBfXeDqaLUJIN-MVMxA,1652
-xradio/image/_util/_casacore/__init__.py,sha256=OlsiRE40o1jSbBI4khgQQzgfDYbAlOMKIhO4UFlbGhg,41
-xradio/image/_util/_casacore/common.py,sha256=ky999eTCWta8w-uIs-7P7rPhZRLuh9yTuQXAxPvaPm4,1579
-xradio/image/_util/_casacore/xds_from_casacore.py,sha256=4puiE2_1-7Y1-0yK7L8FYyDp5Ab8hEhDjLvoXiGMx9E,42561
-xradio/image/_util/_casacore/xds_to_casacore.py,sha256=P6c-yoOjuVQkm07ApA7FFKfje4aPwV-MsRFKaRaPq9I,15338
-xradio/image/_util/_fits/xds_from_fits.py,sha256=kpZ2gdbDQtoUD1DdQZymup5OVnB3e73D66LruLYESsw,28445
-xradio/image/_util/_zarr/common.py,sha256=apMX_bF4Hr3pFGjnDFpp36KgmhTYAPBZquNkjBHrsXk,307
-xradio/image/_util/_zarr/xds_from_zarr.py,sha256=4b6KHmAcnrhBbCi-Z7e3Lm6l6wziJL1zaNIohmPAYDk,3601
-xradio/image/_util/_zarr/xds_to_zarr.py,sha256=wogXbwX8n3Sl9PHoc3_Y_LBowQsQ-94HZQFZ5NcxUZA,1624
-xradio/image/_util/_zarr/zarr_low_level.py,sha256=_skL70DhtmVjmxRJsfZaospt3rndB9l-2QoHFF1kAKE,12786
-xradio/schema/__init__.py,sha256=EzEMnOtN8G_wdjo8QBRKfq5MrYgfr_nt1pfunlI6i6Q,733
-xradio/schema/bases.py,sha256=5BiE6gAq2xmaJEyiaGbpCSoNek83ly9f0R0Rv1rx9DM,17081
-xradio/schema/check.py,sha256=Quugw5pC-c3c6C_JujSOQSfU_XVFIwymmg8wM0IZtXY,18521
-xradio/schema/dataclass.py,sha256=Byegqga9tTkgFDMK6JXwLkDo78OX906v3CBElH592N4,12356
-xradio/schema/metamodel.py,sha256=WjtW7pAVzcjLRWifRH3sQoOiN6TV810hARpOIz1M_gw,3845
-xradio/schema/typing.py,sha256=8-o6fZd99kJ4FVdgBYRTIRJ-wDqpcUNXzCTfJvl3TIw,10439
-xradio-0.0.41.dist-info/LICENSE.txt,sha256=9CYIJt7riOXo9AD0eXBZviLxo_HebD-2JJI8oiWtzfg,1807
-xradio-0.0.41.dist-info/METADATA,sha256=vzs61B5tZwpiZDr-p1PQKm_EedSfE8JeA48D_3Kz43k,4510
-xradio-0.0.41.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-xradio-0.0.41.dist-info/top_level.txt,sha256=dQu27fGBZJ2Yk-gW5XeD-dZ76Xa4Xcvk60Vz-dwXp7k,7
-xradio-0.0.41.dist-info/RECORD,,