xradio 0.0.29__py3-none-any.whl → 0.0.31__py3-none-any.whl

xradio/vis/_vis_utils/_ms/_tables/load_main_table.py

@@ -16,7 +16,7 @@ from xradio.vis._vis_utils._ms._tables.read_main_table import (
     get_baselines,
     get_baseline_indices,
 )
-from xradio._utils.array import unique_1d
+from xradio._utils.list_and_array import unique_1d
 
 
 def load_expanded_main_table_chunk(

xradio/vis/_vis_utils/_ms/_tables/read.py

@@ -747,13 +747,13 @@ def load_generic_cols(
         dict of coordinates and dict of data vars.
     """
 
-    col_cells = find_loadable_filled_cols(tb_tool, ignore)
+    col_types = find_loadable_cols(tb_tool, ignore)
 
     trows = tb_tool.row(ignore, exclude=True)[:]
 
     # Produce coords and data vars from MS columns
     mcoords, mvars = {}, {}
-    for col in col_cells.keys():
+    for col in col_types.keys():
         try:
             # TODO
             # benchmark np.stack() performance
@@ -779,7 +779,7 @@ def load_generic_cols(
             if len(set([isinstance(row[col], dict) for row in trows])) > 1:
                 continue  # can't deal with this case
 
-            data = handle_variable_col_issues(inpath, col, col_cells, trows)
+            data = handle_variable_col_issues(inpath, col, col_types[col], trows)
 
         if len(data) == 0:
             continue
@@ -827,7 +827,7 @@ def load_fixed_size_cols(
         dict of coordinates and dict of data vars, ready to construct an xr.Dataset
     """
 
-    loadable_cols = find_loadable_filled_cols(tb_tool, ignore)
+    loadable_cols = find_loadable_cols(tb_tool, ignore)
 
     # Produce coords and data vars from MS columns
     mcoords, mvars = {}, {}
@@ -856,13 +856,16 @@ def load_fixed_size_cols(
     return mcoords, mvars
 
 
-def find_loadable_filled_cols(
+def find_loadable_cols(
     tb_tool: tables.table, ignore: Union[List[str], None]
-) -> Dict:
+) -> Dict[str, str]:
     """
-    For a table, finds the columns that are:
-    - loadable = not of record type, and not to be ignored
-    - filled = the column cells are populated.
+    For a table, finds the columns that are loadable = not of record type,
+    and not to be ignored
+    In extreme cases of variable size columns, it can happen that all the
+    cells are empty (iscelldefined() == false). This is still considered a
+    loadable column, even though all values of the resulting data var will
+    be empty.
 
     Parameters
     ----------
@@ -874,17 +877,15 @@ def find_loadable_filled_cols(
     Returns
     -------
     Dict
-        dict of {column name => first cell} for columns that can/should be loaded
+        dict of {column name: column type} for columns that can/should be loaded
     """
 
     colnames = tb_tool.colnames()
-    # columns that are not populated are skipped. record columns are not supported
+    table_desc = tb_tool.getdesc()
     loadable_cols = {
-        col: tb_tool.getcell(col, 0)
+        col: table_desc[col]["valueType"]
         for col in colnames
-        if (col not in ignore)
-        and (tb_tool.iscelldefined(col, 0))
-        and tb_tool.coldatatype(col) != "record"
+        if (col not in ignore) and tb_tool.coldatatype(col) != "record"
     }
     return loadable_cols
 
@@ -978,7 +979,7 @@ def raw_col_data_to_coords_vars(
 
 
 def handle_variable_col_issues(
-    inpath: str, col: str, col_cells: dict, trows: tables.tablerow
+    inpath: str, col: str, col_type: str, trows: tables.tablerow
 ) -> np.ndarray:
     """
     load variable-size array columns, padding with nans wherever
@@ -992,8 +993,8 @@ def handle_variable_col_issues(
         path name of the MS
     col : str
         column being loaded
-    col_cells : dict
-        col: cell} values
+    col_type : str
+        type of the column cell values
     trows : tables.tablerow
         rows from a table as loaded by tables.row()
 
@@ -1008,7 +1009,7 @@ def handle_variable_col_issues(
 
     mshape = np.array(max([np.array(row[col]).shape for row in trows]))
     try:
-        pad_nan = get_pad_nan(col_cells[col])
+        pad_nan = get_pad_nan(np.array((), dtype=col_type))
 
         # TODO
         # benchmark np.stack() performance

xradio/vis/_vis_utils/_ms/_tables/read_main_table.py

@@ -17,7 +17,7 @@ from .read import (
 )
 
 from .table_query import open_table_ro, open_query
-from xradio._utils.array import (
+from xradio._utils.list_and_array import (
     unique_1d,
     pairing_function,
     inverse_pairing_function,

xradio/vis/_vis_utils/_ms/_tables/read_subtables.py

@@ -19,7 +19,7 @@ from .read import (
     read_generic_table,
 )
 from .write import revert_time
-from xradio._utils.array import unique_1d
+from xradio._utils.list_and_array import unique_1d
 
 
 def read_ephemerides(

xradio/vis/_vis_utils/_ms/chunks.py

@@ -13,7 +13,7 @@ from ._tables.read import read_generic_table, make_freq_attrs
 from ._tables.read_subtables import read_delayed_pointing_table
 from .._utils.partition_attrs import add_partition_attrs
 from .._utils.xds_helper import make_coords
-from xradio._utils.array import unique_1d
+from xradio._utils.list_and_array import unique_1d
 
 
 def read_spw_ddi_ant_pol(inpath: str) -> Tuple[xr.Dataset]:

xradio/vis/_vis_utils/_ms/conversion.py

@@ -31,7 +31,7 @@ from ._tables.read import (
 )
 from ._tables.read_main_table import get_baselines, get_baseline_indices, get_utimes_tol
 from .._utils.stokes_types import stokes_types
-from xradio._utils.array import check_if_consistent, unique_1d
+from xradio._utils.list_and_array import check_if_consistent, unique_1d, to_list
 
 
 def parse_chunksize(
@@ -637,7 +637,7 @@ def convert_and_write_partition(
         _description_
     out_file : str
         _description_
-    intent : str
+    obs_mode : str
         _description_
     ddi : int, optional
         _description_, by default 0
@@ -670,7 +670,7 @@ def convert_and_write_partition(
 
     taql_where = create_taql_query(partition_info)
     ddi = partition_info["DATA_DESC_ID"][0]
-    intent = str(partition_info["INTENT"][0])
+    obs_mode = str(partition_info["OBS_MODE"][0])
 
     start = time.time()
     with open_table_ro(in_file) as mtable:
@@ -754,9 +754,6 @@ def convert_and_write_partition(
 
             start = time.time()
 
-            xds.attrs["intent"] = intent
-            xds.attrs["ddi"] = ddi
-
             # Time and frequency should always be increasing
             if len(xds.frequency) > 1 and xds.frequency[1] - xds.frequency[0] < 0:
                 xds = xds.sel(frequency=slice(None, None, -1))
@@ -765,46 +762,12 @@ def convert_and_write_partition(
                 xds = xds.sel(time=slice(None, None, -1))
 
             # Add data_groups and field_info
-            xds.attrs["data_groups"] = {}
-            if "VISIBILITY" in xds:
-                xds.attrs["data_groups"]["base"] = {
-                    "visibility": "VISIBILITY",
-                    "flag": "FLAG",
-                    "weight": "WEIGHT",
-                    "uvw": "UVW",
-                }
-
-            if "VISIBILITY_CORRECTED" in xds:
-                xds.attrs["data_groups"]["corrected"] = {
-                    "visibility": "VISIBILITY_CORRECTED",
-                    "flag": "FLAG",
-                    "weight": "WEIGHT",
-                    "uvw": "UVW",
-                }
-
-            is_single_dish = False
-            if "SPECTRUM" in xds:
-                xds.attrs["data_groups"]["base"] = {
-                    "spectrum": "SPECTRUM",
-                    "flag": "FLAG",
-                    "weight": "WEIGHT",
-                    "uvw": "UVW",
-                }
-                is_single_dish = True
-
-            if "SPECTRUM_CORRECTED" in xds:
-                xds.attrs["data_groups"]["corrected"] = {
-                    "spectrum": "SPECTRUM_CORRECTED",
-                    "flag": "FLAG",
-                    "weight": "WEIGHT",
-                    "uvw": "UVW",
-                }
-                is_single_dish = True
+            xds, is_single_dish = add_data_groups(xds)
 
             # Create field_and_source_xds (combines field, source and ephemeris data into one super dataset)
             start = time.time()
             if ephemeris_interpolate:
-                ephemeris_interp_time = xds.time
+                ephemeris_interp_time = xds.time.values
             else:
                 ephemeris_interp_time = None
 
@@ -812,10 +775,7 @@ def convert_and_write_partition(
             scan_id[tidxs, bidxs] = tb_tool.getcol("SCAN_NUMBER")
             scan_id = np.max(scan_id, axis=1)
 
-            if (
-                partition_scheme == "ddi_intent_source"
-                or partition_scheme == "ddi_intent_scan"
-            ):
+            if "FIELD_ID" not in partition_scheme:
                 field_id = np.full(time_baseline_shape, -42, dtype=int)
                 field_id[tidxs, bidxs] = tb_tool.getcol("FIELD_ID")
                 field_id = np.max(field_id, axis=1)
@@ -828,7 +788,7 @@ def convert_and_write_partition(
             # assert len(col_unique) == 1, col_name + " is not consistent."
             # return col_unique[0]
 
-            field_and_source_xds = create_field_and_source_xds(
+            field_and_source_xds, source_id = create_field_and_source_xds(
                 in_file,
                 field_id,
                 xds.frequency.attrs["spectral_window_id"],
@@ -867,23 +827,22 @@ def convert_and_write_partition(
                 + str(ms_v4_id),
             )
 
-            if isinstance(field_id, np.ndarray):
-                field_id = "OTF"
-
             xds.attrs["partition_info"] = {
                 "spectral_window_id": xds.frequency.attrs["spectral_window_id"],
                 "spectral_window_name": xds.frequency.attrs["spectral_window_name"],
-                "field_id": field_id,
-                "field_name": field_and_source_xds.attrs["field_name"],
-                "source_id": field_and_source_xds.attrs["source_id"],
-                "source_name": field_and_source_xds.attrs["source_name"],
-                "polarization_setup": list(xds.polarization.values),
-                "intent": intent,
+                "field_id": to_list(unique_1d(field_id)),
+                "field_name": to_list(
+                    np.unique(field_and_source_xds.field_name.values)
+                ),
+                "source_id": to_list(unique_1d(source_id)),
+                "source_name": to_list(
+                    np.unique(field_and_source_xds.source_name.values)
+                ),
+                "polarization_setup": to_list(xds.polarization.values),
+                "obs_mode": obs_mode,
                 "taql": taql_where,
             }
 
-            # print(xds)
-
             start = time.time()
             if storage_backend == "zarr":
                 xds.to_zarr(store=os.path.join(file_name, "MAIN"), mode=mode)
@@ -910,3 +869,51 @@ def convert_and_write_partition(
             logger.debug("Write data  " + str(time.time() - start))
 
     # logger.info("Saved ms_v4 " + file_name + " in " + str(time.time() - start_with) + "s")
+
+
+def add_data_groups(xds):
+    xds.attrs["data_groups"] = {}
+    if "VISIBILITY" in xds:
+        xds.attrs["data_groups"]["base"] = {
+            "visibility": "VISIBILITY",
+            "flag": "FLAG",
+            "weight": "WEIGHT",
+            "uvw": "UVW",
+        }
+
+    if "VISIBILITY_CORRECTED" in xds:
+        xds.attrs["data_groups"]["corrected"] = {
+            "visibility": "VISIBILITY_CORRECTED",
+            "flag": "FLAG",
+            "weight": "WEIGHT",
+            "uvw": "UVW",
+        }
+
+    if "VISIBILITY_MODEL" in xds:
+        xds.attrs["data_groups"]["model"] = {
+            "visibility": "VISIBILITY_MODEL",
+            "flag": "FLAG",
+            "weight": "WEIGHT",
+            "uvw": "UVW",
+        }
+
+    is_single_dish = False
+    if "SPECTRUM" in xds:
+        xds.attrs["data_groups"]["base"] = {
+            "spectrum": "SPECTRUM",
+            "flag": "FLAG",
+            "weight": "WEIGHT",
+            "uvw": "UVW",
+        }
+        is_single_dish = True
+
+    if "SPECTRUM_CORRECTED" in xds:
+        xds.attrs["data_groups"]["corrected"] = {
+            "spectrum": "SPECTRUM_CORRECTED",
+            "flag": "FLAG",
+            "weight": "WEIGHT",
+            "uvw": "UVW",
+        }
+        is_single_dish = True
+
+    return xds, is_single_dish

xradio/vis/_vis_utils/_ms/descr.py

@@ -7,7 +7,7 @@ import xarray as xr
 
 from ._tables.read import read_generic_table, read_flat_col_chunk
 from ._tables.table_query import open_query, open_table_ro
-from xradio._utils.array import unique_1d
+from xradio._utils.list_and_array import unique_1d
 
 
 def describe_ms(

xradio/vis/_vis_utils/_ms/msv2_to_msv4_meta.py

@@ -4,6 +4,7 @@ col_to_data_variable_names = {
     "FLOAT_DATA": "SPECTRUM",
     "DATA": "VISIBILITY",
     "CORRECTED_DATA": "VISIBILITY_CORRECTED",
+    "MODEL_DATA": "VISIBILITY_MODEL",
     "WEIGHT_SPECTRUM": "WEIGHT",
     "WEIGHT": "WEIGHT",
     "FLAG": "FLAG",
@@ -14,6 +15,7 @@ col_to_data_variable_names = {
 col_dims = {
     "DATA": ("time", "baseline_id", "frequency", "polarization"),
     "CORRECTED_DATA": ("time", "baseline_id", "frequency", "polarization"),
+    "MODEL_DATA": ("time", "baseline_id", "frequency", "polarization"),
     "WEIGHT_SPECTRUM": ("time", "baseline_id", "frequency", "polarization"),
     "WEIGHT": ("time", "baseline_id", "frequency", "polarization"),
     "FLAG": ("time", "baseline_id", "frequency", "polarization"),
@@ -107,7 +109,7 @@ def column_description_casacore_to_msv4_measure(
                 ref_index = np.where(casa_frequency_frames_codes == ref_code)[0][0]
                 casa_ref = casa_frequency_frames[ref_index]
             else:
-                logger.warning(
+                logger.debug(
                     f"Could not determine {measinfo['type']} measure "
                     "reference frame!"
                 )
@@ -116,7 +118,7 @@ def column_description_casacore_to_msv4_measure(
             if casa_ref in msv4_measure_conversion.get("Ref_map", {}):
                 casa_ref = msv4_measure_conversion["Ref_map"][casa_ref]
             else:
-                logger.warning(
+                logger.debug(
                     f"Unknown reference frame for {measinfo['type']} "
                     f"measure, using verbatim: {casa_ref}"
                 )

xradio/vis/_vis_utils/_ms/msv4_sub_xdss.py

@@ -11,7 +11,10 @@ from ._tables.read import make_taql_where_between_min_max, read_generic_table
 
 
 def interpolate_to_time(
-    xds: xr.Dataset, interp_time: Union[xr.DataArray, None], message_prefix: str
+    xds: xr.Dataset,
+    interp_time: Union[xr.DataArray, None],
+    message_prefix: str,
+    time_name: str = "time",
 ) -> xr.Dataset:
     """
     Interpolate the time coordinate of the input xarray dataset to the
@@ -38,13 +41,13 @@ def interpolate_to_time(
         xarray dataset with time axis interpolated to interp_time.
     """
     if interp_time is not None:
-        points_before = xds.time.size
+        points_before = xds[time_name].size
         if points_before > 1:
             method = "linear"
         else:
             method = "nearest"
-        xds = xds.interp(time=interp_time, method=method, assume_sorted=True)
-        points_after = xds.time.size
+        xds = xds.interp({time_name: interp_time}, method=method, assume_sorted=True)
+        points_after = xds[time_name].size
         logger.debug(
             f"{message_prefix}: interpolating the time coordinate "
             f"from {points_before} to {points_after} points"

xradio/vis/_vis_utils/_ms/partition_queries.py

@@ -20,17 +20,19 @@ def enumerated_product(*args):
     )
 
 
-def create_partitions(in_file: str, partition_scheme: Union[str, list], vla_otf=False):
+def create_partitions(in_file: str, partition_scheme: list):
     """Create a list of dictionaries with the partition information.
 
     Args:
         in_file (str): Input MSv2 file path.
-        partition_scheme (Union[str, list]): Partition scheme to be used.
-        vla_otf (bool, optional):  The partioning of VLA OTF (on the fly) mosaics needs a special partitioning scheme. Defaults to False.
-
+        partition_scheme (list) : A MS v4 can only contain a single data description (spectral window and polarization setup), and observation mode. Consequently, the MS v2 is partitioned when converting to MS v4.
+        In addition to data description and polarization setup a finer partitioning is possible by specifying a list of partitioning keys. Any combination of the following keys are possible:
+        "FIELD_ID", "SCAN_NUMBER", "STATE_ID", "SOURCE_ID", "SUB_SCAN_NUMBER". For mosaics where the phase center is rapidly changing (such as VLA on the fly mosaics)
+        partition_scheme should be set to an empty list []. By default, ["FIELD_ID"].
     Returns:
         list: list of dictionaries with the partition information.
     """
+    # vla_otf (bool, optional):  The partioning of VLA OTF (on the fly) mosaics needs a special partitioning scheme. Defaults to False.
 
     # Create partition table
     from casacore import tables
@@ -38,11 +40,9 @@ def create_partitions(in_file: str, partition_scheme: Union[str, list], vla_otf=
     import xarray as xr
     import pandas as pd
     import os
+    import time
 
-    if partition_scheme == "ddi_intent_field":
-        partition_scheme = ["DATA_DESC_ID", "INTENT", "FIELD_ID"]
-    elif partition_scheme == "ddi_intent_scan":
-        partition_scheme = ["DATA_DESC_ID", "INTENT", "SCAN_NUMBER"]
+    partition_scheme = ["DATA_DESC_ID", "OBS_MODE"] + partition_scheme
 
     # Open MSv2 tables and add columns to partition table (par_df):
     par_df = pd.DataFrame()
@@ -61,8 +61,8 @@ def create_partitions(in_file: str, partition_scheme: Union[str, list], vla_otf=
         lockoptions={"option": "usernoread"},
         ack=False,
     )
-    if vla_otf:
-        par_df["FIELD_NAME"] = np.array(field_tb.getcol("NAME"))[par_df["FIELD_ID"]]
+    # if vla_otf:
+    #     par_df["FIELD_NAME"] = np.array(field_tb.getcol("NAME"))[par_df["FIELD_ID"]]
 
     # Get source ids if available from source table.
     if os.path.isdir(os.path.join(os.path.join(in_file, "SOURCE"))):
@@ -74,10 +74,10 @@ def create_partitions(in_file: str, partition_scheme: Union[str, list], vla_otf=
         )
         if source_tb.nrows() != 0:
             par_df["SOURCE_ID"] = field_tb.getcol("SOURCE_ID")[par_df["FIELD_ID"]]
-            if vla_otf:
-                par_df["SOURCE_NAME"] = np.array(source_tb.getcol("NAME"))[
-                    par_df["SOURCE_ID"]
-                ]
+            # if vla_otf:
+            #     par_df["SOURCE_NAME"] = np.array(source_tb.getcol("NAME"))[
+            #         par_df["SOURCE_ID"]
+            #     ]
 
     # Get intents and subscan numbers if available from state table.
     if os.path.isdir(os.path.join(in_file, "STATE")):
@@ -89,7 +89,9 @@ def create_partitions(in_file: str, partition_scheme: Union[str, list], vla_otf=
         )
         if state_tb.nrows() != 0:
             # print('state_tb',state_tb.nrows(),state_tb)
-            par_df["INTENT"] = np.array(state_tb.getcol("OBS_MODE"))[par_df["STATE_ID"]]
+            par_df["OBS_MODE"] = np.array(state_tb.getcol("OBS_MODE"))[
+                par_df["STATE_ID"]
+            ]
             par_df["SUB_SCAN_NUMBER"] = state_tb.getcol("SUB_SCAN")[par_df["STATE_ID"]]
         else:
             par_df.drop(["STATE_ID"], axis=1)
@@ -114,7 +116,7 @@ def create_partitions(in_file: str, partition_scheme: Union[str, list], vla_otf=
         "SCAN_NUMBER",
         "STATE_ID",
         "SOURCE_ID",
-        "INTENT",
+        "OBS_MODE",
         "SUB_SCAN_NUMBER",
     ]
     for idx, pair in enumerated_partitions:

xradio/vis/convert_msv2_to_processing_set.py

@@ -11,7 +11,7 @@ from xradio.vis._vis_utils._ms.conversion import convert_and_write_partition
 def convert_msv2_to_processing_set(
     in_file: str,
     out_file: str,
-    partition_scheme: {"ddi_intent_field", "ddi_state_field"} = "ddi_intent_field",
+    partition_scheme: list = ["FIELD_ID"],
     main_chunksize: Union[Dict, float, None] = None,
     with_pointing: bool = True,
     pointing_chunksize: Union[Dict, float, None] = None,
@@ -30,10 +30,11 @@ def convert_msv2_to_processing_set(
         Input MS name.
     out_file : str
         Output PS name.
-    partition_scheme : {"ddi_intent_field", "ddi_state_field"}, optional
-        A MS v4 can only contain a single spectral window, polarization setup, intent, and field. Consequently, the MS v2 is partitioned when converting to MS v4.
-        The partition_scheme "ddi_intent_field" gives the largest partition that meets the MS v4 specification. The partition_scheme "ddi_state_field" gives a finer granularity where the data is also partitioned by state (the state partitioning will ensure a single intent).
-        By default, "ddi_intent_field".
+    partition_scheme : list, optional
+        A MS v4 can only contain a single data description (spectral window and polarization setup), and observation mode. Consequently, the MS v2 is partitioned when converting to MS v4.
+        In addition to data description and polarization setup a finer partitioning is possible by specifying a list of partitioning keys. Any combination of the following keys are possible:
+        "FIELD_ID", "SCAN_NUMBER", "STATE_ID", "SOURCE_ID", "SUB_SCAN_NUMBER". For mosaics where the phase center is rapidly changing (such as VLA on the fly mosaics)
+        partition_scheme should be set to an empty list []. By default, ["FIELD_ID"].
     main_chunksize : Union[Dict, float, None], optional
         Defines the chunk size of the main dataset. If given as a dictionary, defines the sizes of several dimensions, and acceptable keys are "time", "baseline_id", "antenna_id", "frequency", "polarization". If given as a float, gives the size of a chunk in GiB. By default, None.
     with_pointing : bool, optional
@@ -56,11 +57,12 @@ def convert_msv2_to_processing_set(
 
     partitions = create_partitions(in_file, partition_scheme=partition_scheme)
     logger.info("Number of partitions: " + str(len(partitions)))
-
     delayed_list = []
-    ms_v4_id = 0
-    for partition_info in partitions:
-        logger.debug(
+
+    for ms_v4_id, partition_info in enumerate(partitions):
+        # print(ms_v4_id,len(partition_info['FIELD_ID']))
+
+        logger.info(
             "DDI "
             + str(partition_info["DATA_DESC_ID"])
             + ", STATE "
@@ -103,70 +105,6 @@ def convert_msv2_to_processing_set(
                 compressor=compressor,
                 overwrite=overwrite,
             )
-        ms_v4_id = ms_v4_id + 1
 
     if parallel:
         dask.compute(delayed_list)
-
-    # delayed_list = []
-    # ms_v4_id = 0
-    # for idx, pair in partition_enumerated_product:
-    #     ddi, state_id, field_id, scan_id = pair
-    #     # logger.debug(
-    #     #     "DDI " + str(ddi) + ", STATE " + str(state_id) + ", FIELD " + str(field_id) + ", SCAN " + str(scan_id)
-    #     # )
-
-    #     # if scan_id == 67: #67
-    #     #     logger.debug(
-    #     #     "DDI " + str(ddi) + ", STATE " + str(state_id) + ", FIELD " + str(field_id) + ", SCAN " + str(scan_id)
-    #     #     )
-    #     if partition_scheme == "ddi_intent_field":
-    #         intent = intents[idx[1]]
-    #     else:
-    #         intent = intents[idx[1]] + "_" + str(state_id)
-
-    #     if parallel:
-    #         delayed_list.append(
-    #             dask.delayed(convert_and_write_partition)(
-    #                 in_file,
-    #                 out_file,
-    #                 intent,
-    #                 ms_v4_id,
-    #                 ddi,
-    #                 state_id,
-    #                 field_id,
-    #                 scan_id,
-    #                 partition_scheme,
-    #                 main_chunksize=main_chunksize,
-    #                 with_pointing=with_pointing,
-    #                 pointing_chunksize=pointing_chunksize,
-    #                 pointing_interpolate=pointing_interpolate,
-    #                 ephemeris_interpolate=ephemeris_interpolate,
-    #                 compressor=compressor,
-    #                 overwrite=overwrite,
-    #             )
-    #         )
-    #     else:
-    #         convert_and_write_partition(
-    #             in_file,
-    #             out_file,
-    #             intent,
-    #             ms_v4_id,
-    #             ddi,
-    #             state_id,
-    #             field_id,
-    #             scan_id,
-    #             partition_scheme,
-    #             main_chunksize=main_chunksize,
-    #             with_pointing=with_pointing,
-    #             pointing_chunksize=pointing_chunksize,
-    #             pointing_interpolate=pointing_interpolate,
-    #             ephemeris_interpolate=ephemeris_interpolate,
-    #             compressor=compressor,
-    #             storage_backend=storage_backend,
-    #             overwrite=overwrite,
-    #         )
-    #     ms_v4_id = ms_v4_id + 1
-
-    # if parallel:
-    #     dask.compute(delayed_list)

xradio/vis/read_processing_set.py

@@ -8,7 +8,7 @@ import s3fs
 
 def read_processing_set(
     ps_store: str,
-    intents: list = None,
+    obs_modes: list = None,
 ) -> processing_set:
     """Creates a lazy representation of a Processing Set (only meta-data is loaded into memory).
 
@@ -16,9 +16,9 @@ def read_processing_set(
     ----------
     ps_store : str
         String of the path and name of the processing set. For example '/users/user_1/uid___A002_Xf07bba_Xbe5c_target.lsrk.vis.zarr'.
-    intents : list, optional
-        A list of the intents to be read for example ['OBSERVE_TARGET#ON_SOURCE']. The intents in a processing set can be seem by calling processing_set.summary().
-        By default None, which will read all intents.
+    obs_modes : list, optional
+        A list of obs_mode to be read for example ['OBSERVE_TARGET#ON_SOURCE']. The obs_mode in a processing set can be seem by calling processing_set.summary().
+        By default None, which will read all obs_mode.
 
     Returns
     -------
@@ -37,7 +37,9 @@ def read_processing_set(
         xds = _open_dataset(ms_main_store, file_system)
         data_groups = xds.attrs["data_groups"]
 
-        if (intents is None) or (xds.attrs["intent"] in intents):
+        if (obs_modes is None) or (
+            xds.attrs["partition_info"]["obs_mode"] in obs_modes
+        ):
             sub_xds_dict, field_and_source_xds_dict = _read_sub_xds(
                 ms_store, file_system=file_system, data_groups=data_groups
             )

{xradio-0.0.29.dist-info → xradio-0.0.31.dist-info}/METADATA

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