xradio 0.0.50__tar.gz → 0.0.52__tar.gz

{xradio-0.0.50/src/xradio.egg-info → xradio-0.0.52}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: xradio
-Version: 0.0.50
+Version: 0.0.52
 Summary:  Xarray Radio Astronomy Data IO
-Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>
+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
         
         All works in this repository are copyrighted 2024.  
@@ -43,7 +43,7 @@ License-File: LICENSE.txt
 Requires-Dist: astropy
 Requires-Dist: dask
 Requires-Dist: distributed
-Requires-Dist: toolviper
+Requires-Dist: toolviper>=0.0.11
 Requires-Dist: numba>=0.57.0
 Requires-Dist: numpy
 Requires-Dist: pytest
@@ -79,7 +79,13 @@ Dynamic: license-file
 # xradio
 Xarray Radio Astronomy Data IO is still in development.
 
-[![Python 3.9 3.10 3.11 3.12](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%203.12-blue)](https://www.python.org/downloads/release/python-380/)
+[![Python 3.11 3.12 3.13](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/downloads/release/python-3130/)
+[![Linux Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-linux.yml/badge.svg?branch=main)](https://github.com/casangi/xradio/actions/workflows/python-testing-linux.yml?query=branch%3Amain)
+[![macOS Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml/badge.svg?branch=main)](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml?query=branch%3Amain)
+[![ipynb Tests](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml/badge.svg?branch=main)](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml?query=branch%3Amain)
+[![Coverage](https://codecov.io/gh/casangi/xradio/branch/main/graph/badge.svg)](https://codecov.io/gh/casangi/xradio/branch/main/xradio)
+[![Documentation Status](https://readthedocs.org/projects/xradio/badge/?version=latest)](https://xradio.readthedocs.io)
+[![Version Status](https://img.shields.io/pypi/v/xradio.svg)](https://pypi.python.org/pypi/xradio/)
 
 # Installing
 It is recommended to use the conda environment manager from [miniforge](https://github.com/conda-forge/miniforge) to create a clean, self-contained runtime where XRADIO and all its dependencies can be installed:

xradio-0.0.52/README.md

@@ -0,0 +1,27 @@
+# xradio
+Xarray Radio Astronomy Data IO is still in development.
+
+[![Python 3.11 3.12 3.13](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/downloads/release/python-3130/)
+[![Linux Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-linux.yml/badge.svg?branch=main)](https://github.com/casangi/xradio/actions/workflows/python-testing-linux.yml?query=branch%3Amain)
+[![macOS Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml/badge.svg?branch=main)](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml?query=branch%3Amain)
+[![ipynb Tests](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml/badge.svg?branch=main)](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml?query=branch%3Amain)
+[![Coverage](https://codecov.io/gh/casangi/xradio/branch/main/graph/badge.svg)](https://codecov.io/gh/casangi/xradio/branch/main/xradio)
+[![Documentation Status](https://readthedocs.org/projects/xradio/badge/?version=latest)](https://xradio.readthedocs.io)
+[![Version Status](https://img.shields.io/pypi/v/xradio.svg)](https://pypi.python.org/pypi/xradio/)
+
+# Installing
+It is recommended to use the conda environment manager from [miniforge](https://github.com/conda-forge/miniforge) to create a clean, self-contained runtime where XRADIO and all its dependencies can be installed:
+```sh
+conda create --name xradio python=3.12 --no-default-packages
+conda activate xradio
+```
+> 📝 On macOS it is required to pre-install `python-casacore` using `conda install -c conda-forge python-casacore`.
+
+XRADIO can now be installed using:
+```sh
+pip install xradio
+```
+This will also install the minimal dependencies for XRADIO. To install the minimal dependencies and the interactive components (JupyterLab) use:
+```sh
+pip install "xradio[interactive]"
+```

{xradio-0.0.50 → xradio-0.0.52}/pyproject.toml

@@ -1,9 +1,12 @@
 [project]
 name = "xradio"
-version = "0.0.50"
+version = "0.0.52"
 description = " Xarray Radio Astronomy Data IO"
 authors = [
     {name = "Jan-Willem Steeb", email="jsteeb@nrao.edu"},
+    {name = "Federico Montesino Pouzols", email="pouzols@eso.edu"},
+    {name = "Dave Mehringer", email="dmehring@nrao.edu"},
+    {name = "Peter Wortmann", email="peter.wortmann@skao.int"}
 ]
 license = {file = "LICENSE.txt"}
 readme = "README.md"
@@ -13,7 +16,7 @@ dependencies = [
     'astropy',
     'dask',
     'distributed',
-    'toolviper',
+    'toolviper>=0.0.11',
     'numba>=0.57.0',
     'numpy',
     'pytest',

{xradio-0.0.50 → xradio-0.0.52}/src/xradio/_utils/dict_helpers.py

@@ -43,6 +43,30 @@ def make_time_measure_attrs(units=["s"], scale="utc", time_format="mjd") -> dict
     return {"units": u, "scale": scale, "format": time_format, "type": "time"}
 
 
+def make_time_measure_dict(data, units=["s"], scale="utc", time_format="mjd") -> dict:
+    """
+    create a time measure dictionary given value and units
+    Parameters
+    ----------
+    value : numeric or array of numerics
+        Time value
+    units: str
+        Time units
+    scale: str
+        Time scale
+    time_format: str
+        Time format
+    Returns
+    -------
+    dict
+    """
+    x = {}
+    x["attrs"] = make_time_measure_attrs(units, scale, time_format)
+    x["data"] = data
+    x["dims"] = []
+    return x
+
+
 def make_time_coord_attrs(units=["s"], scale="utc", time_format="mjd") -> dict:
     """
     create a time measure dictionary given value and units

{xradio-0.0.50 → xradio-0.0.52}/src/xradio/_utils/schema.py

@@ -190,14 +190,14 @@ casacore_to_msv4_measure_type = {
             "LSRK": "lsrk",
             "LSRD": "lsrd",
             "BARY": "BARY",
-            "GEO": "GEO",
+            "GEO": "gcrs",
             "TOPO": "TOPO",
         },  # The frames/observer we are not sure if/how to translate to astropy are uppercase
     },
     "position": {
         "type": "location",
         "Ref": "frame",
-        "Ref_map": {"ITRF": "GRS80"},
+        "Ref_map": {"ITRF": "ITRS"},
     },
     "uvw": {
         "type": "uvw",

{xradio-0.0.50 → xradio-0.0.52}/src/xradio/image/_util/_casacore/xds_from_casacore.py

@@ -10,7 +10,7 @@ import numpy as np
 import xarray as xr
 from astropy import units as u
 from casacore import tables
-from casacore.images import coordinates
+from casacore.images import coordinates, image as casa_image
 
 from .common import (
     _active_mask,
@@ -32,10 +32,11 @@ from ..common import (
 from ...._utils._casacore.tables import extract_table_attributes, open_table_ro
 from xradio._utils.coord_math import _deg_to_rad
 from xradio._utils.dict_helpers import (
-    make_quantity,
+    _casacore_q_to_xradio_q,
     make_frequency_reference_dict,
+    make_quantity,
     make_skycoord_dict,
-    _casacore_q_to_xradio_q,
+    make_time_measure_dict,
 )
 
 
@@ -89,19 +90,126 @@ def _add_mask(
     return xds
 
 
+def _casa_image_to_xds_image_attrs(image: casa_image, history: bool = True) -> dict:
+    """
+    get the image attributes from the casacoreimage object
+    """
+    meta_dict = image.info()
+    coord_dict = copy.deepcopy(meta_dict["coordinates"])
+    attrs = {}
+    attrs[_image_type] = image.info()["imageinfo"]["imagetype"]
+    attrs["units"] = image.unit()
+    attrs["telescope"] = {}
+    telescope = attrs["telescope"]
+    for k in ("observer", "obsdate", "telescope", "telescopeposition"):
+        if k.startswith("telescope"):
+            if k == "telescope":
+                telescope["name"] = coord_dict[k]
+            elif k in coord_dict:
+                casa_pos = coord_dict[k]
+                location = {}
+                loc_attrs = {}
+                loc_attrs["type"] = "location"
+                loc_attrs["frame"] = casa_pos["refer"]
+                """
+                if casa_pos["refer"] == "ITRF":
+                    loc_attrs["ellipsoid"] = "GRS80"
+                """
+                loc_attrs["units"] = [
+                    casa_pos["m0"]["unit"],
+                    casa_pos["m1"]["unit"],
+                    casa_pos["m2"]["unit"],
+                ]
+                loc_attrs["coordinate_system"] = "geocentric"
+                loc_attrs["origin_object_name"] = "earth"
+                location["attrs"] = loc_attrs
+                location["data"] = [
+                    casa_pos["m0"]["value"],
+                    casa_pos["m1"]["value"],
+                    casa_pos["m2"]["value"],
+                ]
+                telescope["location"] = location
+                """
+                del (
+                    telescope["position"]["refer"],
+                    telescope["position"]["m0"],
+                    telescope["position"]["m1"],
+                    telescope["position"]["m2"],
+                )
+                """
+        elif k == "obsdate":
+            obsdate = coord_dict[k]
+            """
+            o_attrs = {"type": "time"}
+            o_attrs["scale"] = coord_dict[k]["refer"]
+            myu = coord_dict[k]["m0"]["unit"]
+            o_attrs["units"] = myu if isinstance(myu, list) else [myu]
+            o_attrs["format"] = _get_time_format(m0["value"], m0["unit"])
+            o_date = {}
+            o_date["attrs"] = o_attrs
+            """
+            m0 = obsdate["m0"]
+            attrs["obsdate"] = make_time_measure_dict(
+                data=m0["value"],
+                units=m0["unit"],
+                scale=obsdate["refer"],
+                time_format=_get_time_format(m0["value"], m0["unit"]),
+            )
+        else:
+            attrs[k] = coord_dict[k] if k in coord_dict else ""
+    dir_key = next((k for k in coord_dict if k.startswith("direction")), None)
+    if dir_key:
+        frame, eqnx = _convert_direction_system(coord_dict[dir_key]["system"], "system")
+    else:
+        frame = "icrs"
+        logger.warning(
+            "No direction coordinate found from which "
+            "to get pointing center frame. Assuming ICRS"
+        )
+    # it looks like the pointing center is always in radians in a casa image coord system dict
+    # note that in a casa image, the pointing center does not explicitly have a reference frame
+    # associated with it.
+    # point_center = coord_dict["pointingcenter"]
+    attrs[_pointing_center] = make_skycoord_dict(
+        coord_dict["pointingcenter"]["value"].tolist(), ["rad", "rad"], frame
+    )
+    imageinfo = meta_dict["imageinfo"]
+    obj = "objectname"
+    attrs[_object_name] = imageinfo[obj] if obj in imageinfo else ""
+    attrs["user"] = meta_dict["miscinfo"]
+    defmask = "Image_defaultmask"
+    with open_table_ro(image.name()) as casa_table:
+        # the actual mask is a data var and data var names are all caps by convention
+        attrs[_active_mask] = (
+            casa_table.getkeyword(defmask).upper()
+            if defmask in casa_table.keywordnames()
+            else None
+        )
+    attrs["description"] = None
+    # if also loading history, put it as another xds in the image attrs
+    if history:
+        htable = os.sep.join([os.path.abspath(image.name()), "logtable"])
+        if os.path.isdir(htable):
+            attrs["history"] = read_generic_table(htable)
+        else:
+            logger.warning(
+                f"Unable to find history table {htable}. History will not be included"
+            )
+    return attrs
+
+
 def _add_sky_or_aperture(
     xds: xr.Dataset,
     ary: Union[np.ndarray, da.array],
     dimorder: list,
     img_full_path: str,
     has_sph_dims: bool,
+    history: bool,
 ) -> xr.Dataset:
     xda = xr.DataArray(ary, dims=dimorder).astype(ary.dtype)
     with _open_image_ro(img_full_path) as casa_image:
-        image_type = casa_image.info()["imageinfo"]["imagetype"]
-        unit = casa_image.unit()
-    xda.attrs[_image_type] = image_type
-    xda.attrs["units"] = unit
+        xda.attrs = _casa_image_to_xds_image_attrs(casa_image, history)
+    # xds.attrs = attrs
     name = "SKY" if has_sph_dims else "APERTURE"
     xda = xda.rename(name)
     xds[xda.name] = xda
@@ -143,7 +251,7 @@ def _add_vel_attrs(xds: xr.Dataset, coord_dict: dict) -> xr.Dataset:
     return xds
 
 
-def _casa_image_to_xds_attrs(img_full_path: str, history: bool = True) -> dict:
+def _casa_image_to_xds_attrs(img_full_path: str) -> dict:
     """
     Get the xds level attribut/es as a python dictionary
     """
@@ -187,67 +295,6 @@ def _casa_image_to_xds_attrs(img_full_path: str, history: bool = True) -> dict:
             if j in coord_dir_dict:
                 dir_dict[j] = coord_dir_dict[j]
         attrs["direction"] = dir_dict
-    attrs["telescope"] = {}
-    telescope = attrs["telescope"]
-    attrs["obsdate"] = {"type": "time"}
-    obsdate = attrs["obsdate"]
-    attrs[_pointing_center] = coord_dict["pointingcenter"].copy()
-    for k in ("observer", "obsdate", "telescope", "telescopeposition"):
-        if k.startswith("telescope"):
-            if k == "telescope":
-                telescope["name"] = coord_dict[k]
-            elif k in coord_dict:
-                telescope["position"] = coord_dict[k]
-                telescope["position"]["ellipsoid"] = telescope["position"]["refer"]
-                if telescope["position"]["refer"] == "ITRF":
-                    telescope["position"]["ellipsoid"] = "GRS80"
-                telescope["position"]["units"] = [
-                    telescope["position"]["m0"]["unit"],
-                    telescope["position"]["m1"]["unit"],
-                    telescope["position"]["m2"]["unit"],
-                ]
-                telescope["position"]["value"] = [
-                    telescope["position"]["m0"]["value"],
-                    telescope["position"]["m1"]["value"],
-                    telescope["position"]["m2"]["value"],
-                ]
-                del (
-                    telescope["position"]["refer"],
-                    telescope["position"]["m0"],
-                    telescope["position"]["m1"],
-                    telescope["position"]["m2"],
-                )
-        elif k == "obsdate":
-            obsdate["scale"] = coord_dict[k]["refer"]
-            myu = coord_dict[k]["m0"]["unit"]
-            obsdate["units"] = myu if isinstance(myu, list) else [myu]
-            obsdate["value"] = coord_dict[k]["m0"]["value"]
-            obsdate["format"] = _get_time_format(obsdate["value"], obsdate["units"])
-            obsdate["type"] = "time"
-        else:
-            attrs[k] = coord_dict[k] if k in coord_dict else ""
-    imageinfo = meta_dict["imageinfo"]
-    obj = "objectname"
-    attrs[_object_name] = imageinfo[obj] if obj in imageinfo else ""
-    attrs["user"] = meta_dict["miscinfo"]
-    defmask = "Image_defaultmask"
-    with open_table_ro(img_full_path) as casa_table:
-        # the actual mask is a data var and data var names are all caps by convention
-        attrs[_active_mask] = (
-            casa_table.getkeyword(defmask).upper()
-            if defmask in casa_table.keywordnames()
-            else None
-        )
-    attrs["description"] = None
-    # if also loading history, put it as another xds in the attrs
-    if history:
-        htable = os.sep.join([img_full_path, "logtable"])
-        if os.path.isdir(htable):
-            attrs["history"] = read_generic_table(htable)
-        else:
-            logger.warning(
-                f"Unable to find history table {htable}. History will not be included"
-            )
     return copy.deepcopy(attrs)
 
 

{xradio-0.0.50 → xradio-0.0.52}/src/xradio/image/_util/_casacore/xds_to_casacore.py

@@ -19,12 +19,16 @@ def _compute_direction_dict(xds: xr.Dataset) -> dict:
     """
     direction = {}
     xds_dir = xds.attrs["direction"]
+    direction["_axes_sizes"] = np.array(
+        [xds.sizes[dim] for dim in ("l", "m")], dtype=np.int32
+    )
+    direction["_image_axes"] = np.array([2, 3], dtype=np.int32)
     direction["system"] = xds_dir["reference"]["attrs"]["equinox"].upper()
     if direction["system"] == "J2000.0":
         direction["system"] = "J2000"
     direction["projection"] = xds_dir["projection"]
     direction["projection_parameters"] = xds_dir["projection_parameters"]
-    direction["units"] = np.array(xds_dir["reference"]["attrs"]["units"], dtype="<U16")
+    direction["units"] = xds_dir["reference"]["attrs"]["units"]
     direction["crval"] = np.array(xds_dir["reference"]["data"])
     direction["cdelt"] = np.array((xds.l[1] - xds.l[0], xds.m[1] - xds.m[0]))
     direction["crpix"] = _compute_sky_reference_pixel(xds)
@@ -34,9 +38,9 @@ def _compute_direction_dict(xds: xr.Dataset) -> dict:
     for s in ["longpole", "latpole"]:
         m = "lonpole" if s == "longpole" else s
         # lonpole, latpole are numerical values in degrees in casa images
-        direction[s] = Angle(
-            str(xds_dir[m]["data"]) + xds_dir[m]["attrs"]["units"][0]
-        ).deg
+        direction[s] = float(
+            Angle(str(xds_dir[m]["data"]) + xds_dir[m]["attrs"]["units"][0]).deg
+        )
     return direction
 
 
@@ -69,6 +73,8 @@ def _compute_spectral_dict(xds: xr.Dataset) -> dict:
     for a CASA image coordinate system
     """
     spec = {}
+    spec["_axes_sizes"] = np.array([xds.sizes["frequency"]], dtype=np.int32)
+    spec["_image_axes"] = np.array([0], dtype=np.int32)
     spec["formatUnit"] = ""
     spec["name"] = "Frequency"
     # spec["nativeType"] = _native_types.index(xds.frequency.attrs["native_type"])
@@ -76,7 +82,7 @@ def _compute_spectral_dict(xds: xr.Dataset) -> dict:
     spec["nativeType"] = 0
     spec["restfreq"] = xds.frequency.attrs["rest_frequency"]["data"]
     # spec["restfreqs"] = copy.deepcopy(xds.frequency.attrs["restfreqs"]["value"])
-    spec["restfreqs"] = [spec["restfreq"]]
+    spec["restfreqs"] = np.array([spec["restfreq"]])
     spec["system"] = xds.frequency.attrs["reference_value"]["attrs"]["observer"].upper()
     u = xds.frequency.attrs["reference_value"]["attrs"]["units"]
     spec["unit"] = u if isinstance(u, str) else u[0]
@@ -88,53 +94,65 @@ def _compute_spectral_dict(xds: xr.Dataset) -> dict:
     wcs = {}
     wcs["ctype"] = "FREQ"
     wcs["pc"] = 1.0
-    wcs["crval"] = xds.frequency.attrs["reference_value"]["data"]
-    wcs["cdelt"] = xds.frequency.values[1] - xds.frequency.values[0]
-    wcs["crpix"] = (wcs["crval"] - xds.frequency.values[0]) / wcs["cdelt"]
+    wcs["crval"] = float(xds.frequency.attrs["reference_value"]["data"])
+    wcs["cdelt"] = float(xds.frequency.values[1] - xds.frequency.values[0])
+    wcs["crpix"] = float((wcs["crval"] - xds.frequency.values[0]) / wcs["cdelt"])
     spec["wcs"] = wcs
     return spec
 
 
 def _coord_dict_from_xds(xds: xr.Dataset) -> dict:
     coord = {}
-    coord["telescope"] = xds.attrs["telescope"]["name"]
-    coord["observer"] = xds.attrs["observer"]
+    sky_ap = "SKY" if "SKY" in xds.data_vars else "APERTURE"
+    if "telescope" in xds[sky_ap].attrs:
+        tel = xds[sky_ap].attrs["telescope"]
+        if "name" in tel:
+            coord["telescope"] = xds[sky_ap].attrs["telescope"]["name"]
+        if "location" in tel:
+            xds_telloc = tel["location"]
+            telloc = {}
+            telloc["refer"] = xds_telloc["attrs"]["frame"]
+            if telloc["refer"] == "GRS80":
+                telloc["refer"] = "ITRF"
+            for i in range(3):
+                telloc[f"m{i}"] = {
+                    "unit": xds_telloc["attrs"]["units"][i],
+                    "value": xds_telloc["data"][i],
+                }
+            telloc["type"] = "position"
+            coord["telescopeposition"] = telloc
+    if "observer" in xds[sky_ap].attrs:
+        coord["observer"] = xds[sky_ap].attrs["observer"]
     obsdate = {}
     obsdate["refer"] = xds.coords["time"].attrs["scale"]
     obsdate["type"] = "epoch"
     obsdate["m0"] = {}
     obsdate["m0"]["unit"] = xds.coords["time"].attrs["units"][0]
-    obsdate["m0"]["value"] = xds.coords["time"].values[0]
+    obsdate["m0"]["value"] = float(xds.coords["time"].values[0])
     coord["obsdate"] = obsdate
-    coord["pointingcenter"] = xds.attrs[_pointing_center].copy()
-    if "position" in xds.attrs["telescope"]:
-        telpos = {}
-        telpos["refer"] = xds.attrs["telescope"]["position"]["ellipsoid"]
-        if xds.attrs["telescope"]["position"]["ellipsoid"] == "GRS80":
-            telpos["refer"] = "ITRF"
-        for i in range(3):
-            telpos[f"m{i}"] = {
-                "unit": xds.attrs["telescope"]["position"]["units"][i],
-                "value": xds.attrs["telescope"]["position"]["value"][i],
-            }
-        telpos["type"] = "position"
-        coord["telescopeposition"] = telpos
+    if _pointing_center in xds[sky_ap].attrs:
+        coord["pointingcenter"] = {
+            "initial": True,
+            "value": xds[sky_ap].attrs[_pointing_center]["data"],
+        }
     if "l" in xds.coords:
         coord["direction0"] = _compute_direction_dict(xds)
     else:
         coord["linear0"] = _compute_linear_dict(xds)
     coord["stokes1"] = {
-        "axes": np.array(["Stokes"], dtype="<U16"),
+        "_axes_sizes": np.array([xds.sizes["polarization"]], dtype=np.int32),
+        "_image_axes": np.array([1], dtype=np.int32),
+        "axes": ["Stokes"],
         "cdelt": np.array([1.0]),
         "crpix": np.array([0.0]),
         "crval": np.array([1.0]),
         "pc": np.array([[1.0]]),
-        "stokes": np.array(xds.polarization.values, dtype="<U16"),
+        "stokes": xds.polarization.values.tolist(),
     }
     coord["spectral2"] = _compute_spectral_dict(xds)
-    coord["pixelmap0"] = np.array([0, 1])
-    coord["pixelmap1"] = np.array([2])
-    coord["pixelmap2"] = np.array([3])
+    coord["pixelmap0"] = np.array([0, 1], dtype=np.int32)
+    coord["pixelmap1"] = np.array([2], dtype=np.int32)
+    coord["pixelmap2"] = np.array([3], dtype=np.int32)
     coord["pixelreplace0"] = np.array([0.0, 0.0])
     coord["pixelreplace1"] = np.array([0.0])
     coord["pixelreplace2"] = np.array([0.0])
@@ -144,7 +162,6 @@ def _coord_dict_from_xds(xds: xr.Dataset) -> dict:
     # this probbably needs some verification
     coord["worldreplace0"] = [0.0, 0.0]
     coord["worldreplace1"] = np.array(coord["stokes1"]["crval"])
-    # print("spectral", coord["spectral2"])
     coord["worldreplace2"] = np.array(coord["spectral2"]["wcs"]["crval"])
     return coord
 
@@ -181,7 +198,7 @@ def _imageinfo_dict_from_xds(xds: xr.Dataset) -> dict:
     ii["image_type"] = (
         xds[ap_sky].attrs["image_type"] if "image_type" in xds[ap_sky].attrs else ""
     )
-    ii["objectname"] = xds.attrs[_object_name]
+    ii["objectname"] = xds[ap_sky].attrs[_object_name]
     if "BEAM" in xds.data_vars:
         # multi beam
         pp = {}
@@ -231,7 +248,9 @@ def _write_casa_data(xds: xr.Dataset, image_full_path: str) -> None:
         else ("frequency", "polarization", "v", "u")
     )
     casa_image_shape = xds[sky_ap].isel(time=0).transpose(*trans_coords).shape[::-1]
-    active_mask = xds.attrs["active_mask"] if _active_mask in xds.attrs else ""
+    active_mask = (
+        xds[sky_ap].attrs["active_mask"] if _active_mask in xds[sky_ap].attrs else ""
+    )
     masks = []
     masks_rec = {}
     mask_rec = {