xradio 0.0.27__tar.gz → 0.0.28__tar.gz

{xradio-0.0.27/src/xradio.egg-info → xradio-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xradio
-Version: 0.0.27
+Version: 0.0.28
 Summary: Xarray Radio Astronomy Data IO
 Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>
 License: BSD 3-Clause License

{xradio-0.0.27 → xradio-0.0.28}/pyproject.toml

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

{xradio-0.0.27 → xradio-0.0.28}/src/xradio/image/_util/_fits/xds_from_fits.py

@@ -101,7 +101,7 @@ def _add_vel_attrs(xds: xr.Dataset, helpers: dict) -> xr.Dataset:
     vel_coord = xds.coords["velocity"]
     meta = {"units": "m/s"}
     if helpers["has_freq"]:
-        meta["doppler_type"] = helpers["doppler"]
+        meta["doppler_type"] = helpers.get("doppler", "RADIO")
     else:
         meta["doppler_type"] = _doppler_types[0]
     meta["type"] = "doppler"
@@ -570,8 +570,8 @@ def _get_freq_values(helpers: dict) -> list:
             crval=helpers["crval"][freq_idx],
             crpix=helpers["crpix"][freq_idx],
             cdelt=helpers["cdelt"][freq_idx],
-            cunit=helpers["cunit"][freq_idx],
         )
+        cunit = helpers["cunit"][freq_idx]
         helpers["frequency"] = vals * u.Unit(cunit)
         return vals
     elif "VOPT" in ctype:
@@ -606,9 +606,9 @@ def _get_velocity_values(helpers: dict) -> list:
         return helpers["velocity"].to(u.m / u.s).value
     elif "frequency" in helpers:
         v = _compute_velocity_values(
-            restfreq=helpers["reestfreq"],
+            restfreq=helpers["restfreq"],
             freq_values=helpers["frequency"].to("Hz").value,
-            doppler=helpers["doppler"],
+            doppler=helpers.get("doppler", "RADIO"),
         )
         helpers["velocity"] = v * (u.m / u.s)
         return v
@@ -796,7 +796,12 @@ def _get_transpose_list(helpers: dict) -> tuple:
             transpose_list[4] = i
             not_covered.remove("m")
             not_covered.remove("v")
-        elif b.startswith("frequency") or b.startswith("vopt") or b.startswith("vrad"):
+        elif (
+            b.startswith("frequency")
+            or b.startswith("freq")
+            or b.startswith("vopt")
+            or b.startswith("vrad")
+        ):
             transpose_list[2] = i
             not_covered.remove("f")
         elif b.startswith("stok"):

{xradio-0.0.27 → xradio-0.0.28}/src/xradio/image/_util/_zarr/zarr_low_level.py

@@ -110,53 +110,56 @@ def write_binary_blob_to_disk(arr, file_path, compressor):
     - None
     """
     import graphviper.utils.logger as logger
+
     # Encode the NumPy array using the codec
-    logger.debug('1. Before compressor ' + file_path)
+    logger.debug("1. Before compressor " + file_path)
     compressed_arr = compressor.encode(np.ascontiguousarray(arr))
 
-    logger.debug('2. Before makedir')
+    logger.debug("2. Before makedir")
     # Ensure the directory exists before saving the file
     os.makedirs(os.path.dirname(file_path), exist_ok=True)
 
     arr_len = len(compressed_arr)
-    logger.debug('3. Before write the len is: ' + str(arr_len))
-    #Save the compressed array to disk
+    logger.debug("3. Before write the len is: " + str(arr_len))
+    # Save the compressed array to disk
     # with open(file_path, "wb") as file:
     #     file.write(compressed_arr)
-    
-    logger.debug('4. Using new writer: ' + str(arr_len))
+
+    logger.debug("4. Using new writer: " + str(arr_len))
     write_to_lustre_chunked(file_path, compressed_arr)
-        
+
     # /.lustre/aoc/sciops/pford/CHILES/cube_image/uid___A002_Xee7674_X2844_Cube_3.img.zarr/SKY/0.0.110.0.0
     # 348192501 bytes
     # 332.0622453689575 M
-    
+
     # from io import BufferedWriter
     # # Calculate buffer size based on compressed_arr size (adjust multiplier)
     # buffer_size = min(len(compressed_arr), 1024 * 1024 * 4)  # Max 4 MB buffer
     # with BufferedWriter(open(file_path, "wb"), buffer_size) as f:
     #     f.write(compressed_arr)
-    #     f.flush()  # Ensure data gets written to disk 
-    
-    
-    logger.debug('4. Write completed')
+    #     f.flush()  # Ensure data gets written to disk
+
+    logger.debug("4. Write completed")
 
     # print(f"Compressed array saved to {file_path}")
 
 
-def write_to_lustre_chunked(file_path, compressed_arr, chunk_size=1024 * 1024 * 128):  # 128 MiB chunks
-  """
-  Writes compressed data to a Lustre file path with chunking.
+def write_to_lustre_chunked(
+    file_path, compressed_arr, chunk_size=1024 * 1024 * 128
+):  # 128 MiB chunks
+    """
+    Writes compressed data to a Lustre file path with chunking.
+
+    Args:
+        file_path: Path to the file for writing.
+        compressed_arr: Compressed data array to write.
+        chunk_size: Size of each data chunk in bytes (default: 128 MiB).
+    """
+    with open(file_path, "wb") as f:
+        for i in range(0, len(compressed_arr), chunk_size):
+            chunk = compressed_arr[i : i + chunk_size]
+            f.write(chunk)
 
-  Args:
-      file_path: Path to the file for writing.
-      compressed_arr: Compressed data array to write.
-      chunk_size: Size of each data chunk in bytes (default: 128 MiB).
-  """
-  with open(file_path, "wb") as f:
-    for i in range(0, len(compressed_arr), chunk_size):
-      chunk = compressed_arr[i:i + chunk_size]
-      f.write(chunk)
 
 def read_binary_blob_from_disk(file_path, compressor, dtype=np.float64):
     """

{xradio-0.0.27 → xradio-0.0.28}/src/xradio/image/_util/common.py

@@ -33,7 +33,10 @@ def _convert_beam_to_rad(beam: dict) -> dict:
     """
     mybeam = {}
     for k in beam:
-        q = u.quantity.Quantity(f"{beam[k]['value']}{beam[k]['unit']}")
+        try:
+            q = u.quantity.Quantity(f"{beam[k]['value']}{beam[k]['unit']}")
+        except:
+            q = u.quantity.Quantity(f"{beam[k]['value']}{beam[k]['units']}")
         q = q.to("rad")
         j = "pa" if k == "positionangle" else k
         mybeam[j] = {"type": "quantity", "value": q.value, "units": "rad"}

{xradio-0.0.27 → xradio-0.0.28}/src/xradio/vis/_processing_set.py

@@ -43,10 +43,11 @@ class processing_set(dict):
             "start_frequency": [],
             "end_frequency": [],
             "shape": [],
-            "field_coords": []
+            "field_coords": [],
         }
         from astropy.coordinates import SkyCoord
         import astropy.units as u
+
         for key, value in self.items():
             summary_data["name"].append(key)
             summary_data["ddi"].append(value.attrs["ddi"])
@@ -69,11 +70,23 @@ class processing_set(dict):
             summary_data["start_frequency"].append(value["frequency"].values[0])
             summary_data["end_frequency"].append(value["frequency"].values[-1])
 
-            ra_dec_rad = value[data_name].attrs["field_info"]['phase_direction']['data']
-            frame = value[data_name].attrs["field_info"]['phase_direction']['attrs']['frame'].lower()
-            coord = SkyCoord(ra=ra_dec_rad[0]*u.rad, dec=ra_dec_rad[1]*u.rad, frame=frame)
+            ra_dec_rad = value[data_name].attrs["field_info"]["phase_direction"]["data"]
+            frame = (
+                value[data_name]
+                .attrs["field_info"]["phase_direction"]["attrs"]["frame"]
+                .lower()
+            )
+            coord = SkyCoord(
+                ra=ra_dec_rad[0] * u.rad, dec=ra_dec_rad[1] * u.rad, frame=frame
+            )
 
-            summary_data["field_coords"].append([frame, coord.ra.to_string(unit=u.hour), coord.dec.to_string(unit=u.deg)])
+            summary_data["field_coords"].append(
+                [
+                    frame,
+                    coord.ra.to_string(unit=u.hour),
+                    coord.dec.to_string(unit=u.deg),
+                ]
+            )
         summary_df = pd.DataFrame(summary_data)
         return summary_df
 

{xradio-0.0.27 → xradio-0.0.28}/src/xradio/vis/_vis_utils/_ms/_tables/read.py

@@ -619,10 +619,61 @@ def read_col_conversion(
     Function to perform delayed reads from table columns when converting
     (no need for didxs)
     """
-    data = tb_tool.getcol(col)
+
+    # Workaround for https://github.com/casacore/python-casacore/issues/130
+    # WARNING: Assumes tb_tool is a single measurement set not an MMS.
+    # WARNING: Assumes the num_frequencies * num_polarisations > 2**29. If false,
+    # https://github.com/casacore/python-casacore/issues/130 isn't mitigated.
+
+    # Use casacore to get the shape of a row for this column
+
+    #################################################################################
+
+    # Get the total number of rows in the base measurement set
+    nrows_total = tb_tool.nrows()
+
+    # getcolshapestring() only works on columns where a row element is an
+    # array (ie fails for TIME, etc)
+    # Assumes RuntimeError is because the column is a scalar
+    try:
+
+        shape_string = tb_tool.getcolshapestring(col)[0]
+        extra_dimensions = tuple(
+            [
+                int(idx)
+                for idx in shape_string.replace("[", "").replace("]", "").split(", ")
+            ]
+        )
+        full_shape = tuple(
+            [nrows_total]
+            + [
+                int(idx)
+                for idx in shape_string.replace("[", "").replace("]", "").split(", ")
+            ]
+        )
+    except RuntimeError:
+        extra_dimensions = ()
+        full_shape = (nrows_total,)
+
+    #################################################################################
+
+    # Get dtype of the column. Only read first row from disk
+    col_dtype = np.array(tb_tool.col(col)[0]).dtype
+
+    # Construct the numpy array to populate with data
+    data = np.empty(full_shape, dtype=col_dtype)
+
+    # Use built-in casacore table iterator to populate the data column by unique times.
+    start_row = 0
+    for ts in tb_tool.iter("TIME", sort=False):
+        num_rows = ts.nrows()
+        # Note don't use getcol() because it's less safe. See:
+        # https://github.com/casacore/python-casacore/issues/130#issuecomment-463202373
+        ts.getcolnp(col, data[start_row : start_row + num_rows])
+        start_row += num_rows
 
     # TODO
-    # check np.full() with np.nan performance vs np.zeros or np.ones
-    fulldata = np.full(cshape + data.shape[1:], np.nan, dtype=data.dtype)
+    # Can we return a view of `data` instead of copying?
+    fulldata = np.full(cshape + extra_dimensions, np.nan, dtype=col_dtype)
     fulldata[tidxs, bidxs] = data
     return fulldata

{xradio-0.0.27 → xradio-0.0.28}/src/xradio/vis/_vis_utils/_ms/_tables/read_main_table.py

@@ -196,7 +196,9 @@ def read_main_table_chunks(
     # loop over time chunks
     for time_chunk in range(0, n_unique_times, n_time_chunks):
         time_start = unique_times[time_chunk] - tol
-        time_end = unique_times[min(n_unique_times, time_chunk + n_time_chunks) - 1] + tol
+        time_end = (
+            unique_times[min(n_unique_times, time_chunk + n_time_chunks) - 1] + tol
+        )
 
         # chunk time length
         ctlen = min(n_unique_times, time_chunk + n_time_chunks) - time_chunk

{xradio-0.0.27 → xradio-0.0.28/src/xradio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xradio
-Version: 0.0.27
+Version: 0.0.28
 Summary: Xarray Radio Astronomy Data IO
 Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>
 License: BSD 3-Clause License