xradio 0.0.56__py3-none-any.whl → 0.0.58__py3-none-any.whl

xradio/image/_util/_fits/xds_from_fits.py

@@ -5,6 +5,7 @@ from typing import Union
 import dask
 import dask.array as da
 import numpy as np
+import psutil
 import xarray as xr
 from astropy import units as u
 from astropy.io import fits
@@ -13,7 +14,7 @@ from astropy.time import Time
 from xradio._utils.coord_math import _deg_to_rad
 from xradio._utils.dict_helpers import (
     make_quantity,
-    make_frequency_reference_dict,
+    make_spectral_coord_reference_dict,
     make_skycoord_dict,
     make_time_measure_dict,
 )
@@ -35,20 +36,31 @@ from xradio.image._util.common import (
 
 
 def _fits_image_to_xds(
-    img_full_path: str, chunks: dict, verbose: bool, do_sky_coords: bool
+    img_full_path: str,
+    chunks: dict,
+    verbose: bool,
+    do_sky_coords: bool,
+    compute_mask: bool,
 ) -> dict:
     """
+    compute_mask : bool, optional
+        If True (default), compute and attach valid data masks to the xds.
+        If False, skip mask generation for performance. It is solely the responsibility
+        of the user to ensure downstream apps can handle NaN values; do not
+        ask package developers to add this non-standard behavior.
+
     TODO: complete documentation
     Create an xds without any pixel data from metadata from the specified FITS image
     """
-    # memmap = True allows only part of data to be loaded into memory
     # may also need to pass mode='denywrite'
     # https://stackoverflow.com/questions/35759713/astropy-io-fits-read-row-from-large-fits-file-with-mutliple-hdus
-    hdulist = fits.open(img_full_path, memmap=True)
-    attrs, helpers, header = _fits_header_to_xds_attrs(hdulist)
-    hdulist.close()
-    # avoid keeping reference to mem-mapped fits file
-    del hdulist
+    try:
+        hdulist = fits.open(img_full_path, memmap=True)
+        attrs, helpers, header = _fits_header_to_xds_attrs(hdulist, compute_mask)
+    finally:
+        hdulist.close()
+        # avoid keeping reference to mem-mapped fits file
+        del hdulist
     xds = _create_coords(helpers, header, do_sky_coords)
     sphr_dims = helpers["sphr_dims"]
     ary = _read_image_array(img_full_path, chunks, helpers, verbose)
@@ -86,10 +98,10 @@ def _add_freq_attrs(xds: xr.Dataset, helpers: dict) -> xr.Dataset:
         meta["rest_frequency"] = make_quantity(helpers["restfreq"], "Hz")
         meta["rest_frequencies"] = [meta["rest_frequency"]]
         meta["type"] = "frequency"
-        meta["wave_unit"] = ["mm"]
+        meta["wave_units"] = "mm"
         freq_axis = helpers["freq_axis"]
-        meta["reference_value"] = make_frequency_reference_dict(
-            helpers["crval"][freq_axis], ["Hz"], helpers["specsys"]
+        meta["reference_frequency"] = make_spectral_coord_reference_dict(
+            helpers["crval"][freq_axis], "Hz", helpers["specsys"]
         )
         # meta["cdelt"] = helpers["cdelt"][freq_axis]
     if not meta:
@@ -102,7 +114,7 @@ def _add_freq_attrs(xds: xr.Dataset, helpers: dict) -> xr.Dataset:
 
 def _add_vel_attrs(xds: xr.Dataset, helpers: dict) -> xr.Dataset:
     vel_coord = xds.coords["velocity"]
-    meta = {"units": ["m/s"]}
+    meta = {"units": "m/s"}
     if helpers["has_freq"]:
         meta["doppler_type"] = helpers.get("doppler", "RADIO")
     else:
@@ -159,9 +171,7 @@ def _xds_direction_attrs_from_header(helpers: dict, header) -> dict:
     helpers["ref_sys"] = ref_sys
     helpers["ref_eqx"] = ref_eqx
     # fits does not support conversion frames
-    direction["reference"] = make_skycoord_dict(
-        [0.0, 0.0], units=["rad", "rad"], frame=ref_sys
-    )
+    direction["reference"] = make_skycoord_dict([0.0, 0.0], units="rad", frame=ref_sys)
     dir_axes = helpers["dir_axes"]
     ddata = []
     dunits = []
@@ -239,16 +249,43 @@ def _get_telescope_metadata(helpers: dict, header) -> dict:
         r = np.sqrt(np.sum(xyz * xyz))
         lat = np.arcsin(z / r)
         long = np.arctan2(y, x)
-        tel["location"] = {
+        tel["direction"] = {
+            "attrs": {
+                "coordinate_system": "geocentric",
+                # I haven't seen a FITS keyword for reference frame of telescope posiiton
+                "frame": "ITRF",
+                "origin_object_name": "earth",
+                "type": "location",
+                "units": "rad",
+            },
+            "data": np.array([long, lat]),
+            "dims": ["ellipsoid_dir_label"],
+            "coords": {
+                "ellipsoid_dir_label": {
+                    "dims": ["ellipsoid_dir_label"],
+                    "data": ["lon", "lat"],
+                }
+            },
+        }
+        tel["distance"] = {
             "attrs": {
                 "coordinate_system": "geocentric",
                 # I haven't seen a FITS keyword for reference frame of telescope posiiton
                 "frame": "ITRF",
                 "origin_object_name": "earth",
                 "type": "location",
-                "units": ["rad", "rad", "m"],
+                "units": "m",
+            },
+            "data": np.array([r]),
+            "dims": ["ellipsoid_dis_label"],
+            "coords": {
+                "ellipsoid_dis_label": {
+                    "dims": ["ellipsoid_dis_label"],
+                    "data": [
+                        "dist",
+                    ],
+                }
             },
-            "data": np.array([long, lat, r]),
         }
     return tel
 
@@ -266,9 +303,7 @@ def _compute_pointing_center(helpers: dict, header) -> dict:
     pc_lat = float(header[f"CRVAL{t_axes[1]}"]) * unit[1]
     pc_long = pc_long.to(u.rad).value
     pc_lat = pc_lat.to(u.rad).value
-    return make_skycoord_dict(
-        [pc_long, pc_lat], units=["rad", "rad"], frame=helpers["ref_sys"]
-    )
+    return make_skycoord_dict([pc_long, pc_lat], units="rad", frame=helpers["ref_sys"])
 
 
 def _user_attrs_from_header(header) -> dict:
@@ -367,12 +402,41 @@ def _create_dim_map(helpers: dict, header) -> dict:
     return dim_map
 
 
-def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> tuple:
+def _fits_header_to_xds_attrs(
+    hdulist: fits.hdu.hdulist.HDUList, compute_mask: bool
+) -> tuple:
+    # First: Guard for unsupported compressed images
+    for i, hdu in enumerate(hdulist):
+        if isinstance(hdu, fits.CompImageHDU):
+            raise RuntimeError(
+                f"HDU {i}, name={hdu.name} is a CompImageHDU, which is not supported "
+                "for memory-mapping. "
+                "Cannot memory-map compressed FITS image (CompImageHDU). "
+                "Workaround: decompress the FITS using tools like `funpack`, `cfitsio`, "
+                "or Astropy's `.scale()`/`.copy()` workflows"
+            )
     primary = None
+    # FIXME beams is set but never actually used in this function. What's up with that?
     beams = None
     for hdu in hdulist:
         if hdu.name == "PRIMARY":
             primary = hdu
+            # Memory map support check
+            # avoid possibly non-existent hdu.scale_type attribute check and check header instead
+            header = hdu.header
+            scale = hdu.header.get("BSCALE", 1.0)
+            zero = hdu.header.get("BZERO", 0.0)
+            if not (scale == 1.0 and zero == 0.0):
+                raise RuntimeError(
+                    "Cannot memory-map scaled FITS data (BSCALE/BZERO set). "
+                    f"BZERO={zero}, BSCALE={scale}. "
+                    "Workaround: remove scaling with Astropy's"
+                    "  `HDU.data = HDU.data * BSCALE + BZERO` and save a new file"
+                )
+            # NOTE: check for primary.data size being too large removed, since
+            # data is read in chunks, so no danger of exhausting memory
+            # NOTE: sanity-check for ndarray type has been removed to avoid
+            # forcing eager memory load of possibly very large data array.
         elif hdu.name == "BEAMS":
             beams = hdu
         else:
@@ -402,13 +466,57 @@ def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> tuple:
         raise RuntimeError("Could not find both direction axes")
     if dir_axes is not None:
         attrs["direction"] = _xds_direction_attrs_from_header(helpers, header)
-    # FIXME read fits data in chunks in case all data too large to hold in memory
-    helpers["has_mask"] = da.any(da.isnan(primary.data)).compute()
+    helpers["has_mask"] = False
+    if compute_mask:
+        # 🧠 Why the primary.data reference here is Safe (does not cause
+        # an eager read of entire data array)
+        # primary.data is a memory-mapped array (because fits.open(..., memmap=True)
+        # is used upstream)
+        # da.from_array(...) wraps this without reading it immediately
+        # The actual read occurs inside:
+        # .map_blocks(...).any().compute()
+        # ...and that triggers blockwise loading via Dask → safe and parallel
+        # 💡 Gotcha
+        # What would be dangerous:
+        # arr = np.isnan(primary.data).any()
+        # That would pull the whole array into memory. But we're not doing that.
+        data_dask = da.from_array(primary.data, chunks="auto")
+        # The following code black has corner case exposure, although the guard should
+        # eliminate it. But there is a cleaner, dask-y way that should work that we implement
+        # next, with cautions
+        # def chunk_has_nan(block):
+        #     if not isinstance(block, np.ndarray) or block.size == 0:
+        #         return False
+        #    return np.isnan(block).any()
+        # helpers["has_mask"] = data_dask.map_blocks(chunk_has_nan, dtype=bool).any().compute()
+        # ✅ Option: np.isnan(data_dask).any().compute()
+        # 🔒 Pros:
+        # Cleaner and shorter (no custom function)
+        # Handles all chunk shapes robustly — no risk of empty inputs
+        # Uses Dask’s own optimized blockwise operations under the hood
+        # ⚠️ Cons:
+        # Might trigger more eager computation if Dask can't optimize well:
+        # If chunks are misaligned or small, Dask might combine many or materialize more blocks than needed
+        # Especially on large images, it could bump memory pressure slightly
+        # But since we already call .compute(), we will load some block data no matter
+        # what — this just changes how much and how smartly.
+        # ✅ Verdict for compute_mask
+        # Because this is explicitly for computing a global has-NaN flag (not building the
+        # dataset), recommend:
+        # helpers["has_mask"] = np.isnan(data_dask).any().compute()
+        # It's concise, robust to shape edge cases, and still parallelized.
+        # We can always revisit it later if perf becomes a concern — and even then,
+        # it's likely a matter of tuning chunks= manually rather than the expression itself.
+        #
+        # This compute will normally be done in parallel
+        helpers["has_mask"] = np.isnan(data_dask).any().compute()
     beam = _beam_attr_from_header(helpers, header)
     if beam != "mb":
         helpers["beam"] = beam
     if "BITPIX" in header:
         v = abs(header["BITPIX"])
+        if v == 16:
+            helpers["dtype"] = "int16"
         if v == 32:
             helpers["dtype"] = "float32"
         elif v == 64:
@@ -490,8 +598,8 @@ def _create_coords(
                 cdelt=pick(helpers["cdelt"]),
                 cunit=pick(helpers["cunit"]),
             )
+            helpers["cunit"] = my_ret["units"]
             for j, i in enumerate(dir_axes):
-                helpers["cunit"][i] = my_ret["unit"][j]
                 helpers["crval"][i] = my_ret["ref_val"][j]
                 helpers["cdelt"][i] = my_ret["inc"][j]
             coords[my_ret["axis_name"][0]] = (["l", "m"], my_ret["value"][0])
@@ -566,9 +674,9 @@ def _get_freq_values(helpers: dict) -> list:
         freq, vel = _freq_from_vel(
             crval, cdelt, crpix, cunit, "Z", helpers["shape"][v_idx], restfreq
         )
-        helpers["velocity"] = vel["value"] * u.Unit(vel["unit"])
-        helpers["crval"][v_idx] = (freq["crval"] * u.Unit(freq["unit"])).to(u.Hz).value
-        helpers["cdelt"][v_idx] = (freq["cdelt"] * u.Unit(freq["unit"])).to(u.Hz).value
+        helpers["velocity"] = vel["value"] * u.Unit(vel["units"])
+        helpers["crval"][v_idx] = (freq["crval"] * u.Unit(freq["units"])).to(u.Hz).value
+        helpers["cdelt"][v_idx] = (freq["cdelt"] * u.Unit(freq["units"])).to(u.Hz).value
         return list(freq["value"])
     else:
         return [1420e6]
@@ -587,6 +695,9 @@ def _get_velocity_values(helpers: dict) -> list:
         return v
 
 
+# FIXME change namee, even if there is only a single beam, we make a
+# multi beam array using it. If we have a beam, it will always be
+# "mutltibeam" is name is redundant and confusing
 def _do_multibeam(xds: xr.Dataset, imname: str) -> xr.Dataset:
     """Only run if we are sure there are multiple beams"""
     hdulist = fits.open(imname)
@@ -821,12 +932,12 @@ def _get_transpose_list(helpers: dict) -> tuple:
 
 def _read_image_chunk(img_full_path, shapes: tuple, starts: tuple) -> np.ndarray:
     hdulist = fits.open(img_full_path, memmap=True)
-    s = []
-    for start, length in zip(starts, shapes):
-        s.append(slice(start, start + length))
-    t = tuple(s)
-    z = hdulist[0].data[t]
+    hdu = hdulist[0]
+    # Chunk slice
+    slices = tuple(
+        slice(start, start + length) for start, length in zip(starts, shapes)
+    )
+    chunk = hdu.data[slices]
     hdulist.close()
-    # delete to avoid having a reference to a mem-mapped hdulist
     del hdulist
-    return z
+    return chunk

xradio/image/_util/casacore.py

@@ -46,8 +46,8 @@ def _load_casa_image_block(infile: str, block_des: dict, do_sky_coords) -> xr.Da
         cshape = casa_image.shape()
     ret = _casa_image_to_xds_coords(image_full_path, False, do_sky_coords)
     xds = ret["xds"].isel(block_des)
-    nchan = ret["xds"].dims["frequency"]
-    npol = ret["xds"].dims["polarization"]
+    nchan = ret["xds"].sizes["frequency"]
+    npol = ret["xds"].sizes["polarization"]
     starts, shapes, slices = _get_starts_shapes_slices(block_des, coords, cshape)
     dimorder = _get_xds_dim_order(ret["sphr_dims"])
     transpose_list, new_axes = _get_transpose_list(coords)
@@ -105,7 +105,7 @@ def _read_casa_image(
             xds = _add_mask(xds, m.upper(), ary, dimorder)
     xds.attrs = _casa_image_to_xds_attrs(img_full_path)
     beam = _get_beam(
-        img_full_path, xds.dims["frequency"], xds.dims["polarization"], True
+        img_full_path, xds.sizes["frequency"], xds.sizes["polarization"], True
     )
     if beam is not None:
         xds["BEAM"] = beam
@@ -133,6 +133,7 @@ def _xds_to_casa_image(xds: xr.Dataset, imagename: str) -> None:
         lockoptions={"option": "permanentwait"},
         ack=False,
     )
+
     tb.putkeyword("coords", coord)
     tb.putkeyword("imageinfo", ii)
     if units:

xradio/image/_util/common.py

@@ -110,7 +110,7 @@ def _numpy_arrayize_dv(xds: xr.Dataset) -> xr.Dataset:
 def _default_freq_info() -> dict:
     return {
         "rest_frequency": make_quantity(1420405751.7860003, "Hz"),
-        "type": "frequency",
+        "type": "spectral_coord",
         "frame": "lsrk",
         "units": "Hz",
         "waveUnit": "mm",
@@ -141,7 +141,7 @@ def _freq_from_vel(
     vel = vel * u.Unit(cunit)
     v_dict = {
         "value": vel.value,
-        "unit": cunit,
+        "units": cunit,
         "crval": crval,
         "cdelt": cdelt,
         "crpix": crpix,
@@ -154,7 +154,7 @@ def _freq_from_vel(
         fcdelt = -restfreq / _c / (crval * vel.unit / _c + 1) ** 2 * cdelt * vel.unit
         f_dict = {
             "value": freq.value,
-            "unit": "Hz",
+            "units": "Hz",
             "crval": fcrval.to(u.Hz).value,
             "cdelt": fcdelt.to(u.Hz).value,
             "crpix": crpix,
@@ -180,7 +180,7 @@ def _compute_world_sph_dims(
         "axis_name": [None, None],
         "ref_val": [None, None],
         "inc": [None, None],
-        "unit": ["rad", "rad"],
+        "units": "rad",
         "value": [None, None],
     }
     for i in range(2):

xradio/image/_util/image_factory.py

@@ -6,7 +6,7 @@ from typing import List, Union
 from .common import _c, _compute_world_sph_dims, _l_m_attr_notes
 from xradio._utils.coord_math import _deg_to_rad
 from xradio._utils.dict_helpers import (
-    make_frequency_reference_dict,
+    make_spectral_coord_reference_dict,
     make_quantity,
     make_skycoord_dict,
     make_time_coord_attrs,
@@ -50,24 +50,24 @@ def _add_common_attrs(
     cell_size: Union[List[float], np.ndarray],
     projection: str,
 ) -> xr.Dataset:
-    xds.time.attrs = make_time_coord_attrs(units=["d"], scale="utc", time_format="mjd")
+    xds.time.attrs = make_time_coord_attrs(units="d", scale="utc", time_format="mjd")
     freq_vals = np.array(xds.frequency)
     xds.frequency.attrs = {
         "observer": spectral_reference.lower(),
-        "reference_value": make_frequency_reference_dict(
+        "reference_frequency": make_spectral_coord_reference_dict(
             value=freq_vals[len(freq_vals) // 2].item(),
-            units=["Hz"],
+            units="Hz",
             observer=spectral_reference.lower(),
         ),
         "rest_frequencies": make_quantity(restfreq, "Hz"),
         "rest_frequency": make_quantity(restfreq, "Hz"),
-        "type": "frequency",
-        "units": ["Hz"],
-        "wave_unit": ["mm"],
+        "type": "spectral_coord",
+        "units": "Hz",
+        "wave_units": "mm",
     }
     xds.velocity.attrs = {"doppler_type": "radio", "type": "doppler", "units": "m/s"}
     reference = make_skycoord_dict(
-        data=phase_center, units=["rad", "rad"], frame=direction_reference
+        data=phase_center, units="rad", frame=direction_reference
     )
     reference["attrs"].update({"equinox": "j2000.0"})
     xds.attrs = {

xradio/image/image.py

@@ -15,13 +15,15 @@ import xarray as xr
 # from .._utils.zarr.common import _load_no_dask_zarr
 
 from ._util.casacore import _load_casa_image_block, _xds_to_casa_image
-from ._util.fits import _read_fits_image
+
+# from ._util.fits import _read_fits_image
 from ._util.image_factory import (
     _make_empty_aperture_image,
     _make_empty_lmuv_image,
     _make_empty_sky_image,
 )
 from ._util.zarr import _load_image_from_zarr_no_dask, _xds_from_zarr, _xds_to_zarr
+from ._util._fits.xds_from_fits import _fits_image_to_xds
 
 warnings.filterwarnings("ignore", category=FutureWarning)
 
@@ -32,12 +34,37 @@ def read_image(
     verbose: bool = False,
     do_sky_coords: bool = True,
     selection: dict = {},
+    compute_mask: bool = True,
 ) -> xr.Dataset:
     """
     Convert CASA, FITS, or zarr image to xradio image xds format
     ngCASA image spec is located at
     https://docs.google.com/spreadsheets/d/1WW0Gl6z85cJVPgtdgW4dxucurHFa06OKGjgoK8OREFA/edit#gid=1719181934
 
+    Notes on FITS compatibility and memory mapping:
+
+    This function relies on Astropy's `memmap=True` to avoid loading full image data into memory.
+    However, not all FITS files support memory-mapped reads.
+
+    ⚠️ The following FITS types are incompatible with memory mapping:
+
+    1. Compressed images (`CompImageHDU`)
+        = Workaround: decompress the FITS using tools like `funpack`, `cfitsio`,
+          or Astropy's `.scale()`/`.copy()` workflows
+    2. Some scaled images (using BSCALE/BZERO headers)
+        ✅ Supported:
+            - Files with no BSCALE/BZERO headers (or BSCALE=1.0 and BZERO=0.0)
+            - Uncompressed, unscaled primary HDUs
+        ⚠️ Unsupported: Files with BSCALE ≠ 1.0 or BZERO ≠ 0.0
+            - These require data rescaling in memory, which disables lazy access
+            - Attempting to slice such arrays forces eager read of the full dataset
+            - Workaround: remove scaling with Astropy's
+                `HDU.data = HDU.data * BSCALE + BZERO` and save a new file
+
+    These cases will raise `RuntimeError` to prevent silent eager loads that can exhaust memory.
+
+    If you encounter such an error, consider preprocessing the file to make it memory-mappable.
+
     Parameters
     ----------
     infile : str
@@ -69,11 +96,19 @@ def read_image(
         the selection, and the end pixel is not. An empty dictionary (the
         default) indicates that the entire image should be returned. Currently
         only supported for images stored in zarr format.
-
+     compute_mask : bool, optional
+        If True (default), compute and attach valid data masks when converting from FITS to xds.
+        If False, skip mask computation entirely. This may improve performance if the mask
+        is not required for subsequent processing. It may, however, result in unpredictable behavior
+        for applications that are not designed to handle missing data. It is the user's responsibility,
+        not the software's, to ensure that the mask is computed if it is necessary. Currently only
+        implemented for FITS images.
     Returns
     -------
     xarray.Dataset
     """
+    # from ._util.casacore import _read_casa_image
+    # return _read_casa_image(infile, chunks, verbose, do_sky_coords)
     emsgs = []
     do_casa = True
     try:
@@ -92,9 +127,10 @@ def read_image(
         except Exception as e:
             emsgs.append(f"image format appears not to be casacore: {e.args}")
     # next statement is for debug, comment when done debugging
-    # return _read_fits_image(infile, chunks, verbose, do_sky_coords)
+    # return _fits_image_to_xds(infile, chunks, verbose, do_sky_coords, compute_mask)
     try:
-        return _read_fits_image(infile, chunks, verbose, do_sky_coords)
+        img_full_path = os.path.expanduser(infile)
+        return _fits_image_to_xds(infile, chunks, verbose, do_sky_coords, compute_mask)
     except Exception as e:
         emsgs.append(f"image format appears not to be fits {e.args}")
     # when done debuggin comment out next line
@@ -111,7 +147,7 @@ def read_image(
     raise RuntimeError("\n".join(emsgs))
 
 
-def load_image(infile: str, block_des: dict = {}, do_sky_coords=True) -> xr.Dataset:
+def load_image(infile: str, block_des: dict = None, do_sky_coords=True) -> xr.Dataset:
     """
     Load an image or portion of an image (subimage) into memory with data variables
     being converted from dask to numpy arrays and coordinate arrays being converted
@@ -144,6 +180,10 @@ def load_image(infile: str, block_des: dict = {}, do_sky_coords=True) -> xr.Data
     """
     do_casa = True
     emsgs = []
+
+    if block_des is None:
+        block_des = {}
+
     selection = copy.deepcopy(block_des) if block_des else block_des
     if selection:
         for k, v in selection.items():

xradio/measurement_set/__init__.py

@@ -4,13 +4,11 @@ convert, and retrieve information from Processing Set and Measurement Sets nodes
 Processing Set DataTree
 """
 
-from .processing_set_xdt import *
+import toolviper.utils.logger as _logger
+
+from .processing_set_xdt import ProcessingSetXdt
 from .open_processing_set import open_processing_set
-from .load_processing_set import load_processing_set  # , ProcessingSetIterator
-from .convert_msv2_to_processing_set import (
-    convert_msv2_to_processing_set,
-    estimate_conversion_memory_and_cores,
-)
+from .load_processing_set import load_processing_set
 from .measurement_set_xdt import MeasurementSetXdt
 from .schema import SpectrumXds, VisibilityXds
 
@@ -19,9 +17,21 @@ __all__ = [
     "MeasurementSetXdt",
     "open_processing_set",
     "load_processing_set",
-    "ProcessingSetIterator",
-    "convert_msv2_to_processing_set",
-    "estimate_conversion_memory_and_cores",
     "SpectrumXds",
     "VisibilityXds",
 ]
+
+try:
+    from .convert_msv2_to_processing_set import (
+        convert_msv2_to_processing_set,
+        estimate_conversion_memory_and_cores,
+    )
+except ModuleNotFoundError as exc:
+    _logger.warning(
+        "Could not import the function to convert from MSv2 to MSv4. "
+        f"That functionality will not be available. Details: {exc}"
+    )
+else:
+    __all__.extend(
+        ["convert_msv2_to_processing_set", "estimate_conversion_memory_and_cores"]
+    )

xradio/measurement_set/_utils/__init__.py

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