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

xradio/__init__.py

@@ -1,5 +1,5 @@
-import os
-from toolviper.utils.logger import setup_logger
+# import os
+# from toolviper.utils.logger import setup_logger
 
 
 # _logger_name = "xradio"

xradio/_utils/_casacore/casacore_from_casatools.py

@@ -18,7 +18,17 @@ from typing import Any, Dict, List, Sequence, Union
 # Configure casaconfig settings prior to casatools import
 # this ensures optimal initialization and resource allocation for casatools
 # Also see : https://casadocs.readthedocs.io/en/stable/api/casaconfig.html
-import casaconfig.config
+try:
+    import casaconfig.config
+except ModuleNotFoundError as exc:
+    raise ModuleNotFoundError(
+        f"casaconfig.config cannot be found, probably because the package "
+        "casatools is not available. If you are here that is probably because "
+        "python-casacore is not available either. MSv2 related functionality "
+        "requires either python-casacore or casatools. Import failure details: "
+        f"{exc}"
+    )
+
 import numpy as np
 import toolviper.utils.logger as logger
 
@@ -70,7 +80,7 @@ else:
     casaconfig.config.logfile = "/dev/null"
     casaconfig.config.nologfile = True
 
-import casatools
+import casatools  # noqa: E402 (because of previous config initialization)
 
 casatools.logger.setglobal(True)
 casatools.logger.ompSetNumThreads(1)

xradio/_utils/_casacore/tables.py

@@ -4,6 +4,7 @@ except ImportError:
     import xradio._utils._casacore.casacore_from_casatools as tables
 
 from contextlib import contextmanager
+import os
 from typing import Dict, Generator
 
 # common casacore table handling code

xradio/_utils/coord_math.py

@@ -63,38 +63,37 @@ def wrap_to_pi(angles):
     return (angles + np.pi) % (2 * np.pi) - np.pi
 
 
-def wrap_to_pi(angles):
-    return (angles + np.pi) % (2 * np.pi) - np.pi
+def convert_to_si_units(xds):
+    import xarray as xr
 
+    with xr.set_options(keep_attrs=True):
+        for data_var in xds.data_vars:
+            if "units" in xds[data_var].attrs:
+                u = xds[data_var].attrs["units"]
 
-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"
+                    xds[data_var] = xds[data_var] * 1e3
+                    xds[data_var].attrs["units"] = "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"
+                    xds[data_var] = xds[data_var] * 1e3
+                    xds[data_var].attrs["units"] = "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"
+                    xds[data_var] = xds[data_var] * np.pi / 180
+                    xds[data_var].attrs["units"] = "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"
+                    xds[data_var] = xds[data_var] * 149597870700
+                    xds[data_var].attrs["units"] = "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"
+                    xds[data_var] = xds[data_var] * 149597870700 / 86400
+                    xds[data_var].attrs["units"] = "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"
+                    xds[data_var] = xds[data_var] * np.pi / 648000
+                    xds[data_var].attrs["units"] = "rad"
                 if u == "hPa":
-                    xds[data_var][..., u_i] = xds[data_var][..., u_i] * 100.0
-                    xds[data_var].attrs["units"][u_i] = "Pa"
+                    xds[data_var] = xds[data_var] * 100.0
+                    xds[data_var].attrs["units"] = "Pa"
                 if u == "m-2":
                     # IONOS_ELECTRON sometimes has "m-2" instead of "/m^2"
-                    xds[data_var].attrs["units"][u_i] = "/m^2"
+                    xds[data_var].attrs["units"] = "/m^2"
+
     return xds

xradio/_utils/dict_helpers.py

@@ -1,49 +1,114 @@
 def make_quantity(value, units: str, dims: list = []) -> dict:
     """
     create a quantity dictionary given value and units
+
     Parameters
     ----------
     value : numeric or array of numerics
         Quantity value
     units: str
         Quantity units
+
     Returns
     -------
     dict
     """
-    u = units if isinstance(units, list) else [units]
-    return {"data": value, "dims": dims, "attrs": {"units": u, "type": "quantity"}}
+    return {"data": value, "dims": dims, "attrs": make_quantity_attrs(units)}
+
+
+def ensure_units_are_consistent(units):
+    if isinstance(units, str):
+        return units
+    else:
+        u0 = units[0]
+        for u in units:
+            assert u0 == u, f"Units are not consistent: {u0} != {u}. "
+        return u0
 
 
-def make_frequency_reference_dict(
+def make_quantity_attrs(units: str) -> dict:
+    """
+    Creates the dict of attributes of a quantity
+
+    Parameters
+    ----------
+    units: str
+        Quantity units
+
+    Returns
+    -------
+    dict
+    """
+    return {"units": ensure_units_are_consistent(units), "type": "quantity"}
+
+
+def make_spectral_coord_reference_dict(
     value: float, units: str, observer: str = "lsrk"
 ) -> dict:
-    u = units if isinstance(units, list) else [units]
+    """
+    creates a spectral_coord measure dict given the value, units, and observer
+
+    Parameters
+    ----------
+    value : numeric or array of numerics
+        measure value
+    units : str
+        measure units
+    observer :
+        observer reference frame
+
+    Returns
+    -------
+    dict
+    """
+    u = ensure_units_are_consistent(units)
     return {
-        "attrs": {"units": u, "observer": observer.lower(), "type": "frequency"},
+        "attrs": make_spectral_coord_measure_attrs(
+            u,
+            observer.lower() if observer not in ["TOPO", "BARY", "REST"] else observer,
+        ),
         "data": value,
         "dims": [],
     }
 
 
-def make_skycoord_dict(data: list[float], units: list[str], frame: str) -> dict:
+def make_spectral_coord_measure_attrs(units: str, observer: str = "lsrk") -> dict:
+    """
+    Creates a spectral_coord measure attrs dict given units and observer
+
+    Parameters
+    ----------
+    units: str or list of str
+        Spectral coordinate units
+    observer: str
+        Spectral reference frame
+    Returns
+    -------
+    dict
+        Attrs dict for a spectral_coord measure
+    """
+    u = ensure_units_are_consistent(units)
+    return {"units": u, "observer": observer, "type": "spectral_coord"}
+
+
+def make_skycoord_dict(data: list[float], units: str, frame: str) -> dict:
     return {
         "attrs": {
             "frame": frame.lower(),
             "type": "sky_coord",
-            "units": units,
+            "units": ensure_units_are_consistent(units),
         },
         "data": data,
         "dims": ["l", "m"],
     }
 
 
-def make_time_measure_attrs(units=["s"], scale="utc", time_format="mjd") -> dict:
-    u = units if isinstance(units, list) else [units]
+def make_time_measure_attrs(units="s", scale="utc", time_format="mjd") -> dict:
+    u = ensure_units_are_consistent(units)
     return {"units": u, "scale": scale, "format": time_format, "type": "time"}
 
 
-def make_time_measure_dict(data, units=["s"], scale="utc", time_format="mjd") -> dict:
+def make_time_measure_dict(data, units="s", scale="utc", time_format="mjd") -> dict:
     """
     create a time measure dictionary given value and units
     Parameters
@@ -67,7 +132,7 @@ def make_time_measure_dict(data, units=["s"], scale="utc", time_format="mjd") ->
     return x
 
 
-def make_time_coord_attrs(units=["s"], scale="utc", time_format="mjd") -> dict:
+def make_time_coord_attrs(units="s", scale="utc", time_format="mjd") -> dict:
     """
     create a time measure dictionary given value and units
     Parameters

xradio/_utils/schema.py

@@ -1,6 +1,7 @@
 import toolviper.utils.logger as logger
 import xarray as xr
 from typing import Union
+from xradio._utils.dict_helpers import ensure_units_are_consistent
 
 
 def convert_generic_xds_to_xradio_schema(
@@ -108,7 +109,7 @@ def column_description_casacore_to_msv4_measure(
 
         # Convert type, copy unit
         msv4_measure["type"] = msv4_measure_conversion["type"]
-        msv4_measure["units"] = list(
+        msv4_measure["units"] = ensure_units_are_consistent(
             casacore_column_description["keywords"]["QuantumUnits"]
         )
 
@@ -154,7 +155,9 @@ def column_description_casacore_to_msv4_measure(
     elif "QuantumUnits" in casacore_column_description["keywords"]:
         msv4_measure = {
             "type": "quantity",
-            "units": list(casacore_column_description["keywords"]["QuantumUnits"]),
+            "units": ensure_units_are_consistent(
+                casacore_column_description["keywords"]["QuantumUnits"]
+            ),
         }
 
     return msv4_measure

xradio/_utils/zarr/common.py

@@ -1,6 +1,4 @@
-import copy
 import xarray as xr
-import zarr
 import s3fs
 import os
 from botocore.exceptions import NoCredentialsError
@@ -34,7 +32,7 @@ def _get_file_system_and_items(ps_store: str):
                 for bd in file_system.listdir(ps_store, detail=False)
             ]
 
-        except (NoCredentialsError, PermissionError) as e:
+        except (NoCredentialsError, PermissionError):
             # only public, read-only buckets will be accessible
             # we will want to add messaging and error handling here
             file_system = s3fs.S3FileSystem(anon=True)
@@ -97,73 +95,3 @@ def _open_dataset(
         with dask.config.set(scheduler="synchronous"):
             xds = xds.load()
     return xds
-
-
-# Code to depricate:
-def _get_attrs(zarr_obj):
-    """
-    get attributes of zarr obj (groups or arrays)
-    """
-    return {k: v for k, v in zarr_obj.attrs.asdict().items() if not k.startswith("_NC")}
-
-
-def _load_no_dask_zarr(zarr_name, slice_dict={}):
-    """
-    Alternative to xarray open_zarr where the arrays are not Dask Arrays.
-
-    slice_dict: A dictionary of slice objects for which values to read form a dimension.
-                For example silce_dict={'time':slice(0,10)} would select the first 10 elements in the time dimension.
-                If a dim is not specified all values are retruned.
-    return:
-        xarray.Dataset()
-
-    #Should go into general utils.
-    """
-    # Used by xarray to store array labeling info in zarr meta data.
-    DIMENSION_KEY = "_ARRAY_DIMENSIONS"
-
-    # logger = _get_logger()
-    zarr_group = zarr.open_group(store=zarr_name, mode="r")
-    group_attrs = _get_attrs(zarr_group)
-
-    slice_dict_complete = copy.deepcopy(slice_dict)
-    coords = {}
-    xds = xr.Dataset()
-    for var_name, var in zarr_group.arrays():
-        print("Hallo 3", var_name, var.shape)
-        var_attrs = _get_attrs(var)
-
-        for dim in var_attrs[DIMENSION_KEY]:
-            if dim not in slice_dict_complete:
-                slice_dict_complete[dim] = slice(None)  # No slicing.
-
-        if (var_attrs[DIMENSION_KEY][0] == var_name) and (
-            len(var_attrs[DIMENSION_KEY]) == 1
-        ):
-            coord = var[
-                slice_dict_complete[var_attrs[DIMENSION_KEY][0]]
-            ]  # Dimension coordinates.
-            del var_attrs["_ARRAY_DIMENSIONS"]
-            xds = xds.assign_coords({var_name: coord})
-            xds[var_name].attrs = var_attrs
-        else:
-            # Construct slicing
-            slicing_list = []
-            for dim in var_attrs[DIMENSION_KEY]:
-                slicing_list.append(slice_dict_complete[dim])
-            slicing_tuple = tuple(slicing_list)
-
-            print(var_attrs[DIMENSION_KEY])
-
-            xds[var_name] = xr.DataArray(
-                var[slicing_tuple], dims=var_attrs[DIMENSION_KEY]
-            )
-
-            if "coordinates" in var_attrs:
-                del var_attrs["coordinates"]
-            del var_attrs["_ARRAY_DIMENSIONS"]
-            xds[var_name].attrs = var_attrs
-
-    xds.attrs = group_attrs
-
-    return xds

xradio/image/_util/_casacore/xds_from_casacore.py

@@ -41,7 +41,7 @@ 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 (
     _casacore_q_to_xradio_q,
-    make_frequency_reference_dict,
+    make_spectral_coord_reference_dict,
     make_quantity,
     make_skycoord_dict,
     make_time_measure_dict,
@@ -85,34 +85,50 @@ def _casa_image_to_xds_image_attrs(image: casa_image, history: bool = True) -> d
     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
+                telescope["direction"] = {
+                    "attrs": {
+                        "coordinate_system": "geocentric",
+                        "frame": casa_pos["refer"],
+                        "origin_object_name": "earth",
+                        "type": "location",
+                        "units": casa_pos["m0"]["unit"],
+                    },
+                    "data": [casa_pos["m0"]["value"], casa_pos["m1"]["value"]],
+                    "dims": ["ellipsoid_dir_label"],
+                    "coords": {
+                        "ellipsoid_dir_label": {
+                            "dims": ["ellipsoid_dir_label"],
+                            "data": ["lon", "lat"],
+                        }
+                    },
+                }
+                telescope["distance"] = {
+                    "attrs": {
+                        "coordinate_system": "geocentric",
+                        "frame": casa_pos["refer"],
+                        "origin_object_name": "earth",
+                        "type": "location",
+                        "units": casa_pos["m2"]["unit"],
+                    },
+                    "data": [casa_pos["m2"]["value"]],
+                    "dims": ["ellipsoid_dis_label"],
+                    "coords": {
+                        "ellipsoid_dis_label": {
+                            "dims": ["ellipsoid_dis_label"],
+                            "data": [
+                                "dist",
+                            ],
+                        }
+                    },
+                }
+
                 """
                 del (
                     telescope["position"]["refer"],
@@ -155,7 +171,7 @@ def _casa_image_to_xds_image_attrs(image: casa_image, history: bool = True) -> d
     # associated with it.
     # point_center = coord_dict["pointingcenter"]
     attrs[_pointing_center] = make_skycoord_dict(
-        coord_dict["pointingcenter"]["value"].tolist(), ["rad", "rad"], frame
+        coord_dict["pointingcenter"]["value"].tolist(), "rad", frame
     )
     imageinfo = meta_dict["imageinfo"]
     obj = "objectname"
@@ -221,7 +237,7 @@ def _add_time_attrs(xds: xr.Dataset, coord_dict: dict) -> xr.Dataset:
 
 def _add_vel_attrs(xds: xr.Dataset, coord_dict: dict) -> xr.Dataset:
     vel_coord = xds["velocity"]
-    meta = {"units": ["m/s"]}
+    meta = {"units": "m/s"}
     for k in coord_dict:
         if k.startswith("spectral"):
             sd = coord_dict[k]
@@ -259,7 +275,7 @@ def _casa_image_to_xds_attrs(img_full_path: str) -> dict:
         dir_dict = {}
 
         dir_dict["reference"] = make_skycoord_dict(
-            data=[0.0, 0.0], units=["rad", "rad"], frame=ap_system
+            data=[0.0, 0.0], units="rad", frame=ap_system
         )
         if ap_equinox:
             dir_dict["reference"]["attrs"]["equinox"] = ap_equinox
@@ -534,14 +550,14 @@ def _get_freq_values_attrs(
                     cdelt=wcs["cdelt"],
                 )
                 attrs["rest_frequency"] = make_quantity(sd["restfreq"], "Hz")
-                # attrs["type"] = "frequency"
-                # attrs["units"] = sd["unit"]
-                # attrs["frame"] = sd["system"]
-                attrs["wave_unit"] = [sd["waveUnit"]]
+                attrs["type"] = "spectral_coord"
+                attrs["units"] = sd["unit"]
+                attrs["frame"] = sd["system"]
+                attrs["wave_units"] = sd["waveUnit"]
                 # attrs["crval"] = sd["wcs"]["crval"]
                 # attrs["cdelt"] = sd["wcs"]["cdelt"]
 
-                attrs["reference_value"] = make_frequency_reference_dict(
+                attrs["reference_frequency"] = make_spectral_coord_reference_dict(
                     value=sd["wcs"]["crval"],
                     units=sd["unit"],
                     observer=sd["system"],
@@ -672,7 +688,7 @@ def _get_time_values_attrs(cimage_coord_dict: dict) -> Tuple[List[float], dict]:
     attrs["type"] = "time"
     attrs["scale"] = cimage_coord_dict["obsdate"]["refer"]
     unit = cimage_coord_dict["obsdate"]["m0"]["unit"]
-    attrs["units"] = unit if isinstance(unit, list) else [unit]
+    attrs["units"] = unit
     time_val = cimage_coord_dict["obsdate"]["m0"]["value"]
     attrs["format"] = _get_time_format(time_val, unit)
     return ([time_val], copy.deepcopy(attrs))
@@ -802,7 +818,7 @@ def _get_velocity_values_attrs(
     if not attrs:
         attrs["doppler_type"] = _doppler_types[0]
 
-    attrs["units"] = ["m/s"]
+    attrs["units"] = "m/s"
     attrs["type"] = "doppler"
     return (
         _compute_velocity_values(

xradio/image/_util/_casacore/xds_to_casacore.py

@@ -32,7 +32,10 @@ def _compute_direction_dict(xds: xr.Dataset) -> dict:
         direction["system"] = "J2000"
     direction["projection"] = xds_dir["projection"]
     direction["projection_parameters"] = xds_dir["projection_parameters"]
-    direction["units"] = xds_dir["reference"]["attrs"]["units"]
+    direction["units"] = [
+        xds_dir["reference"]["attrs"]["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)
@@ -43,7 +46,7 @@ def _compute_direction_dict(xds: xr.Dataset) -> dict:
         m = "lonpole" if s == "longpole" else s
         # lonpole, latpole are numerical values in degrees in casa images
         direction[s] = float(
-            Angle(str(xds_dir[m]["data"]) + xds_dir[m]["attrs"]["units"][0]).deg
+            Angle(str(xds_dir[m]["data"]) + xds_dir[m]["attrs"]["units"]).deg
         )
     return direction
 
@@ -87,20 +90,22 @@ def _compute_spectral_dict(xds: xr.Dataset) -> dict:
     spec["restfreq"] = xds.frequency.attrs["rest_frequency"]["data"]
     # spec["restfreqs"] = copy.deepcopy(xds.frequency.attrs["restfreqs"]["value"])
     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]
+    spec["system"] = xds.frequency.attrs["reference_frequency"]["attrs"][
+        "observer"
+    ].upper()
+    u = xds.frequency.attrs["reference_frequency"]["attrs"]["units"]
+    spec["unit"] = u
     spec["velType"] = _doppler_types.index(xds.velocity.attrs["doppler_type"])
     u = xds.velocity.attrs["units"]
     spec["version"] = 2
     # vel unit is a list[str] in the xds but needs to be a str in the casa image
-    spec["velUnit"] = xds.velocity.attrs["units"][0]
+    spec["velUnit"] = xds.velocity.attrs["units"]
     # wave unit is a list[str] in the xds but needs to be a str in the casa image
-    spec["waveUnit"] = xds.frequency.attrs["wave_unit"][0]
+    spec["waveUnit"] = xds.frequency.attrs["wave_units"]
     wcs = {}
     wcs["ctype"] = "FREQ"
     wcs["pc"] = 1.0
-    wcs["crval"] = float(xds.frequency.attrs["reference_value"]["data"])
+    wcs["crval"] = float(xds.frequency.attrs["reference_frequency"]["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
@@ -114,26 +119,46 @@ def _coord_dict_from_xds(xds: xr.Dataset) -> dict:
         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"]
+
+        if "direction" in tel:
+            xds_telloc = tel["direction"]
             telloc = {}
             telloc["refer"] = xds_telloc["attrs"]["frame"]
             if telloc["refer"] == "GRS80":
                 telloc["refer"] = "ITRF"
-            for i in range(3):
+            for i in range(2):
                 telloc[f"m{i}"] = {
-                    "unit": xds_telloc["attrs"]["units"][i],
+                    "unit": xds_telloc["attrs"]["units"],
                     "value": xds_telloc["data"][i],
                 }
+            telloc[f"m{2}"] = {
+                "unit": tel["distance"]["attrs"]["units"],
+                "value": tel["distance"]["data"][0],
+            }
+
             telloc["type"] = "position"
             coord["telescopeposition"] = telloc
+
+        # 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"],
+        #             "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"]["unit"] = xds.coords["time"].attrs["units"]
     obsdate["m0"]["value"] = float(xds.coords["time"].values[0])
     coord["obsdate"] = obsdate
     if _pointing_center in xds[sky_ap].attrs:
@@ -212,6 +237,7 @@ def _imageinfo_dict_from_xds(xds: xr.Dataset) -> dict:
         pp = {}
         pp["nChannels"] = xds.sizes["frequency"]
         pp["nStokes"] = xds.sizes["polarization"]
+
         bu = xds.BEAM.attrs["units"]
         chan = 0
         polarization = 0
@@ -229,6 +255,7 @@ def _imageinfo_dict_from_xds(xds: xr.Dataset) -> dict:
                 chan = 0
                 polarization += 1
         ii["perplanebeams"] = pp
+
     """
     elif "beam" in xds.attrs and xds.attrs["beam"]:
         # do nothing if xds.attrs['beam'] is None
@@ -236,7 +263,7 @@ def _imageinfo_dict_from_xds(xds: xr.Dataset) -> dict:
         for k in ["major", "minor", "pa"]:
             # print("*** ", k, ii["restoringbeam"][k])
             del ii["restoringbeam"][k]["dims"]
-            ii["restoringbeam"][k]["unit"] = ii["restoringbeam"][k]["attrs"]["units"][0]
+            ii["restoringbeam"][k]["units"] = ii["restoringbeam"][k]["attrs"]["units"]
             del ii["restoringbeam"][k]["attrs"]
             ii["restoringbeam"][k]["value"] = ii["restoringbeam"][k]["data"]
             del ii["restoringbeam"][k]["data"]