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

xradio/measurement_set/_utils/_zarr/write.py

@@ -1,329 +0,0 @@
-import toolviper.utils.logger as logger, numcodecs, os, time, warnings
-from itertools import cycle
-from pathlib import Path
-from typing import Any, Dict, Union
-
-import xarray as xr
-import zarr
-
-
-def write_part_keys(
-    partitions: Dict[Any, xr.Dataset], outpath: str, compressor: numcodecs.abc.Codec
-) -> None:
-    """
-    Writes an xds with the partition keys.
-
-    Parameters
-    ----------
-    partitions : Dict[Any, xr.Dataset]
-        partitions from a cds
-    outpath : str
-        path to write a cds
-    compressor : numcodecs.abc.Codec
-        compressor used for the partition keys variable
-
-    Returns
-    -------
-
-    """
-
-    spw_ids, pol_setup_ids, intents = map(list, zip(*partitions.keys()))
-    part_keys = xr.Dataset(
-        data_vars={
-            "spw_ids": spw_ids,
-            "pol_setup_ids": pol_setup_ids,
-            "intents": intents,
-        }
-    )
-
-    encoding = dict(zip(list(part_keys.data_vars), cycle([{"compressor": compressor}])))
-
-    out_path = Path(outpath, "partition_keys")
-    xr.Dataset.to_zarr(
-        part_keys,
-        store=out_path,
-        mode="w",
-        encoding=encoding,
-        consolidated=False,
-    )
-    zarr.consolidate_metadata(out_path)
-
-
-def write_metainfo(
-    outpath: str,
-    metainfo: Dict[str, xr.Dataset],
-    chunks_on_disk: Union[Dict, None] = None,
-    compressor: Union[numcodecs.abc.Codec, None] = None,
-    consolidated: bool = True,
-) -> None:
-    """
-    Write all metainfo subtables from a cds to zarr storage
-
-    Parameters
-    ----------
-    outpath : str
-
-    metainfo : Dict[str, xr.Dataset]:
-
-    chunks_on_disk : Union[Dict, None] (Default value = None)
-
-    compressor : Union[numcodecs.abc.Codec, None) (Default value = None)
-
-    consolidated : bool (Default value = True)
-
-
-    Returns
-    -------
-
-    """
-    metadir = Path(outpath, "metainfo")
-    os.mkdir(metadir)
-    for key, xds in metainfo.items():
-        xds_outpath = Path(metadir, key)
-        logger.debug(f"Saving metainfo xds {key} into {xds_outpath}")
-        write_xds_to_zarr(
-            xds, key, xds_outpath, chunks_on_disk, compressor, consolidated=True
-        )
-
-
-def write_partitions(
-    outpath: str,
-    partitions: Dict[str, xr.Dataset],
-    chunks_on_disk: Union[Dict, None] = None,
-    compressor: Union[numcodecs.abc.Codec, None] = None,
-    consolidated: bool = True,
-) -> None:
-    """
-    Write all data partitions metainfo from a cds to zarr storage
-
-    Parameters
-    ----------
-    outpath : str :
-
-    partitions : Dict[str, xr.Dataset]
-
-    chunks_on_disk : Union[Dict, None] (Default value = None)
-
-    compressor : Union[numcodecs.abc.Codec, None] (Default value = True)
-
-    consolidated: bool (Default value = True)
-
-
-    Returns
-    -------
-
-    """
-
-    partdir = Path(outpath, "partitions")
-    os.mkdir(partdir)
-    for cnt, (key, xds) in enumerate(partitions.items()):
-        xds_name = f"xds_{cnt}"
-        xds_outpath = Path(partdir, str(xds_name))
-        logger.debug(f"Saving partition xds {key} into {xds_outpath}")
-        write_xds_to_zarr(
-            xds, xds_name, xds_outpath, chunks_on_disk, compressor, consolidated=True
-        )
-
-
-def write_xds_to_zarr(
-    xds: xr.Dataset,
-    name: str,
-    outpath: str,
-    chunks_on_disk: Union[Dict, None] = None,
-    compressor: Union[numcodecs.abc.Codec, None] = None,
-    consolidated: bool = True,
-    graph_name: str = "write_xds_to_zarr",
-) -> None:
-    """
-    Write one xr dataset from a cds (either metainfo or a partition).
-
-    Parameters
-    ----------
-    xds : xr.Dataset
-        cds (sub)dataset
-    name : str
-        dataset name (example subtable name, or xds{i})
-    outpath: str :
-
-    chunks_on_disk : Union[Dict, None] (Default value = None)
-
-    compressor : Union[numcodecs.abc.Codec, None] (Default value = None)
-
-    consolidated : bool (Default value = True)
-
-    graph_name : str
-        the time taken to execute the graph and save the
-        dataset is measured and saved as an attribute in the zarr file.
-        The graph_name is the label for this timing information.
-
-    Returns
-    -------
-
-    """
-
-    xds_for_disk = xds
-    if chunks_on_disk is not None:
-        xds_for_disk = xds_for_disk.chunk(chunks=chunks_on_disk)
-
-    xds_for_disk = prepare_attrs_for_zarr(name, xds_for_disk)
-
-    if name.startswith("xds"):
-        # Do not write replicated/interpolated pointing (keep only original
-        # pointing subtable
-        pointing_vars = [
-            var for var in xds_for_disk.data_vars if var.startswith("pointing_")
-        ]
-        xds_for_disk = xds_for_disk.drop_vars(pointing_vars)
-        # https://github.com/pydata/xarray/issues/2300
-        # Could: compute / xds_for_disk[var] = xds_for_disk[var].chunk(chunks_on_disk)
-
-    for var in xds_for_disk.data_vars:
-        # Need a dequantify/quantify-kind of pair of functions for units?
-        if (
-            xds_for_disk.data_vars[var].dtype == "datetime64[ns]"
-            and "units" in xds_for_disk.data_vars[var].attrs
-        ):
-            xds_for_disk.data_vars[var].attrs.pop("units")
-
-    for coord in xds_for_disk.coords:
-        if (
-            xds_for_disk.coords[coord].dtype == "datetime64[ns]"
-            and "units" in xds_for_disk.coords[coord].attrs
-        ):
-            xds_for_disk.coords[coord].attrs.pop("units")
-
-    # Create compression encoding for each datavariable
-    encoding = dict(
-        zip(list(xds_for_disk.data_vars), cycle([{"compressor": compressor}]))
-    )
-
-    start = time.time()
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", "invalid value encountered in cast")
-        xr.Dataset.to_zarr(
-            xds_for_disk,
-            store=outpath,
-            mode="w",
-            encoding=encoding,
-            consolidated=consolidated,
-        )
-    time_to_calc_and_store = time.time() - start
-    logger.debug(
-        f"time to store and execute graph ({graph_name}) for {name}: {time_to_calc_and_store}"
-    )
-
-    # Add timing information?
-    # dataset_group = zarr.open_group(xds_outpath, mode='a')
-    # dataset_group.attrs[graph_name+'_time'] = time_to_calc_and_store
-
-    if consolidated:
-        zarr.consolidate_metadata(outpath)
-
-
-def prepare_attrs_for_zarr(name: str, xds: xr.Dataset) -> xr.Dataset:
-    """
-    Deal with types that cannot be serialized as they are in the
-    cds/xds (ndarray etc.)
-
-    Parameters
-    ----------
-    name : str
-
-    xds : xr.Dataset
-
-
-    Returns
-    -------
-
-    """
-    ctds_attrs = xds.attrs["other"]["msv2"]["ctds_attrs"]
-    col_descrs = ctds_attrs["column_descriptions"]
-
-    # Present in some old vla/alma MSs (model_0, model_1, model_2...
-    # vla/ngc5921.applycal.ms, alma/uid___A002_X71a45c_X1d24.ms.split): Just drop.
-    for attr in list(ctds_attrs):
-        if attr.startswith("model_"):
-            ctds_attrs.pop(attr)
-
-    # Seen for example in vla/ngc5921_statwt_ref_test_algorithm_sep_corr_no_fitspw.ms. Just drop.
-    data_cols = ["DATA", "CORRECTED_DATA", "MODEL_DATA"]
-    for col in data_cols:
-        if col in col_descrs and "CHANNEL_SELECTION" in col_descrs[col]["keywords"]:
-            col_descrs[col]["keywords"].pop("CHANNEL_SELECTION")
-
-    if "xds" in name:
-        col_descrs["UVW"]["shape"] = ",".join(map(str, col_descrs["UVW"]["shape"]))
-
-    if "spectral_window" == name:
-        for col in ["CHAN_FREQ", "REF_FREQUENCY"]:
-            measinfo = col_descrs[col]["keywords"]["MEASINFO"]
-            if "TabRefCodes" in measinfo:
-                measinfo["TabRefCodes"] = ",".join(
-                    map(
-                        str,
-                        measinfo["TabRefCodes"],
-                    )
-                )
-
-    if "antenna" == name:
-        for col in ["OFFSET", "POSITION"]:
-            if col in col_descrs:
-                col_descrs[col]["shape"] = ",".join(map(str, col_descrs[col]["shape"]))
-        # ARRAY_POSITION present in keywords of some ALMA-SD datasets
-        # example: almasd/expected.ms
-        for kw in ["ARRAY_POSITION"]:
-            if kw in col_descrs["POSITION"]["keywords"]:
-                col_descrs["POSITION"]["keywords"][kw] = ",".join(
-                    map(str, col_descrs["POSITION"]["keywords"][kw])
-                )
-
-    if "ephemerides" == name:
-        if "radii" in ctds_attrs:
-            ctds_attrs["radii"]["value"] = ",".join(
-                map(str, ctds_attrs["radii"]["value"])
-            )
-
-    if "feed" == name:
-        col_descrs["POSITION"]["shape"] = ",".join(
-            map(str, col_descrs["POSITION"]["shape"])
-        )
-
-    if "field" == name:
-        for col in ["DELAY_DIR", "PHASE_DIR", "REFERENCE_DIR"]:
-            # These shapes are not present in many MSs
-            if col in col_descrs and "shape" in col_descrs[col]:
-                col_descrs[col]["shape"] = ",".join(map(str, col_descrs[col]["shape"]))
-            if "TabRefCodes" in col_descrs[col]["keywords"]["MEASINFO"]:
-                col_descrs[col]["keywords"]["MEASINFO"]["TabRefCodes"] = ",".join(
-                    map(
-                        str,
-                        col_descrs[col]["keywords"]["MEASINFO"]["TabRefCodes"],
-                    )
-                )
-
-    if "observation" == name:
-        col_descrs["TIME_RANGE"]["shape"] = ",".join(
-            map(str, col_descrs["TIME_RANGE"]["shape"])
-        )
-
-    if "source" == name:
-        # Note several of these cols are optional and/or only
-        # populated with arrays sometimes!
-        for col in [
-            "DIRECTION",
-            "PROPER_MOTION",
-            "POSITION",
-            "TRANSITION",
-            "REST_FREQUENCY",
-            "SYSVEL",
-        ]:
-            if col in col_descrs and "shape" in col_descrs[col]:
-                col_descrs[col]["shape"] = ",".join(map(str, col_descrs[col]["shape"]))
-
-    if "weather" == name:
-        # Non-std col
-        for col in ["NS_WX_STATION_POSITION"]:
-            if col in col_descrs and "shape" in col_descrs[col]:
-                col_descrs[col]["shape"] = ",".join(map(str, col_descrs[col]["shape"]))
-
-    return xds

xradio/measurement_set/_utils/msv2.py

@@ -1,106 +0,0 @@
-import os
-import toolviper.utils.logger as logger
-from typing import List, Tuple, Union
-
-from xradio.measurement_set._utils._utils.cds import CASAVisSet
-from xradio.measurement_set._utils._msv2.partitions import (
-    finalize_partitions,
-    read_ms_ddi_partitions,
-    read_ms_scan_subscan_partitions,
-)
-from xradio.measurement_set._utils._msv2.subtables import read_ms_subtables
-from xradio.measurement_set._utils._utils.xds_helper import vis_xds_packager_cds
-
-
-def read_ms(
-    infile: str,
-    subtables: bool = True,
-    asdm_subtables: bool = False,
-    partition_scheme: str = "intent",
-    chunks: Union[Tuple[int], List[int]] = None,
-    expand: bool = False,
-    **kwargs: str,
-) -> CASAVisSet:
-    """
-    Read a MeasurementSet (MSv2 format) into a next generation CASA
-    dataset (visibilities dataset as a set of Xarray datasets).
-
-    The MS is partitioned into multiple sub- Xarray datasets (where the data variables are read as
-    Dask delayed arrays).
-    The MS is partitioned by DDI, which guarantees a fixed data shape per partition (in terms of channels
-    and polarizations) and, subject to experimentation, by scan and subscan. This results in multiple
-    partitions as xarray datasets (xds) contained within a main xds (mxds).
-
-    Parameters
-    ----------
-    infile : str
-        Input MS filename
-    subtables : bool (Default value = True)
-        Also read and include subtables along with main table selection. Default False will
-        omit subtables (faster)
-    asdm_subtables : bool (Default value = False)
-        in addition to MeasurementSet subtables (if enabled), also read extension
-        subtables named "ASDM_*"
-    partition_scheme : str (Default value = "intent")
-        experimenting) Whether to partition sub-xds datasets by scan/subscan
-        (in addition to DDI), or other alternative partitioning schemes. Accepted values: 'scan/subscan',
-        'scan', 'ddi', 'intent'. Default: 'intent'
-    chunks : Union[Tuple[int], List[int]] (Default value = None)
-        Can be used to set a specific chunk shape (with a tuple of ints), or to control the
-        optimization used for automatic chunking (with a list of ints). A tuple of ints in the form of (row,
-        chan, pol) will use a fixed chunk shape. A list or numpy array of ints in the form of [idx1, etc]
-        will trigger auto-chunking optimized for the given indices, with row=0, chan=1, pol=2. Default None
-        uses auto-chunking with a best fit across all dimensions (probably sub-optimal for most cases).
-    expand : bool (Default value = False)
-        to be removed) Whether or not to return the original flat row structure of the MS (False)
-        or expand the rows to time x baseline dimensions (True). Expanding the rows allows for easier indexing
-        and parallelization across time and baseline dimensions, at the cost of some conversion time.
-    **kwargs: str :
-
-
-    Returns
-    -------
-    CASAVisSet
-        Main xarray dataset of datasets for this visibility dataset
-    """
-
-    infile = os.path.expanduser(infile)
-    if not os.path.isdir(infile):
-        raise ValueError(f"invalid input filename to read_ms {infile}")
-
-    # Several alternatives to experiment for now
-    part_descr = {
-        "intent": "scan/subscan intent + DDI",
-        "ddi": "DDI",
-        "scan": "scan + DDI",
-        "scan/subscan": "scan + subscan + DDI",
-    }
-
-    if partition_scheme not in part_descr:
-        raise ValueError(f"Invalid partition_scheme: {partition_scheme}")
-
-    logger.info(
-        f"Reading {infile} as MSv2 and applying partitioning by {part_descr[partition_scheme]}"
-    )
-
-    if partition_scheme == "ddi":
-        logger.info(f"Reading {infile} as MSv2 and applying DDI partitioning")
-        # get the indices of the ms selection (if any)
-        # rowmap = ms_selection(infile, verbose=verbose, **kwargs)
-        rowmap = None
-        parts, subts, done_subts = read_ms_ddi_partitions(
-            infile, expand, rowmap, chunks
-        )
-    else:
-        parts, subts, done_subts = read_ms_scan_subscan_partitions(
-            infile, partition_scheme, expand, chunks
-        )
-
-    if subtables:
-        subts.update(read_ms_subtables(infile, done_subts, asdm_subtables))
-
-    parts = finalize_partitions(parts, subts)
-
-    # build the visibilities container (metainfo + partitions) to return
-    cds = vis_xds_packager_cds(subts, parts, "read_ms")
-    return cds

xradio/measurement_set/_utils/zarr.py

@@ -1,133 +0,0 @@
-import numcodecs, os, time
-from pathlib import Path
-from typing import Dict, Union
-
-import zarr
-import toolviper.utils.logger as logger
-
-from ._utils.cds import CASAVisSet
-from ._zarr.read import read_part_keys, read_partitions, read_subtables
-from ._zarr.write import write_metainfo, write_part_keys, write_partitions
-
-
-def is_zarr_cor(inpath: str) -> bool:
-    """
-    Check if a given path has a visibilities dataset in Zarr format
-
-    Parameters
-    ----------
-    inpath : str
-        path to a (possibly) Zarr vis dataset
-
-    Returns
-    -------
-    bool
-        whether zarr.open can open this path
-    """
-    try:
-        with zarr.open(Path(inpath, "partition_keys"), mode="r"):
-            logger.debug(f"{inpath} can be opened as Zarr format data")
-            return True
-    except zarr.errors.PathNotFoundError:
-        return False
-
-
-def read_cor(
-    inpath: str,
-    subtables: bool = True,
-    asdm_subtables: bool = False,
-) -> CASAVisSet:
-    """
-    Read a CASAVisSet stored in zarr format.
-
-    Parameters
-    ----------
-    inpath : str
-        Input Zarr path
-    subtables : bool (Default value = True)
-        Also read and (metainformation) subtables along with main visibilities data.
-    asdm_subtables : bool (Default value = False)
-        Also read extension subtables named "ASDM_*"
-
-    Returns
-    -------
-    CASAVisSet
-        Main xarray dataset of datasets for this visibility dataset
-    """
-    inpath = os.path.expanduser(inpath)
-    if not os.path.isdir(inpath):
-        raise ValueError(f"invalid input filename to read_vis {inpath}")
-
-    logger.info(f"Reading {inpath} as visibilities dataset stored in Zarr format")
-
-    all_start = time.time()
-
-    metainfo = {}
-    if subtables:
-        metainfo = read_subtables(inpath, asdm_subtables)
-
-    part_keys = read_part_keys(inpath)
-    partitions = read_partitions(inpath, part_keys)
-
-    all_time = time.time() - all_start
-    logger.info(f"Time to read dataset from_zarr {inpath}: {all_time}")
-
-    vers = "version-WIP"
-    descr_add = "read_vis from zarr"
-    cds = CASAVisSet(
-        metainfo=metainfo,
-        partitions=dict.fromkeys(part_keys, partitions),
-        descr=f"CASA vis set produced by xradio {vers}/{descr_add}",
-    )
-
-    return cds
-
-
-def write_cor(
-    cds: CASAVisSet,
-    outpath: str,
-    chunks_on_disk: Union[Dict, None] = None,
-    compressor: Union[numcodecs.abc.Codec, None] = None,
-) -> None:
-    """
-    Write CASA vis dataset to zarr format on disk. When
-    chunks_on_disk is not specified the chunking in the input dataset
-    is used. When chunks_on_disk is specified that dataset is saved
-    using that chunking.
-
-    Parameters
-    ----------
-    cds : CASAVisSet
-        CASA visibilities dataset to write to disk
-    outpath : str
-        output path, generally ends in .zarr
-    chunks_on_disk : Union[Dict, None] = None (Default value = None)
-        a dictionary with the chunk size that will
-        be used when writing to disk. For example {'time': 20, 'chan': 6}.
-        If chunks_on_disk is not specified the chunking of dataset will
-        be used.
-    compressor : Union[numcodecs.abc.Codec, None] (Default value = None)
-        the blosc compressor to use when saving the
-        converted data to disk using zarr. If None the zstd compression
-        algorithm used with compression level 2.
-
-    Returns
-    -------
-    """
-
-    if compressor is None:
-        compressor = numcodecs.Blosc(cname="zstd", clevel=2, shuffle=0)
-
-    if os.path.lexists(outpath):
-        raise ValueError(f"output vis.zarr path ({outpath}) already exists")
-
-    all_start = time.time()
-
-    write_part_keys(cds.partitions, outpath, compressor)
-
-    write_metainfo(outpath, cds.metainfo, chunks_on_disk, compressor)
-
-    write_partitions(outpath, cds.partitions, chunks_on_disk, compressor)
-
-    all_time = time.time() - all_start
-    logger.info(f"Time to prepare and save dataset to_zarr {outpath}: {all_time}")

xradio-0.0.56.dist-info/RECORD

@@ -1,78 +0,0 @@
-xradio/__init__.py,sha256=82picDsKDBYZRlIpp5JjWsBEf_daXgiLVM7zq6rY_6Q,383
-xradio/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xradio/_utils/coord_math.py,sha256=n4Td6jcEX4vM49Xseuwrg6USylTGsySS6CND93DEG_8,3587
-xradio/_utils/dict_helpers.py,sha256=-g2ZvRufOYACzD7d_8BBFpFwhDFxIm4Psm_TRaVJZ38,2690
-xradio/_utils/list_and_array.py,sha256=fW0LDSXlPrSQguSUcZM5oy2Zw-KQVqq9vmmLS8jhc70,4340
-xradio/_utils/schema.py,sha256=iF4cU9nmBvYvmG5HxkN3fJN4BFEMmIWiBY15HI7mbbw,7472
-xradio/_utils/_casacore/casacore_from_casatools.py,sha256=O26SLSTkKA1y1nXx2yejhxd4lou0vdVcBfvaNpqojiw,30734
-xradio/_utils/_casacore/tables.py,sha256=X2_-fpjcxzau8PC3ti9yAyaxrKEqbrSTkMSdVMdduUg,1379
-xradio/_utils/zarr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xradio/_utils/zarr/common.py,sha256=egj3Zma0BUK0msOBDozMa-62rHrcxrjCNE5XkkZUq70,5332
-xradio/image/__init__.py,sha256=HAD0GfopIbhdxOYckyW6S9US_dSWmZrwIl3FHUzZwrE,435
-xradio/image/image.py,sha256=bPgjJoQaur10XEnK7nw66YG68tRKFmdXFlER7GjWh64,14579
-xradio/image/_util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xradio/image/_util/casacore.py,sha256=XiBE2nzkoCv1LX_gvaN6yeB0lgvJO4WaY4HqUiPYYgc,4610
-xradio/image/_util/common.py,sha256=y2QJXTHowvjqwNPG5a-cOzl0WneH7c8c9jAVSKQeK2w,8429
-xradio/image/_util/fits.py,sha256=gyGm06fuCKqVGK7uv-ObvQNfFawUDsIOa_nQyklM3Aw,329
-xradio/image/_util/image_factory.py,sha256=Mm0ZDraD0WoNpGqy98EneFr1PxgfyNZNQwquIH2t0nc,8610
-xradio/image/_util/zarr.py,sha256=lhQqVRC1GEWClG3zRbuDr2IlQBfXeDqaLUJIN-MVMxA,1652
-xradio/image/_util/_casacore/__init__.py,sha256=OlsiRE40o1jSbBI4khgQQzgfDYbAlOMKIhO4UFlbGhg,41
-xradio/image/_util/_casacore/common.py,sha256=2a88YrveQY9x8bcM7SQSn-L5y60W92rLW34OXC5VwSs,1764
-xradio/image/_util/_casacore/xds_from_casacore.py,sha256=7JBJwxzJ_K6hb2sE_z3BHlKCXajZOhn8p8UoYw7uLkg,43128
-xradio/image/_util/_casacore/xds_to_casacore.py,sha256=Wf_K_SmYqDBKhgdou2lVMW2MmJR03L0mR2dtNbZUIk4,17183
-xradio/image/_util/_fits/xds_from_fits.py,sha256=_QakC4_7syLPM9X_g8c94aPeEeGP_R0kVGd8Lqh7umg,29173
-xradio/image/_util/_zarr/common.py,sha256=ltlj3uFa-uv8lXlDtV79QnfNmfm0tyhXN5FDAjZtjzg,308
-xradio/image/_util/_zarr/xds_from_zarr.py,sha256=KMsfaSSm9kyVoztS6pUzGNxMZzQnCxkk0kDv2GxW5Kw,4451
-xradio/image/_util/_zarr/xds_to_zarr.py,sha256=nsDvDD-kuMuMF2dDlj0jTxSW4mdR-jjIsvXHi5uIERU,2373
-xradio/image/_util/_zarr/zarr_low_level.py,sha256=xnYm6EmVbmLxMlOSXH32SABfQBLHfr2H9ch9gYwFNXs,13338
-xradio/measurement_set/__init__.py,sha256=Vrr1Py50TvbzeZ_VMCswYNz0Wcccbf-iJDj4ArlfcJ0,870
-xradio/measurement_set/convert_msv2_to_processing_set.py,sha256=uLZjXplVPXa0XnNa-Fty85k_-fsw6ZC98Hfiwd1WF-U,9704
-xradio/measurement_set/load_processing_set.py,sha256=8EPApyGy0Tmzu6Seeby7dKxvtxtAFA585kK50DYVHas,8164
-xradio/measurement_set/measurement_set_xdt.py,sha256=kN337gyn7Q8nF4ENy292PYsmBJJLu5ozhJ3FyT5BcVo,11986
-xradio/measurement_set/open_processing_set.py,sha256=kMODJmXT2KU12L6Y2NdTV8shvLGb5PgLIOqJgMCzlHI,5308
-xradio/measurement_set/processing_set_xdt.py,sha256=CkwBbilEPh3Sy6qTdtfV2bjZ2MhTCGy3A3fYWk7JstA,64413
-xradio/measurement_set/schema.py,sha256=V6DdXp5tshtck5VOOvnf4iVAdZ2WCv4Iu42a945wuKg,89867
-xradio/measurement_set/_utils/__init__.py,sha256=XE-h1yMfr6tVD6gdUwXO1CVq5SQ6kD_oj-e5TFwslds,97
-xradio/measurement_set/_utils/msv2.py,sha256=7hnZMFoQ-s1g0ATjEupLvtdqQCdroPv-Rl5OwjqXjh8,4430
-xradio/measurement_set/_utils/zarr.py,sha256=ehXlu0Xh_UZ5Xm2RnHCxESsRZ26c3DQAO5rqMK5MwTk,3947
-xradio/measurement_set/_utils/_msv2/chunks.py,sha256=JTPk3il6fk570BjWZMoOAtsbvnLmqPcBv9EPY6A2yOs,2964
-xradio/measurement_set/_utils/_msv2/conversion.py,sha256=OErxwczoX6ElZCtftd8bSJIHU_8vdKGVBk8MIT_KTyw,53527
-xradio/measurement_set/_utils/_msv2/create_antenna_xds.py,sha256=MhNg-tf1B0OYpLWIq9W9RFKihzsfKw0PGfBxFFgwCj4,17798
-xradio/measurement_set/_utils/_msv2/create_field_and_source_xds.py,sha256=UWimMYDf4ZgF8XJpSpnZjt0Jq14kON115PY81qSf01A,37299
-xradio/measurement_set/_utils/_msv2/descr.py,sha256=PGY39PYQj0K4th5RUv0jOWszcHlZDt6VQRTOuntCeYI,5213
-xradio/measurement_set/_utils/_msv2/msv2_msv3.py,sha256=9AKs2HWly7Ivv_Cjr11dIPGmm33_rtSBoGF9wN5ZwEQ,116
-xradio/measurement_set/_utils/_msv2/msv2_to_msv4_meta.py,sha256=gk9gU7g2Lk7dmaiLW8qecOEt574pRtGsCHnUnHXM3D0,1614
-xradio/measurement_set/_utils/_msv2/msv4_info_dicts.py,sha256=IzPxzcHKDWwnaFIL4viY9PETMmmFiD3Druasy_5qA6g,7312
-xradio/measurement_set/_utils/_msv2/msv4_sub_xdss.py,sha256=vpRbSCSAyHUZB0W7c5Ey7dbiukINojy_W3Giw4QQlk4,31785
-xradio/measurement_set/_utils/_msv2/optimised_functions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xradio/measurement_set/_utils/_msv2/partition_queries.py,sha256=7r2hU6clFFMu3xtB4nx_d2TF9pXzD2JgFK6tXT286PM,14807
-xradio/measurement_set/_utils/_msv2/partitions.py,sha256=_KhRq8bSx2QxuWp9K57fLoLxcU6kvJ35e6wvJ-THbwc,12979
-xradio/measurement_set/_utils/_msv2/subtables.py,sha256=_mpOOtHexqhiqEKt7S4LVqImJoNMJKSY18vNVw83r_U,3945
-xradio/measurement_set/_utils/_msv2/_tables/load.py,sha256=MEgcinRSciDRfSUSTTu_br03VbiNNCBSuIFNHmf5nL0,1897
-xradio/measurement_set/_utils/_msv2/_tables/load_main_table.py,sha256=Z-grLSZTODjp7d-94Cw6kT6-Zf6IYMwcomB0FGfFuv8,14904
-xradio/measurement_set/_utils/_msv2/_tables/read.py,sha256=ZPNA5OH6aUkE8_7x7qGw4yhrmDfAx9nhiSLs8RaU1tk,47238
-xradio/measurement_set/_utils/_msv2/_tables/read_main_table.py,sha256=vzxIdAnggRx3l3lEpVvwoo9tXbVfdxE9xGQWR8BpWzM,26154
-xradio/measurement_set/_utils/_msv2/_tables/read_subtables.py,sha256=VS2NaAt08Sn5ra_GtdtFJRLUM2jy1LErkkVxMEoc0rk,12536
-xradio/measurement_set/_utils/_msv2/_tables/table_query.py,sha256=Uc1zeiU-rYtCsYXpij8jzFG5NPBYvIh70qW1srn7B98,1498
-xradio/measurement_set/_utils/_msv2/_tables/write.py,sha256=ZaJiqn5HgxJ0WGZPbVzO4mMmfXKq-4pwpqmXTYth79I,9638
-xradio/measurement_set/_utils/_msv2/_tables/write_exp_api.py,sha256=-TNUZUMVaHChlx45BwdpXv0cMTeej-f4jgXlzKy-ncE,15609
-xradio/measurement_set/_utils/_utils/cds.py,sha256=OpvKowSheIthUbcPEv2AoKmxlEt3DqJZS5C1AYh5z10,1179
-xradio/measurement_set/_utils/_utils/partition_attrs.py,sha256=JaePHts_A0EbB4K-0a_uC98RZ2EmfjB9pDSEI11oAwk,3401
-xradio/measurement_set/_utils/_utils/stokes_types.py,sha256=DMa8TmmS7BQ99Xm8c7ZjcRapMtLbrKVxrt4f0qUIOvg,561
-xradio/measurement_set/_utils/_utils/xds_helper.py,sha256=3BYwpeklJCRJCkkwNU54JbFgibaQOffK6vJzNcwicHI,13229
-xradio/measurement_set/_utils/_zarr/encoding.py,sha256=GENIlThV6a9CUCL6gIGlu9c6NR3OFWNos6mpxZjMwDc,536
-xradio/measurement_set/_utils/_zarr/read.py,sha256=O9DiwD2Gn8WiatQ-Q6WGGSwjsXwFktG4f81lM-mgcSg,7596
-xradio/measurement_set/_utils/_zarr/write.py,sha256=k5IfqtI44Dm4KBDiKFGhL5hN7kwNOulvVHmeP5Mi7N4,10043
-xradio/schema/__init__.py,sha256=EzEMnOtN8G_wdjo8QBRKfq5MrYgfr_nt1pfunlI6i6Q,733
-xradio/schema/bases.py,sha256=dk24pFhugCe5RjaR41xxP38FxVVsIC9bdmBdsarwFvk,17162
-xradio/schema/check.py,sha256=1DAOeW46TC8htQSnMWOy1HkrgeZfhQJ8y9qApzKXkFo,21859
-xradio/schema/dataclass.py,sha256=w6FbFtmGnAX4SYwYar7v8-YFf6j40G7g_jvIfVCuxjc,14087
-xradio/schema/metamodel.py,sha256=WjtW7pAVzcjLRWifRH3sQoOiN6TV810hARpOIz1M_gw,3845
-xradio/schema/typing.py,sha256=8-o6fZd99kJ4FVdgBYRTIRJ-wDqpcUNXzCTfJvl3TIw,10439
-xradio/sphinx/__init__.py,sha256=VGY-7Ty3q67qpnBee0-znbiJ-Iy0F93UO--IpjEdHXc,380
-xradio/sphinx/schema_table.py,sha256=uq33habbAbReqnEG6ASKSd4UOMZGUzA3qoTX45rq84U,12373
-xradio-0.0.56.dist-info/licenses/LICENSE.txt,sha256=9CYIJt7riOXo9AD0eXBZviLxo_HebD-2JJI8oiWtzfg,1807
-xradio-0.0.56.dist-info/METADATA,sha256=82A_AvtUlJtGpThOuXEbLbCm247uSuVc9-6z3665n8M,6805
-xradio-0.0.56.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-xradio-0.0.56.dist-info/top_level.txt,sha256=dQu27fGBZJ2Yk-gW5XeD-dZ76Xa4Xcvk60Vz-dwXp7k,7
-xradio-0.0.56.dist-info/RECORD,,