xradio 0.0.51__tar.gz → 0.0.52__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xradio
-Version: 0.0.51
+Version: 0.0.52
 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
@@ -80,9 +80,9 @@ Dynamic: license-file
 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)
-![macOS Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml/badge.svg?branch=main)
-![ipynb Tests](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml/badge.svg?branch=main)
+[![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/)

{xradio-0.0.51 → xradio-0.0.52}/README.md

@@ -2,9 +2,9 @@
 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)
-![macOS Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml/badge.svg?branch=main)
-![ipynb Tests](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml/badge.svg?branch=main)
+[![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/)
@@ -24,4 +24,4 @@ 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.51 → xradio-0.0.52}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xradio"
-version = "0.0.51"
+version = "0.0.52"
 description = " Xarray Radio Astronomy Data IO"
 authors = [
     {name = "Jan-Willem Steeb", email="jsteeb@nrao.edu"},

{xradio-0.0.51 → 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.51 → 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.51 → 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 = {

{xradio-0.0.51 → xradio-0.0.52}/src/xradio/image/_util/_fits/xds_from_fits.py

@@ -17,9 +17,10 @@ from ..common import (
 )
 from xradio._utils.coord_math import _deg_to_rad
 from xradio._utils.dict_helpers import (
-    make_quantity,
     make_frequency_reference_dict,
+    make_quantity,
     make_skycoord_dict,
+    make_time_measure_dict,
 )
 import copy
 import dask
@@ -49,7 +50,7 @@ def _fits_image_to_xds(
     sphr_dims = helpers["sphr_dims"]
     ary = _read_image_array(img_full_path, chunks, helpers, verbose)
     dim_order = _get_xds_dim_order(sphr_dims)
-    xds = _add_sky_or_aperture(xds, ary, dim_order, helpers, sphr_dims)
+    xds = _add_sky_or_aperture(xds, ary, dim_order, header, helpers, sphr_dims)
     xds.attrs = attrs
     xds = _add_coord_attrs(xds, helpers)
     if helpers["has_multibeam"]:
@@ -70,13 +71,7 @@ def _add_coord_attrs(xds: xr.Dataset, helpers: dict) -> xr.Dataset:
 
 def _add_time_attrs(xds: xr.Dataset, helpers: dict) -> xr.Dataset:
     time_coord = xds.coords["time"]
-    meta = copy.deepcopy(helpers["obsdate"])
-    del meta["value"]
-    # meta["units"] = [ meta["units"] ]
-    # meta['format'] = 'MJD'
-    # meta['time_scale'] = meta['refer']
-    # del meta['refer']
-    time_coord.attrs = meta
+    time_coord.attrs = copy.deepcopy(helpers["obsdate"]["attrs"])
     xds.assign_coords(time=time_coord)
     return xds
 
@@ -176,15 +171,6 @@ def _xds_direction_attrs_from_header(helpers: dict, header) -> dict:
     direction["reference"] = make_skycoord_dict(
         [0.0, 0.0], units=["rad", "rad"], frame=ref_sys
     )
-    """
-    direction["reference"] = {
-        "type": "sky_coord",
-        "frame": ref_sys,
-        "equinox": ref_eqx,
-        "units": ["rad", "rad"],
-        "value": [0.0, 0.0],
-    }
-    """
     dir_axes = helpers["dir_axes"]
     ddata = []
     dunits = []
@@ -261,18 +247,21 @@ 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["position"] = {
-            "type": "position",
-            # I haven't seen a FITS keyword for reference frame of telescope posiiton
-            "ellipsoid": "GRS80",
-            "units": ["rad", "rad", "m"],
-            "value": np.array([long, lat, r]),
+        tel["location"] = {
+            "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"],
+            },
+            "data": np.array([long, lat, r]),
         }
-        helpers["tel_pos"] = tel["position"]
     return tel
 
 
-def _pointing_center_to_metadata(helpers: dict, header) -> dict:
+def _compute_pointing_center(helpers: dict, header) -> dict:
     # Neither helpers or header is modified
     t_axes = helpers["t_axes"]
     long_unit = header[f"CUNIT{t_axes[0]}"]
@@ -285,7 +274,9 @@ def _pointing_center_to_metadata(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 {"value": np.array([pc_long, pc_lat]), "initial": True}
+    return make_skycoord_dict(
+        [pc_long, pc_lat], units=["rad", "rad"], frame=helpers["ref_sys"]
+    )
 
 
 def _user_attrs_from_header(header) -> dict:
@@ -382,7 +373,7 @@ def _create_dim_map(helpers: dict, header) -> dict:
     return dim_map
 
 
-def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> dict:
+def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> tuple:
     primary = None
     beams = None
     for hdu in hdulist:
@@ -418,9 +409,7 @@ def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> dict:
     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
-    has_mask = da.any(da.isnan(primary.data)).compute()
-    attrs["active_mask"] = "MASK0" if has_mask else None
-    helpers["has_mask"] = has_mask
+    helpers["has_mask"] = da.any(da.isnan(primary.data)).compute()
     beam = _beam_attr_from_header(helpers, header)
     if beam != "mb":
         helpers["beam"] = beam
@@ -432,24 +421,15 @@ def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> dict:
             helpers["dtype"] = "float64"
         else:
             raise RuntimeError(f'Unhandled data type {header["BITPIX"]}')
-    helpers["btype"] = header["BTYPE"] if "BTYPE" in header else None
-    helpers["bunit"] = header["BUNIT"] if "BUNIT" in header else None
-    attrs["object_name"] = header["OBJECT"] if "OBJECT" in header else None
-    obsdate = {}
-    obsdate["type"] = "time"
-    obsdate["value"] = Time(header["DATE-OBS"], format="isot").mjd
-    obsdate["units"] = ["d"]
-    obsdate["scale"] = header["TIMESYS"]
-    obsdate["format"] = "MJD"
-    attrs["obsdate"] = obsdate
-    helpers["obsdate"] = obsdate
-    attrs["observer"] = header["OBSERVER"]
-    attrs["pointing_center"] = _pointing_center_to_metadata(helpers, header)
-    attrs["description"] = None
-    attrs["telescope"] = _get_telescope_metadata(helpers, header)
+    helpers["obsdate"] = make_time_measure_dict(
+        data=Time(header["DATE-OBS"], format="isot").mjd,
+        units=["d"],
+        scale=header["TIMESYS"],
+        time_format="MJD",
+    )
+
     # TODO complete _make_history_xds when spec has been finalized
     # attrs['history'] = _make_history_xds(header)
-    attrs["user"] = _user_attrs_from_header(header)
     return attrs, helpers, header
 
 
@@ -532,7 +512,7 @@ def _create_coords(
 
 
 def _get_time_values(helpers):
-    return [helpers["obsdate"]["value"]]
+    return [helpers["obsdate"]["data"]]
 
 
 def _get_pol_values(helpers):
@@ -710,14 +690,22 @@ def _add_sky_or_aperture(
     xds: xr.Dataset,
     ary: Union[np.ndarray, da.array],
     dim_order: list,
+    header,
     helpers: dict,
     has_sph_dims: bool,
 ) -> xr.Dataset:
     xda = xr.DataArray(ary, dims=dim_order)
-    image_type = helpers["btype"]
-    unit = helpers["bunit"]
-    xda.attrs[_image_type] = image_type
-    xda.attrs["units"] = unit
+    for h, a in zip(
+        ["BUNIT", "BTYPE", "OBJECT", "OBSERVER"],
+        ["units", _image_type, "object_name", "observer"],
+    ):
+        if h in header:
+            xda.attrs[a] = header[h]
+    xda.attrs["obsdate"] = helpers["obsdate"].copy()
+    xda.attrs["pointing_center"] = _compute_pointing_center(helpers, header)
+    xda.attrs["telescope"] = _get_telescope_metadata(helpers, header)
+    xda.attrs["description"] = None
+    xda.attrs["user"] = _user_attrs_from_header(header)
     name = "SKY" if has_sph_dims else "APERTURE"
     xda = xda.rename(name)
     xds[xda.name] = xda
@@ -727,6 +715,9 @@ def _add_sky_or_aperture(
         mask.attrs = {}
         mask = mask.rename("MASK0")
         xds["MASK0"] = mask
+        xda.attrs["active_mask"] = "MASK0"
+    xda = xda.rename(name)
+    xds[xda.name] = xda
     return xds
 
 

{xradio-0.0.51 → xradio-0.0.52}/src/xradio/image/_util/_zarr/common.py

@@ -13,4 +13,4 @@ _np_types = {
     "int64": np.int64,
 }
 
-_top_level_sub_xds = "_attrs_xds"
+_top_level_sub_xds = "_attrs_xds_"

{xradio-0.0.51 → xradio-0.0.52}/src/xradio/image/_util/_zarr/xds_from_zarr.py

@@ -12,9 +12,9 @@ from xradio._utils.zarr.common import _get_file_system_and_items
 
 
 def _read_zarr(
-    zarr_store: str, output: dict, selection: dict = {}
+    zarr_store: str, id_dict: dict, selection: dict = {}
 ) -> (xr.Dataset, bool):
-    # supported key/values in output are:
+    # supported key/values in id_dict are:
     # "dv"
     #    what data variables should be returned as.
     #    "numpy": numpy arrays
@@ -29,27 +29,27 @@ def _read_zarr(
     do_dask = False
     do_numpy = False
     do_np_coords = False
-    if "dv" in output:
-        dv = output["dv"]
+    if "dv" in id_dict:
+        dv = id_dict["dv"]
         if dv in ["dask", "numpy"]:
             do_dask = dv == "dask"
             do_numpy = not do_dask
         else:
             raise ValueError(
-                f"Unsupported value {output[dv]} for output[dv]. "
+                f"Unsupported value {id_dict[dv]} for id_dict[dv]. "
                 "Supported values are 'dask' and 'numpy'"
             )
-    if "coords" in output:
-        c = output["coords"]
+    if "coords" in id_dict:
+        c = id_dict["coords"]
         if c == "numpy":
             do_np_coords = True
         else:
             raise ValueError(
-                f"Unexpected value {c} for output[coords]. "
+                f"Unexpected value {c} for id_dict[coords]. "
                 "The supported value is 'numpy'"
             )
     # do not pass selection, because that is only for the top level data vars
-    xds = _decode(xds, zarr_store, output)
+    xds = _decode(xds, zarr_store, id_dict)
     if do_np_coords:
         xds = _coords_to_numpy(xds)
     if do_dask:
@@ -59,11 +59,9 @@ def _read_zarr(
     return xds
 
 
-def _decode(xds: xr.Dataset, zarr_store: str, output: dict) -> (xr.Dataset, bool):
+def _decode(xds: xr.Dataset, zarr_store: str, id_dict: dict) -> xr.Dataset:
     xds.attrs = _decode_dict(xds.attrs, "")
-    sub_xdses = _decode_sub_xdses(zarr_store, output)
-    for k, v in sub_xdses.items():
-        xds.attrs[k] = v
+    _decode_sub_xdses(xds, zarr_store, id_dict)
     return xds
 
 
@@ -85,26 +83,45 @@ def _decode_dict(my_dict: dict, top_key: str) -> dict:
     return my_dict
 
 
-def _decode_sub_xdses(zarr_store: str, output: dict) -> dict:
-    sub_xdses = {}
+def _decode_sub_xdses(xarrayObj, top_dir: str, id_dict: dict) -> None:
+    # FIXME this also needs to support S3
+    # determine immediate subdirs of zarr_store
+    entries = os.scandir(top_dir)
+    for d in entries:
+        path = os.path.join(top_dir, d.name)
+        if os.path.isdir(path):
+            if d.name.startswith(_top_level_sub_xds):
+                ky = d.name[len(_top_level_sub_xds) :]
+                xarrayObj.attrs[ky] = _read_zarr(path, id_dict)
+                # TODO if attrs that are xdses have attrs that are xdses ...
+            else:
+                # descend into the directory
+                _decode_sub_xdses(xarrayObj[d.name], path, id_dict)
 
-    fs, store_contents = _get_file_system_and_items(zarr_store)
 
+"""
+def _decode_sub_xdses(zarr_store: str, id_dict: dict) -> dict:
+    sub_xdses = {}
+    fs, store_contents = _get_file_system_and_items(zarr_store)
     if isinstance(fs, s3fs.core.S3FileSystem):
         # could we just use the items as returned from the helper function..?
         store_tree = fs.walk(zarr_store, topdown=True)
+        # Q: what is prepend_s3 used for? In this version it is defined but not used.
         prepend_s3 = "s3://"
     else:
         store_tree = os.walk(zarr_store, topdown=True)
         prepend_s3 = ""
-
     for root, dirs, files in store_tree:
+        relpath = os.path.relpath(root, zarr_store)
+        print("rpath", relpath)
         for d in dirs:
             if d.startswith(_top_level_sub_xds):
-                xds = _read_zarr(os.sep.join([root, d]), output)
+                xds = _read_zarr(os.sep.join([root, d]), id_dict)
                 # for k, v in xds.data_vars.items():
                 #    xds = xds.drop_vars([k]).assign({k: v.compute()})
-                ky = d[len(_top_level_sub_xds) + 1 :]
+                ky = d[len(_top_level_sub_xds) :]
                 sub_xdses[ky] = xds
-
+    print(f"Sub xdses: {sub_xdses.keys()}")
+    print("return")
     return sub_xdses
+"""

xradio-0.0.52/src/xradio/image/_util/_zarr/xds_to_zarr.py

@@ -0,0 +1,48 @@
+import logging
+import numpy as np
+import xarray as xr
+import os
+from .common import _np_types, _top_level_sub_xds
+
+
+def _write_zarr(xds: xr.Dataset, zarr_store: str):
+    xds_copy = xds.copy(deep=True)
+    sub_xds_dict = _encode(xds_copy, zarr_store)
+    z_obj = xds_copy.to_zarr(store=zarr_store, compute=True)
+    if sub_xds_dict:
+        _write_sub_xdses(sub_xds_dict)
+
+
+def _encode(xds: xr.Dataset, top_path: str) -> dict:
+    # encode attrs
+    sub_xds_dict = {}
+    _encode_dict(xds.attrs, top_path, sub_xds_dict)
+    for dv in xds.data_vars:
+        _encode_dict(xds[dv].attrs, os.sep.join([top_path, dv]), sub_xds_dict)
+    logging.debug(f"Encoded sub_xds_dict: {sub_xds_dict}")
+    return sub_xds_dict
+
+
+def _encode_dict(my_dict: dict, top_path: str, sub_xds_dict) -> tuple:
+    del_keys = []
+    for k, v in my_dict.items():
+        if isinstance(v, dict):
+            z = os.sep.join([top_path, k])
+            _encode_dict(v, z, sub_xds_dict)
+        elif isinstance(v, np.ndarray):
+            my_dict[k] = {}
+            my_dict[k]["_type"] = "numpy.ndarray"
+            my_dict[k]["_value"] = v.tolist()
+            my_dict[k]["_dtype"] = str(v.dtype)
+        elif isinstance(v, xr.Dataset):
+            sub_xds_dict[os.sep.join([top_path, f"{_top_level_sub_xds}{k}"])] = v.copy(
+                deep=True
+            )
+            del_keys.append(k)
+    for k in del_keys:
+        del my_dict[k]
+
+
+def _write_sub_xdses(sub_xds: dict):
+    for k, v in sub_xds.items():
+        z_obj = v.to_zarr(store=k, compute=True)

{xradio-0.0.51 → xradio-0.0.52}/src/xradio/image/_util/casacore.py

@@ -48,7 +48,9 @@ def _load_casa_image_block(infile: str, block_des: dict, do_sky_coords) -> xr.Da
     block = _get_persistent_block(
         image_full_path, shapes, starts, dimorder, transpose_list, new_axes
     )
-    xds = _add_sky_or_aperture(xds, block, dimorder, image_full_path, ret["sphr_dims"])
+    xds = _add_sky_or_aperture(
+        xds, block, dimorder, image_full_path, ret["sphr_dims"], True
+    )
     mymasks = _get_mask_names(image_full_path)
     for m in mymasks:
         full_path = os.sep.join([image_full_path, m])
@@ -57,7 +59,7 @@ def _load_casa_image_block(infile: str, block_des: dict, do_sky_coords) -> xr.Da
         )
         # data vars are all caps by convention
         xds = _add_mask(xds, m.upper(), block, dimorder)
-    xds.attrs = _casa_image_to_xds_attrs(image_full_path, True)
+    xds.attrs = _casa_image_to_xds_attrs(image_full_path)
     mb = _multibeam_array(xds, image_full_path, False)
     if mb is not None:
         selectors = {}
@@ -86,6 +88,7 @@ def _read_casa_image(
         dimorder,
         img_full_path,
         ret["sphr_dims"],
+        history,
     )
     if masks:
         mymasks = _get_mask_names(img_full_path)
@@ -93,7 +96,7 @@ def _read_casa_image(
             ary = _read_image_array(img_full_path, chunks, mask=m, verbose=verbose)
             # data var names are all caps by convention
             xds = _add_mask(xds, m.upper(), ary, dimorder)
-    xds.attrs = _casa_image_to_xds_attrs(img_full_path, history)
+    xds.attrs = _casa_image_to_xds_attrs(img_full_path)
     mb = _multibeam_array(xds, img_full_path, True)
     if mb is not None:
         xds["BEAM"] = mb

{xradio-0.0.51 → xradio-0.0.52}/src/xradio/measurement_set/_utils/_msv2/create_field_and_source_xds.py

@@ -17,7 +17,8 @@ from xradio.measurement_set._utils._msv2._tables.read import (
     make_taql_where_between_min_max,
     load_generic_table,
 )
-from xradio._utils.list_and_array import cast_to_str
+from xradio._utils.list_and_array import cast_to_str, get_pad_value
+
 from xradio._utils.coord_math import (
     convert_to_si_units,
     add_position_offsets,
@@ -547,10 +548,16 @@ def pad_missing_sources(
         for source_id in unique_source_ids
         if source_id not in source_xds.coords["SOURCE_ID"]
     ]
+    if len(missing_source_ids) < 1:
+        return source_xds
 
     # would like to use the new-ish xr.pad, but it creates issues with indices/coords and is
     # also not free of overheads, as it for example changes all numeric types to float64
-    missing_source_xds = xr.full_like(source_xds.isel(SOURCE_ID=0), fill_value=np.nan)
+    fill_value = {
+        var_name: get_pad_value(var.dtype)
+        for var_name, var in source_xds.data_vars.items()
+    }
+    missing_source_xds = xr.full_like(source_xds.isel(SOURCE_ID=0), fill_value)
     pad_str = "Unknown"
     pad_str_type = "<U9"
     for var in missing_source_xds.data_vars:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xradio
-Version: 0.0.51
+Version: 0.0.52
 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
@@ -80,9 +80,9 @@ Dynamic: license-file
 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)
-![macOS Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml/badge.svg?branch=main)
-![ipynb Tests](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml/badge.svg?branch=main)
+[![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/)

xradio-0.0.51/src/xradio/image/_util/_zarr/xds_to_zarr.py

@@ -1,49 +0,0 @@
-import numpy as np
-import xarray as xr
-import os
-from .common import _np_types, _top_level_sub_xds
-
-
-def _write_zarr(xds: xr.Dataset, zarr_store: str):
-    xds_copy = xds.copy(deep=True)
-    xds_copy, xds_dict = _encode(xds_copy)
-    z_obj = xds_copy.to_zarr(store=zarr_store, compute=True)
-    _write_sub_xdses(zarr_store, xds_dict, _top_level_sub_xds)
-
-
-def _encode(xds: xr.Dataset):
-    # encode attrs
-    xds.attrs, xds_dict = _encode_dict(xds.attrs)
-    return xds, xds_dict
-
-
-def _encode_dict(my_dict: dict, top_key="") -> tuple:
-    xds_dict = {}
-    del_keys = []
-    for k, v in my_dict.items():
-        if isinstance(v, dict):
-            z = os.sep.join([top_key, k]) if top_key else k
-            my_dict[k], ret_xds_dict = _encode_dict(v, z)
-            if ret_xds_dict:
-                xds_dict[k] = ret_xds_dict
-        elif isinstance(v, np.ndarray):
-            my_dict[k] = {}
-            my_dict[k]["_type"] = "numpy.ndarray"
-            my_dict[k]["_value"] = v.tolist()
-            my_dict[k]["_dtype"] = str(v.dtype)
-        elif isinstance(v, xr.Dataset):
-            xds_dict[k] = v.copy(deep=True)
-            del_keys.append(k)
-    for k in del_keys:
-        del my_dict[k]
-    return my_dict, xds_dict
-
-
-def _write_sub_xdses(zarr_store: str, xds_dict: dict, path: str):
-    for k, v in xds_dict.items():
-        my_path = f"{path}_{k}" if path else f"{k}"
-        if isinstance(v, dict):
-            _write_sub_xdses(zarr_store, xds_dict[k], my_path)
-        elif isinstance(v, xr.Dataset):
-            zs = os.sep.join([zarr_store, my_path])
-            z_obj = v.to_zarr(store=zs, compute=True)