xradio 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

xradio/data/_dropbox.py

@@ -8,18 +8,26 @@ from tqdm import tqdm
 #https://www.dropbox.com/scl/fi/x8tp0wu21gssbd1gxrnmy/Antennae_North.cal.lsrk.vis.zarr.zip?rlkey=l9jdr6tvyq4pe3381gukuly0d&dl=0
 
 FILE_ID = {
+ 'AA2-Mid-sim_00000.ms':
+  {
+    'file':'AA2-Mid-sim_00000.ms.zip',
+    'id':'2buf75ebhurjlfhe123qs',
+    'rlkey':'8wzgiavzxfp4aza4sx84qanid&dl'
+  },
+
+  'Antennae_M8.img.zarr':
+  {
+    'file':'Antennae_M8.img.zarr.zip',
+    'id':'9v0a1rv7nzm3kqte0u7vp',
+    'rlkey':'ws6vd0jbo1dg7jvxsit42q5ba&dl'
+  },
+
   'demo_simulated.im':
   {
     'file':'demo_simulated.im.zip',
     'id':'z87gibxshwg9e2h155ukk',
     'rlkey':'bn7uvs697wtedij63fa2hu7ed&dl'
   },
- 'Antennae_North.cal.lsrk.vis.zarr':
-  {
-    'file':'Antennae_North.cal.lsrk.vis.zarr.zip',
-    'id':'x8tp0wu21gssbd1gxrnmy',
-    'rlkey':'l9jdr6tvyq4pe3381gukuly0d&dl'
-  },
   
   'Antennae_North.cal.lsrk.ms':
    {
@@ -27,6 +35,20 @@ FILE_ID = {
     'id':'olx5qv9avdxxiyjlhlwx2',
     'rlkey':'trrqy43rfcqj4blf9robz4p47&dl'
    },
+   
+ 'Antennae_North.cal.lsrk.vis.zarr':
+  {
+    'file':'Antennae_North.cal.lsrk.vis.zarr.zip',
+    'id':'9hcunmq3iqtfiww593nrp',
+    'rlkey':'7fingboduee7logszh25n95x5&dl'
+  },
+  
+  'Antennae_North.cal.lsrk.split.ms':
+  {
+    'file':'Antennae_North.cal.lsrk.split.ms.zip',
+    'id':'j2e5pd4y7ppvw9efxdfdj',
+    'rlkey':'hlb85n40vtac3k9nna14giwsf&dl'
+  },
 }
 
 def download(file, folder='.'):

xradio/image/__init__.py

@@ -1,11 +1,11 @@
 # methods in cngi_io.image.image should be used going forward,
 # methods in cngi_io.image.cngi_image_io are deprecated
 from .image import (
-    load_image_block, make_empty_sky_image, read_image, write_image
+    load_image, make_empty_sky_image, read_image, write_image
 )
 
 __all__ = [
-    'load_image_block', 'make_empty_sky_image', 'read_image', 'write_image'
+    'load_image', 'make_empty_sky_image', 'read_image', 'write_image'
 ]
 
 

xradio/image/_util/_casacore/xds_from_casacore.py

@@ -61,7 +61,7 @@ def __add_dir_lin_attrs(xds, coord_dict, dir_axes):
 
 
 def __add_freq_attrs(xds, coord_dict):
-    freq_coord = xds['freq']
+    freq_coord = xds['frequency']
     meta = {}
     for k in coord_dict:
         if k.startswith('spectral'):
@@ -89,7 +89,7 @@ def __add_freq_attrs(xds, coord_dict):
 		# this is the default frequency information CASA creates
         meta = __default_freq_info()
     freq_coord.attrs = copy.deepcopy(meta)
-    xds['freq'] = freq_coord
+    xds['frequency'] = freq_coord
     return xds
 
 
@@ -282,9 +282,9 @@ def __casa_image_to_xds_metadata(img_full_path:str, verbose:bool=False) -> dict:
     attrs['sphr_dims'] = sphr_dims
     coords = {}
     coords['time'] = __get_time_values(coord_dict)
-    coords['pol'] = __get_pol_values(coord_dict)
-    coords['freq'] = __get_freq_values(casa_image.coordinates(), shape)
-    coords['vel'] = (['freq'], __get_velocity_values(coord_dict, coords['freq']))
+    coords['polarization'] = __get_pol_values(coord_dict)
+    coords['frequency'] = __get_freq_values(casa_image.coordinates(), shape)
+    coords['vel'] = (['frequency'], __get_velocity_values(coord_dict, coords['frequency']))
     if len(sphr_dims) > 0:
         for k in coord_dict.keys():
             if k.startswith('direction'):
@@ -446,11 +446,11 @@ def __get_chunk_list(chunks:dict, coords:list, image_shape:Union[list, tuple]) -
                 if i == 0:
                     axis += 1
         elif c == 'spectral':
-            if 'freq' in chunks:
-                ret_list[axis] = chunks['freq']
+            if 'frequency' in chunks:
+                ret_list[axis] = chunks['frequency']
         elif c == 'stokes':
-            if 'pol' in chunks:
-                ret_list[axis] = chunks['pol']
+            if 'polarization' in chunks:
+                ret_list[axis] = chunks['polarization']
         else:
             raise Exception(f'Unhandled coordinate type {c}')
         axis += 1
@@ -468,10 +468,10 @@ def __get_dimmap(coords: list, verbose: bool=False) -> dict:
     if verbose:
         print(f'dimmap: {dimmap}')
     # example of dimmap after next statment
-    # [('l', 0), ('m', 1), ('chan', 2), ('pol', 3)]
+    # [('l', 0), ('m', 1), ('chan', 2), ('polarization', 3)]
     dimmap = [
         (rr[0].replace(
-            'stokes0','pol'
+            'stokes0','polarization'
         ).replace('spectral0','chan').replace('direction0','l').replace(
             'direction1','m').replace('linear0', 'u').replace(
             'linear1', 'v'
@@ -493,7 +493,7 @@ def __get_dimmap(coords: list, verbose: bool=False) -> dict:
         for rr in dimmap if rr[1] >= 0
     ]
     # conversion to dict, example dimmap after this statement
-    # dimmap: {'l': 0, 'm': 1, 'chan': 2, 'pol': 3}
+    # dimmap: {'l': 0, 'm': 1, 'chan': 2, 'polarization': 3}
     dimmap = dict(
         [(diraxes[int(rr[0][-1])], rr[1])
         if rr[0].startswith('linear') or rr[0].startswith('direction')
@@ -552,10 +552,10 @@ def __get_image_dim_order(coords: coordinates.coordinatesystem) -> list:
             ret.append('l')
         elif b.startswith('dec') or b.startswith('vv'):
             ret.append('m')
-        elif b.startswith('freq'):
-            ret.append('freq')
+        elif b.startswith('frequency'):
+            ret.append('frequency')
         elif b.startswith('stok'):
-            ret.append('pol')
+            ret.append('polarization')
         else:
             raise Exception(f'Unhandled axis name {c}')
     return ret
@@ -617,7 +617,7 @@ def __get_starts_shapes_slices(
     shapes = []
     slices = {}
     for i, dim in enumerate(img_dim_order):
-        if dim not in ['pol', 'freq', 'l', 'm', 'u', 'v']:
+        if dim not in ['polarization', 'frequency', 'l', 'm', 'u', 'v']:
             raise Exception(f'Unsupported dimension {dim}')
         if dim in blockdes:
             extent = blockdes[dim]
@@ -662,7 +662,7 @@ def __get_transpose_list(coords: coordinates.coordinatesystem) -> list:
             # transpose_list[4] = csys['pixelmap0'][1]
             not_covered.remove('m')
             not_covered.remove('v')
-        elif b.startswith('freq'):
+        elif b.startswith('frequency'):
             # transpose_list[2] = csys['pixelmap1'][0]
             transpose_list[2] = i
             not_covered.remove('f')
@@ -767,7 +767,7 @@ def __multibeam_array(
             del xds.attrs['beam']
             if as_dask_array:
                 mb = da.array(mb)
-            xdb = xr.DataArray(mb, dims=['time', 'pol', 'freq', 'beam_param'])
+            xdb = xr.DataArray(mb, dims=['time', 'polarization', 'frequency', 'beam_param'])
             xdb = xdb.rename('beam')
             xdb = xdb.assign_coords(beam_param=['major', 'minor', 'pa'])
             xdb.attrs['unit'] = 'rad'
@@ -869,7 +869,7 @@ def __read_image_array(
 ) -> dask.array:
     """
     Read an array of image pixels into a dask array. The returned dask array
-    will have axes in time, pol, freq, l, m order
+    will have axes in time, polarization, frequency, l, m order
     If specified, it's the caller's responsibility to ensure the specified blc and
     trc are coincident with chunk corners. If not, there could be performance degradation
     The blc, trc box is inclusive of blc pixel coordinates and exclusive trc pixel
@@ -887,7 +887,7 @@ def __read_image_array(
                    Freq, Stokes and the desired chunking is 40 pixels in RA, 30
                    pixels in Dec, 20 pixels in Freq, and 2 pixels in Stokes,
                    chunks would be specified as [40, 30, 20, 2].
-                   If dict, supported optional keys are 'l', 'm', 'freq', 'pol',
+                   If dict, supported optional keys are 'l', 'm', 'frequency', 'polarization',
                    and 'time'. The supported values are positive integers,
                    indicating the length of a chunk on that particular axis. If
                    a key is missing, the associated chunk length along that axis
@@ -904,7 +904,7 @@ def __read_image_array(
     :type blc: a type that is convertable to a list via list(blc)
     :param trc: top right corner, given in the axes ordering of the input image.None=>image shape - 1
     :type trc: a type that is convertable to a list via list(trc)
-    :return: Dask array in time, pol, freq, l, m order
+    :return: Dask array in time, polarization, frequency, l, m order
     :rtype: dask.array
 
     """

xradio/image/_util/_casacore/xds_to_casacore.py

@@ -146,7 +146,7 @@ def __compute_spectral_dict(
     for a CASA image coordinate system
     """
     spec = {}
-    spec_conv = copy.deepcopy(xds.freq.attrs['conversion'])
+    spec_conv = copy.deepcopy(xds.frequency.attrs['conversion'])
     for k in ('direction', 'epoch', 'position'):
         spec_conv[k]['type'] = k
     spec_conv['direction']['refer'] = spec_conv['direction']['system']
@@ -160,19 +160,19 @@ def __compute_spectral_dict(
     spec['conversion'] = spec_conv
     spec['formatUnit'] = ''
     spec['name'] = 'Frequency'
-    spec['nativeType'] = __native_types.index(xds.freq.attrs['native_type'])
-    spec['restfreq'] = xds.freq.attrs['restfreq']
-    spec['restfreqs'] = copy.deepcopy(xds.freq.attrs['restfreqs'])
-    spec['system'] = xds.freq.attrs['system']
-    spec['unit'] = xds.freq.attrs['unit']
+    spec['nativeType'] = __native_types.index(xds.frequency.attrs['native_type'])
+    spec['restfreq'] = xds.frequency.attrs['restfreq']
+    spec['restfreqs'] = copy.deepcopy(xds.frequency.attrs['restfreqs'])
+    spec['system'] = xds.frequency.attrs['system']
+    spec['unit'] = xds.frequency.attrs['unit']
     spec['velType'] = __doppler_types.index(xds.vel.attrs['doppler_type'])
     spec['velUnit'] = xds.vel.attrs['unit']
     spec['version'] = 2
-    spec['waveUnit'] = xds.freq.attrs['wave_unit']
-    spec_wcs = copy.deepcopy(xds.freq.attrs['wcs'])
+    spec['waveUnit'] = xds.frequency.attrs['wave_unit']
+    spec_wcs = copy.deepcopy(xds.frequency.attrs['wcs'])
     spec_wcs['ctype'] = 'FREQ'
     spec_wcs['pc'] = 1.0
-    spec_wcs['crpix'] = (spec_wcs['crval'] - xds.freq.values[0])/spec_wcs['cdelt']
+    spec_wcs['crpix'] = (spec_wcs['crval'] - xds.frequency.values[0])/spec_wcs['cdelt']
     spec['wcs'] = spec_wcs
     return spec
 
@@ -195,7 +195,7 @@ def __coord_dict_from_xds(xds: xr.Dataset) -> dict:
     coord['stokes1'] = {
         'axes': np.array(['Stokes'], dtype='<U16'), 'cdelt': np.array([1.]),
         'crpix': np.array([0.]), 'crval': np.array([1.]), 'pc': np.array([[1.]]),
-        'stokes': np.array(xds.pol.values, dtype='<U16')
+        'stokes': np.array(xds.polarization.values, dtype='<U16')
     }
     coord['spectral2'] = __compute_spectral_dict(
         xds, coord['direction0'], coord['obsdate'], coord['telescopeposition']
@@ -213,7 +213,7 @@ def __coord_dict_from_xds(xds: xr.Dataset) -> dict:
     # this probbably needs some verification
     coord['worldreplace0'] = [0.0, 0.0]
     coord['worldreplace1'] = np.array(coord['stokes1']['crval'])
-    coord['worldreplace2'] = np.array([xds.freq.attrs['wcs']['crval']])
+    coord['worldreplace2'] = np.array([xds.frequency.attrs['wcs']['crval']])
     return coord
 
 
@@ -259,24 +259,24 @@ def __imageinfo_dict_from_xds(xds: xr.Dataset) -> dict:
     elif 'beam' in xds.data_vars:
         # multi beam
         pp = {}
-        pp['nChannels'] = len(xds.freq)
-        pp['nStokes'] = len(xds.pol)
+        pp['nChannels'] = len(xds.frequency)
+        pp['nStokes'] = len(xds.polarization)
         bu = xds.beam.attrs['unit']
         chan = 0
-        pol = 0
+        polarization = 0
         bv = xds.beam.values
         for i in range(pp['nChannels'] * pp['nStokes']):
-            bp = bv[0][pol][chan][:]
+            bp = bv[0][polarization][chan][:]
             b = {
                 'major': {'unit': bu, 'value': bp[0]},
                 'minor': {'unit': bu, 'value': bp[1]},
                 'positionangle': {'unit': bu, 'value': bp[2]}
             }
-            pp['*' + str(pp['nChannels']*pol + chan)] = b
+            pp['*' + str(pp['nChannels']*polarization + chan)] = b
             chan += 1
             if chan >= pp['nChannels']:
                 chan = 0
-                pol += 1
+                polarization += 1
         ii['perplanebeams'] = pp
     return ii
 
@@ -346,7 +346,7 @@ def __write_pixels(
             tb = tables.table(os.sep.join([image_full_path, active_mask]))
             tb.copy(filename, deep=True, valuecopy=True)
             tb.close()
-    arr = xds[v].isel(time=0).transpose(*('freq', 'pol', 'm', 'l'))
+    arr = xds[v].isel(time=0).transpose(*('frequency', 'polarization', 'm', 'l'))
     chunk_bounds = arr.chunks
     b = [0, 0, 0, 0]
     loc0, loc1, loc2, loc3 = (0, 0, 0, 0)

xradio/image/_util/_fits/xds_from_fits.py

@@ -64,7 +64,7 @@ def __add_time_attrs(xds:xr.Dataset, helpers:dict) -> xr.Dataset:
 
 
 def __add_freq_attrs(xds:xr.Dataset, helpers:dict) -> xr.Dataset:
-    freq_coord = xds.coords['freq']
+    freq_coord = xds.coords['frequency']
     meta = {}
     if helpers['has_freq']:
         conv = {}
@@ -97,7 +97,7 @@ def __add_freq_attrs(xds:xr.Dataset, helpers:dict) -> xr.Dataset:
         # this is the default frequency information CASA creates
         meta = __default_freq_info()
     freq_coord.attrs = copy.deepcopy(meta)
-    xds['freq'] = freq_coord
+    xds['frequency'] = freq_coord
     return xds
 
 
@@ -176,7 +176,7 @@ def __fits_header_to_xds_attrs(hdulist:fits.hdu.hdulist.HDUList) -> dict:
         elif ax_type.startswith('DEC-'):
             t_axes[1] = i
         elif ax_type == 'STOKES':
-            dim_map['pol'] = i - 1
+            dim_map['polarization'] = i - 1
         elif __is_freq_like(ax_type):
             dim_map['freq'] = i - 1
             helpers['has_freq'] = True
@@ -378,9 +378,9 @@ def __create_coords(helpers, header):
     helpers['sphr_dims'] = sphr_dims
     coords = {}
     coords['time'] = __get_time_values(helpers)
-    coords['pol'] = __get_pol_values(helpers)
-    coords['freq'] = __get_freq_values(helpers)
-    coords['vel'] = (['freq'], __get_velocity_values(helpers))
+    coords['polarization'] = __get_pol_values(helpers)
+    coords['frequency'] = __get_freq_values(helpers)
+    coords['vel'] = (['frequency'], __get_velocity_values(helpers))
     if len(sphr_dims) > 0:
         l_world, m_world = __compute_world_sph_dims(
             sphr_dims, dir_axes, dim_map, helpers
@@ -439,7 +439,7 @@ def __get_freq_values(helpers:dict) -> list:
         freq_start_val = crval - cdelt*crpix
         for i in range(helpers['shape'][freq_idx]):
             vals.append(freq_start_val + i*cdelt)
-        helpers['freq'] = vals * u.Unit(cunit)
+        helpers['frequency'] = vals * u.Unit(cunit)
         return vals
     elif 'VOPT' in ctype:
         if 'restfreq' in helpers:
@@ -476,10 +476,10 @@ def __get_freq_values(helpers:dict) -> list:
 def __get_velocity_values(helpers:dict) -> list:
     if 'vel' in helpers:
         return helpers['vel'].to(u.m/u.s).value
-    elif 'freq' in helpers:
+    elif 'frequency' in helpers:
         if helpers['doppler'] == 'Z':
             # (-1 + f0/f) = v/c
-            v = (helpers['restfreq']*u.Hz/helpers['freq'].to('Hz').value - 1) * __c
+            v = (helpers['restfreq']*u.Hz/helpers['frequency'].to('Hz').value - 1) * __c
             v = v.to(u.m/u.s)
             helpers['vel'] = v
             return v.value
@@ -557,7 +557,7 @@ def __do_multibeam(xds:xr.Dataset, imname:str) -> xr.Dataset:
                     (beam_array[:, :, :, i] * units[i]).to('rad').value
                 )
             xdb = xr.DataArray(
-                beam_array, dims=['time', 'pol', 'freq', 'beam_param']
+                beam_array, dims=['time', 'polarization', 'frequency', 'beam_param']
             )
             xdb = xdb.rename('beam')
             xdb = xdb.assign_coords(beam_param=['major', 'minor', 'pa'])
@@ -694,11 +694,11 @@ def __get_chunk_list(chunks:dict, helpers:dict) -> tuple:
             if 'm' in chunks:
                 ret_list[axis] = chunks['m']
         elif c.startswith('FREQ') or c.startswith('VOPT') or c.startswith('VRAD'):
-            if 'freq' in chunks:
-                ret_list[axis] = chunks['freq']
+            if 'frequency' in chunks:
+                ret_list[axis] = chunks['frequency']
         elif c.startswith('STOKES'):
-            if 'pol' in chunks:
-                ret_list[axis] = chunks['pol']
+            if 'polarization' in chunks:
+                ret_list[axis] = chunks['polarization']
         else:
             raise RuntimeError(f'Unhandled coordinate type {c}')
         axis += 1
@@ -723,7 +723,7 @@ def __get_transpose_list(helpers:dict) -> tuple:
             transpose_list[4] = i
             not_covered.remove('m')
             not_covered.remove('v')
-        elif b.startswith('freq') or b.startswith('vopt') or b.startswith('vrad'):
+        elif b.startswith('frequency') or b.startswith('vopt') or b.startswith('vrad'):
             transpose_list[2] = i
             not_covered.remove('f')
         elif b.startswith('stok'):

xradio/image/_util/_zarr/zarr_low_level.py

@@ -0,0 +1,185 @@
+import os
+import numpy as np
+import json
+
+from numcodecs.compat import (
+    ensure_text,
+    ensure_ndarray_like,
+    ensure_bytes,
+    ensure_contiguous_ndarray_like
+)
+
+def pad_array_with_nans(input_array, output_shape):
+    """
+    Pad an integer array with NaN values to match the specified output shape.
+
+    Parameters:
+    - input_array: The input NumPy array to be padded.
+    - output_shape: A tuple specifying the desired output shape (e.g., (rows, columns)).
+
+    Returns:
+    - A NumPy array with NaN padding to match the specified output shape.
+    """
+    # Get the input shape
+    input_shape = input_array.shape
+
+    # Calculate the padding dimensions
+    padding_shape = tuple(max(0, o - i) for i, o in zip(input_shape, output_shape))
+
+    # Create a new array filled with NaN values
+    padded_array = np.empty(output_shape)
+    padded_array[:] = np.nan
+
+    # Copy the input array to the appropriate position within the padded array
+    padded_array[:input_shape[0], :input_shape[1]] = input_array
+
+    return padded_array
+
+def write_binary_blob_to_disk(arr, file_path, compressor):
+    """
+    Compress a NumPy array using Blosc and save it to disk.
+
+    Parameters:
+    - arr: The NumPy array to compress and save.
+    - file_path: The path to the output file where the compressed array will be saved.
+    - compressor:
+
+    Returns:
+    - None
+    """
+    # Encode the NumPy array using the codec
+    compressed_arr = compressor.encode(arr)
+
+    # Ensure the directory exists before saving the file
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+    # Save the compressed array to disk
+    with open(file_path, 'wb') as file:
+        file.write(compressed_arr)
+
+    print(f"Compressed array saved to {file_path}")
+    
+def read_binary_blob_from_disk(file_path, compressor, dtype=np.float64):
+    """
+    Read a compressed binary blob from disk and decode it using Blosc.
+
+    Parameters:
+    - file_path: The path to the compressed binary blob file.
+    - compressor: The Blosc compressor to use (e.g., 'zstd', 'lz4', 'blosclz', etc.).
+
+    Returns:
+    - The decoded NumPy array.
+    """
+    # Check if the file exists
+    if not os.path.exists(file_path):
+        print(f"Error: File '{file_path}' not found.")
+        return None
+
+    # Read the compressed binary blob from disk
+    with open(file_path, 'rb') as file:
+        compressed_arr = file.read()
+
+    # Decode the compressed data using the Blosc compressor
+    decoded_bytes = compressor.decode(compressed_arr)
+
+    decoded_arr = np.frombuffer(decoded_bytes, dtype)  # Adjust dtype as needed
+
+    return decoded_arr
+
+
+
+def read_json_file(file_path):
+    """
+    Read a JSON file and return its contents as a Python dictionary.
+
+    Parameters:
+    - file_path: The path to the JSON file to be read.
+
+    Returns:
+    - A Python dictionary containing the JSON data.
+    """
+    try:
+        with open(file_path, 'r') as file:
+            data = json.load(file)
+        return data
+    except FileNotFoundError:
+        print(f"Error: File '{file_path}' not found.")
+        return None
+    except json.JSONDecodeError as e:
+        print(f"Error decoding JSON from '{file_path}': {e}")
+        return None
+        
+class NumberEncoder(json.JSONEncoder):
+    def default(self, o):
+        # See json.JSONEncoder.default docstring for explanation
+        # This is necessary to encode numpy dtype
+        if isinstance(o, numbers.Integral):
+            return int(o)
+        if isinstance(o, numbers.Real):
+            return float(o)
+        return json.JSONEncoder.default(self, o)
+        
+        
+def write_json_file(data, file_path):
+    """
+    Write a Python dictionary to a JSON file.
+
+    Parameters:
+    - data: The Python dictionary to be written to the JSON file.
+    - file_path: The path to the JSON file to be created or overwritten.
+
+    Returns:
+    - None
+    """
+    with open(file_path, 'w') as file:
+        json.dump(data, file, indent=4,sort_keys=True, ensure_ascii=True, separators=(",", ": "), cls=NumberEncoder)
+
+
+def create_data_variable_meta_data_on_disk(zarr_group_name,data_varaibles_and_dims,compressor):
+
+    for data_varaible, dims in data_varaibles_and_dims.items():
+        print(data_varaible,dims)
+        data_variable_path = os.path.join(zarr_group_name,data_varaible)
+        os.system('mkdir ' + data_variable_path)
+        #Create .zattrs
+        zattrs = {
+            "_ARRAY_DIMENSIONS": dims,
+            #"coordinates": "time declination right_ascension"
+        }
+    
+        write_json_file(zattrs,os.path.join(data_variable_path,'.zattrs'))
+        
+        #Create .zarray
+        from zarr import n5
+        compressor_config = n5.compressor_config_to_zarr(n5.compressor_config_to_n5(compressor.get_config()))
+        zarray = {
+            "chunks": [
+                1,
+                1,
+                2,
+                500,
+                500
+            ],
+            "compressor":compressor_config,
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": None,
+            "order": "C",
+            "shape": [
+                1,
+                1,
+                3,
+                500,
+                500
+            ],
+            "zarr_format": 2
+        }
+
+        write_json_file(zarray,os.path.join(data_variable_path,'.zarray'))
+        
+        
+        
+##Image definitions
+# parallel_coords
+# img_xds (get image size and chunk size)
+# SKY, dims, dtype

xradio/image/_util/casacore.py

@@ -72,7 +72,7 @@ def __load_casa_image_block(infile: str, block_des: dict) -> xr.Dataset:
     mb = __multibeam_array(xds, image_full_path, False)
     if mb is not None:
         selectors = {}
-        for k in ('time', 'pol', 'freq'):
+        for k in ('time', 'polarization', 'frequency'):
             if k in block_des:
                 selectors[k] = block_des[k]
         xds['beam'] = mb.isel(selectors)
@@ -110,7 +110,7 @@ def __xds_to_casa_image(xds: xr.Dataset, imagename:str) -> None:
     sky_ap = 'sky' if 'sky' in xds else 'apeature'
     if xds[sky_ap].shape[0] != 1:
         raise Exception('XDS can only be converted if it has exactly one time plane')
-    arr = xds[sky_ap].isel(time=0).transpose(*('freq', 'pol', 'm', 'l'))
+    arr = xds[sky_ap].isel(time=0).transpose(*('frequency', 'polarization', 'm', 'l'))
     image_full_path = os.path.expanduser(imagename)
     maskname = ''
     if __active_mask in xds.attrs and xds.attrs[__active_mask]:

xradio/image/_util/common.py

@@ -12,7 +12,7 @@ __image_type = 'image_type'
 
 
 def __get_xds_dim_order(has_sph:bool) -> list:
-    dimorder = ['time', 'pol', 'freq']
+    dimorder = ['time', 'polarization', 'frequency']
     dir_lin = ['l', 'm'] if has_sph else ['u', 'v']
     dimorder.extend(dir_lin)
     return dimorder

xradio/image/_util/image_factory.py

@@ -46,13 +46,13 @@ def __make_empty_sky_image(
         time_coords = [ time_coords ]
     time_coords = np.array(time_coords, dtype=np.float64)
     coords = {
-        'time': time_coords, 'pol': pol_coords, 'freq': chan_coords,
-        'vel': (('freq'), vel), 'right_ascension': (('l', 'm'), long),
+        'time': time_coords, 'polarization': pol_coords, 'frequency': chan_coords,
+        'vel': (('frequency'), vel), 'right_ascension': (('l', 'm'), long),
         'declination': (('l', 'm'), lat)
     }
     xds = xds.assign_coords(coords)
     xds.time.attrs = {'format': 'MJD', 'refer': 'UTC', 'unit': 'd'}
-    xds.freq.attrs = {
+    xds.frequency.attrs = {
         'conversion': {
             'direction': {
                 'm0': {'unit': 'rad', 'value': 0.0},
@@ -103,9 +103,11 @@ def __make_empty_sky_image(
             'conversion_system': direction_reference,
             'conversion_equinox': 'J2000',
             'long_pole': 0.0, 'lat_pole': 0.0,
-            'pc': np.array([[1.0, 0.0], [0.0, 1.0]]),
+            #'pc': np.array([[1.0, 0.0], [0.0, 1.0]]),
+            'pc': [[1.0, 0.0], [0.0, 1.0]],
             'projection': projection,
-            'projection_parameters': np.array([0.0, 0.0]),
+            #'projection_parameters': np.array([0.0, 0.0]),
+            'projection_parameters': [0.0, 0.0],
             'system': direction_reference, 'equinox': 'J2000',
         },
         'active_mask': '', 'beam': None, 'object_name': '',
@@ -114,8 +116,11 @@ def __make_empty_sky_image(
             'value': time_coords[0], 'unit': 'd'
         },
         'observer': 'Karl Jansky',
+        #'pointing_center': {
+        #    'value': np.array(phase_center), 'initial': True
+        #},
         'pointing_center': {
-            'value': np.array(phase_center), 'initial': True
+            'value': list(phase_center), 'initial': True
         },
         'description': '',
         'telescope': {

xradio/image/image.py

@@ -42,7 +42,7 @@ def read_image(infile:str, chunks:dict={}, verbose:bool=False) -> xr.Dataset:
     :param infile: Path to the input CASA image
     :type infile: str, required
     :param chunks: The desired dask chunk size. Only applicable for casacore and fits images.
-                   Supported optional keys are 'l', 'm', 'freq', 'pol',
+                   Supported optional keys are 'l', 'm', 'frequency', 'polarization',
                    and 'time'. The supported values are positive integers,
                    indicating the length of a chunk on that particular axis. If
                    a key is missing, then the associated chunk length along that axis
@@ -85,12 +85,12 @@ def read_image(infile:str, chunks:dict={}, verbose:bool=False) -> xr.Dataset:
     raise RuntimeError('\n'.join(emsgs))
 
 
-def load_image_block(infile:str, block_des:dict={}) -> xr.Dataset:
-    """Load an image block (subimage) into memory
+def load_image(infile:str, block_des:dict={}) -> xr.Dataset:
+    """Load an image or portion of an image (subimage) into memory
     :param infile: Path to the input image, currently only casacore images are supported
     :type infile: str, required
     :param block_des: The description of data to return, supported keys are time,
-        pol, freq, l (or u if apeture image), m (or v if apeture image) a
+        polarization, frequency, l (or u if apeture image), m (or v if apeture image) a
         missing key indicates to return the entire axis length for that
         dimension. Values can be non-negative integers or slices. Slicing
         behaves as numpy slicing does, that is the start pixel is included in
@@ -104,6 +104,8 @@ def load_image_block(infile:str, block_des:dict={}) -> xr.Dataset:
     """
     do_casa = True
     emsgs = []
+    
+    from ._util.casacore import __read_casa_image
     try:
         from ._util.casacore import __read_casa_image
     except Exception as e:

xradio/vis/_processing_set.py

@@ -17,3 +17,6 @@ class _processing_set(dict):
             summary_data["end_frequency"].append(value["frequency"].values[-1])
         summary_df = pd.DataFrame(summary_data)
         return summary_df
+        
+    def get(self,id):
+        return self[list(self.keys())[id]]

xradio/vis/convert_msv2_to_processing_set.py

@@ -633,14 +633,16 @@ def get_unqiue_intents(infile):
         rename_ids=subt_rename_ids["STATE"],
     )
 
-    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()), obs_mode_dict.values()
+    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"], [0]
 
 
 def enumerated_product(*args):
@@ -674,8 +676,13 @@ def convert_msv2_to_processing_set(
         field_ids = np.arange(read_generic_table(infile, "FIELD").dims["row"])
     elif partition_scheme == "ddi_state":
         state_xds = read_generic_table(infile, "STATE")
-        state_ids = np.arange(state_xds.dims["row"])
-        intents = state_xds.obs_mode.values
+
+        if len(state_xds.data_vars) > 0:
+            state_ids = [np.arange(state_xds.dims["row"])]
+            intents = state_xds.obs_mode.values
+        else:  # empty state table
+            state_ids = [0]
+            intents = ["None"]
         # print(state_xds, intents)
         # field_ids = [None]
         field_ids = np.arange(read_generic_table(infile, "FIELD").dims["row"])

{xradio-0.0.6.dist-info → xradio-0.0.8.dist-info}/METADATA

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

{xradio-0.0.6.dist-info → xradio-0.0.8.dist-info}/RECORD

@@ -1,27 +1,28 @@
 xradio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xradio/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xradio/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xradio/data/_dropbox.py,sha256=C749TtLFuqEExph4H8HhNYdPSzWzIpBrnUB7tLkZQ5o,1803
+xradio/data/_dropbox.py,sha256=PUz25GUfgjOzzV0-Aim1lF7LSwT3TocPdy2XHlrk7Jo,2288
 xradio/data/_google_drive.py,sha256=GA3XabwzvA9lBGcHteHYQJhW8pbAXGhMCQBiNeWPphY,4340
 xradio/data/datasets.py,sha256=rBsum83Qe9v_SIRsD0Ym9roz0dyVKKZrysRXezwkDho,457
-xradio/image/__init__.py,sha256=ZhTma3aF9LgC6bEc2Y36QmH7AhfjAAQyVrEfA6JAxsg,303
-xradio/image/image.py,sha256=o4T7aAPZc-P0gNKSUeH8Pluke09_ahYuaDHLnQKvuXA,8096
-xradio/image/_util/casacore.py,sha256=5d6HwEFTObUa8DchRON03hcz8hoo5g8h7FXAjmITUks,5777
-xradio/image/_util/common.py,sha256=QA0NiZWok642pL0mNZ2gSzC79j8nUPEbSV42Oa8fVM0,3947
+xradio/image/__init__.py,sha256=OXBgZQK9f_EgSwW2Uz18GOwsc_OeU1XCHw9IWOybsZk,291
+xradio/image/image.py,sha256=uMA3oEJszImgwThGWJrfBWon6h7n-PoOrMkmGlZPJR8,8190
+xradio/image/_util/casacore.py,sha256=cgb7DVm4HciMQsry0r-gh_peajYUT9V_6GxARgN0Rak,5805
+xradio/image/_util/common.py,sha256=CjCvsxp2NT1rxYs-XeMSAfbGtjL4ZrHdgAR9QIJRZXs,3961
 xradio/image/_util/fits.py,sha256=NkVxRWH2LPpCHeA0sIqMrJSB8SCiYS9zSNtb0ku0HxM,336
-xradio/image/_util/image_factory.py,sha256=0XEgtO8MDCiXhqQvO-WkHExPHNoyQG4uU5JxKpVLqsA,4932
+xradio/image/_util/image_factory.py,sha256=y75Sru2cEXDCA2CnAuDbPIDrxFVjzwZJVjg0--0vrh0,5151
 xradio/image/_util/zarr.py,sha256=HAmQzvukFGltlMdJhbKRkZhfRYxtX1aPpVKiwQaERtw,454
 xradio/image/_util/_casacore/__init__.py,sha256=AzU22a8tVAbxO7EAYfE8M3Xn8217YANKiXYtPkewM20,42
 xradio/image/_util/_casacore/common.py,sha256=FrTjUCdSnDmpfBV6R_gcYo05Uk-Iq36GoLxdmP1tEQg,165
-xradio/image/_util/_casacore/xds_from_casacore.py,sha256=HXFpA9UPjBnY-Q60kzfa-Cqtz8oLXmGSkpzHQaoFM8o,38961
-xradio/image/_util/_casacore/xds_to_casacore.py,sha256=SFq9n86DUSnyA4yFXjeft1vNJYQX2wWkamzpGC1aj2Q,13795
-xradio/image/_util/_fits/xds_from_fits.py,sha256=IOT7tYfYOsnLfsM_IDRJ2YV4UBkRn0-CV_MBMD9OLgM,26537
+xradio/image/_util/_casacore/xds_from_casacore.py,sha256=LzJurgU7X4Eh_fa05Q-LO36mLkh5VcU1ZBPSg2o42Ys,39144
+xradio/image/_util/_casacore/xds_to_casacore.py,sha256=c9RoN_RGVgzxS4ISF13fxOYNr8g6DLxNjh4HZdsI_90,13918
+xradio/image/_util/_fits/xds_from_fits.py,sha256=B1LcJIPEO7IlvXnKpWEHuXlY5O6xgwu5fvPAEd_sq3E,26637
 xradio/image/_util/_zarr/common.py,sha256=rCntE2QrGMseMJ7DsuWnbNk9kuvCgFFJXMyIzzedo0U,349
 xradio/image/_util/_zarr/xds_from_zarr.py,sha256=Es97yMB74SY2D_ecY8c_y6M4Vm7eqmvofWWyWe_btUE,1697
 xradio/image/_util/_zarr/xds_to_zarr.py,sha256=Sh2RbvKHLJx3vOVzDcrurNE215YWbKP1NFGM7zuQFRA,1642
+xradio/image/_util/_zarr/zarr_low_level.py,sha256=KRWx_UO3FwC9CDPTUh7k4ChotVJr6nPIdjkl8raaA9E,5452
 xradio/vis/__init__.py,sha256=u5CAJpknYDspPF_50istwz70FHSNc3eL8J76ndwgYZo,111
-xradio/vis/_processing_set.py,sha256=dpZbhGDvq4EQFBp5-XgUFJ48MYF897_21Xw77UF0SmE,905
-xradio/vis/convert_msv2_to_processing_set.py,sha256=liKLEpLTJLuIXCDKrxaokegnIlmUyu8lkBbR4egiMJg,25250
+xradio/vis/_processing_set.py,sha256=vk2mm66bGWxcIoGEk2gYJRPAhYDudB-7tpYmf-2hZ10,979
+xradio/vis/convert_msv2_to_processing_set.py,sha256=9hfm876CPUZRB1OM-dLBUCiNNx1AlBXk4Kk_LR4K-j8,25526
 xradio/vis/load_processing_set.py,sha256=HXQEjfZThK85sVhwp1JxxUTl1LqedZgAXQFyf9i5Wuw,4505
 xradio/vis/read_processing_set.py,sha256=E4nIWGz3fDkoOaF1uG09OcmstEN11Do3ekGIHONn2ac,688
 xradio/vis/vis_io.py,sha256=5b0htEaaAJ1XFJcR2HSNgQmxmmJNW-znrku7-QuPdSo,6022
@@ -49,8 +50,8 @@ xradio/vis/_vis_utils/_utils/stokes_types.py,sha256=rMX7BQFbGFfT6oP54qTit4q16JRA
 xradio/vis/_vis_utils/_utils/xds_helper.py,sha256=xrS46H7INWTxiuo2zN_a2wOaTr6irbVlkv1efjm7YxY,11853
 xradio/vis/_vis_utils/_zarr/read.py,sha256=fxznKzP0G8YFjkyMxg04PMI3Mtnu1mMjSnvEhY2arIU,7834
 xradio/vis/_vis_utils/_zarr/write.py,sha256=fnu9xh_AZ4OfoOGHsMnCpVEZ_2UiZGP7qXhlqZesCCs,9585
-xradio-0.0.6.dist-info/LICENSE.txt,sha256=dvACd-5O67yjSZlnEKcWmu3DqwzBtbC922iPv0KOeAw,1516
-xradio-0.0.6.dist-info/METADATA,sha256=RmE9rGFyOamgG0DNfZeo2tHyjIR4ufogzwL_8FcjFBQ,4000
-xradio-0.0.6.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-xradio-0.0.6.dist-info/top_level.txt,sha256=dQu27fGBZJ2Yk-gW5XeD-dZ76Xa4Xcvk60Vz-dwXp7k,7
-xradio-0.0.6.dist-info/RECORD,,
+xradio-0.0.8.dist-info/LICENSE.txt,sha256=dvACd-5O67yjSZlnEKcWmu3DqwzBtbC922iPv0KOeAw,1516
+xradio-0.0.8.dist-info/METADATA,sha256=eqF7XXFxnCMosiqCcXr4rOTl21madMMW19H925MLWKU,4000
+xradio-0.0.8.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+xradio-0.0.8.dist-info/top_level.txt,sha256=dQu27fGBZJ2Yk-gW5XeD-dZ76Xa4Xcvk60Vz-dwXp7k,7
+xradio-0.0.8.dist-info/RECORD,,