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

xradio-0.0.42.dist-info/RECORD

@@ -0,0 +1,76 @@
+xradio/__init__.py,sha256=WHBhQWQie3YQqfIxQBL3LKiKuUcN7ZL7sPMEcdWOp5E,382
+xradio/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xradio/_utils/coord_math.py,sha256=n4Td6jcEX4vM49Xseuwrg6USylTGsySS6CND93DEG_8,3587
+xradio/_utils/list_and_array.py,sha256=epw4IRnQUWP9x5mdsZPstECD7jUjXx7y9RgMdCDolEg,4291
+xradio/_utils/schema.py,sha256=p6Iet4Lfs1qUI3vWMUr-Sh2PsilSoSz9tqSP43U_0uQ,7398
+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/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=gCVIq547PZMOM7urkdwPXyKcfstD-loJFcf6YGa8CGM,9039
+xradio/image/_util/fits.py,sha256=gyGm06fuCKqVGK7uv-ObvQNfFawUDsIOa_nQyklM3Aw,329
+xradio/image/_util/image_factory.py,sha256=-ZCDkCg25HMN4ubDxeBPv24HsEpYB5_zJYajgPx6_pg,10514
+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=o03KTPEyJpG78GJJeT2gqYZWe7gqqWQ9ned0UEQw710,42596
+xradio/image/_util/_casacore/xds_to_casacore.py,sha256=qSoKemfH4wX7-7QrEQa_y3Qitn7NCIoCV7fLfDhaaUM,15427
+xradio/image/_util/_fits/xds_from_fits.py,sha256=MNlZfW0exYBlCoMCA_Nd84eggNw_W8WhjSICgAihyLk,28543
+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=fVaPnxYazz6UDLBZuyUOekZKQ945OwhfBHeNeDgnW0w,13338
+xradio/measurement_set/__init__.py,sha256=0M0Zl5uKozIp5mgPhNaIoal_UuZc1HCA6_zQOhLFo8A,567
+xradio/measurement_set/convert_msv2_to_processing_set.py,sha256=hviYPhiytkC8PqTPQvEp5ttKZs6MoDC0Rh57nqIgqMQ,6426
+xradio/measurement_set/load_processing_set.py,sha256=RedC4i4dOHzgYiz_C0P-3F0PwvEGUomvq_ilpcfUCco,5540
+xradio/measurement_set/measurement_set_xds.py,sha256=i1CQ8oz9lvRDpwkuRPYJPbbW9SB5oght4DrrfAkllAU,2953
+xradio/measurement_set/open_processing_set.py,sha256=533fwEP4pJIBB-NdwFttbobVb8zEXsblvDTjF4ptTDU,3831
+xradio/measurement_set/processing_set.py,sha256=NaxnJw2temC3N5V0ohvp5CLewAJHAm26TpTfZ0GXjuw,29733
+xradio/measurement_set/schema.py,sha256=e5bdPw9GHd0k2RGUL6ozNNz8eAz-dhru8XaLmBmZI7I,73511
+xradio/measurement_set/_utils/__init__.py,sha256=XE-h1yMfr6tVD6gdUwXO1CVq5SQ6kD_oj-e5TFwslds,97
+xradio/measurement_set/_utils/msv2.py,sha256=7hnZMFoQ-s1g0ATjEupLvtdqQCdroPv-Rl5OwjqXjh8,4430
+xradio/measurement_set/_utils/zarr.py,sha256=ehXlu0Xh_UZ5Xm2RnHCxESsRZ26c3DQAO5rqMK5MwTk,3947
+xradio/measurement_set/_utils/_msv2/chunks.py,sha256=JTPk3il6fk570BjWZMoOAtsbvnLmqPcBv9EPY6A2yOs,2964
+xradio/measurement_set/_utils/_msv2/conversion.py,sha256=LeHZomIbQcSXwprYvgilOUvzhIF3nuzonovl7_C9vNs,42387
+xradio/measurement_set/_utils/_msv2/create_antenna_xds.py,sha256=HhNieztzuP0Fg898mVHFHaDoaLrxw7JS98osuDSYHnI,18333
+xradio/measurement_set/_utils/_msv2/create_field_and_source_xds.py,sha256=jpAaNV76iTrRn-vOTPdihByaoZwl1viyK5VZNNOGdTE,34159
+xradio/measurement_set/_utils/_msv2/descr.py,sha256=dYK8mhXxODIh-dfqaOm-YZb7kmoN1N2golX_RFncO94,5215
+xradio/measurement_set/_utils/_msv2/msv2_msv3.py,sha256=9AKs2HWly7Ivv_Cjr11dIPGmm33_rtSBoGF9wN5ZwEQ,116
+xradio/measurement_set/_utils/_msv2/msv2_to_msv4_meta.py,sha256=gk9gU7g2Lk7dmaiLW8qecOEt574pRtGsCHnUnHXM3D0,1614
+xradio/measurement_set/_utils/_msv2/msv4_info_dicts.py,sha256=kQpKNvgIki_ZIpC-lbKRqCKah7aLBoy5Q_NH1Q2vz3g,6895
+xradio/measurement_set/_utils/_msv2/msv4_sub_xdss.py,sha256=6zEWiTraYGekZ9vb-V7OZ1kLxspzOzOYjETZWH26SCo,20148
+xradio/measurement_set/_utils/_msv2/optimised_functions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xradio/measurement_set/_utils/_msv2/partition_queries.py,sha256=hEe3VAzGqtEPg3X4GUhvHaxyesjS6WVy5et421qSdZg,14573
+xradio/measurement_set/_utils/_msv2/partitions.py,sha256=_KhRq8bSx2QxuWp9K57fLoLxcU6kvJ35e6wvJ-THbwc,12979
+xradio/measurement_set/_utils/_msv2/subtables.py,sha256=_mpOOtHexqhiqEKt7S4LVqImJoNMJKSY18vNVw83r_U,3945
+xradio/measurement_set/_utils/_msv2/_tables/load.py,sha256=IR3fdKlq8rgH4bHmB1JTtB5gSGuITIvErJEVjUA8rWM,1799
+xradio/measurement_set/_utils/_msv2/_tables/load_main_table.py,sha256=IOGHMyemLbc6kJZC81LE6l0gVdgXuIFmDty2pxb5rr0,14806
+xradio/measurement_set/_utils/_msv2/_tables/read.py,sha256=OV6Zfoz1mhOK4Fv4SeQ_M9f600nHK-BQfJ551Wmr5hA,42947
+xradio/measurement_set/_utils/_msv2/_tables/read_main_table.py,sha256=8AbNt-AxrhPK3EPRa7xqJXffxzIgfVsv1BDfoVJEXLU,26056
+xradio/measurement_set/_utils/_msv2/_tables/read_subtables.py,sha256=JM6pGUQtjQR881u9VqakmbJjppEFq-EVKnEZ14JqnAw,12438
+xradio/measurement_set/_utils/_msv2/_tables/table_query.py,sha256=q8EGFf_zIwHcHnvFJOn8hPh8zFZQ3f7BGbXvL3bHad4,555
+xradio/measurement_set/_utils/_msv2/_tables/write.py,sha256=43XQ-tHhbhex0eUTRknNpPEEOnNR-w1lGCox9WZ9NHE,9540
+xradio/measurement_set/_utils/_msv2/_tables/write_exp_api.py,sha256=GDEll8nMwkQGc6vosu4UddFL5_ld7WurRgF9hYFTRmU,15511
+xradio/measurement_set/_utils/_utils/cds.py,sha256=OpvKowSheIthUbcPEv2AoKmxlEt3DqJZS5C1AYh5z10,1179
+xradio/measurement_set/_utils/_utils/partition_attrs.py,sha256=JaePHts_A0EbB4K-0a_uC98RZ2EmfjB9pDSEI11oAwk,3401
+xradio/measurement_set/_utils/_utils/stokes_types.py,sha256=DMa8TmmS7BQ99Xm8c7ZjcRapMtLbrKVxrt4f0qUIOvg,561
+xradio/measurement_set/_utils/_utils/xds_helper.py,sha256=3BYwpeklJCRJCkkwNU54JbFgibaQOffK6vJzNcwicHI,13229
+xradio/measurement_set/_utils/_zarr/encoding.py,sha256=GENIlThV6a9CUCL6gIGlu9c6NR3OFWNos6mpxZjMwDc,536
+xradio/measurement_set/_utils/_zarr/read.py,sha256=O9DiwD2Gn8WiatQ-Q6WGGSwjsXwFktG4f81lM-mgcSg,7596
+xradio/measurement_set/_utils/_zarr/write.py,sha256=k5IfqtI44Dm4KBDiKFGhL5hN7kwNOulvVHmeP5Mi7N4,10043
+xradio/schema/__init__.py,sha256=EzEMnOtN8G_wdjo8QBRKfq5MrYgfr_nt1pfunlI6i6Q,733
+xradio/schema/bases.py,sha256=5BiE6gAq2xmaJEyiaGbpCSoNek83ly9f0R0Rv1rx9DM,17081
+xradio/schema/check.py,sha256=AWdqGwcbH1wW3_sWSAeILZd9L8_e3Ae5L9TURt3ns1k,19304
+xradio/schema/dataclass.py,sha256=w6FbFtmGnAX4SYwYar7v8-YFf6j40G7g_jvIfVCuxjc,14087
+xradio/schema/metamodel.py,sha256=WjtW7pAVzcjLRWifRH3sQoOiN6TV810hARpOIz1M_gw,3845
+xradio/schema/typing.py,sha256=8-o6fZd99kJ4FVdgBYRTIRJ-wDqpcUNXzCTfJvl3TIw,10439
+xradio/sphinx/__init__.py,sha256=VGY-7Ty3q67qpnBee0-znbiJ-Iy0F93UO--IpjEdHXc,380
+xradio/sphinx/schema_table.py,sha256=YTQvK-VOBIpFtcx7sjcaMod4OSbl0uowelYIcdP3oVg,11878
+xradio-0.0.42.dist-info/LICENSE.txt,sha256=9CYIJt7riOXo9AD0eXBZviLxo_HebD-2JJI8oiWtzfg,1807
+xradio-0.0.42.dist-info/METADATA,sha256=nuEv90nQvqHhEmGwQ53zU3xaIoE6ZaTLkF-mDhNYa6E,4488
+xradio-0.0.42.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+xradio-0.0.42.dist-info/top_level.txt,sha256=dQu27fGBZJ2Yk-gW5XeD-dZ76Xa4Xcvk60Vz-dwXp7k,7
+xradio-0.0.42.dist-info/RECORD,,

{xradio-0.0.40.dist-info → xradio-0.0.42.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.2)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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/vis/__init__.py

@@ -1,14 +0,0 @@
-from .read_processing_set import read_processing_set
-from .load_processing_set import load_processing_set
-from .convert_msv2_to_processing_set import convert_msv2_to_processing_set
-
-from .schema import VisibilityXds
-
-__all__ = [
-    "read_processing_set",
-    "load_processing_set",
-    "convert_msv2_to_processing_set",
-    "VisibilityXds",
-    "PointingXds",
-    "AntennaXds",
-]

xradio/vis/_processing_set.py

@@ -1,302 +0,0 @@
-import pandas as pd
-from xradio._utils.list_and_array import to_list
-import numbers
-
-
-class processing_set(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": [],
-            "obs_mode": [],
-            "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["obs_mode"].append(value.attrs["partition_info"]["obs_mode"])
-            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"]
-            )
-
-            if "visibility" in value.attrs["data_groups"][data_group]:
-                data_name = value.attrs["data_groups"][data_group]["visibility"]
-                center_name = "FIELD_PHASE_CENTER"
-
-            if "spectrum" in value.attrs["data_groups"][data_group]:
-                data_name = value.attrs["data_groups"][data_group]["spectrum"]
-                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, obs_mode, 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(obs_mode='OBSERVE_TARGET#ON_SOURCE', polarization=['RR', 'LL']) # Select all MSs with obs_mode '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 = processing_set()
-        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 = processing_set()
-        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 = processing_set()
-        for key, val in self.items():
-            sub_ps[key] = val.isel(kwargs)
-        return sub_ps

xradio/vis/_vis_utils/__init__.py

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