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

xradio/schema/metamodel.py

@@ -1,7 +1,10 @@
-from dataclasses import dataclass
+from __future__ import annotations
+
+from dataclasses import dataclass, MISSING
 import typing
 
 __all__ = [
+    "ValueSchema",
     "AttrSchemaRef",
     "ArraySchema",
     "ArraySchemaRef",
@@ -10,8 +13,44 @@ __all__ = [
 ]
 
 
-@dataclass(frozen=True)
-class AttrSchemaRef:
+@dataclass
+class ValueSchema:
+    """
+    Schema information about a value in an attribute or dictionary.
+    """
+
+    type: typing.Literal[
+        "bool", "str", "int", "float", "list[str]", "dict", "dataarray"
+    ]
+    """
+    Type of value
+
+    * ``bool``: A boolean
+    * ``str``: A UTF-8 string
+    * ``int``: A 64-bit signed integer
+    * ``float``: A double-precision floating point number
+    * ``list[str]``: A list of strings
+    * ``dict``: Dictionary
+    * ``dataarray``: An xarray dataarray (encoded using ``to_dict``)
+    """
+    dict_schema: typing.Optional[DictSchema] = None
+    """
+    Dictionary schema, if it is a dict
+    """
+    array_schema: typing.Optional[ArraySchema] = None
+    """
+    Array schema, if it is an xarray DataArray
+    """
+    literal: typing.Optional[typing.List[typing.Any]] = None
+    """
+    Allowed literal values, if specified.
+    """
+    optional: bool = False
+    """Is the value optional?"""
+
+
+@dataclass
+class AttrSchemaRef(ValueSchema):
     """
     Schema information about an attribute as referenced from an array or
     dataset schema.
@@ -20,18 +59,11 @@ class AttrSchemaRef:
     in the array or dataset schema definition.
     """
 
-    name: str
+    name: str = ""
     """Name of attribute as given in data array / dataset."""
-    typ: type
-    """
-    Python type of attribute. Note that this might again be a data
-    array or dataset, but we don't track that explicitly.
-    """
-    optional: bool
-    """Is the attribute optional?"""
-    default: typing.Optional[typing.Any]
+    default: typing.Optional[typing.Any] = None
     """If optional: What is the default value?"""
-    docstring: str
+    docstring: str = ""
     """Documentation string of attribute reference"""
 
 
@@ -49,8 +81,11 @@ class ArraySchema:
     """(Class) name of the schema"""
     dimensions: typing.List[typing.List[str]]
     """List of possible dimensions"""
-    dtypes: typing.List[typing.List["numpy.dtype"]]
-    """List of possible (numpy) types"""
+    dtypes: typing.List[typing.List[str]]
+    """List of possible dtype options, where each inner list contains
+    (numpy) types as array interface protocol descriptors (e.g. `">f4"`).
+    Each inner list corresponds to a possible configuration of dtypes
+    for the data array."""
 
     coordinates: typing.List["ArraySchemaRef"]
     """Coordinates data arrays giving values to dimensions"""
@@ -97,7 +132,7 @@ class ArraySchemaRef(ArraySchema):
     """Name of array schema as given in dataset."""
     optional: bool
     """Is the data array optional?"""
-    default: typing.Optional[typing.Any]
+    default: typing.Optional[typing.Any] = None
     """If optional: What is the default value?"""
     docstring: typing.Optional[str] = None
     """Documentation string of array reference"""

xradio/schema/typing.py

@@ -312,26 +312,26 @@ def get_dims(tp: Any) -> List[Dims]:
 
     dims_out = []
     for dim in dims_in:
-        args = get_args(dim)
+        args = list(get_args(dim))
         origin = get_origin(dim)
 
         # One-dimensional dimension
         if origin is Literal:
-            dims_out.append((str(args[0]),))
+            dims_out.append([str(args[0])])
             continue
 
         if not (origin is tuple or origin is Tuple):
             raise TypeError(f"Could not find any dims in {tp!r}.")
 
         # Zero-dimensions
-        if args == () or args == ((),):
-            dims_out.append(())
+        if args == [] or args == [()]:
+            dims_out.append([])
             continue
 
         if not all(get_origin(arg) is Literal for arg in args):
             raise TypeError(f"Could not find any dims in {tp!r}.")
 
-        dims_out.append(tuple(str(get_args(arg)[0]) for arg in args))
+        dims_out.append([str(get_args(arg)[0]) for arg in args])
 
     return dims_out
 

xradio/sphinx/schema_table.py

@@ -154,40 +154,46 @@ class SchemaTableDirective(ObjectDescription):
                 self.state.nested_parse(vl, 0, entry)
 
 
-def format_literals(typ):
+def format_literals(literal) -> nodes.line:
 
-    # a | b | c: Recurse and merge
-    if typing.get_origin(typ) == typing.Union:
-        type_args = typing.get_args(typ)
-        options = []
-        for arg in type_args:
-            options += format_literals(arg)
-        return options
+    if isinstance(literal, list) and all([isinstance(item, str) for item in literal]):
+        formatted_literal = [nodes.literal(text=f"'{val}'") for val in literal]
+    else:
+        raise ValueError(f"Must be a list of literal string values: {literal}")
 
-    # Literal['a', 'b', ...]: Wrap into individual "literal" nodes
-    if typing.get_origin(typ) == typing.Literal:
-        return list(map(lambda t: nodes.literal(text=repr(t)), typing.get_args(typ)))
+    # Join the literals with ... , .. , .. , or ...
+    line = nodes.line()
+    for i, lit in enumerate(formatted_literal):
+        if i > 0:
+            if i + 1 >= len(formatted_literal):
+                line += nodes.Text(" or\xa0")
+            else:
+                line += nodes.Text(", ")
+        line += lit
 
-    # list[Literal['a'], Literal['b'], ...]: Format as one literal (compound) value
-    if typing.get_origin(typ) == list:
-        type_args = typing.get_args(typ)
-        if any([typing.get_origin(arg) != typing.Literal for arg in type_args]):
-            raise ValueError(f"List must contain only literals: {typ}")
-        values = [repr(typing.get_args(val)[0]) for val in typing.get_args(typ)]
-        return [nodes.literal(text=f"[{', '.join(values)}]")]
+    return line
+
+
+def format_class_types(state, attr_type) -> nodes.line:
+    line = nodes.line()
+    vl = StringList()
+    vl.append(f":py:class:`~{attr_type}`", "")
+    with switch_source_input(state, vl):
+        state.nested_parse(vl, 0, line)
 
-    raise ValueError(f"Must be either a type or a literal: {typ}")
+    return line
 
 
-def format_attr_model_text(state, attr) -> StringList:
+def format_attr_model_text(state, attr) -> nodes.line:
     """
-    Formats the text for the 'model' column in schema tables (arrays and datasets).
+    For an attribute, formats the text for the 'model' column in schema tables
+    (arrays and datasets).
     Doesn't aim at supporting any literal types or combinations of types in general,
     but the following three ones specifically:
 
-    - Literals (with multiple options (implicit Union of literals))
-    - List of literals (e.g. ["rad","rad"]
-    - Union of list of literals (e.g. ["m","m","m"]/["rad","rad","m"]
+    - String literals (units, frames, measure types, etc.)
+    - Other classes (for example usual built-in types such str, bool or ints,
+      or schema classes: schema dicts and schema arrays)
 
     This is meant to produce readable text listing literals as quoted text and
     their combinations, in schema attributes (particularly quantities and measures).
@@ -196,58 +202,16 @@ def format_attr_model_text(state, attr) -> StringList:
     type name.
     """
 
-    type_args = typing.get_args(attr.typ)
-    is_list_of_literals = typing.get_origin(attr.typ) is list and all(
-        [typing.get_origin(arg) is typing.Literal for arg in type_args]
-    )
-
-    line = nodes.line()
-
-    if not is_list_of_literals:
-        # A type?
-        if isinstance(attr.typ, type):
-            vl = StringList()
-            vl.append(f":py:class:`~{attr.typ.__module__}.{attr.typ.__name__}`", "")
-            with switch_source_input(state, vl):
-                state.nested_parse(vl, 0, line)
-            return line
-
-        if typing.get_origin(attr.typ) == typing.Union:
-            vl = StringList()
-            type_args = typing.get_args(attr.typ)
-            options = []
-            for i, arg in enumerate(type_args):
-                vl.append(f":py:class:`~{arg.__module__}.{arg.__name__}`", "")
-                if i + 1 < len(type_args):
-                    vl.append(" or ", "")
-            with switch_source_input(state, vl):
-                state.nested_parse(vl, 0, line)
-            return line
-
-        # Derived type, e.g. list of types?
-        if typing.get_origin(attr.typ) == list and all(
-            [isinstance(arg, type) for arg in type_args]
-        ):
-            vl = StringList()
-            vl.append("[", "")
-            for i, arg in enumerate(typing.get_args(attr.typ)):
-                if i > 0:
-                    vl.append(", ", "")
-                vl.append(f":py:class:`~{arg.__module__}.{arg.__name__}`", "")
-            vl.append("]", "")
-            with switch_source_input(state, vl):
-                state.nested_parse(vl, 0, line)
-            return line
-
-    # Assume it's a literal of some kind - collect options
-    literals = format_literals(attr.typ)
-    for i, lit in enumerate(literals):
-        if i > 0:
-            if i + 1 >= len(literals):
-                line += nodes.Text(" or\xa0")
-            else:
-                line += nodes.Text(", ")
-        line += lit
+    if getattr(attr, "literal"):
+        line = format_literals(attr.literal)
+    else:
+        if getattr(attr, "dict_schema"):
+            attr_type = attr.dict_schema.schema_name
+        elif getattr(attr, "array_schema"):
+            attr_type = attr.array_schema.schema_name
+        else:
+            attr_type = attr.type
+        line = format_class_types(state, attr_type)
 
     return line
 
@@ -356,7 +320,7 @@ class DictSchemaTableDirective(SchemaTableDirective):
             for attr in schema.attributes:
                 self._add_row(
                     attr.name,
-                    types=[f"{attr.typ.__name__}"],
+                    types=[attr.type],
                     optional=attr.optional,
                     descr=attr.docstring,
                     default=attr.default,

{xradio-0.0.56.dist-info → xradio-0.0.59.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xradio
-Version: 0.0.56
+Version: 0.0.59
 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
@@ -50,6 +50,7 @@ Requires-Dist: zarr<3,>=2
 Requires-Dist: pyarrow
 Requires-Dist: typeguard
 Requires-Dist: numcodecs<0.16
+Requires-Dist: psutil
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
@@ -107,25 +108,32 @@ Xarray Radio Astronomy Data IO is still in development.
 [![Version Status](https://img.shields.io/pypi/v/xradio.svg)](https://pypi.python.org/pypi/xradio/)
 
 # Installing
-It is recommended to use the conda environment manager from [miniforge](https://github.com/conda-forge/miniforge) to create a clean, self-contained runtime where XRADIO and all its dependencies can be installed:
+XRADIO can be installed in virtual environments via pip. It is recommended to use the conda environment manager from [miniforge](https://github.com/conda-forge/miniforge) to create a clean, self-contained runtime where XRADIO and all its dependencies can be installed, for example:
 ```sh
 conda create --name xradio python=3.12 --no-default-packages
 conda activate xradio
 ```
+> 📝 On macOS it is required to pre-install `python-casacore` using `conda install -c conda-forge python-casacore`.
+
 XRADIO can now be installed using:
 ```sh
 pip install xradio
 ```
-This will also install the minimal dependencies for XRADIO. To install the minimal dependencies and the interactive components (JupyterLab) use:
+This will also install the minimal dependencies for XRADIO.
+
+Note that if only the minimal dependencies are installed, the functionality to convert MSv2 to MSv4 will not be available.
+This requires installing `python-casacore` (also included in the `all` group, see below), or alternatively the
+`casatools` backend, as explained in the [casatools I/O backend guide](docs/source/measurement_set/guides/backends.md).
+
+To install the minimal dependencies and the interactive components (JupyterLab) use:
 ```sh
 pip install "xradio[interactive]"
 ```
+
 To enable conversion from MSv2 to MSv4 use (this only works for Linux):
 ```sh
 pip install "xradio[python-casacore]"
 ```
-> 📝 On macOS it is required to pre-install `python-casacore` using `conda install -c conda-forge python-casacore`.
-
 To be able to run tests:
 ```sh
 pip install "xradio[test]"
@@ -134,3 +142,10 @@ Multiple-dependencies can be installed using:
 ```sh
 pip install "xradio[interactive,python-casacore,test]"
 ```
+
+To install a more complete set of dependencies:
+```sh
+pip install "xradio[all]"
+```
+This will include the dependencies required to run the interactive Jupyter notebooks, run tests, build documentation,
+and python-casacore to enable MSv2=>MSv4 functionality.

xradio-0.0.59.dist-info/RECORD

@@ -0,0 +1,65 @@
+xradio/__init__.py,sha256=YTpM274ZBWK14HmIXyah27yiKPsmR6xCILvlXkQrYG4,387
+xradio/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xradio/_utils/coord_math.py,sha256=ZdbgStXqQ_HS7qQ9UBPk8Z3Zse5P_DrYQsgn2UCf22U,3342
+xradio/_utils/dict_helpers.py,sha256=a4veG6Dgwmtb9yO0kV9qvcQ9IZAKKrC9rAJ_m4EukcE,4072
+xradio/_utils/list_and_array.py,sha256=fW0LDSXlPrSQguSUcZM5oy2Zw-KQVqq9vmmLS8jhc70,4340
+xradio/_utils/schema.py,sha256=OYfAljwNU94KyxGSpKuKxSzSdebW6T43RkMA13aTaeU,7615
+xradio/_utils/_casacore/casacore_from_casatools.py,sha256=ugmWEIzJbuXsPDgJbtuzv0qSXx5Vybu8Sp73NAFt5oQ,31207
+xradio/_utils/_casacore/tables.py,sha256=puRidbjtVx6caEG_Z5TebTLdTUbtBUhzvqByKLQTHfo,1389
+xradio/_utils/zarr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xradio/_utils/zarr/common.py,sha256=rqqGAogp75xCE9ZiUvV-cU2n4aOw2qHycKh0F_EW518,2964
+xradio/image/__init__.py,sha256=HAD0GfopIbhdxOYckyW6S9US_dSWmZrwIl3FHUzZwrE,435
+xradio/image/image.py,sha256=L-6hhAbO6Bm1zbPRzcl_P3REjHyjFd2rjQvnpYO5Q8Q,16726
+xradio/image/_util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xradio/image/_util/casacore.py,sha256=_o8767_zYGbXMqqN4k4clq2VhfgEls09h2WXInKEFe0,4615
+xradio/image/_util/common.py,sha256=VGJ21x-Uifk9kf_O6o7URwesYInVZeMh1RLCXQOlgq0,8428
+xradio/image/_util/image_factory.py,sha256=TSrbrrcjK5qzPU5MipGMw3W7aHJFCcmVrZ80CiVpprQ,8613
+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=egL5pavyYs66sAHuWQGywnZUmaSle1IPtHSPeG25F1M,43731
+xradio/image/_util/_casacore/xds_to_casacore.py,sha256=RO8xOU2DwjNyLfAmAZAz9dCAf_RSlLotRVYRBLhnGOI,17938
+xradio/image/_util/_fits/xds_from_fits.py,sha256=DsuKAer43rWwDjA9gFNs2sCqFrFVdFW6O0i21RVZzzE,34654
+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=rGhy9tz5d60hln-SSWFLieDrZ2sodli3npKuCEQc8bc,1127
+xradio/measurement_set/convert_msv2_to_processing_set.py,sha256=ffdqpNQE01YHP_rXR74EvNtGVYaxBlY646vzh3Aimeo,9666
+xradio/measurement_set/load_processing_set.py,sha256=r_eO7DTr-3EphujOEh-P_VfcVRpYzx1M-tGBwpxFC-8,8201
+xradio/measurement_set/measurement_set_xdt.py,sha256=KHfm0AvjpLDLXHCOCtp51oFGwbrUVA2vKh6ZZ2sWK2M,12234
+xradio/measurement_set/open_processing_set.py,sha256=yfXhs1co8UBf4-m7LLAnc7lV2hFvGKV-HwQ_yAcusH8,5243
+xradio/measurement_set/processing_set_xdt.py,sha256=4ZnYT-hYw2upEil_jViOKptmi4JWrnbPOyAOQffd5Ek,34295
+xradio/measurement_set/schema.py,sha256=C32tb7gNIgOZvvr9b3uF5tODqXfbpOQPECI3dgr-udA,90729
+xradio/measurement_set/_utils/__init__.py,sha256=iTbgPiQPw9hyXSdQYPcwGRrP2PFXgF6CZi8A3KNKya0,43
+xradio/measurement_set/_utils/_msv2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xradio/measurement_set/_utils/_msv2/conversion.py,sha256=rPokAkZ7_4oJOOZ_byEv4nSL14L9oV5kbpj1yopgTjw,54089
+xradio/measurement_set/_utils/_msv2/create_antenna_xds.py,sha256=s3HnTbyOl7h6pAocJ4dpd095s7qHSSngeQ34Ygo8Uk0,17650
+xradio/measurement_set/_utils/_msv2/create_field_and_source_xds.py,sha256=HSmeR2BZvsVBPp7ySUgFIR_LXQ0-fLu9cFd_ScsJgZ0,33523
+xradio/measurement_set/_utils/_msv2/msv2_to_msv4_meta.py,sha256=ZpxJJ2yTjjEy6A4XWS9eT-1J92jLwR8CNyoDBfhAVm8,1572
+xradio/measurement_set/_utils/_msv2/msv4_info_dicts.py,sha256=s7K4MUWtrxKG9e6brNSXXJ6EYvsUf30PYEkkb1P13Mc,7320
+xradio/measurement_set/_utils/_msv2/msv4_sub_xdss.py,sha256=6BXZkypfe1C4n5bQDtxMdY0qnVuO3DDjtwDLUwtUOow,30453
+xradio/measurement_set/_utils/_msv2/optimised_functions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xradio/measurement_set/_utils/_msv2/partition_queries.py,sha256=1dzwAVraEktkMl8MYn6bzhjlpCCSgy6KTqlTmjeC3nQ,5661
+xradio/measurement_set/_utils/_msv2/subtables.py,sha256=mrf7g7mbC4crtnQ0wFocPcFRNlvq_7e7iDzE5B6ugl4,843
+xradio/measurement_set/_utils/_msv2/_tables/read.py,sha256=tW0ROevR4tXpydIWuj2UyNhWNtvkKU9NkYxMi1ZoVKc,45421
+xradio/measurement_set/_utils/_msv2/_tables/read_main_table.py,sha256=FFoTVpY8JNvcXnTvUiraWNU9gB9-_9GR7he0NbODabg,3168
+xradio/measurement_set/_utils/_msv2/_tables/table_query.py,sha256=Uc1zeiU-rYtCsYXpij8jzFG5NPBYvIh70qW1srn7B98,1498
+xradio/measurement_set/_utils/_utils/interpolate.py,sha256=LlDYi-h7aj_tsuZqAu5Kr-vOi6fVBPpVbew-i-HnmA0,1962
+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/_zarr/encoding.py,sha256=ze5ncHEBa-sVwJCayJa2irOdaxZEkYfBKObuij7uVRc,371
+xradio/schema/__init__.py,sha256=EzEMnOtN8G_wdjo8QBRKfq5MrYgfr_nt1pfunlI6i6Q,733
+xradio/schema/bases.py,sha256=dk24pFhugCe5RjaR41xxP38FxVVsIC9bdmBdsarwFvk,17162
+xradio/schema/check.py,sha256=JJg8x0PiNQ7zX04XBqg8l_AIAK1SDv8mRp8HJxYd1Rw,21942
+xradio/schema/dataclass.py,sha256=gzNqXzkBLV7ETEyddNOd_jRgP8rkivCkfUlURLz8z5c,19300
+xradio/schema/export.py,sha256=_dqUToirb_T6eC_x2b4bzhUtDSB6VmvLTC8kW9z2XOI,2781
+xradio/schema/metamodel.py,sha256=4Pnymp34Pli2mQU_3LEBIx-2TUtlza-ZRwXLzBm1SjA,4859
+xradio/schema/typing.py,sha256=BJactfOKXgnIm4Y7BZE72lLKYhPt-N0xxlMjkTL6ecY,10438
+xradio/sphinx/__init__.py,sha256=VGY-7Ty3q67qpnBee0-znbiJ-Iy0F93UO--IpjEdHXc,380
+xradio/sphinx/schema_table.py,sha256=CrhWMDYHwB7CbBMGfWtW20bLoBkeQZHd6l91cihvaBA,10709
+xradio-0.0.59.dist-info/licenses/LICENSE.txt,sha256=9CYIJt7riOXo9AD0eXBZviLxo_HebD-2JJI8oiWtzfg,1807
+xradio-0.0.59.dist-info/METADATA,sha256=ZBTavpFX7VvjtRZkANWIZO1jKxsRc2WrXwETbo91JN4,7513
+xradio-0.0.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xradio-0.0.59.dist-info/top_level.txt,sha256=dQu27fGBZJ2Yk-gW5XeD-dZ76Xa4Xcvk60Vz-dwXp7k,7
+xradio-0.0.59.dist-info/RECORD,,

{xradio-0.0.56.dist-info → xradio-0.0.59.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

xradio/image/_util/fits.py

@@ -1,13 +0,0 @@
-import os
-
-import xarray as xr
-
-from ._fits.xds_from_fits import _fits_image_to_xds
-
-
-def _read_fits_image(
-    infile: str, chunks: dict, verbose: bool, do_sky_coords: bool
-) -> xr.Dataset:
-    img_full_path = os.path.expanduser(infile)
-    xds = _fits_image_to_xds(img_full_path, chunks, verbose, do_sky_coords)
-    return xds

xradio/measurement_set/_utils/_msv2/_tables/load.py

@@ -1,66 +0,0 @@
-from typing import Tuple
-
-import numpy as np
-
-try:
-    from casacore import tables
-except ImportError:
-    import xradio._utils._casacore.casacore_from_casatools as tables
-from ....._utils.common import get_pad_value
-
-
-def load_col_chunk(
-    tb_tool: tables.table,
-    col: str,
-    cshape: Tuple[int],
-    tidxs: np.ndarray,
-    bidxs: np.ndarray,
-    didxs: np.ndarray,
-    d1: Tuple[int, int],
-    d2: Tuple[int, int],
-) -> np.ndarray:
-    """
-    Loads a slice of a col (using casacore getcol(slice))
-
-    Parameters
-    ----------
-    tb_tool : tables.table
-        a table/TaQL query open and being used to load columns
-    col : str
-        colum to load
-    cshape : Tuple[int]
-        shape of the resulting col data chunk
-    tidxs : np.ndarray
-        time axis indices
-    bidxs : np.ndarray
-        baseline axis indices
-    didxs : np.ndarray
-        effective) data indices, excluding missing baselines
-    d1 : Tuple[int, int]
-        indices to load on dimension 1 (None=all, pols or chans)
-    d2 : Tuple[int, int]
-        indices to load on dimension 2 (None=all, pols)
-
-    Returns
-    -------
-    np.ndarray
-        data array loaded directly with casacore getcol/getcolslice
-    """
-
-    if (len(cshape) == 2) or (col == "UVW"):
-        # all the scalars and UVW
-        data = np.array(tb_tool.getcol(col, 0, -1))
-    elif len(cshape) == 3:
-        # WEIGHT, SIGMA
-        data = tb_tool.getcolslice(col, d1[0], d1[1], [], 0, -1)
-    elif len(cshape) == 4:
-        # DATA, FLAG, WEIGHT_SPECTRUM / SIGMA_SPECTRUM
-        data = tb_tool.getcolslice(col, (d1[0], d2[0]), (d1[1], d2[1]), [], 0, -1)
-
-    # full data is the maximum of the data shape and chunk shape dimensions
-    fill_value = get_pad_value(data.dtype)
-    chunk = np.full(cshape, np.fill_value, dtype=data.dtype)
-    if len(didxs) > 0:
-        chunk[tidxs[didxs], bidxs[didxs]] = data[didxs]
-
-    return chunk