tabsim 0.0.4__tar.gz → 0.0.5__tar.gz

{tabsim-0.0.4 → tabsim-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tabsim
-Version: 0.0.4
+Version: 0.0.5
 Summary: Trajectory-based Radio Frequency Interference (RFI) simulations for radio interferometeric data.
 Author-email: Chris Finlay <christopher.finlay@epfl.ch>
 Maintainer-email: Chris Finlay <christopher.finlay@epfl.ch>
@@ -680,11 +680,11 @@ License:                     GNU GENERAL PUBLIC LICENSE
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
         
 Project-URL: Repository, https://github.com/chrisfinlay/tab-sim.git
-Requires-Python: <3.13,>=3.9
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jax
-Requires-Dist: dask<=2024.10.0
+Requires-Dist: dask
 Requires-Dist: xarray
 Requires-Dist: zarr<3.0.0
 Requires-Dist: dask-ms>=0.2.21
@@ -694,7 +694,7 @@ Requires-Dist: matplotlib
 Requires-Dist: astropy
 Requires-Dist: spacetrack
 Requires-Dist: skyfield
-Requires-Dist: numpy<2.0.0
+Requires-Dist: numpy
 Provides-Extra: gpu
 Requires-Dist: jax[cuda12]; extra == "gpu"
 Provides-Extra: sat

{tabsim-0.0.4 → tabsim-0.0.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tabsim"
-version = "0.0.4"
+version = "0.0.5"
 license = {file = "LICENSE"}
 readme = "README.md"
 # dynamic = ["version", "readme"]
@@ -17,11 +17,11 @@ maintainers = [
 ]
 description = "Trajectory-based Radio Frequency Interference (RFI) simulations for radio interferometeric data."
 
-requires-python = ">=3.9,<3.13"
+requires-python = ">=3.9"
 dependencies = [
-    "jax", "dask<=2024.10.0", "xarray", "zarr<3.0.0", 
+    "jax", "dask", "xarray", "zarr<3.0.0", 
     "dask-ms>=0.2.21", "scipy", "tqdm", "matplotlib", 
-    "astropy", "spacetrack", "skyfield", "numpy<2.0.0", 
+    "astropy", "spacetrack", "skyfield", "numpy", 
 ]
 
 [project.optional-dependencies]
@@ -51,3 +51,4 @@ tle-region = "tabsim.scripts.tle_sat_region:main"
 ast-region = "tabsim.scripts.ast_region:main"
 flag-data = "tabsim.scripts.flag_data:main"
 sim-vis = "tabsim.scripts.sim_vis:main"
+write-config = "tabsim.scripts.write_config_from_ms:main"

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim/config.py

@@ -18,7 +18,6 @@ from astropy.time import Time
 
 from tabsim.dask.observation import Observation
 from tabsim.sky import generate_random_sky
-from tabsim.plot import plot_uv, plot_src_alt, plot_angular_seps
 from tabsim.write import write_ms, mk_obs_name, mk_obs_dir
 from tabsim.jax.coordinates import calculate_fringe_frequency, jd_to_mjd
 from tabsim.tle import get_visible_satellite_tles, id_generator
@@ -256,9 +255,7 @@ def load_obs(obs_spec: dict) -> Observation:
         start_time_mjd = jd_to_mjd(obs_["start_time_jd"])
     elif obs_["start_time_isot"]:
 
-        start_time_mjd = jd_to_mjd(
-            Time(obs_["start_time_isot"], format="isot", scale="ut1").jd
-        )
+        start_time_mjd = jd_to_mjd(Time(obs_["start_time_isot"], format="isot").jd)
     elif obs_["start_time_lha"] is not None:
         gsa = obs_["start_time_lha"] - tel_["longitude"] + obs_["ra"]
         start_time_mjd = MJD0 + (gsa / 360)
@@ -668,6 +665,8 @@ def add_gains(obs: Observation, obs_spec: dict) -> None:
 
 def plot_diagnostics(obs: Observation, obs_spec: dict, save_path: str) -> None:
 
+    from tabsim.plot import plot_uv, plot_src_alt, plot_angular_seps
+
     diag_ = obs_spec["diagnostics"]
 
     if diag_["src_alt"]:
@@ -808,11 +807,14 @@ def print_fringe_freq_sat(obs: Observation):
         for i in range(obs.n_rfi_satellite)
     ]
     fringe_freq = [calculate_fringe_frequency(**f_params) for f_params in fringe_params]
+    noise_std = obs.noise_std.mean().compute()
+    if noise_std == 0:
+        noise_std = 1.0
     f_sample = (
         np.pi
         * np.max(np.abs(fringe_freq))
         * np.max(obs.rfi_satellite_A_app)
-        / np.sqrt(6 * obs.noise_std.mean()).compute()
+        / np.sqrt(6 * noise_std)
     )
     n_int = int(np.ceil(obs.int_time * f_sample))
 
@@ -843,11 +845,14 @@ def print_fringe_freq_tle_sat(obs: Observation):
         for i in range(obs.n_rfi_tle_satellite)
     ]
     fringe_freq = [calculate_fringe_frequency(**f_params) for f_params in fringe_params]
+    noise_std = obs.noise_std.mean().compute()
+    if noise_std == 0:
+        noise_std = 1.0
     f_sample = (
         np.pi
         * np.max(np.abs(fringe_freq))
         * np.max(obs.rfi_tle_satellite_A_app)
-        / np.sqrt(6 * obs.noise_std.mean()).compute()
+        / np.sqrt(6 * noise_std)
     )
     n_int = int(np.ceil(obs.int_time * f_sample))
 
@@ -933,9 +938,26 @@ def run_sim_config(
     print()
     print(f"Writing data to : {save_path}")
 
-    plot_diagnostics(obs, obs_spec, save_path)
+    plot_cond = np.array(
+        [
+            obs_spec["diagnostics"]["rfi_seps"],
+            obs_spec["diagnostics"]["src_alt"],
+            obs_spec["diagnostics"]["uv_cov"],
+        ]
+    )
+    if np.any(plot_cond):
+        plot_diagnostics(obs, obs_spec, save_path)
+    else:
+        print("\nNo diagnostic plots.")
+
     save_data(obs, obs_spec, zarr_path, ms_path)
 
+    if obs_spec["output"]["accumulate_ms"] is not None:
+        from tabsim.write import add_to_ms
+
+        xds = xr.open_zarr(zarr_path)
+        add_to_ms(xds, obs_spec["output"]["accumulate_ms"])
+
     end = datetime.now()
     print()
     print(f"Total simulation time : {end - start}")
@@ -947,4 +969,11 @@ def run_sim_config(
     os.remove(log_path)
     sys.stdout = backup
 
-    return obs, save_path
+    if (
+        not obs_spec["output"]["keep_sim"]
+        and obs_spec["output"]["accumulate_ms"] is not None
+    ):
+        shutil.rmtree(save_path)
+        return obs, save_path
+    else:
+        return obs, save_path

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim/dask/observation.py

@@ -290,11 +290,17 @@ class Observation(Telescope):
             self.n_int_samples // 2, self.n_time_fine, self.n_int_samples
         ).rechunk(self.time_chunk)
 
+        # self.gsa = da.asarray(
+        #     Time(self.times_mjd_fine.compute(), format="mjd")
+        #     .sidereal_time("mean", "greenwich")
+        #     .hour
+        #     * 15,
+        #     chunks=(self.time_fine_chunk,),
+        # )
+        from tabsim.jax.coordinates import mjd_to_gast
+
         self.gsa = da.asarray(
-            Time(self.times_mjd_fine.compute(), format="mjd")
-            .sidereal_time("mean", "greenwich")
-            .hour
-            * 15,
+            mjd_to_gast(self.times_mjd_fine.compute()),
             chunks=(self.time_fine_chunk,),
         )
         self.gha = (self.gsa - self.ra) % 360
@@ -313,7 +319,9 @@ class Observation(Telescope):
         self.dish_d = da.asarray(dish_d)
         self.fov = beam_size(dish_d, freqs.max(), fwhp=False)
 
-        self.ants_uvw = ITRF_to_UVW(self.ITRF, self.gha, self.dec)
+        self.ants_uvw = da.asarray(
+            np.array(ITRF_to_UVW(self.ITRF, self.gha, self.dec).compute())
+        )
 
         if no_w:
             self.ants_uvw[:, :, -1] = 0.0
@@ -725,6 +733,11 @@ Number of stationary RFI :  {n_stat}"""
             get_satellite_positions(tles, mjd_to_jd(self.times_mjd_fine.compute())),
             chunks=(-1, self.time_fine_chunk, 3),
         )
+        # from tabsim.jax.coordinates import kepler_orbit_many
+        # from tabsim.tle import
+        # rfi_xyz = da.asarray(
+        #     kepler_orbit_many(mjd_to_jd(self.times_mjd_fine.compute()), )
+        # )
         tles = da.asarray(da.atleast_2d(tles), chunks=(-1,))
         # rfi_xyz is shape (n_src,n_time_fine,3)
         # self.ants_xyz is shape (n_time_fine,n_ant,3)
@@ -938,7 +951,7 @@ Number of stationary RFI :  {n_stat}"""
             else:
                 self.flags = (
                     da.abs(self.vis_cal - self.vis_ast)
-                    > 3.0 * da.std(self.vis_model, axis=0)[None, ...]
+                    > 3.0 * da.std(self.vis_ast, axis=0)[None, ...]
                 )
         else:
             self.flags = da.zeros(shape=self.vis_cal.shape, dtype=bool)

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim/data/config/sim_config_base.yaml

@@ -122,6 +122,8 @@ observation:
 output:
   zarr: True                  # Optional - Whether to save the output to a zarr file. This contains almost all inputs ot the simulation
   ms: True                    # Optional - Whether to save the output to a Measurement Set file
+  accumulate_ms: null         # Optional - Whether to add the RFI visibilities to a provided MS file. This should be the MS file path to add to.
+  keep_sim: True              # Optional - Whether to keep the simulation files generated by tabsim after adding to RFI visibilities to accumulate_ms. This includes all data including generated MS files. 
   flag_data: True             # Optional - Whether to apply ideal 3sigma flags
   overwrite: False            # Optional - Whether to overwrite a previous simulation with the same name
   path: ./                    # Optional - Path to where the simulation should be saved

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim/jax/coordinates.py

@@ -386,6 +386,61 @@ def jd_from_gmst(gmst: float) -> float:
     return jd
 
 
+def mjd_to_gmst(mjd: float) -> float:
+    """Taken from OSKAR simulator"""
+
+    sec2rad = 7.2722052166430399038487e-5
+    two_pi = 6.28318530717958647693
+
+    # Days since J2000
+    jd2000 = mjd - 51544.5
+
+    # Centuries from J2000.0
+    t = jd2000 / 36525.0
+
+    # GMST at this time
+    gmst = (mjd % 1.0) * two_pi + (
+        24110.54841 + (8640184.812866 + (0.093104 - 6.2e-6 * t) * t) * t
+    ) * sec2rad
+
+    # Restrict to 2 pi
+    x = (gmst % two_pi) / two_pi * 360
+
+    return x
+
+
+def equation_of_equinoxes(mjd: float) -> float:
+    """Taken from OSKAR simulator"""
+
+    deg2rad = 0.0174532925199432957692
+    hour2rad = 0.261799387799149436539
+    #  Days from J2000.0
+    jd2000 = mjd - 51544.5
+
+    # Longitude of ascending node of the Moon
+    omega = (125.04 - 0.052954 * jd2000) * deg2rad
+
+    # Mean Longitude of the Sun
+    L = (280.47 + 0.98565 * jd2000) * deg2rad
+
+    # eqeq = delta_psi * cos(epsilon)
+    delta_psi = -0.000319 * jnp.sin(omega) - 0.000024 * jnp.sin(2.0 * L)
+    epsilon = (23.4393 - 0.0000004 * jd2000) * deg2rad
+
+    # Return equation of equinoxes in radians
+    eqeq = delta_psi * jnp.cos(epsilon) * hour2rad
+
+    return eqeq
+
+
+def mjd_to_gast(mjd: float) -> float:
+    """Taken from OSKAR simulator"""
+
+    gast = mjd_to_gmst(mjd) + equation_of_equinoxes(mjd)
+
+    return gast
+
+
 def jd_to_mjd(jd):
 
     mjd = jd - 2400000.5

tabsim-0.0.5/tabsim/read_ms.py

@@ -0,0 +1,137 @@
+from daskms import xds_from_table, xds_from_ms
+import numpy as np
+from astropy.time import Time
+from astropy.coordinates import EarthLocation
+
+from typing import Union
+import os
+import yaml
+
+
+def write_antenna_itrf_from_ms(
+    ms_path: str, tel_name: str = "telescope", save_dir: str = "./"
+) -> tuple[str, int, float]:
+
+    xds_ant = xds_from_table(ms_path + "::ANTENNA")[0]
+
+    itrf = xds_ant.POSITION.data.compute()
+    n_ant = len(itrf)
+
+    dish_d = float(xds_ant.DISH_DIAMETER.data[0].compute())
+
+    itrf_path = os.path.abspath(os.path.join(save_dir, f"{tel_name}.itrf.txt"))
+
+    np.savetxt(itrf_path, itrf, fmt="%.6f")
+
+    return itrf_path, n_ant, dish_d
+
+
+def read_tel_location_from_ms(ms_path: str) -> tuple[float, float, float]:
+
+    xds_ant = xds_from_table(ms_path + "::ANTENNA")[0]
+
+    tel_itrf = xds_ant.POSITION.data.mean(axis=0).compute()
+
+    tel_loc = EarthLocation(x=tel_itrf[0], y=tel_itrf[1], z=tel_itrf[2], unit="m")
+
+    lat, lon, elevation = (
+        float(tel_loc.lat.deg),
+        float(tel_loc.lon.deg),
+        float(tel_loc.height.value),
+    )
+
+    return lat, lon, elevation
+
+
+def read_time_data_from_ms(ms_path: str) -> tuple[str, float, int]:
+
+    xds_ms = xds_from_ms(ms_path)[0]
+
+    times = np.unique(xds_ms.TIME.data.compute())
+
+    n_time = len(times)
+    int_time = float(np.diff(np.sort(times)[:2])[0])
+
+    start_time_isot = Time(np.min(times) / (24 * 3600), format="mjd").isot
+
+    return start_time_isot, int_time, n_time
+
+
+def read_freq_data_from_ms(
+    ms_path: str,
+) -> tuple[Union[float, None], Union[float, None], Union[int, None]]:
+
+    try:
+        xds_spec = xds_from_table(ms_path + "::SPECTRAL_WINDOW")[0]
+
+        freqs = xds_spec.CHAN_FREQ.data[0].compute()
+        start_freq = float(freqs[0])
+        n_freq = len(freqs)
+
+        chan_width = float(xds_spec.CHAN_WIDTH.data[0, 0].compute())
+    except:
+        print("Frequency information could not be red from MS file.")
+        start_freq, chan_width, n_freq = None, None, None
+
+    return start_freq, chan_width, n_freq
+
+
+def read_phase_centre_from_ms(
+    ms_path: str,
+) -> tuple[Union[float, None], Union[float, None]]:
+
+    try:
+        xds_src = xds_from_table(ms_path + "::SOURCE")[0]
+
+        ra, dec = [float(x) for x in np.rad2deg(xds_src.DIRECTION.data[0]).compute()]
+    except:
+        print("Phase centre could not be read from MS file.")
+        ra, dec = None, None
+
+    return ra, dec
+
+
+def construct_config_from_ms(
+    ms_path: str, tel_name: str = "telescope", save_dir: str = "./"
+) -> tuple[str, dict]:
+
+    itrf_path, n_ant, dish_d = write_antenna_itrf_from_ms(ms_path, tel_name, save_dir)
+    lat, lon, elevation = read_tel_location_from_ms(ms_path)
+    ra, dec = read_phase_centre_from_ms(ms_path)
+    start_time_isot, int_time, n_time = read_time_data_from_ms(ms_path)
+    start_freq, chan_width, n_freq = read_freq_data_from_ms(ms_path)
+
+    config = {
+        "telescope": {
+            "name": tel_name,
+            "latitude": lat,
+            "longitude": lon,
+            "elevation": elevation,
+            "itrf_path": itrf_path,
+            "n_ant": n_ant,
+            # "dish_d": dish_d,
+        },
+        "observation": {
+            "start_time_isot": start_time_isot,
+            "int_time": int_time,
+            "n_time": n_time,
+            "start_freq": start_freq,
+            "chan_width": chan_width,
+            "n_freq": n_freq,
+        },
+    }
+
+    if ra is not None:
+        config["observation"].update(
+            {
+                "target_name": f"pointing_{ra:.3f}_{dec:.3f}",
+                "ra": ra,
+                "dec": dec,
+            }
+        )
+
+    config_path = os.path.abspath(os.path.join(save_dir, f"{tel_name}_sim_config.yaml"))
+
+    yaml.dump(config, open(config_path, "w"))
+
+    return config_path, config

tabsim-0.0.5/tabsim/scripts/write_config_from_ms.py

@@ -0,0 +1,40 @@
+from tabsim.read_ms import construct_config_from_ms
+
+
+def main():
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Extract simulation configuration parameters from an MS file and write to disk."
+    )
+    parser.add_argument(
+        "-ms",
+        "--ms_path",
+        required=True,
+        help="File path to the MS file.",
+    )
+    parser.add_argument(
+        "-t",
+        "--tel_name",
+        default="telescope",
+        help="Telescope name.",
+    )
+    parser.add_argument(
+        "-s",
+        "--save_dir",
+        default="./",
+        help="Path to directory where config and antenna coordinates should be saved.",
+    )
+    args = parser.parse_args()
+
+    config_path, config = construct_config_from_ms(
+        args.ms_path, args.tel_name, args.save_dir
+    )
+
+    print(f"Simulation configuration file save to : {config_path}")
+
+
+if __name__ == "__main__":
+
+    main()

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim/write.py

@@ -383,7 +383,37 @@ def get_stationary_rfi_data(obs: Observation):
     return rfi_stat
 
 
-def add_to_ms(ds: Dataset, ms_path: str, flags: Optional[Array] = None):
+def construct_rfi_mscol(vis_rfi: Array, data: Array):
+
+    n_corr = data.shape[-1]
+
+    if n_corr == 1:
+        vis_rfi_ms = xr.DataArray(
+            vis_rfi[:, :, None],
+            dims=("row", "chan", "corr"),
+        )
+    elif n_corr == 2:
+        vis_rfi_ms = xr.DataArray(
+            da.stack([vis_rfi, vis_rfi], axis=2),
+            dims=("row", "chan", "corr"),
+        )
+    elif n_corr == 4:
+        vis_rfi_ms = xr.DataArray(
+            da.stack(
+                [vis_rfi, da.zeros_like(vis_rfi), da.zeros_like(vis_rfi), vis_rfi],
+                axis=2,
+            ),
+            dims=("row", "chan", "corr"),
+        )
+    else:
+        raise ValueError("Correlation axis in target MS file is non-standard")
+
+    return vis_rfi_ms
+
+
+def add_to_ms(
+    ds: xr.Dataset, ms_path: str, flags: Optional[Array] = None, data_col: str = "DATA"
+):
 
     n_time = ds.attrs["n_time"]
     n_freq = ds.attrs["n_freq"]
@@ -396,24 +426,27 @@ def add_to_ms(ds: Dataset, ms_path: str, flags: Optional[Array] = None):
     dims = ["row", "chan", "corr"]
     chunks = {k: v for k, v in xds_ms.chunks.items() if k in dims}
 
-    vis_rfi = ds.vis_rfi.data.reshape(n_row, n_freq, n_corr)
-    vis_rfi = xr.DataArray(
-        da.stack(
-            [vis_rfi, da.zeros_like(vis_rfi), da.zeros_like(vis_rfi), vis_rfi], axis=2
-        ),
-        dims=("row", "chan", "corr"),
+    # vis_rfi_ms = construct_rfi_mscol(
+    #     ds.vis_rfi.data.reshape(n_row, n_freq), xds_ms[data_col]
+    # )
+    vis_rfi_ms = construct_rfi_mscol(
+        np.conjugate(ds.vis_rfi.data.reshape(n_row, n_freq)), xds_ms[data_col]
+    )  # Needed for OSKAR simulations compatibility
+
+    xds_ms = xds_ms.assign({data_col: xds_ms[data_col] + vis_rfi_ms.chunk(chunks)})
+    cols = data_col
+
+    # if flags:
+    #     flags = xr.DataArray(
+    #         ds.flags.data.reshape(n_row, n_freq, n_corr), dims=("row", "chan", "corr")
+    #     )
+    #     xds_ms = xds_ms.assign(FLAG=flags)
+    #     cols.append("FLAG")
+
+    print(
+        f"Writing tabsim generated RFI visibilities to {data_col} column in {ms_path}"
     )
 
-    xds_ms = xds_ms.assign(DATA=xds_ms.DATA + vis_rfi)
-    cols = "DATA"
-
-    if flags:
-        flags = xr.DataArray(
-            ds.flags.data.reshape(n_row, n_freq, n_corr), dims=("row", "chan", "corr")
-        )
-        xds_ms = xds_ms.assign(FLAG=flags)
-        cols.append("FLAG")
-
     dask.compute(xds_to_table([xds_ms], ms_path, cols))
 
 
@@ -479,6 +512,7 @@ def construct_ms_data_table(
 
     row_times = da.asarray(
         (ds.coords["time_mjd"].data[:, None] * da.ones(shape=(1, n_bl))).flatten()
+        * (24 * 3600)
     )
     ant1 = (
         (ds.antenna1.data[None, :] * da.ones(shape=(n_time, 1)))
@@ -515,10 +549,10 @@ def construct_ms_data_table(
         "ARRAY_ID": (("row"), a_id),
         "FLAG": (("row", "chan", "corr"), flags),
         "INTERVAL": (("row"), interval),
-        "FLAG_CATEGORY": (
-            ("row", "chan", "corr", "flagcat"),
-            da.expand_dims(flags, axis=3),
-        ),
+        # "FLAG_CATEGORY": (
+        #     ("row", "chan", "corr", "flagcat"),
+        #     da.expand_dims(flags, axis=3),
+        # ),
     }
 
     if extras:
@@ -677,7 +711,7 @@ def construct_ms_spectral_window_table(ds: Dataset, ms_path: str):
         "CHAN_FREQ": (("row", "chan"), chan_freq),
         "CHAN_WIDTH": (("row", "chan"), chan_width),
         "EFFECTIVE_BW": (("row", "chan"), chan_width),
-        "EFFECTIVE_BW": (("row", "chan"), n_freq * chan_width),
+        # "EFFECTIVE_BW": (("row", "chan"), n_freq * chan_width),
         "FLAG_ROW": (("row"), zero),
         "FREQ_GROUP": (("row"), zero),
         # 'FREQ_GROUP_NAME': (('row'), zero),
@@ -685,7 +719,7 @@ def construct_ms_spectral_window_table(ds: Dataset, ms_path: str):
         "MEAS_FREQ_REF": (("row"), 5 * one),
         # 'NAME': (('row'), zero),
         "NET_SIDEBAND": (("row"), one),
-        "NUM_CHAN": (("row"), one),
+        "NUM_CHAN": (("row"), n_freq * one),
         "REF_FREQUENCY": (("row"), ref_freq),
         "RESOLUTION": (("row", "chan"), chan_width),
         "TOTAL_BANDWIDTH": (("row"), total_bw),

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tabsim
-Version: 0.0.4
+Version: 0.0.5
 Summary: Trajectory-based Radio Frequency Interference (RFI) simulations for radio interferometeric data.
 Author-email: Chris Finlay <christopher.finlay@epfl.ch>
 Maintainer-email: Chris Finlay <christopher.finlay@epfl.ch>
@@ -680,11 +680,11 @@ License:                     GNU GENERAL PUBLIC LICENSE
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
         
 Project-URL: Repository, https://github.com/chrisfinlay/tab-sim.git
-Requires-Python: <3.13,>=3.9
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jax
-Requires-Dist: dask<=2024.10.0
+Requires-Dist: dask
 Requires-Dist: xarray
 Requires-Dist: zarr<3.0.0
 Requires-Dist: dask-ms>=0.2.21
@@ -694,7 +694,7 @@ Requires-Dist: matplotlib
 Requires-Dist: astropy
 Requires-Dist: spacetrack
 Requires-Dist: skyfield
-Requires-Dist: numpy<2.0.0
+Requires-Dist: numpy
 Provides-Extra: gpu
 Requires-Dist: jax[cuda12]; extra == "gpu"
 Provides-Extra: sat

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ docs/conf.py
 tabsim/__init__.py
 tabsim/config.py
 tabsim/plot.py
+tabsim/read_ms.py
 tabsim/sky.py
 tabsim/tle.py
 tabsim/tools.py
@@ -44,6 +45,7 @@ tabsim/scripts/ast_region.py
 tabsim/scripts/flag_data.py
 tabsim/scripts/sim_vis.py
 tabsim/scripts/tle_sat_region.py
+tabsim/scripts/write_config_from_ms.py
 tests/test_basic.py
 tests/test_sim-vis.py
 tests/test_version.py

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim.egg-info/entry_points.txt

@@ -3,3 +3,4 @@ ast-region = tabsim.scripts.ast_region:main
 flag-data = tabsim.scripts.flag_data:main
 sim-vis = tabsim.scripts.sim_vis:main
 tle-region = tabsim.scripts.tle_sat_region:main
+write-config = tabsim.scripts.write_config_from_ms:main

{tabsim-0.0.4 → tabsim-0.0.5}/tabsim.egg-info/requires.txt

@@ -1,5 +1,5 @@
 jax
-dask<=2024.10.0
+dask
 xarray
 zarr<3.0.0
 dask-ms>=0.2.21
@@ -9,7 +9,7 @@ matplotlib
 astropy
 spacetrack
 skyfield
-numpy<2.0.0
+numpy
 
 [docs]
 sphinx