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

xradio/vis/_vis_utils/_ms/partition_queries.py

@@ -1,6 +1,5 @@
 import itertools
 import graphviper.utils.logger as logger
-import numbers
 from pathlib import Path
 from typing import Dict, List, Tuple, Union
 
@@ -10,8 +9,6 @@ import xarray as xr
 from casacore import tables
 
 from ._tables.table_query import open_table_ro, open_query
-from ._tables.read import read_generic_table
-from .subtables import subt_rename_ids
 
 
 def enumerated_product(*args):
@@ -23,26 +20,29 @@ def enumerated_product(*args):
 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 (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.
+    Parameters
+    ----------
+    in_file: str
+        Input MSv2 file path.
+    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.
+        "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
     import numpy as np
-    import xarray as xr
     import pandas as pd
     import os
-    import time
 
-    partition_scheme = ["DATA_DESC_ID", "OBS_MODE"] + partition_scheme
+    partition_scheme = ["DATA_DESC_ID", "OBS_MODE", "OBSERVATION_ID"] + partition_scheme
 
     # Open MSv2 tables and add columns to partition table (par_df):
     par_df = pd.DataFrame()
@@ -53,6 +53,7 @@ def create_partitions(in_file: str, partition_scheme: list):
     par_df["FIELD_ID"] = main_tb.getcol("FIELD_ID")
     par_df["SCAN_NUMBER"] = main_tb.getcol("SCAN_NUMBER")
     par_df["STATE_ID"] = main_tb.getcol("STATE_ID")
+    par_df["OBSERVATION_ID"] = main_tb.getcol("OBSERVATION_ID")
     par_df = par_df.drop_duplicates()
 
     field_tb = tables.table(
@@ -108,10 +109,13 @@ def create_partitions(in_file: str, partition_scheme: list):
     # Make all possible combinations of the partition criteria.
     enumerated_partitions = enumerated_product(*list(partition_criteria.values()))
 
+    # print('par_df',par_df)
+
     # Create a list of dictionaries with the partition information. This will be used to query the MSv2 main table.
     partitions = []
     partition_axis_names = [
         "DATA_DESC_ID",
+        "OBSERVATION_ID",
         "FIELD_ID",
         "SCAN_NUMBER",
         "STATE_ID",
@@ -144,68 +148,8 @@ def create_partitions(in_file: str, partition_scheme: list):
     return partitions
 
 
-# Used by code that will be deprecated at some stage.
-
-
-def make_partition_ids_by_ddi_scan(
-    infile: str, do_subscans: bool
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """
-    Produces arrays of per-partition ddi, scan, state_id, for when
-    using partiion schemes 'scan' or 'scan/subscan', that is
-    partitioning by some variant of (ddi, scan, subscan(state_id))
-
-    Parameters
-    ----------
-    infile : str
-        Path to MS
-    do_subscans : bool
-        also partitioning by subscan, not only scan
-
-    Returns
-    -------
-    Tuple[np.ndarray, np.ndarray, np.ndarray]
-        arrays with indices that define every partition
-    """
-    try:
-        cctable = None
-        taql_distinct_states = None
-        cctable = tables.table(
-            infile, readonly=True, lockoptions={"option": "usernoread"}, ack=False
-        )
-        if do_subscans:
-            taql_distinct_states = (
-                "select DISTINCT SCAN_NUMBER, STATE_ID, DATA_DESC_ID from $cctable"
-            )
-        else:
-            taql_distinct_states = (
-                "select DISTINCT SCAN_NUMBER, DATA_DESC_ID from $cctable"
-            )
-        with open_query(cctable, taql_distinct_states) as query_states:
-            logger.debug(
-                f"Got query, nrows: {query_states.nrows()}, query: {query_states}"
-            )
-            scan_number = query_states.getcol("SCAN_NUMBER")
-            logger.debug(
-                f"Got col SCAN_NUMBER (len: {len(scan_number)}): {scan_number}"
-            )
-            if do_subscans:
-                state_id = query_states.getcol("STATE_ID")
-                data_desc_id = np.full(len(scan_number), None)
-            else:
-                state_id = [None] * len(scan_number)
-                logger.debug(f"Got col STATE_ID (len: {len(state_id)}): {state_id}")
-                data_desc_id = query_states.getcol("DATA_DESC_ID")
-
-        logger.debug(f"Got col DATA_DESC_ID (len: {len(data_desc_id)}): {data_desc_id}")
-        logger.debug(
-            f"Len of DISTINCT SCAN_NUMBER,etc.: {len(scan_number)}. Will generate that number of partitions"
-        )
-    finally:
-        if cctable:
-            cctable.close()
-
-    return data_desc_id, scan_number, state_id
+# Used by code that will be deprecated at some stage. See #192
+# Still need to clarify what to do about intent string filtering ('WVR', etc.)
 
 
 def make_partition_ids_by_ddi_intent(
@@ -458,113 +402,3 @@ def partition_when_empty_state(
             main_table.close()
 
     return distinct_ddis, [None] * nparts, [None] * nparts, [""] * nparts
-
-
-def create_taql_query_and_file_name(out_file, intent, state_ids, field_id, ddi):
-    file_name = (
-        out_file
-        + "/"
-        + out_file.replace(".vis.zarr", "").split("/")[-1]
-        + "_ddi_"
-        + str(ddi)
-        + "_intent_"
-        + intent
-    )
-
-    taql_where = f"where (DATA_DESC_ID = {ddi})"
-
-    if isinstance(state_ids, numbers.Integral):
-        taql_where += f" AND (STATE_ID = {state_ids})"
-    elif state_ids is not None:
-        state_ids_or = " OR STATE_ID = ".join(np.char.mod("%d", state_ids))
-        taql_where += f" AND (STATE_ID = {state_ids_or})"
-
-    if field_id is not None:
-        taql_where += f" AND (FIELD_ID = {field_id})"
-        file_name = file_name + "_field_id_" + str(field_id)
-
-    return taql_where, file_name
-
-
-def get_unqiue_intents(in_file):
-    """
-    _summary_
-
-    Parameters
-    ----------
-    in_file : str
-        _description_
-
-    Returns
-    -------
-    _type_
-        _description_
-    """
-    state_xds = read_generic_table(
-        in_file,
-        "STATE",
-        rename_ids=subt_rename_ids["STATE"],
-    )
-
-    if len(state_xds.data_vars) > 0:
-        obs_mode_dict = {}
-        for i, obs_mode in enumerate(state_xds.obs_mode.values):
-            if obs_mode in obs_mode_dict:
-                obs_mode_dict[obs_mode].append(i)
-            else:
-                obs_mode_dict[obs_mode] = [i]
-        return list(obs_mode_dict.keys()), list(obs_mode_dict.values())
-    else:  # empty state table
-        return ["None"], [None]
-
-
-def enumerated_product(*args):
-    yield from zip(
-        itertools.product(*(range(len(x)) for x in args)), itertools.product(*args)
-    )
-
-
-def create_partition_enumerated_product(in_file: str, partition_scheme: str):
-    """
-    Creates an enumerated_product of the data_desc_ids, state_ids, field_ids in a MS v2 that define the partions in a processing set.
-
-    Parameters
-    ----------
-    in_file : str
-        _description_
-    partition_scheme : str
-        _description_
-
-    Returns
-    -------
-    _type_
-        _description_
-    """
-    # Unused?
-    # spw_xds = read_generic_table(
-    #     in_file,
-    #     "SPECTRAL_WINDOW",
-    #     rename_ids=subt_rename_ids["SPECTRAL_WINDOW"],
-    # )
-
-    # TODO: probably get this via query to subtable instead of read_generic_table, we just
-    # need the row numbers
-    ddi_xds = read_generic_table(in_file, "DATA_DESCRIPTION")
-    data_desc_ids = np.arange(ddi_xds.sizes["row"])
-    state_xds = read_generic_table(in_file, "STATE")
-
-    if (partition_scheme == "ddi_intent_field") and (len(state_xds.data_vars) > 0):
-        intents, state_ids = get_unqiue_intents(in_file)
-        field_ids = np.arange(read_generic_table(in_file, "FIELD").sizes["row"])
-    else:  # partition_scheme == "ddi_state_field"
-        if len(state_xds.data_vars) > 0:
-            state_ids = [np.arange(state_xds.sizes["row"])]
-            intents = state_xds.obs_mode.values
-        else:  # empty state table
-            state_ids = [None]
-            intents = ["None"]
-        # print(state_xds, intents)
-        # field_ids = [None]
-        field_ids = np.arange(read_generic_table(in_file, "FIELD").sizes["row"])
-
-    return enumerated_product(data_desc_ids, state_ids, field_ids), intents

xradio/vis/_vis_utils/_ms/partitions.py

@@ -7,11 +7,10 @@ import xarray as xr
 from .msv2_msv3 import ignore_msv2_cols
 from .partition_queries import (
     make_partition_ids_by_ddi_intent,
-    make_partition_ids_by_ddi_scan,
 )
 from .subtables import subt_rename_ids, add_pointing_to_partition
 from .descr import describe_ms
-from ._tables.read import read_generic_table, make_freq_attrs
+from ._tables.read import load_generic_table, make_freq_attrs
 from ._tables.read_main_table import read_flat_main_table, read_expanded_main_table
 from .._utils.partition_attrs import add_partition_attrs
 from .._utils.xds_helper import expand_xds, make_coords, optimal_chunking
@@ -23,8 +22,8 @@ VisSetPartitions = Dict[PartitionKey, xr.Dataset]
 
 
 def make_spw_names_by_ddi(ddi_xds: xr.Dataset, spw_xds: xr.Dataset) -> Dict[int, str]:
-    spw_ids_by_ddi = ddi_xds.spectral_window_id[ddi_xds.row].values
-    spw_names = spw_xds.name[spw_ids_by_ddi].values
+    spw_ids_by_ddi = ddi_xds.SPECTRAL_WINDOW_ID[ddi_xds.row].values
+    spw_names = spw_xds.NAME[spw_ids_by_ddi].values
     return {ddi: spw_names[ddi] for ddi in np.arange(0, len(spw_names))}
 
 
@@ -138,12 +137,12 @@ def read_ms_scan_subscan_partitions(
         subtables already read
     """
 
-    spw_xds = read_generic_table(
+    spw_xds = load_generic_table(
         infile,
         "SPECTRAL_WINDOW",
         rename_ids=subt_rename_ids["SPECTRAL_WINDOW"],
     )
-    ddi_xds = read_generic_table(infile, "DATA_DESCRIPTION")
+    ddi_xds = load_generic_table(infile, "DATA_DESCRIPTION")
 
     if partition_scheme == "intent":
         spw_names_by_ddi = make_spw_names_by_ddi(ddi_xds, spw_xds)
@@ -154,15 +153,12 @@ def read_ms_scan_subscan_partitions(
             distinct_intents,
         ) = make_partition_ids_by_ddi_intent(infile, spw_names_by_ddi)
     else:
-        do_subscans = partition_scheme == "scan/subscan"
-        data_desc_id, scan_number, state_id = make_partition_ids_by_ddi_scan(
-            infile, do_subscans
-        )
+        raise ValueError("foo")
 
-    ant_xds = read_generic_table(
+    ant_xds = load_generic_table(
         infile, "ANTENNA", rename_ids=subt_rename_ids["ANTENNA"]
     )
-    pol_xds = read_generic_table(
+    pol_xds = load_generic_table(
         infile, "POLARIZATION", rename_ids=subt_rename_ids["POLARIZATION"]
     )
 
@@ -263,25 +259,25 @@ def read_ms_ddi_partitions(
     """
     # we need the antenna, spectral window, polarization, and data description tables
     # to define the (sub)datasets (their dims and coords) and to process the main table
-    ant_xds = read_generic_table(
+    ant_xds = load_generic_table(
         infile, "ANTENNA", rename_ids=subt_rename_ids["ANTENNA"]
     )
-    spw_xds = read_generic_table(
+    spw_xds = load_generic_table(
         infile,
         "SPECTRAL_WINDOW",
         rename_ids=subt_rename_ids["SPECTRAL_WINDOW"],
     )
-    pol_xds = read_generic_table(
+    pol_xds = load_generic_table(
         infile, "POLARIZATION", rename_ids=subt_rename_ids["POLARIZATION"]
     )
-    ddi_xds = read_generic_table(infile, "DATA_DESCRIPTION")
+    ddi_xds = load_generic_table(infile, "DATA_DESCRIPTION")
 
     # each DATA_DESC_ID (ddi) is a fixed shape that may differ from others
     # form a list of ddis to process, each will be placed it in its own xarray dataset and partition
     ddis = np.arange(ddi_xds.row.shape[0]) if rowmap is None else list(rowmap.keys())
 
     # figure out the chunking for each DDI, either one fixed shape or an auto-computed one
-    if type(chunks) != tuple:
+    if type(chunks) is not tuple:
         mshape = describe_ms(infile, mode="flat", rowmap=rowmap)
         chunks = dict(
             [
@@ -307,7 +303,7 @@ def read_ms_ddi_partitions(
             continue
         logger.debug(
             "reading DDI %i with chunking %s..."
-            % (ddi, str(chunks[ddi] if type(chunks) == dict else chunks))
+            % (ddi, str(chunks[ddi] if type(chunks) is dict else chunks))
         )
 
         # experimenting, comparing overheads of expanded vs. flat
@@ -321,7 +317,7 @@ def read_ms_ddi_partitions(
                 infile,
                 ddi,
                 rowidxs=rowidxs,
-                chunks=chunks[ddi] if type(chunks) == dict else chunks,
+                chunks=chunks[ddi] if type(chunks) is dict else chunks,
                 ignore_msv2_cols=ignore_msv2_cols,
             )
         if len(xds.sizes) == 0:
@@ -339,9 +335,9 @@ def read_ms_ddi_partitions(
         # filter by channel selection
         if (chanidxs is not None) and (len(chanidxs) < len(xds.chan)):
             xds = xds.isel(chan=chanidxs)
-            spw_xds["chan_freq"][
-                ddi_xds.spectral_window_id.values[ddi], : len(chanidxs)
-            ] = spw_xds.chan_freq[ddi_xds.spectral_window_id.values[ddi], chanidxs]
+            spw_xds["CHAN_FREQ"][
+                ddi_xds.SPECTRAL_WINDOW_ID.values[ddi], : len(chanidxs)
+            ] = spw_xds.CHAN_FREQ[ddi_xds.SPECTRAL_WINDOW_ID.values[ddi], chanidxs]
 
         # expand the row dimension out to (time, baseline)
         if not expanded and expand:

xradio/vis/_vis_utils/_ms/subtables.py

@@ -7,7 +7,7 @@ from typing import Dict, List
 
 import xarray as xr
 
-from ._tables.read import read_generic_table, table_exists
+from ._tables.read import load_generic_table, table_exists
 from ._tables.read_subtables import read_ephemerides, read_delayed_pointing_table
 
 
@@ -75,7 +75,7 @@ def read_ms_subtables(
             rename_ids = {"dim_2": "n_polynomial", "dim_3": "dir"}
             xds = read_delayed_pointing_table(str(subt_path), rename_ids=rename_ids)
         else:
-            xds = read_generic_table(
+            xds = load_generic_table(
                 infile,
                 subt_name,
                 timecols=["TIME"],

xradio/vis/_vis_utils/_utils/partition_attrs.py

@@ -73,8 +73,8 @@ def init_partition_ids(
     ddi_xds: xr.Dataset,
     part_ids: PartitionIds,
 ) -> PartitionIds:
-    spw_id = ddi_xds.spectral_window_id.values[ddi]
-    pol_setup_id = ddi_xds.polarization_id.values[ddi]
+    spw_id = ddi_xds.SPECTRAL_WINDOW_ID.values[ddi]
+    pol_setup_id = ddi_xds.POLARIZATION_ID.values[ddi]
     ids: PartitionIds = {
         # The -1 are expected to be be updated from part_ids
         "array_id": -1,

xradio/vis/_vis_utils/_utils/xds_helper.py

@@ -35,11 +35,11 @@ def make_coords(
     Dict[str, np.ndarray]
     """
     ant_xds, ddi_xds, spw_xds, pol_xds = subtables
-    freq = spw_xds.chan_freq.values[
-        ddi_xds.spectral_window_id.values[ddi], : xds.freq.shape[0]
+    freq = spw_xds.CHAN_FREQ.values[
+        ddi_xds.SPECTRAL_WINDOW_ID.values[ddi], : xds.freq.shape[0]
     ]
-    pol_ids = pol_xds.corr_type.values[
-        ddi_xds.polarization_id.values[ddi], : xds.pol.shape[0]
+    pol_ids = pol_xds.CORR_TYPE.values[
+        ddi_xds.POLARIZATION_ID.values[ddi], : xds.pol.shape[0]
     ]
     pol_names = np.vectorize(stokes_types.get)(pol_ids)
     ant_id = ant_xds.antenna_id.values
@@ -125,31 +125,31 @@ def make_global_coords(mxds: xr.Dataset) -> Dict[str, xr.DataArray]:
     if "antenna" in metainfo:
         coords["antenna_ids"] = metainfo["antenna"].antenna_id.values
         coords["antennas"] = xr.DataArray(
-            metainfo["antenna"].name.values, dims=["antenna_ids"]
+            metainfo["antenna"].NAME.values, dims=["antenna_ids"]
         )
     if "field" in metainfo:
         coords["field_ids"] = metainfo["field"].field_id.values
         coords["fields"] = xr.DataArray(
-            metainfo["field"].name.values, dims=["field_ids"]
+            metainfo["field"].NAME.values, dims=["field_ids"]
         )
     if "feed" in mxds.attrs:
-        coords["feed_ids"] = metainfo["feed"].feed_id.values
+        coords["feed_ids"] = metainfo["feed"].FEED_ID.values
     if "observation" in metainfo:
         coords["observation_ids"] = metainfo["observation"].observation_id.values
         coords["observations"] = xr.DataArray(
-            metainfo["observation"].project.values, dims=["observation_ids"]
+            metainfo["observation"].PROJECT.values, dims=["observation_ids"]
         )
     if "polarization" in metainfo:
         coords["polarization_ids"] = metainfo["polarization"].pol_setup_id.values
     if "source" in metainfo:
-        coords["source_ids"] = metainfo["source"].source_id.values
+        coords["source_ids"] = metainfo["source"].SOURCE_ID.values
         coords["sources"] = xr.DataArray(
-            metainfo["source"].name.values, dims=["source_ids"]
+            metainfo["source"].NAME.values, dims=["source_ids"]
         )
     if "spectral_window" in metainfo:
         coords["spw_ids"] = metainfo["spectral_window"].spw_id.values
     if "state" in metainfo:
-        coords["state_ids"] = metainfo["state"].state_id.values
+        coords["state_ids"] = metainfo["state"].STATE_ID.values
 
     return coords
 
@@ -225,7 +225,7 @@ def flatten_xds(xds: xr.Dataset) -> xr.Dataset:
         # compute for issue https://github.com/hainegroup/oceanspy/issues/332
         # drop=True silently does compute (or at least used to)
         txds = txds.where(
-            ((txds.state_id != nan_int) & (txds.field_id != nan_int)).compute(),
+            ((txds.STATE_ID != nan_int) & (txds.FIELD_ID != nan_int)).compute(),
             drop=True,
         )  # .unify_chunks()
 

xradio/vis/_vis_utils/ms.py

@@ -1,11 +1,8 @@
 import os
 import graphviper.utils.logger as logger
-from typing import Dict, List, Tuple, Union
-
-import xarray as xr
+from typing import List, Tuple, Union
 
 from ._utils.cds import CASAVisSet
-from ._ms.chunks import load_main_chunk
 from ._ms.partitions import (
     finalize_partitions,
     read_ms_ddi_partitions,
@@ -107,42 +104,3 @@ def read_ms(
     # build the visibilities container (metainfo + partitions) to return
     cds = vis_xds_packager_cds(subts, parts, "read_ms")
     return cds
-
-
-def load_vis_chunk(
-    infile: str,
-    block_des: Dict[str, slice],
-    partition_key: Tuple[int, int, str],
-) -> Dict[Tuple[int, int], xr.Dataset]:
-    """
-    Read a chunk of a MeasurementSet (MSv2 format) into an Xarray
-    dataset, loading the data in memory.
-
-    Parameters
-    ----------
-    infile : str
-        Input MS filename
-    block_des : Dict[str, slice]
-        specification of chunk to load
-    partition_key: partition_key: Tuple[int, int, str]
-
-    Returns
-    -------
-    Dict[Tuple[int, int], xr.Dataset]
-        Xarray datasets with chunk of visibility data, one per DDI
-        (spw_id, pol_setup_id pair)
-    """
-    infile = os.path.expanduser(infile)
-
-    logger.info(f"Loading from {infile} as MSv2 a chunk of data into memory")
-
-    if not os.path.isdir(infile):
-        raise ValueError(f"invalid input filename to read_ms {infile}")
-
-    orig_chunk_to_improve = load_main_chunk(infile, block_des)
-    res = vis_xds_packager_cds(
-        subtables={},
-        partitions={partition_key: orig_chunk_to_improve},
-        descr_add="load_vis_block",
-    )
-    return res

xradio/vis/_vis_utils/zarr.py

@@ -3,7 +3,6 @@ from pathlib import Path
 from typing import Dict, Union
 
 import zarr
-import xradio
 import graphviper.utils.logger as logger
 
 from ._utils.cds import CASAVisSet

xradio/vis/convert_msv2_to_processing_set.py

@@ -17,6 +17,7 @@ def convert_msv2_to_processing_set(
     pointing_chunksize: Union[Dict, float, None] = None,
     pointing_interpolate: bool = False,
     ephemeris_interpolate: bool = False,
+    use_table_iter: bool = False,
     compressor: numcodecs.abc.Codec = numcodecs.Zstd(level=2),
     storage_backend="zarr",
     parallel: bool = False,
@@ -45,6 +46,8 @@ def convert_msv2_to_processing_set(
         Whether to interpolate the time axis of the pointing sub-dataset to the time axis of the main dataset
     ephemeris_interpolate : bool, optional
         Whether to interpolate the time axis of the ephemeris data variables (of the field_and_source sub-dataset) to the time axis of the main dataset
+    use_table_iter : bool, optional
+        Whether to use the table iterator to read the main table of the MS v2. This should be set to True when reading datasets with large number of rows and few partitions, by default False.
     compressor : numcodecs.abc.Codec, optional
         The Blosc compressor to use when saving the converted data to disk using Zarr, by default numcodecs.Zstd(level=2).
     storage_backend : {"zarr", "netcdf"}, optional
@@ -63,7 +66,9 @@ def convert_msv2_to_processing_set(
         # print(ms_v4_id,len(partition_info['FIELD_ID']))
 
         logger.info(
-            "DDI "
+            "OBSERVATION_ID "
+            + str(partition_info["OBSERVATION_ID"])
+            + ", DDI "
             + str(partition_info["DATA_DESC_ID"])
             + ", STATE "
             + str(partition_info["STATE_ID"])
@@ -80,6 +85,7 @@ def convert_msv2_to_processing_set(
                     out_file,
                     ms_v4_id,
                     partition_info=partition_info,
+                    use_table_iter=use_table_iter,
                     partition_scheme=partition_scheme,
                     main_chunksize=main_chunksize,
                     with_pointing=with_pointing,
@@ -96,6 +102,7 @@ def convert_msv2_to_processing_set(
                 out_file,
                 ms_v4_id,
                 partition_info=partition_info,
+                use_table_iter=use_table_iter,
                 partition_scheme=partition_scheme,
                 main_chunksize=main_chunksize,
                 with_pointing=with_pointing,

xradio/vis/load_processing_set.py

@@ -1,6 +1,3 @@
-import xarray as xr
-import zarr
-import copy
 import os
 from ._processing_set import processing_set
 from typing import Dict, Union

xradio/vis/read_processing_set.py

@@ -1,5 +1,5 @@
 import os
-import xarray as xr
+
 from ._processing_set import processing_set
 import graphviper.utils.logger as logger
 from xradio._utils.zarr.common import _open_dataset, _get_ms_stores_and_file_system
@@ -17,7 +17,7 @@ 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'.
     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().
+        A list of obs_mode to be read for example ['OBSERVE_TARGET#ON_SOURCE']. The obs_mode in a processing set can be seen by calling processing_set.summary().
         By default None, which will read all obs_mode.
 
     Returns

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

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