jolly-roger 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

jolly_roger/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)

jolly_roger/delays.py

@@ -0,0 +1,107 @@
+"""Utilities and structures around the delay calculations"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import astropy.units as u
+import numpy as np
+from numpy.typing import NDArray
+
+from jolly_roger.logging import logger
+
+if TYPE_CHECKING:
+    # avoid circular imports
+    from jolly_roger.tractor import BaselineData, DataChunk
+
+
+@dataclass
+class DelayTime:
+    """Container for delay time and associated metadata."""
+
+    delay_time: NDArray[np.complexfloating]
+    """ The delay vs time data. shape=(time, delay, pol)"""
+    delay: u.Quantity
+    """The delay values corresponding to the delay time data."""
+
+
+def data_to_delay_time(data: BaselineData | DataChunk) -> DelayTime:
+    logger.debug("Converting freq-time to delay-time")
+    delay_time = np.fft.fftshift(
+        np.fft.fft(data.masked_data.filled(0 + 0j), axis=1), axes=1
+    )
+    delay = np.fft.fftshift(
+        np.fft.fftfreq(
+            n=len(data.freq_chan),
+            d=np.diff(data.freq_chan).mean(),
+        ).decompose()
+    )
+    return DelayTime(
+        delay_time=delay_time,
+        delay=delay,
+    )
+
+
+def delay_time_to_data(
+    delay_time: DelayTime,
+    original_data: DataChunk,
+) -> DataChunk:
+    """Convert delay time data back to the original data format."""
+    logger.debug("Converting delay-time to freq-time")
+    new_data = np.fft.ifft(
+        np.fft.ifftshift(delay_time.delay_time, axes=1),
+        axis=1,
+    )
+    new_data_masked = np.ma.masked_array(
+        new_data,
+        mask=original_data.masked_data.mask,
+    )
+    new_data = original_data
+    new_data.masked_data = new_data_masked
+    return new_data
+
+
+@dataclass
+class DelayRate:
+    """Container for delay rate and associated metadata."""
+
+    delay_rate: np.ndarray
+    """The delay rate vs time data. shape=(rate, delay, pol)"""
+    delay: u.Quantity
+    """The delay values corresponding to the delay rate data."""
+    rate: u.Quantity
+    """The delay rate values corresponding to the delay rate data."""
+
+
+def data_to_delay_rate(
+    baseline_data: BaselineData,
+) -> DelayRate:
+    """Convert baseline data to delay rate."""
+    # This only makes sense when running on time data. Hence
+    # asserting the type of BaelineData
+
+    assert isinstance(baseline_data, BaselineData), (
+        f"baseline_data is type={type(baseline_data)}, but needs to be BaselineData"
+    )
+
+    logger.info("Converting freq-time to delay-rate")
+    delay_rate = np.fft.fftshift(np.fft.fft2(baseline_data.masked_data.filled(0 + 0j)))
+    delay = np.fft.fftshift(
+        np.fft.fftfreq(
+            n=len(baseline_data.freq_chan),
+            d=np.diff(baseline_data.freq_chan).mean(),
+        ).decompose()
+    )
+    rate = np.fft.fftshift(
+        np.fft.fftfreq(
+            n=len(baseline_data.time),
+            d=np.diff(baseline_data.time.mjd * u.day).mean(),
+        ).decompose()
+    )
+
+    return DelayRate(
+        delay_rate=delay_rate,
+        delay=delay,
+        rate=rate,
+    )

jolly_roger/hour_angles.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Literal
 
 import astropy.units as u
 import numpy as np
@@ -26,13 +25,13 @@ class PositionHourAngles:
 
     hour_angle: u.rad
     """The hour angle across sampled time intervales of a source for a Earth location"""
-    time_mjds: np.ndarray
+    time_mjds: u.Quantity
     """The MJD time in seconds from which other quantities are evalauted against. Should be drawn from a measurement set."""
     location: EarthLocation
     """The location these quantities have been derived from."""
     position: SkyCoord
     """The sky-position that is being used to calculate quantities towards"""
-    elevation: np.ndarray
+    elevation: u.Quantity
     """The elevation of the ``position` direction across time"""
     time: Time
     """Representation of the `time_mjds` attribute"""
@@ -43,7 +42,7 @@ class PositionHourAngles:
 
 
 def _process_position(
-    position: SkyCoord | Literal["sun"] | None = None,
+    position: SkyCoord | str | None = None,
     ms_path: Path | None = None,
     times: Time | None = None,
 ) -> SkyCoord:
@@ -54,7 +53,7 @@ def _process_position(
     set
 
     Args:
-        position (SkyCoord | Literal["sun"] | None, optional): The position to be considered. Defaults to None.
+        position (SkyCoord | str | None, optional): The position to be considered. Defaults to None.
         ms_path (Path | None, optional): The path with the PHASE_DIR to use should `position` be None. Defaults to None.
         times (Time | None, optional): Times to used if they are required in the lookup. Defaults to None.
 
@@ -71,8 +70,8 @@ def _process_position(
         if times is None:
             msg = f"{times=}, but needs to be set when position is a name"
             raise ValueError(msg)
-        if position == "sun":
-            logger.info("Getting sky-position of the sun")
+        if position.lower() == "sun":
+            logger.info("Getting sky-position of the Sun")
             position = get_sun(times)
         else:
             logger.info(f"Getting sky-position of {position=}")
@@ -142,7 +141,7 @@ def make_hour_angles_for_ms(
     lst = times.sidereal_time("apparent", longitude=location.lon)
     hour_angle = (lst - sky_position.ra).wrap_at(12 * u.hourangle)
 
-    logger.info("Creatring elevation curve")
+    logger.info("Creating elevation curve")
     altaz = sky_position.transform_to(AltAz(obstime=times, location=location))
 
     return PositionHourAngles(

jolly_roger/plots.py

@@ -0,0 +1,171 @@
+"""Routines around plotting"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from jolly_roger.uvws import WDelays
+
+if TYPE_CHECKING:
+    from jolly_roger.delays import DelayTime
+    from jolly_roger.tractor import BaselineData
+
+
+def plot_baseline_data(
+    baseline_data: BaselineData,
+    output_dir: Path,
+    suffix: str = "",
+) -> None:
+    from astropy.visualization import quantity_support, time_support
+
+    with quantity_support(), time_support():
+        data_masked = baseline_data.masked_data
+        data_xx = data_masked[..., 0]
+        data_yy = data_masked[..., -1]
+        data_stokesi = (data_xx + data_yy) / 2
+        amp_stokesi = np.abs(data_stokesi)
+
+        fig, ax = plt.subplots()
+        im = ax.pcolormesh(
+            baseline_data.time,
+            baseline_data.freq_chan,
+            amp_stokesi.T,
+        )
+        fig.colorbar(im, ax=ax, label="Stokes I Amplitude / Jy")
+        ax.set(
+            ylabel=f"Frequency / {baseline_data.freq_chan.unit:latex_inline}",
+            title=f"Ant {baseline_data.ant_1} - Ant {baseline_data.ant_2}",
+        )
+        output_path = (
+            output_dir
+            / f"baseline_data_{baseline_data.ant_1}_{baseline_data.ant_2}{suffix}.png"
+        )
+        fig.savefig(output_path)
+
+
+def plot_baseline_comparison_data(
+    before_baseline_data: BaselineData,
+    after_baseline_data: BaselineData,
+    before_delays: DelayTime,
+    after_delays: DelayTime,
+    output_dir: Path,
+    suffix: str = "",
+    w_delays: WDelays | None = None,
+) -> Path:
+    from astropy.visualization import (
+        ImageNormalize,
+        LogStretch,
+        MinMaxInterval,
+        SqrtStretch,
+        ZScaleInterval,
+        quantity_support,
+        time_support,
+    )
+
+    with quantity_support(), time_support():
+        before_amp_stokesi = np.abs(
+            (
+                before_baseline_data.masked_data[..., 0]
+                + before_baseline_data.masked_data[..., -1]
+            )
+            / 2
+        )
+        after_amp_stokesi = np.abs(
+            (
+                after_baseline_data.masked_data[..., 0]
+                + after_baseline_data.masked_data[..., -1]
+            )
+            / 2
+        )
+
+        norm = ImageNormalize(
+            after_amp_stokesi, interval=ZScaleInterval(), stretch=SqrtStretch()
+        )
+
+        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(
+            2, 2, figsize=(10, 10), sharex=True, sharey="row"
+        )
+        im = ax1.pcolormesh(
+            before_baseline_data.time,
+            before_baseline_data.freq_chan,
+            before_amp_stokesi.T,
+            norm=norm,
+        )
+        ax1.set(
+            ylabel=f"Frequency / {before_baseline_data.freq_chan.unit:latex_inline}",
+            title="Before",
+        )
+        ax2.pcolormesh(
+            after_baseline_data.time,
+            after_baseline_data.freq_chan,
+            after_amp_stokesi.T,
+            norm=norm,
+        )
+        ax2.set(
+            ylabel=f"Frequency / {after_baseline_data.freq_chan.unit:latex_inline}",
+            title="After",
+        )
+        fig.colorbar(im, ax=ax2, label="Stokes I Amplitude / Jy")
+
+        # TODO: Move these delay calculations outside of the plotting function
+        # And here we calculate the delay information
+
+        before_delays_i = np.abs(
+            (before_delays.delay_time[:, :, 0] + before_delays.delay_time[:, :, -1]) / 2
+        )
+        after_delays_i = np.abs(
+            (after_delays.delay_time[:, :, 0] + after_delays.delay_time[:, :, -1]) / 2
+        )
+
+        delay_norm = ImageNormalize(
+            before_delays_i, interval=MinMaxInterval(), stretch=LogStretch()
+        )
+
+        im = ax3.pcolormesh(
+            before_baseline_data.time,
+            before_delays.delay,
+            before_delays_i.T,
+            norm=delay_norm,
+        )
+        ax3.set(ylabel="Delay / s", title="Before")
+        ax4.pcolormesh(
+            after_baseline_data.time,
+            after_delays.delay,
+            after_delays_i.T,
+            norm=delay_norm,
+        )
+        ax4.set(ylabel="Delay / s", title="After")
+        fig.colorbar(im, ax=ax4, label="Stokes I Amplitude / Jy")
+
+        if w_delays is not None:
+            for ax, baseline_data in zip(  # type:ignore[call-overload]
+                (ax3, ax4),
+                (before_baseline_data, after_baseline_data),
+                strict=True,
+            ):
+                ant_1, ant_2 = baseline_data.ant_1, baseline_data.ant_2
+                b_idx = w_delays.b_map[ant_1, ant_2]
+                ax.plot(
+                    baseline_data.time,
+                    w_delays.w_delays[b_idx],
+                    color="k",
+                    linestyle="--",
+                    label=f"Delay for {w_delays.object_name}",
+                )
+                ax.legend()
+
+        output_path = (
+            output_dir
+            / f"baseline_data_{before_baseline_data.ant_1}_{before_baseline_data.ant_2}{suffix}.png"
+        )
+        fig.suptitle(
+            f"Ant {after_baseline_data.ant_1} - Ant {after_baseline_data.ant_2}"
+        )
+        fig.tight_layout()
+        fig.savefig(output_path)
+
+        return output_path

jolly_roger/tractor.py

@@ -0,0 +1,808 @@
+from __future__ import annotations
+
+from argparse import ArgumentParser
+from collections.abc import Generator
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import astropy.units as u
+import numpy as np
+from astropy.coordinates import (
+    SkyCoord,
+)
+from astropy.time import Time
+from casacore.tables import makecoldesc, table, taql
+from numpy.typing import NDArray
+from tqdm.auto import tqdm
+
+from jolly_roger.delays import data_to_delay_time, delay_time_to_data
+from jolly_roger.logging import logger
+from jolly_roger.plots import plot_baseline_comparison_data
+from jolly_roger.uvws import WDelays, get_object_delay_for_ms
+
+
+@dataclass(frozen=True)
+class OpenMSTables:
+    """Open MS table references"""
+
+    main_table: table
+    """The main MS table"""
+    spw_table: table
+    """The spectral window table"""
+    field_table: table
+    """The field table"""
+    ms_path: Path
+    """The path to the MS used to open tables"""
+
+
+def get_open_ms_tables(ms_path: Path, read_only: bool = True) -> OpenMSTables:
+    """Open up the set of MS table and sub-tables necessary for tractoring.
+
+    Args:
+        ms_path (Path): The path to the measurement set
+        read_only (bool, optional): Whether to open in a read-only mode. Defaults to True.
+
+    Returns:
+        OpenMSTables: Set of open table references
+    """
+    main_table = table(str(ms_path), ack=False, readonly=read_only)
+    spw_table = table(str(ms_path / "SPECTRAL_WINDOW"), ack=False, readonly=read_only)
+    field_table = table(str(ms_path / "FIELD"), ack=False, readonly=read_only)
+
+    # TODO: Get the data without auto-correlations e.g.
+    # no_auto_main_table = taql(
+    #     "select from $main_table where ANTENNA1 != ANTENNA2",
+    # )
+
+    return OpenMSTables(
+        main_table=main_table,
+        spw_table=spw_table,
+        field_table=field_table,
+        ms_path=ms_path,
+    )
+
+
+def tukey_taper(
+    x: np.typing.NDArray[np.floating],
+    outer_width: float = np.pi / 4,
+    tukey_width: float = np.pi / 8,
+    tukey_x_offset: NDArray[np.floating] | None = None,
+) -> np.ndarray:
+    x_freq = np.linspace(-np.pi, np.pi, len(x))
+
+    if tukey_x_offset is not None:
+        x_freq = x_freq[:, None] - tukey_x_offset[None, :]
+
+    taper = np.ones_like(x_freq)
+    logger.debug(f"{x_freq.shape=} {type(x_freq)=}")
+    # Fully zero region
+    taper[np.abs(x_freq) > outer_width] = 0
+
+    # Transition regions
+    left_idx = (-outer_width < x_freq) & (x_freq < -outer_width + tukey_width)
+    right_idx = (outer_width - tukey_width < x_freq) & (x_freq < outer_width)
+
+    taper[left_idx] = (
+        1 - np.cos(np.pi * (x_freq[left_idx] + outer_width) / tukey_width)
+    ) / 2
+
+    taper[right_idx] = (
+        1 - np.cos(np.pi * (outer_width - x_freq[right_idx]) / tukey_width)
+    ) / 2
+
+    return taper
+
+
+@dataclass
+class BaselineData:
+    """Container for baseline data and associated metadata."""
+
+    masked_data: np.ma.MaskedArray
+    """The baseline data, masked where flags are set. shape=(time, chan, pol)"""
+    freq_chan: u.Quantity
+    """The frequency channels corresponding to the data."""
+    phase_center: SkyCoord
+    """The target sky coordinate for the baseline."""
+    uvws_phase_center: u.Quantity
+    """The UVW coordinates of the phase center of the baseline."""
+    time: Time
+    """The time of the observations."""
+    ant_1: int
+    """The first antenna in the baseline."""
+    ant_2: int
+    """The second antenna in the baseline."""
+
+
+@dataclass
+class BaselineArrays:
+    data: NDArray[np.complexfloating]
+    flags: NDArray[np.bool_]
+    uvws: NDArray[np.floating]
+    time_centroid: NDArray[np.floating]
+
+
+@dataclass
+class DataChunkArray:
+    """Container for a chunk of data"""
+
+    data: NDArray[np.complexfloating]
+    """The data from the nominated data column loaded"""
+    flags: NDArray[np.bool_]
+    """Flags that correspond to the loaded data"""
+    uvws: NDArray[np.floating]
+    """The uvw coordinates for each loaded data record"""
+    time_centroid: NDArray[np.floating]
+    """The time of each data record"""
+    ant_1: NDArray[np.int64]
+    """Antenna 1 that formed the baseline"""
+    ant_2: NDArray[np.int64]
+    """Antenna 2 that formed the baseline"""
+    row_start: int
+    """The starting row of the portion of data loaded"""
+    chunk_size: int
+    """The size of the data chunk loaded (may be larger if this is the last record)"""
+
+
+@dataclass
+class DataChunk:
+    """Container for a collection of data and associated metadata.
+    Here data are drawn from a series of rows.
+    """
+
+    masked_data: np.ma.MaskedArray
+    """The baseline data, masked where flags are set. shape=(time, chan, pol)"""
+    freq_chan: u.Quantity
+    """The frequency channels corresponding to the data."""
+    phase_center: SkyCoord
+    """The target sky coordinate for the baseline."""
+    uvws_phase_center: u.Quantity
+    """The UVW coordinates of the phase center of the baseline."""
+    time: Time
+    """The time of the observations."""
+    time_mjds: NDArray[np.floating]
+    """The raw time extracted from the measurement set in MJDs"""
+    ant_1: NDArray[np.int64]
+    """The first antenna in the baseline."""
+    ant_2: NDArray[np.int64]
+    """The second antenna in the baseline."""
+    row_start: int
+    """Starting row index of the data"""
+    chunk_size: int
+    """Size of the chunked portion of the data"""
+
+
+def _list_to_array(
+    list_of_rows: list[dict[str, Any]], key: str
+) -> np.typing.NDArray[Any]:
+    """Helper to make a simple numpy object from list of items"""
+    return np.array([row[key] for row in list_of_rows])
+
+
+def _get_data_chunk_from_main_table(
+    ms_table: table,
+    chunk_size: int,
+    data_column: str,
+) -> Generator[DataChunkArray, None, None]:
+    """Return an appropriately size data chunk from the main
+    table of a measurement set. These data are ase they are
+    in the measurement set without any additional scaling
+    or unit adjustments.
+
+    Args:
+        ms_table (table): The opened main table of a measurement set
+        chunk_size (int): The size of the data to chunk and return
+        data_column (str): The data column to be returned
+
+    Yields:
+        Generator[DataChunkArray, None, None]: A segment of rows and columns
+    """
+
+    table_length = len(ms_table)
+    logger.debug(f"Length of open table: {table_length} rows")
+
+    lower_row = 0
+    upper_row = chunk_size
+
+    while lower_row < table_length:
+        rows: list[dict[str, Any]] = ms_table[lower_row:upper_row]
+
+        data = _list_to_array(list_of_rows=rows, key=data_column)
+        flags = _list_to_array(list_of_rows=rows, key="FLAG")
+        uvws = _list_to_array(list_of_rows=rows, key="UVW")
+        time_centroid = _list_to_array(list_of_rows=rows, key="TIME_CENTROID")
+        ant_1 = _list_to_array(list_of_rows=rows, key="ANTENNA1")
+        ant_2 = _list_to_array(list_of_rows=rows, key="ANTENNA2")
+
+        yield DataChunkArray(
+            data=data,
+            flags=flags,
+            uvws=uvws,
+            time_centroid=time_centroid,
+            ant_1=ant_1,
+            ant_2=ant_2,
+            row_start=lower_row,
+            chunk_size=chunk_size,
+        )
+
+        lower_row += chunk_size
+        upper_row += chunk_size
+
+
+def get_data_chunks(
+    open_ms_tables: OpenMSTables,
+    chunk_size: int,
+    data_column: str,
+) -> Generator[DataChunk, None, None]:
+    """Yield a collection of rows with appropriate units
+    attached to the quantities. These quantities are not
+    the same data encoded in the measurement set, e.g.
+    masked array has been formed, astropy units have
+    been attached.
+
+    Args:
+        open_ms_tables (OpenMSTables): References to open tables from the measurement set
+        chunk_size (int): The number of rows to return at a time
+        data_column (str): The data column that would be modified
+
+    Yields:
+        Generator[DataChunk, None, None]: Representation of the current chunk of rows
+    """
+    freq_chan = open_ms_tables.spw_table.getcol("CHAN_FREQ")
+    phase_dir = open_ms_tables.field_table.getcol("PHASE_DIR")
+
+    freq_chan = freq_chan.squeeze() * u.Hz
+    target = SkyCoord(*(phase_dir * u.rad).squeeze())
+
+    for data_chunk_array in _get_data_chunk_from_main_table(
+        ms_table=open_ms_tables.main_table,
+        chunk_size=chunk_size,
+        data_column=data_column,
+    ):
+        # Transform the native arrays but attach astropy quantities
+        uvws_phase_center = data_chunk_array.uvws * u.m
+        time = Time(
+            data_chunk_array.time_centroid.squeeze() * u.s,
+            format="mjd",
+            scale="utc",
+        )
+        masked_data = np.ma.masked_array(
+            data_chunk_array.data, mask=data_chunk_array.flags
+        )
+
+        yield DataChunk(
+            masked_data=masked_data,
+            freq_chan=freq_chan,
+            phase_center=target,
+            uvws_phase_center=uvws_phase_center,
+            time=time,
+            time_mjds=data_chunk_array.time_centroid,
+            ant_1=data_chunk_array.ant_1,
+            ant_2=data_chunk_array.ant_2,
+            row_start=data_chunk_array.row_start,
+            chunk_size=data_chunk_array.chunk_size,
+        )
+
+
+def _get_baseline_data(
+    ms_tab: table,
+    ant_1: int,
+    ant_2: int,
+    data_column: str = "DATA",
+) -> BaselineArrays:
+    _ = ms_tab, ant_1, ant_2
+    with taql(
+        "select from $ms_tab where ANTENNA1 == $ant_1 and ANTENNA2 == $ant_2",
+    ) as subtab:
+        logger.info(f"Opening subtable for baseline {ant_1} {ant_2}")
+        data = subtab.getcol(data_column)
+        flags = subtab.getcol("FLAG")
+        uvws = subtab.getcol("UVW")
+        time_centroid = subtab.getcol("TIME_CENTROID")
+
+    return BaselineArrays(
+        data=data,
+        flags=flags,
+        uvws=uvws,
+        time_centroid=time_centroid,
+    )
+
+
+def get_baseline_data(
+    open_ms_tables: OpenMSTables,
+    ant_1: int,
+    ant_2: int,
+    data_column: str = "DATA",
+) -> BaselineData:
+    """Get data of a baseline from a measurement set
+
+    Args:
+        open_ms_tables (OpenMSTables): The measurement set to draw data from
+        ant_1 (int): The first antenna of the baseline
+        ant_2 (int): The second antenna of the baseline
+        data_column (str, optional): The data column to extract. Defaults to "DATA".
+
+    Returns:
+        BaselineData:  Extracted baseline data
+    """
+    logger.info(f"Getting baseline {ant_1} {ant_2}")
+
+    freq_chan = open_ms_tables.spw_table.getcol("CHAN_FREQ")
+    phase_dir = open_ms_tables.field_table.getcol("PHASE_DIR")
+
+    logger.debug(f"Processing {ant_1=} {ant_2=}")
+
+    baseline_data = _get_baseline_data(
+        ms_tab=open_ms_tables.main_table,
+        ant_1=ant_1,
+        ant_2=ant_2,
+        data_column=data_column,
+    )
+
+    freq_chan = freq_chan.squeeze() * u.Hz
+    target = SkyCoord(*(phase_dir * u.rad).squeeze())
+    uvws_phase_center = np.swapaxes(baseline_data.uvws * u.m, 0, 1)
+    time = Time(
+        baseline_data.time_centroid.squeeze() * u.s,
+        format="mjd",
+        scale="utc",
+    )
+    masked_data = np.ma.masked_array(baseline_data.data, mask=baseline_data.flags)
+
+    logger.info(f"Got data for baseline {ant_1} {ant_2} with shape {masked_data.shape}")
+    return BaselineData(
+        masked_data=masked_data,
+        freq_chan=freq_chan,
+        phase_center=target,
+        uvws_phase_center=uvws_phase_center,
+        time=time,
+        ant_1=ant_1,
+        ant_2=ant_2,
+    )
+
+
+def add_output_column(
+    tab: table,
+    data_column: str = "DATA",
+    output_column: str = "CORRECTED_DATA",
+    overwrite: bool = False,
+    copy_column_data: bool = False,
+) -> None:
+    """Add in the output data column where the modified data
+    will be recorded
+
+    Args:
+        tab (table): Open reference to the table to modify
+        data_column (str, optional): The base data column the new will be based from. Defaults to "DATA".
+        output_column (str, optional): The new data column to be created. Defaults to "CORRECTED_DATA".
+        overwrite (bool, optional): Whether to overwrite the new output column. Defaults to False.
+        copy_column_data (bool, optional): Copy the original data over to the output column. Defaults to False.
+
+    Raises:
+        ValueError: Raised if the output column already exists and overwrite is False
+    """
+    colnames = tab.colnames()
+    if output_column in colnames:
+        if not overwrite:
+            msg = f"Output column {output_column} already exists in the measurement set. Not overwriting."
+            raise ValueError(msg)
+
+        logger.warning(
+            f"Output column {output_column} already exists in the measurement set. Will be overwritten!"
+        )
+    else:
+        logger.info(f"Adding {output_column=}")
+        desc = makecoldesc(data_column, tab.getcoldesc(data_column))
+        desc["name"] = output_column
+        tab.addcols(desc)
+        tab.flush()
+
+    if copy_column_data:
+        logger.info(f"Copying {data_column=} to {output_column=}")
+        taql(f"UPDATE $tab SET {output_column}={data_column}")
+
+
+def write_output_column(
+    ms_path: Path,
+    output_column: str,
+    baseline_data: BaselineData,
+    update_flags: bool = False,
+) -> None:
+    """Write the output column to the measurement set."""
+    ant_1 = baseline_data.ant_1
+    ant_2 = baseline_data.ant_2
+    _ = ant_1, ant_2
+    logger.info(f"Writing {output_column=} for baseline {ant_1} {ant_2}")
+    with table(str(ms_path), readonly=False) as tab:
+        colnames = tab.colnames()
+        if output_column not in colnames:
+            msg = f"Output column {output_column} does not exist in the measurement set. Cannot write data."
+            raise ValueError(msg)
+
+        with taql(
+            "select from $tab where ANTENNA1 == $ant_1 and ANTENNA2 == $ant_2",
+        ) as subtab:
+            logger.info(f"Writing {output_column=}")
+            subtab.putcol(output_column, baseline_data.masked_data.filled(0 + 0j))
+            if update_flags:
+                # If we want to update the flags, we need to set the flags to False
+                # for the output column
+                subtab.putcol("FLAG", baseline_data.masked_data.mask)
+            subtab.flush()
+
+
+def make_plot_results(
+    open_ms_tables: OpenMSTables,
+    data_column: str,
+    output_column: str,
+    w_delays: WDelays | None = None,
+) -> list[Path]:
+    output_paths = []
+    output_dir = open_ms_tables.ms_path.parent / "plots"
+    output_dir.mkdir(exist_ok=True, parents=True)
+    for i in range(10):
+        logger.info(f"Plotting baseline={i + 1}")
+        before_baseline_data = get_baseline_data(
+            open_ms_tables=open_ms_tables,
+            ant_1=0,
+            ant_2=i + 1,
+            data_column=data_column,
+        )
+        after_baseline_data = get_baseline_data(
+            open_ms_tables=open_ms_tables,
+            ant_1=0,
+            ant_2=i + 1,
+            data_column=output_column,
+        )
+        before_delays = data_to_delay_time(data=before_baseline_data)
+        after_delays = data_to_delay_time(data=after_baseline_data)
+
+        # TODO: the baseline data and delay times could be put into a single
+        # structure to pass around easier.
+        plot_path = plot_baseline_comparison_data(
+            before_baseline_data=before_baseline_data,
+            after_baseline_data=after_baseline_data,
+            before_delays=before_delays,
+            after_delays=after_delays,
+            output_dir=output_dir,
+            suffix="_comparison",
+            w_delays=w_delays,
+        )
+        output_paths.append(plot_path)
+
+    return output_paths
+
+
+def _get_baseline_time_indicies(
+    w_delays: WDelays, data_chunk: DataChunk
+) -> tuple[NDArray[np.int_], NDArray[np.int_]]:
+    """Extract the mappings into the data array"""
+
+    # When computing uvws we have ignored auto-correlations!
+    # TODO: Either extend the uvw calculations to include auto-correlations
+    # or ignore them during iterations. Certainly the former is the better
+    # approach.
+
+    # Again, note the auto-correlations are ignored!!! Here be pirates mate
+    baseline_idx = np.array(
+        [
+            w_delays.b_map[(int(ant_1), int(ant_2))] if ant_1 != ant_2 else 0
+            for ant_1, ant_2 in zip(  # type: ignore[call-overload]
+                data_chunk.ant_1, data_chunk.ant_2, strict=False
+            )
+        ]
+    )
+
+    time_idx = np.array(
+        [w_delays.time_map[time * u.s] for time in data_chunk.time_mjds]
+    )
+
+    return baseline_idx, time_idx
+
+
+def _tukey_tractor(
+    data_chunk: DataChunk,
+    tukey_tractor_options: TukeyTractorOptions,
+    w_delays: WDelays | None = None,
+) -> NDArray[np.complex128]:
+    """Compute a tukey taper for a dataset and then apply it
+    to the dataset. Here the data corresponds to a (chan, time, pol)
+    array. Data is not necessarily a single baseline.
+
+    If a `w_delays` is provided it represents the delay (in seconds)
+    between the phase direction of the measurement set and the Sun.
+    This quantity may be derived in a number of ways, but in `jolly_roger`
+    it is based on the difference of the w-coordinated towards these
+    two directions. It should have a shape of [baselines, time]
+
+    Args:
+        data_chunk (DataChunk): The representation of the data with attached units
+        tukey_tractor_options (TukeyTractorOptions): Options for the tukey taper
+        w_delays (WDelays | None, optional): The w-derived delays to apply. If None taper is applied to large delays. Defaults to None.
+
+    Returns:
+        NDArray[np.complex128]: Scaled complex visibilities
+    """
+
+    delay_time = data_to_delay_time(data=data_chunk)
+
+    # Look up the delay offset if requested
+    tukey_x_offset: u.Quantity = np.zeros_like(delay_time.delay)
+
+    if w_delays is not None:
+        baseline_idx, time_idx = _get_baseline_time_indicies(
+            w_delays=w_delays, data_chunk=data_chunk
+        )
+        tukey_x_offset = w_delays.w_delays[baseline_idx, time_idx]
+        # logger.info(f"{tukey_x_offset=}")
+
+        # need to scale the x offsert to the -pi to pi
+        # The delay should be symmetric
+        tukey_x_offset = (
+            tukey_x_offset / (np.max(delay_time.delay) / np.pi).decompose()
+        ).value
+        # logger.info(f"{tukey_x_offset=}")
+
+    taper = tukey_taper(
+        x=delay_time.delay,
+        outer_width=tukey_tractor_options.outer_width,
+        tukey_width=tukey_tractor_options.tukey_width,
+        tukey_x_offset=tukey_x_offset,
+    )
+    if w_delays is not None:
+        # The use of the `tukey_x_offset` changes the
+        # shape of the output array. The internals of that
+        # function returns a different shape via the broadcasting
+        taper = np.swapaxes(taper[:, :, None], 0, 1)
+
+        # Since we want to dampen the target object we invert the taper
+        taper = 1.0 - taper
+
+        # Delay with the elevation of the target object
+        elevation_mask = w_delays.elevation < (-3 * u.deg)
+        taper[elevation_mask[time_idx], :, :] = 1.0
+
+        # TODO: Handle case of aliased delays
+
+        # TODO: Create heuristic to determine where baseline is long enough to
+        # ignore the tapering. Aliasing may give us this though...
+
+        # TODO: Create flags where delay is 'close' to 0
+
+    else:
+        taper = taper[None, :, None]
+
+    # Delay-time is a 3D array: (time, delay, pol)
+    # Taper is 1D: (delay,)
+    tapered_delay_time_data_real = delay_time.delay_time.real * taper
+    tapered_delay_time_data_imag = delay_time.delay_time.imag * taper
+    tapered_delay_time_data = (
+        tapered_delay_time_data_real + 1j * tapered_delay_time_data_imag
+    )
+    tapered_delay_time = delay_time
+    tapered_delay_time.delay_time = tapered_delay_time_data
+
+    tapered_data = delay_time_to_data(
+        delay_time=tapered_delay_time,
+        original_data=data_chunk,
+    )
+    logger.debug(f"{tapered_data.masked_data.shape=} {tapered_data.masked_data.dtype}")
+
+    return tapered_data
+
+
+@dataclass
+class TukeyTractorOptions:
+    """Options to describe the tukey taper to apply"""
+
+    ms_path: Path
+    """Measurement set to be modified"""
+    outer_width: float = np.pi / 4
+    """The start of the tapering in frequency space"""
+    tukey_width: float = np.pi / 8
+    """The width of the tapered region in frequency space"""
+    data_column: str = "DATA"
+    """The visibility column to modify"""
+    output_column: str = "CORRECTED_DATA"
+    """The output column to be created with the modified data"""
+    copy_column_data: bool = False
+    """Copy the data from the data column to the output column before applying the taper"""
+    dry_run: bool = False
+    """Indicates whether the data will be written back to the measurement set"""
+    make_plots: bool = False
+    """Create a small set of diagnostic plots"""
+    overwrite: bool = False
+    """If the output column exists it will be overwritten"""
+    chunk_size: int = 1000
+    """Size of the row-wise chunking iterator"""
+    apply_towards_object: bool = False
+    """apply the taper using the delay towards the target object."""
+    target_object: str = "Sun"
+    """The target object to apply the delay towards."""
+
+
+def tukey_tractor(
+    tukey_tractor_options: TukeyTractorOptions,
+) -> None:
+    """Iterate row-wise over a specified measurement set and
+    apply a tukey taper operation to the delay data. Iteration
+    is performed based on a chunk soize, indicating the number
+    of rows to read in at a time.
+
+    Full description of options are outlined in `TukeyTaperOptions`.
+
+    Args:
+        tukey_tractor_options (TukeyTractorOptions): The settings to use during the taper, and measurement set to apply them to.
+    """
+    logger.info("jolly-roger")
+    logger.info(f"Options: {tukey_tractor_options}")
+
+    # acquire all the tables necessary to get unit information and data from
+    open_ms_tables = get_open_ms_tables(
+        ms_path=tukey_tractor_options.ms_path, read_only=False
+    )
+
+    if not tukey_tractor_options.dry_run:
+        add_output_column(
+            tab=open_ms_tables.main_table,
+            output_column=tukey_tractor_options.output_column,
+            data_column=tukey_tractor_options.data_column,
+            overwrite=tukey_tractor_options.overwrite,
+            copy_column_data=tukey_tractor_options.copy_column_data,
+        )
+
+    # Generate the delay for all baselines and time steps
+    w_delays: WDelays | None = None
+    if tukey_tractor_options.apply_towards_object:
+        logger.info(
+            f"Pre-calculating delays towards the target: {tukey_tractor_options.target_object}"
+        )
+        w_delays = get_object_delay_for_ms(
+            ms_path=tukey_tractor_options.ms_path,
+            object_name=tukey_tractor_options.target_object,
+        )
+        assert len(w_delays.w_delays.shape) == 2
+
+    if not tukey_tractor_options.dry_run:
+        with tqdm(total=len(open_ms_tables.main_table)) as pbar:
+            for data_chunk in get_data_chunks(
+                open_ms_tables=open_ms_tables,
+                chunk_size=tukey_tractor_options.chunk_size,
+                data_column=tukey_tractor_options.data_column,
+            ):
+                taper_data_chunk = _tukey_tractor(
+                    data_chunk=data_chunk,
+                    tukey_tractor_options=tukey_tractor_options,
+                    w_delays=w_delays,
+                )
+
+                pbar.update(len(taper_data_chunk.masked_data))
+
+                # only put if not a dry run
+                open_ms_tables.main_table.putcol(
+                    columnname=tukey_tractor_options.output_column,
+                    value=taper_data_chunk.masked_data,
+                    startrow=taper_data_chunk.row_start,
+                    nrow=taper_data_chunk.chunk_size,
+                )
+
+    if tukey_tractor_options.make_plots:
+        plot_paths = make_plot_results(
+            open_ms_tables=open_ms_tables,
+            data_column=tukey_tractor_options.data_column,
+            output_column=tukey_tractor_options.output_column,
+            w_delays=w_delays,
+        )
+
+        logger.info(f"Made {len(plot_paths)} output plots")
+
+
+def get_parser() -> ArgumentParser:
+    """Create the CLI argument parser
+
+    Returns:
+        ArgumentParser: Constructed argument parser
+    """
+    parser = ArgumentParser(description="Run the Jolly Roger Tractor")
+    subparsers = parser.add_subparsers(dest="mode")
+
+    tukey_parser = subparsers.add_parser(
+        name="tukey", help="Perform a dumb Tukey taper across delay-time data"
+    )
+    tukey_parser.add_argument(
+        "ms_path",
+        type=Path,
+        help="The measurement set to process with the Tukey tractor",
+    )
+    tukey_parser.add_argument(
+        "--outer-width",
+        type=float,
+        default=np.pi / 4,
+        help="The outer width of the Tukey taper in radians",
+    )
+    tukey_parser.add_argument(
+        "--tukey-width",
+        type=float,
+        default=np.pi / 8,
+        help="The Tukey width of the Tukey taper in radians",
+    )
+    tukey_parser.add_argument(
+        "--data-column",
+        type=str,
+        default="DATA",
+        help="The data column to use for the Tukey tractor",
+    )
+    tukey_parser.add_argument(
+        "--output-column",
+        type=str,
+        default="CORRECTED_DATA",
+        help="The output column to write the Tukey tractor results to",
+    )
+    tukey_parser.add_argument(
+        "--copy-column-data",
+        action="store_true",
+        help="If set, the Tukey tractor will copy the data from the data column to the output column before applying the taper",
+    )
+    tukey_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="If set, the Tukey tractor will not write any output, but will log what it would do",
+    )
+    tukey_parser.add_argument(
+        "--make-plots",
+        action="store_true",
+        help="If set, the Tukey tractor will make plots of the results",
+    )
+    tukey_parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="If set, the Tukey tractor will overwrite the output column if it already exists",
+    )
+    tukey_parser.add_argument(
+        "--chunk-size",
+        type=int,
+        default=10000,
+        help="The number of rows to process in one chunk. Larger numbers require more memory but fewer interactions with I/O.",
+    )
+    tukey_parser.add_argument(
+        "--target-object",
+        type=str,
+        default="Sun",
+        help="The target object to apply the delay towards. Defaults to 'Sun'.",
+    )
+    tukey_parser.add_argument(
+        "--apply-towards-object",
+        action="store_true",
+        help="Whether the tukey taper is applied towards the target object (e.g. the Sun). If not set, the taper is applied towards large delays.",
+    )
+
+    return parser
+
+
+def cli() -> None:
+    """Command line interface for the Jolly Roger Tractor."""
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if args.mode == "tukey":
+        tukey_tractor_options = TukeyTractorOptions(
+            ms_path=args.ms_path,
+            outer_width=args.outer_width,
+            tukey_width=args.tukey_width,
+            data_column=args.data_column,
+            output_column=args.output_column,
+            copy_column_data=args.copy_column_data,
+            dry_run=args.dry_run,
+            make_plots=args.make_plots,
+            overwrite=args.overwrite,
+            chunk_size=args.chunk_size,
+            target_object=args.target_object,
+            apply_towards_object=args.apply_towards_object,
+        )
+        tukey_tractor(tukey_tractor_options=tukey_tractor_options)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    cli()

jolly_roger/uvws.py

@@ -11,17 +11,67 @@ from astropy.constants import c as speed_of_light
 from casacore.tables import table, taql
 from tqdm import tqdm
 
-from jolly_roger.baselines import Baselines
-from jolly_roger.hour_angles import PositionHourAngles
+from jolly_roger.baselines import Baselines, get_baselines_from_ms
+from jolly_roger.hour_angles import PositionHourAngles, make_hour_angles_for_ms
 from jolly_roger.logging import logger
 
 
+@dataclass(frozen=True)
+class WDelays:
+    """Representation and mappings for the w-coordinate derived delays"""
+
+    object_name: str
+    """The name of the object that the delays are derived towards"""
+    w_delays: u.Quantity
+    """The w-derived delay. Shape is [baseline, time]"""
+    b_map: dict[tuple[int, int], int]
+    """The mapping between (ANTENNA1,ANTENNA2) to baseline index"""
+    time_map: dict[u.Quantity, int]
+    """The mapping between time (MJDs from measurement set) to index"""
+    elevation: u.Quantity
+    """The elevation of the target object in time order of steps in the MS"""
+
+
+def get_object_delay_for_ms(
+    ms_path: Path,
+    object_name: str = "sun",
+) -> WDelays:
+    # Generate the two sets of uvw coordinate objects
+    baselines: Baselines = get_baselines_from_ms(ms_path=ms_path)
+    hour_angles_phase = make_hour_angles_for_ms(
+        ms_path=ms_path,
+        position=None,  # gets the position from phase direction
+    )
+    uvws_phase: UVWs = xyz_to_uvw(baselines=baselines, hour_angles=hour_angles_phase)
+
+    hour_angles_object = make_hour_angles_for_ms(
+        ms_path=ms_path,
+        position=object_name,  # gets the position from phase direction
+    )
+    uvws_object: UVWs = xyz_to_uvw(baselines=baselines, hour_angles=hour_angles_object)
+
+    # Subtract the w-coordinates out. Since these uvws have
+    # been computed towards different directions the difference
+    # in w-coordinate is the delay distance
+    w_diffs = uvws_object.uvws[2] - uvws_phase.uvws[2]
+
+    delay_object = (w_diffs / speed_of_light).decompose()
+
+    return WDelays(
+        object_name=object_name,
+        w_delays=delay_object,
+        b_map=baselines.b_map,
+        time_map=hour_angles_phase.time_map,
+        elevation=hour_angles_object.elevation,
+    )
+
+
 @dataclass
 class UVWs:
     """A small container to represent uvws"""
 
     uvws: np.ndarray
-    """The (U,V,W) coordinates"""
+    """The (U,V,W) coordinatesm shape [coord, baseline, time]"""
     hour_angles: PositionHourAngles
     """The hour angle information used to construct the UVWs"""
     baselines: Baselines
@@ -51,9 +101,9 @@ def xyz_to_uvw(
     declination = hour_angles.position.dec
 
     # This is necessary for broadcastung in the matrix to work.
-    # Should the position be a solar object like the sub its position
+    # Should the position be a solar object like the sun its position
     # will change throughout the observation. but it will have
-    ## been created consistently with the hour angles. If it is fixed
+    # been created consistently with the hour angles. If it is fixed
     # then the use of the numpy ones like will ensure the same shape.
     declination = (np.ones(len(ha)) * declination).decompose()
 

{jolly_roger-0.1.0.dist-info → jolly_roger-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jolly-roger
-Version: 0.1.0
+Version: 0.2.0
 Summary: The pirate flagger
 Project-URL: Homepage, https://github.com/flint-crew/jolly-roger
 Project-URL: Bug Tracker, https://github.com/flint-crew/jolly-roger/issues
@@ -23,6 +23,8 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: astropy
+Requires-Dist: dask-ms
+Requires-Dist: matplotlib
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: python-casacore>=3.6.0
 Requires-Dist: tqdm

jolly_roger-0.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+jolly_roger/__init__.py,sha256=7xiZLdeY-7sgrYGQ1gNdCjgCfqnoPXK7AeaHncY_DGU,204
+jolly_roger/_version.py,sha256=iB5DfB5V6YB5Wo4JmvS-txT42QtmGaWcWp3udRT7zCI,511
+jolly_roger/_version.pyi,sha256=j5kbzfm6lOn8BzASXWjGIA1yT0OlHTWqlbyZ8Si_o0E,118
+jolly_roger/baselines.py,sha256=C_vC3v_ciU2T_si31oS0hUmsMNTQA0USxrm4118vYvY,4615
+jolly_roger/delays.py,sha256=cvLMhChkkB6PkS11v6JU8Wn23Zqv5bQY1HTMzeIGTNw,3015
+jolly_roger/flagger.py,sha256=tlC-M_MpLpqOvkF544zw2EvOUpbSpasO2zlMlXMcxSs,3034
+jolly_roger/hour_angles.py,sha256=ld3jiEDQXlYLHrChUxYD_UBSxKH0qarstakBPLQ0M8s,6044
+jolly_roger/logging.py,sha256=04YVHnF_8tKDkXNtXQ-iMyJ2BLV-qowbPAqqMFDxYE4,1338
+jolly_roger/plots.py,sha256=LsueygCHpGvBXZe2y4q1fmJEMyjoMl65JzFMzbduawI,5280
+jolly_roger/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jolly_roger/tractor.py,sha256=ORkQb7T7jxMFVcDihH1McYYGq07OgsvbfT44D82ghL4,27723
+jolly_roger/uvws.py,sha256=ujZdIIxNY2k4HY9p65kUyH-VqN6thNpOrBb-wpL9mYM,12424
+jolly_roger-0.2.0.dist-info/METADATA,sha256=vFDa_-0nKwhoFVmm9x_qqQgZURZV8jPBprgRue9h7XY,4221
+jolly_roger-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+jolly_roger-0.2.0.dist-info/entry_points.txt,sha256=q8RYosASYsPShzsIo58NxOhIMuB4F-gQ2uG6zS2p224,98
+jolly_roger-0.2.0.dist-info/licenses/LICENSE,sha256=7G-TthaPSOehr-pdj4TJydXj3eIUmerMbCUSatMr8hc,1522
+jolly_roger-0.2.0.dist-info/RECORD,,

{jolly_roger-0.1.0.dist-info → jolly_roger-0.2.0.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 jolly_flagger = jolly_roger.flagger:cli
+jolly_tractor = jolly_roger.tractor:cli

jolly_roger-0.1.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-jolly_roger/__init__.py,sha256=7xiZLdeY-7sgrYGQ1gNdCjgCfqnoPXK7AeaHncY_DGU,204
-jolly_roger/_version.py,sha256=-LyU5F1uZDjn6Q8_Z6-_FJt_8RE4Kq9zcKdg1abSSps,511
-jolly_roger/_version.pyi,sha256=j5kbzfm6lOn8BzASXWjGIA1yT0OlHTWqlbyZ8Si_o0E,118
-jolly_roger/baselines.py,sha256=C_vC3v_ciU2T_si31oS0hUmsMNTQA0USxrm4118vYvY,4615
-jolly_roger/flagger.py,sha256=tlC-M_MpLpqOvkF544zw2EvOUpbSpasO2zlMlXMcxSs,3034
-jolly_roger/hour_angles.py,sha256=SUUN_DcT3xzYp9JZ1U9ZcJpMjsfYETJ4D0YghUjee7Y,6096
-jolly_roger/logging.py,sha256=04YVHnF_8tKDkXNtXQ-iMyJ2BLV-qowbPAqqMFDxYE4,1338
-jolly_roger/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jolly_roger/uvws.py,sha256=42FngtA425Fk8QSlEIbl-9tEBd_-In0FtV2LYcnk6-0,10555
-jolly_roger-0.1.0.dist-info/METADATA,sha256=d40uefWM1e6HJtaqxNoak1PFBNFFZaBaS_18wno_Au8,4172
-jolly_roger-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-jolly_roger-0.1.0.dist-info/entry_points.txt,sha256=ZwEZAe4DBn5nznVI0tP0a1wUinYouwXxxcZP6p7Pkvk,58
-jolly_roger-0.1.0.dist-info/licenses/LICENSE,sha256=7G-TthaPSOehr-pdj4TJydXj3eIUmerMbCUSatMr8hc,1522
-jolly_roger-0.1.0.dist-info/RECORD,,