xradio 1.1.0__tar.gz → 1.1.1__tar.gz

{xradio-1.1.0/src/xradio.egg-info → xradio-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xradio
-Version: 1.1.0
+Version: 1.1.1
 Summary:  Xarray Radio Astronomy Data IO
 Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>, Federico Montesino Pouzols <pouzols@eso.edu>, Dave Mehringer <dmehring@nrao.edu>, Peter Wortmann <peter.wortmann@skao.int>
 License: BSD 3-Clause License
@@ -98,6 +98,7 @@ Requires-Dist: sphinx-autosummary-accessors; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
 Requires-Dist: twine; extra == "docs"
 Requires-Dist: pandoc; extra == "docs"
+Requires-Dist: toolviper; extra == "docs"
 Provides-Extra: all
 Requires-Dist: astropy; extra == "all"
 Requires-Dist: toolviper>=0.0.12; extra == "all"

{xradio-1.1.0 → xradio-1.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xradio"
-version = "v1.1.0"
+version = "v1.1.1"
 description = " Xarray Radio Astronomy Data IO"
 authors = [
     {name = "Jan-Willem Steeb", email="jsteeb@nrao.edu"},
@@ -85,7 +85,8 @@ docs = [
     'sphinx-autosummary-accessors',
     'sphinx_rtd_theme',
     'twine',
-    'pandoc'
+    'pandoc',
+    'toolviper',
 ]
 
 all = [

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/_utils/_casacore/casacore_from_casatools.py

@@ -29,6 +29,24 @@ except ModuleNotFoundError as exc:
         f"{exc}"
     )
 
+# Valid casacore ImageInfo enum values
+# Reference: https://casacore.github.io/casacore/classcasacore_1_1ImageInfo.html
+_VALID_IMAGE_TYPES = (
+    "Undefined",
+    "Intensity",
+    "Beam",
+    "ColumnDensity",
+    "DepolarizationRatio",
+    "KineticTemperature",
+    "MagneticField",
+    "OpticalDepth",
+    "RotationMeasure",
+    "RotationalTemperature",
+    "SpectralIndex",
+    "Velocity",
+    "VelocityDispersion",
+)
+
 import numpy as np
 import toolviper.utils.logger as logger
 
@@ -166,6 +184,32 @@ def wrap_class_methods(cls: type) -> type:
     return cls
 
 
+def _validate_image_type(value: str) -> str:
+    """Validate and normalize an image type string.
+
+    Parameters
+    ----------
+    value
+        The image type string to validate.
+
+    Returns
+    -------
+    str
+        A valid casacore ImageInfo enum value with proper capitalization.
+        Returns 'Intensity' if the input is not a valid type.
+
+    Notes
+    -----
+    Validation is case-insensitive. The returned string uses the
+    canonical capitalization from the casacore ImageInfo enum.
+    """
+    value_lower = value.lower()
+    for valid_type in _VALID_IMAGE_TYPES:
+        if valid_type.lower() == value_lower:
+            return valid_type
+    return "Intensity"
+
+
 @wrap_class_methods
 class table(casatools.table):
     """A wrapper for the casatools table object.
@@ -513,7 +557,7 @@ class image(casatools.image):
         self,
         imagename,
         axis=0,
-        maskname="mask_0",
+        maskname="MASK_0",
         images=(),
         values=None,
         coordsys=None,
@@ -702,18 +746,36 @@ class image(casatools.image):
     def imageinfo(self) -> dict:
         """Retrieve metadata from the image table.
 
-        This method accesses the image table associated with the image name
-        and attempts to retrieve information stored under the 'imageinfo'
-        keyword. If the 'imageinfo' keyword is not found in the table,
-        a default dictionary containing basic information is returned.
+        Accesses the image table and retrieves information stored under the
+        'imageinfo' keyword. The 'imagetype' value is validated against
+        casacore's ImageInfo enumeration values to mimic python-casacore
+        `image.imageinfo()` behavior.
 
         Returns
         -------
         dict
-            A dictionary containing image metadata. This is either the
-            value associated with the 'imageinfo' keyword in the table,
-            or a default dictionary {'imagetype': 'Intensity',
-            'objectname': ''} if the keyword is absent.
+            Image metadata dictionary containing:
+
+            - **imagetype** : str
+                Type of the image, validated against casacore ImageInfo enum.
+                Defaults to 'Intensity' if invalid or missing.
+            - **objectname** : str
+                Name of the observed object.
+
+        Notes
+        -----
+        image.info()['imageinfo'] and image.imageinfo() from python-casacore
+        always returns "imagetype" in a predefined enum value. When the "imageinfo"
+        keyword is missing from the image table, or a non-standard value of "imagetype"
+        (e.g. 'sky') was written into that keyword, image.info() will just return
+        "Intensity" as the imagetype.
+
+        Examples
+        --------
+        >>> img = image('my_image.im')
+        >>> info = img.imageinfo()
+        >>> info['imagetype']
+        'Intensity'
         """
         with table(self._imagename) as tb:
             if "imageinfo" in tb.keywordnames():
@@ -721,6 +783,10 @@ class image(casatools.image):
             else:
                 image_metadata = {"imagetype": "Intensity", "objectname": ""}
 
+        image_metadata["imagetype"] = _validate_image_type(
+            image_metadata.get("imagetype", "Intensity")
+        )
+
         return image_metadata
 
     def datatype(self):

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/image/_util/_casacore/xds_from_casacore.py

@@ -217,7 +217,7 @@ def _add_sky_or_aperture(
     img_full_path: str,
     has_sph_dims: bool,
     history: bool,
-    image_type: str = "SKY",
+    image_type: str,
 ) -> xr.Dataset:
     xda = xr.DataArray(ary, dims=dimorder).astype(ary.dtype)
     with _open_image_ro(img_full_path) as casa_image:
@@ -270,8 +270,6 @@ def _casa_image_to_xds_attrs(img_full_path: str) -> dict:
     """
     with _open_image_ro(img_full_path) as casa_image:
         meta_dict = casa_image.info()
-    # print("meta_dict:", meta_dict)
-    # print("***********")
     coord_dict = copy.deepcopy(meta_dict["coordinates"])
     attrs = {}
     dir_key = None
@@ -350,14 +348,13 @@ def _casa_image_to_xds_attrs(img_full_path: str) -> dict:
 
 
 def _casa_image_to_xds_coords(
-    img_full_path: str, verbose: bool, do_sky_coords: bool
+    img_full_path: str, verbose: bool, do_sky_coords: bool, image_type: str
 ) -> dict:
     """
     TODO: complete documentation
     Create an xds without any pixel data from metadata from the specified CASA image
     """
     attrs = {}
-    # casa_image = images.image(img_full_path)
     with _open_image_ro(img_full_path) as casa_image:
         # shape list is the reverse of the actual image shape
         shape = casa_image.shape()[::-1]
@@ -390,46 +387,47 @@ def _casa_image_to_xds_coords(
         coord_dict
     )
     coords["velocity"] = (["frequency"], velocity_vals)
-    if len(sphr_dims) > 0:
-        crpix = _flatten_list(csys.get_referencepixel())[::-1]
-        inc = _flatten_list(csys.get_increment())[::-1]
-        unit = _flatten_list(csys.get_unit())[::-1]
-        attr_note = _l_m_attr_notes()
-        for c in ["l", "m"]:
-            idx = dimmap[c]
-            delta = ((inc[idx]) * u.Unit(_get_unit(unit[idx]))).to("rad").value
-            coords[c] = _compute_linear_world_values(
-                naxis=shape[idx], crval=0.0, crpix=crpix[idx], cdelt=delta
-            )
-            coord_attrs[c] = {
-                "note": attr_note[c],
-            }
-        if do_sky_coords:
-            for k in coord_dict.keys():
-                if k.startswith("direction"):
-                    dc = coordinates.directioncoordinate(coord_dict[k])
-                    break
-            crval = _flatten_list(csys.get_referencevalue())[::-1]
-            pick = lambda my_list: [my_list[i] for i in sphr_dims]
-            my_ret = _compute_world_sph_dims(
-                projection=dc.get_projection(),
-                shape=pick(shape),
-                ctype=diraxes,
-                crval=pick(crval),
-                crpix=pick(crpix),
-                cdelt=pick(inc),
-                cunit=pick(unit),
-            )
-            for i in [0, 1]:
-                axis_name = my_ret["axis_name"][i]
-                coords[axis_name] = (["l", "m"], my_ret["value"][i])
-                coord_attrs[axis_name] = {}
-    else:
-        # Fourier image
-        ret = _get_uv_values_attrs(coord_dict, axis_names, shape)
-        for z in ["u", "v"]:
-            coords[z], coord_attrs[z] = ret[z]
-    coords["beam_params_label"] = ["major", "minor", "pa"]
+    if image_type.upper() != "VISIBILITY_NORMALIZATION":
+        if len(sphr_dims) > 0:
+            crpix = _flatten_list(csys.get_referencepixel())[::-1]
+            inc = _flatten_list(csys.get_increment())[::-1]
+            unit = _flatten_list(csys.get_unit())[::-1]
+            attr_note = _l_m_attr_notes()
+            for c in ["l", "m"]:
+                idx = dimmap[c]
+                delta = ((inc[idx]) * u.Unit(_get_unit(unit[idx]))).to("rad").value
+                coords[c] = _compute_linear_world_values(
+                    naxis=shape[idx], crval=0.0, crpix=crpix[idx], cdelt=delta
+                )
+                coord_attrs[c] = {
+                    "note": attr_note[c],
+                }
+            if do_sky_coords:
+                for k in coord_dict.keys():
+                    if k.startswith("direction"):
+                        dc = coordinates.directioncoordinate(coord_dict[k])
+                        break
+                crval = _flatten_list(csys.get_referencevalue())[::-1]
+                pick = lambda my_list: [my_list[i] for i in sphr_dims]
+                my_ret = _compute_world_sph_dims(
+                    projection=dc.get_projection(),
+                    shape=pick(shape),
+                    ctype=diraxes,
+                    crval=pick(crval),
+                    crpix=pick(crpix),
+                    cdelt=pick(inc),
+                    cunit=pick(unit),
+                )
+                for i in [0, 1]:
+                    axis_name = my_ret["axis_name"][i]
+                    coords[axis_name] = (["l", "m"], my_ret["value"][i])
+                    coord_attrs[axis_name] = {}
+        else:
+            # Fourier image
+            ret = _get_uv_values_attrs(coord_dict, axis_names, shape)
+            for z in ["u", "v"]:
+                coords[z], coord_attrs[z] = ret[z]
+        coords["beam_params_label"] = ["major", "minor", "pa"]
     attrs["shape"] = shape
     xds = xr.Dataset(coords=coords)
     for c in coord_attrs.keys():

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/image/_util/_casacore/xds_to_casacore.py

@@ -177,7 +177,7 @@ def _coord_dict_from_xds(xds: xr.Dataset) -> dict:
     if "observer" in xds[sky_ap].attrs:
         coord["observer"] = xds[sky_ap].attrs["observer"]
     obsdate = {}
-    obsdate["refer"] = xds.coords["time"].attrs["scale"]
+    obsdate["refer"] = xds.coords["time"].attrs["scale"].upper()
     obsdate["type"] = "epoch"
     obsdate["m0"] = {}
     obsdate["m0"]["unit"] = xds.coords["time"].attrs["units"]

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/image/_util/_fits/xds_from_fits.py

@@ -72,7 +72,7 @@ def _fits_image_to_xds(
     xds = _create_coords(helpers, header, do_sky_coords)
     sphr_dims = helpers["sphr_dims"]
     ary = _read_image_array(img_full_path, chunks, helpers, verbose)
-    dim_order = _get_xds_dim_order(sphr_dims)
+    dim_order = _get_xds_dim_order(sphr_dims, image_type)
     xds = _add_sky_or_aperture(
         xds, ary, dim_order, header, helpers, sphr_dims, image_type
     )

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/image/_util/casacore.py

@@ -10,7 +10,7 @@ from typing import Union
 
 import xarray as xr
 import re
-
+import dask.array as da
 from xradio._utils.schema import get_data_group_keys
 
 try:
@@ -47,25 +47,63 @@ from xradio.image._util._casacore.common import _beam_fit_params, _open_image_ro
 warnings.filterwarnings("ignore", category=FutureWarning)
 
 
-def _load_casa_image_block(
-    infile: str, block_des: dict, do_sky_coords, image_type: str
-) -> xr.Dataset:
+def _squeeze_if_needed(ary: da, image_type: str) -> da:
+    if image_type.upper() == "VISIBILITY_NORMALIZATION":
+        shape = ary.shape
+        if shape[3] != 1 or shape[4] != 1:
+            raise ValueError(
+                "VISIBILITY_NORMALIZATION casa image must have l and m of length 1. Found "
+                + [shape[3], shape[4]]
+            )
+        ary = ary.squeeze(axis=(3, 4))
+    return ary
+
+
+def _get_casa_image_metadata(infile: str, do_sky_coords: bool, image_type: str) -> dict:
     image_full_path = os.path.expanduser(infile)
     with _open_image_ro(image_full_path) as casa_image:
         coords = casa_image.coordinates()
         cshape = casa_image.shape()
-    ret = _casa_image_to_xds_coords(image_full_path, False, do_sky_coords)
-    xds = ret["xds"].isel(block_des)
+    ret = _casa_image_to_xds_coords(image_full_path, False, do_sky_coords, image_type)
+    xds = ret["xds"]
+    sphr_dims = ret["sphr_dims"]
     nchan = ret["xds"].sizes["frequency"]
     npol = ret["xds"].sizes["polarization"]
+    dimorder = _get_xds_dim_order(ret["sphr_dims"], image_type)
+    metadata = {
+        "coords": coords,
+        "cshape": cshape,
+        "image_full_path": image_full_path,
+        "nchan": nchan,
+        "npol": npol,
+        "dimorder": dimorder,
+        # "xds_attrs": _casa_image_to_xds_attrs(image_full_path),
+        "sphr_dims": sphr_dims,
+        "xds": xds,
+    }
+    return metadata
+
+
+def _load_casa_image_block(
+    infile: str, block_des: dict, do_sky_coords: bool, image_type: str
+) -> xr.Dataset:
+    md = _get_casa_image_metadata(infile, do_sky_coords, image_type)
+    coords = md["coords"]
+    cshape = md["cshape"]
+    dimorder = md["dimorder"]
+    sphr_dims = md["sphr_dims"]
+    nchan = md["nchan"]
+    npol = md["npol"]
+    xds = md["xds"].isel(block_des)
+    image_full_path = md["image_full_path"]
     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)
     block = _get_persistent_block(
         image_full_path, shapes, starts, dimorder, transpose_list, new_axes
     )
+    block = _squeeze_if_needed(block, image_type)
     xds = _add_sky_or_aperture(
-        xds, block, dimorder, image_full_path, ret["sphr_dims"], False, image_type
+        xds, block, dimorder, image_full_path, sphr_dims, False, image_type
     )
     mymasks = _get_mask_names(image_full_path)
     for m in mymasks:
@@ -104,18 +142,21 @@ def _open_casa_image(
     history: bool = False,
     image_type: str = "SKY",
 ) -> xr.Dataset:
-    img_full_path = os.path.expanduser(infile)
-    ret = _casa_image_to_xds_coords(img_full_path, verbose, do_sky_coords)
-    xds = ret["xds"]
-    dimorder = _get_xds_dim_order(ret["sphr_dims"])
+    md = _get_casa_image_metadata(infile, do_sky_coords, image_type)
+    xds = md["xds"]
+    dimorder = md["dimorder"]
+    sphr_dims = md["sphr_dims"]
+    img_full_path = md["image_full_path"]
+    ary = _read_image_array(img_full_path, chunks, verbose=verbose)
+    ary = _squeeze_if_needed(ary, image_type)
     xds = _add_sky_or_aperture(
         xds,
-        _read_image_array(img_full_path, chunks, verbose=verbose),
+        ary,
         dimorder,
         img_full_path,
-        ret["sphr_dims"],
+        sphr_dims,
         history,
-        image_type=image_type,
+        image_type,
     )
     if masks:
         mymasks = _get_mask_names(img_full_path)

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/image/_util/common.py

@@ -25,10 +25,11 @@ def _aperture_or_sky(xds: xr.Dataset) -> str:
     return "SKY" if "SKY" in xds.data_vars or "l" in xds.coords else "APERTURE"
 
 
-def _get_xds_dim_order(has_sph: bool) -> list:
+def _get_xds_dim_order(has_sph: bool, image_type: str) -> list:
     dimorder = ["time", "frequency", "polarization"]
-    dir_lin = ["l", "m"] if has_sph else ["u", "v"]
-    dimorder.extend(dir_lin)
+    if image_type.upper() != "VISIBILITY_NORMALIZATION":
+        dir_lin = ["l", "m"] if has_sph else ["u", "v"]
+        dimorder.extend(dir_lin)
     return dimorder
 
 

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/image/_util/image_factory.py

@@ -693,14 +693,17 @@ def create_image_xds_from_store(
                         data_group["beam_fit_params_point_spread_function"] = (
                             "BEAM_FIT_PARAMS_" + image_type.upper()
                         )
+    if (
+        "visibility_normalization" not in image_type.lower()
+        or len(img_xds.data_vars) > 1
+    ):
+        # if beam_param coord not in image type it is not auto assigned to img_xds
+        # but it must be present even if unused
+        if "beam_params_label" not in img_xds.dims:
+            img_xds.expand_dims(beam_params_label=3)
 
-    # if beam_param coord not in image type it is not auto assigned to img_xds
-    # but it must be present even if unused
-    if "beam_params_label" not in img_xds.dims:
-        img_xds.expand_dims(beam_params_label=3)
-
-    if "beam_params_label" not in img_xds.coords:
-        img_xds = _move_beam_param_dim_coord(img_xds)
+        if "beam_params_label" not in img_xds.coords:
+            img_xds = _move_beam_param_dim_coord(img_xds)
     img_xds.attrs["type"] = "image_dataset"
     img_xds.attrs["data_groups"] = data_groups
     return img_xds

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/measurement_set/_utils/_msv2/_tables/read.py

@@ -93,12 +93,9 @@ def convert_mjd_time(rawtimes: np.ndarray) -> np.ndarray:
     np.ndarray
         times converted to pandas reference and datetime type
     """
-
-    print("^^^^^^^", rawtimes, MJD_DIF_UNIX, SECS_IN_DAY)
     times_reref = pd.to_datetime(
         (rawtimes - MJD_DIF_UNIX) * SECS_IN_DAY, unit="s"
     ).values
-    print("^^^^^^^", times_reref)
 
     return times_reref
 

{xradio-1.1.0 → xradio-1.1.1}/src/xradio/testing/measurement_set/__init__.py

@@ -5,8 +5,6 @@ This module provides reusable test utilities for generating test data,
 custom assertions, and helper functions for testing xradio functionality.
 """
 
-import toolviper.utils.logger as _logger
-
 __all__ = [
     # Generators
     "gen_test_ms",
@@ -49,6 +47,8 @@ try:
         build_minimal_msv4_xdt,
     )
 except ModuleNotFoundError as exc:
+    import toolviper.utils.logger as _logger
+
     _logger.warning(
         "Could not import casacore tables to handle MSv2. "
         "Could not import the functions to convert from MSv2 to MSv4. "

{xradio-1.1.0 → xradio-1.1.1/src/xradio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xradio
-Version: 1.1.0
+Version: 1.1.1
 Summary:  Xarray Radio Astronomy Data IO
 Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>, Federico Montesino Pouzols <pouzols@eso.edu>, Dave Mehringer <dmehring@nrao.edu>, Peter Wortmann <peter.wortmann@skao.int>
 License: BSD 3-Clause License
@@ -98,6 +98,7 @@ Requires-Dist: sphinx-autosummary-accessors; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
 Requires-Dist: twine; extra == "docs"
 Requires-Dist: pandoc; extra == "docs"
+Requires-Dist: toolviper; extra == "docs"
 Provides-Extra: all
 Requires-Dist: astropy; extra == "all"
 Requires-Dist: toolviper>=0.0.12; extra == "all"

{xradio-1.1.0 → xradio-1.1.1}/src/xradio.egg-info/requires.txt

@@ -53,6 +53,7 @@ sphinx-autosummary-accessors
 sphinx_rtd_theme
 twine
 pandoc
+toolviper
 
 [interactive]
 astropy