lvm-tools 0.0.2__py3-none-any.whl

lvm_tools/__init__.py

@@ -0,0 +1,10 @@
+from lvm_tools.config.data_config import DataConfig
+from lvm_tools.data.tile import LVMTile, LVMTileCollection
+from lvm_tools.fit_data.builder import FitDataBuilder
+
+__all__ = [
+    "LVMTile",
+    "LVMTileCollection",
+    "DataConfig",
+    "FitDataBuilder",
+]

lvm_tools/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.2'
+__version_tuple__ = version_tuple = (0, 0, 2)

lvm_tools/config/__init__.py

@@ -0,0 +1 @@
+"""config - subpackage for configurations used in data processing before fitting."""

lvm_tools/config/data_config.py

@@ -0,0 +1,206 @@
+"""data_config.py - Objects for specifying configuration of data processing before fitting."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+import numpy as np
+
+from lvm_tools.config.validation import (
+    validate_apply_mask,
+    validate_excl_strategy,
+    validate_fib_status_incl,
+    validate_norm_strategy,
+    validate_offset,
+    validate_range,
+    validate_scale,
+)
+from lvm_tools.data.tile import LVMTileLike
+from lvm_tools.fit_data.filtering import (
+    BAD_FLUX_THRESHOLD,
+    ExcludeStrategy,
+    FibreStatus,
+)
+from lvm_tools.fit_data.normalisation import NormaliseStrategy
+from lvm_tools.fit_data.processing import get_normalisations, get_αδ_ranges, process_tile_data
+
+
+@dataclass(frozen=True)
+class DataConfig:
+    """
+    Configuration object for data processing before fitting.
+
+    args:
+        λ_range: tuple[float, float] - Wavelength range to include.
+        α_range: tuple[float, float] - Right Ascension range to include.
+        δ_range: tuple[float, float] - Declination range to include.
+        nans_strategy: ExcludeStrategy - Strategy for handling NaN values.
+        F_bad_strategy: ExcludeStrategy - Strategy for handling bad flux values. For "pixel", the flux range is applied to each pixel. For "spaxel", the flux range is applied to the median of all pixels in a spaxel.
+        F_range: tuple[float, float] - Flux range to include.
+        fibre_status_include: tuple[FibreStatus] - Fibre status values to include.
+        apply_mask: bool - Whether to apply a mask to the data.
+        normalise_F_strategy: NormaliseStrategy - Strategy for normalising flux data.
+        normalise_F_offset: float - Offset for normalising flux data.
+        normalise_F_scale: float - Scale for normalising flux data.
+        normalise_αδ_strategy: NormaliseStrategy - Strategy for normalising α and δ data.
+        normalise_αδ_offset: float - Offset for normalising α and δ data.
+        normalise_αδ_scale: float - Scale for normalising α and δ data.
+    """
+
+    # Data clipping ranges (aka choose data of interest)
+    λ_range: tuple[float, float] = (-np.inf, np.inf)
+    α_range: tuple[float, float] = (-np.inf, np.inf)
+    δ_range: tuple[float, float] = (-np.inf, np.inf)
+    # Bad data ranges and strategies (aka exclude bad data)
+    nans_strategy: ExcludeStrategy = "pixel"
+    F_bad_strategy: ExcludeStrategy = "spaxel"
+    F_range: tuple[float, float] = (BAD_FLUX_THRESHOLD, np.inf)
+    # Handling of flagged data
+    fibre_status_include: tuple[FibreStatus] = (0,)
+    apply_mask: bool = True
+    # Normalisation
+    normalise_F_strategy: NormaliseStrategy = "max only"
+    normalise_F_offset: float = 0.0
+    normalise_F_scale: float = 1.0
+    normalise_αδ_strategy: NormaliseStrategy = "padded"
+    normalise_α_offset: float = 0.0
+    normalise_α_scale: float = 1.0
+    normalise_δ_offset: float = 0.0
+    normalise_δ_scale: float = 1.0
+
+    def __post_init__(self) -> None:
+        validate_range(self.λ_range)
+        validate_range(self.α_range)
+        validate_range(self.δ_range)
+        validate_excl_strategy(self.nans_strategy)
+        validate_excl_strategy(self.F_bad_strategy)
+        validate_range(self.F_range)
+        validate_fib_status_incl(self.fibre_status_include)
+        validate_apply_mask(self.apply_mask)
+        validate_norm_strategy(self.normalise_F_strategy)
+        validate_norm_strategy(self.normalise_αδ_strategy)
+        validate_offset(self.normalise_F_offset)
+        validate_scale(self.normalise_F_scale)
+        validate_norm_strategy(self.normalise_αδ_strategy)
+        validate_offset(self.normalise_α_offset)
+        validate_scale(self.normalise_α_scale)
+        validate_offset(self.normalise_δ_offset)
+        validate_scale(self.normalise_δ_scale)
+
+    @staticmethod
+    def default() -> DataConfig:
+        return DataConfig()
+
+    @staticmethod
+    def from_tiles(
+        tiles: LVMTileLike,
+        λ_range: tuple[float, float] = (-np.inf, np.inf),
+        **overrides,
+    ) -> DataConfig:
+        # λ_range cannot be set automatically
+        α_range, δ_range = get_αδ_ranges(tiles)
+
+        # Instantiate a data config with calc'd + default + overrides
+        config_dict = DataConfig(λ_range=λ_range, α_range=α_range, δ_range=δ_range).to_dict()
+        config = DataConfig.from_dict(config_dict | overrides)
+
+        # Clip and filter the data
+        ds = process_tile_data(tiles, config)
+
+        # Calculate the normalisation parameters
+        (
+            (normalise_F_offset, normalise_F_scale),
+            (normalise_α_offset, normalise_α_scale),
+            (normalise_δ_offset, normalise_δ_scale),
+        ) = get_normalisations(ds, config)
+
+        # We want a square domain in the α, δ plane
+        norm_αδ_scale = max(normalise_α_scale, normalise_δ_scale)
+
+        # Update the config with the calculated values
+        norm_overrides = {
+            "normalise_F_offset": normalise_F_offset,
+            "normalise_F_scale": normalise_F_scale,
+            "normalise_α_offset": normalise_α_offset,
+            "normalise_α_scale": norm_αδ_scale,
+            "normalise_δ_offset": normalise_δ_offset,
+            "normalise_δ_scale": norm_αδ_scale,
+        }
+
+        # Merge partial config + norm + user overrides, with user overrides taking precedence
+        return DataConfig.from_dict(config.to_dict() | norm_overrides | overrides)
+
+    @staticmethod
+    def from_dict(config: dict) -> DataConfig:
+        if len(config) != len(DataConfig.default().to_dict()):
+            raise ValueError("config has the wrong number of entries.")
+        return DataConfig(**config)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    def __repr__(self) -> str:
+        def format_tuple(t):
+            """Format tuple with floats to 2 decimal places or scientific notation if very small."""
+            formatted = []
+            for x in t:
+                if isinstance(x, float):
+                    if abs(x) < 1e-3 and x != 0:
+                        formatted.append(f"{x:.2e}")
+                    else:
+                        formatted.append(f"{x:.2f}")
+                else:
+                    formatted.append(str(x))
+            return f"({', '.join(formatted)})"
+
+        def format_float(f):
+            """Format float to 2 decimal places, or scientific notation if very small."""
+            if abs(f) < 1e-3 and f != 0:
+                return f"{f:.2e}"
+            else:
+                return f"{f:.2f}"
+
+        lines = [f"{self.__class__.__name__}("]
+
+        lines = [f"{self.__class__.__name__} ({hex(id(self))}):"]
+
+        pad = 26
+
+        # Data clipping ranges
+        lines.append("    Data clipping ranges:")
+        lines.append(f"        {'λ_range:':{pad}}{format_tuple(self.λ_range)}")
+        lines.append(f"        {'α_range:':{pad}}{format_tuple(self.α_range)}")
+        lines.append(f"        {'δ_range:':{pad}}{format_tuple(self.δ_range)}")
+
+        # Bad data handling
+        lines.append("    Bad data handling:")
+        lines.append(f"        {'nans_strategy:':{pad}}'{self.nans_strategy}'")
+        lines.append(f"        {'F_bad_strategy:':{pad}}'{self.F_bad_strategy}'")
+        lines.append(f"        {'F_range:':{pad}}{format_tuple(self.F_range)}")
+
+        # Flagged data handling
+        lines.append("    Flagged data handling:")
+        lines.append(f"        {'fibre_status_include:':{pad}}{self.fibre_status_include}")
+        lines.append(f"        {'apply_mask:':{pad}}{self.apply_mask}")
+
+        # Flux normalisation
+        lines.append("    Flux normalisation:")
+        lines.append(f"        {'normalise_F_strategy:':{pad}}'{self.normalise_F_strategy}'")
+        lines.append(
+            f"        {'normalise_F_offset:':{pad}}{format_float(self.normalise_F_offset)}"
+        )
+        lines.append(f"        {'normalise_F_scale:':{pad}}{format_float(self.normalise_F_scale)}")
+
+        # Coordinate normalisation
+        lines.append("    Coordinate normalisation:")
+        lines.append(f"        {'normalise_αδ_strategy:':{pad}}'{self.normalise_αδ_strategy}'")
+        lines.append(
+            f"        {'normalise_α_offset:':{pad}}{format_float(self.normalise_α_offset)}"
+        )
+        lines.append(f"        {'normalise_α_scale:':{pad}}{format_float(self.normalise_α_scale)}")
+        lines.append(
+            f"        {'normalise_δ_offset:':{pad}}{format_float(self.normalise_δ_offset)}"
+        )
+        lines.append(f"        {'normalise_δ_scale:':{pad}}{format_float(self.normalise_δ_scale)}")
+
+        return "\n".join(lines)

lvm_tools/config/validation.py

@@ -0,0 +1,58 @@
+"""validation.py - Validation functions for data processing configuration."""
+
+from typing import get_args
+
+import numpy as np
+
+from lvm_tools.fit_data.filtering import ExcludeStrategy, FibreStatus
+from lvm_tools.fit_data.normalisation import NormaliseStrategy
+
+
+def validate_range(x_range: tuple[float, float]) -> None:
+    # if not isinstance(x_range, tuple):
+    # raise TypeError("Data range must be in a tuple.")
+    if len(x_range) != 2:
+        raise ValueError(
+            "Data range must be a tuple with exactly two values (min, max)."
+        )
+    if x_range[1] < x_range[0]:
+        raise ValueError("Requested data range restriction has max < min.")
+
+
+def validate_excl_strategy(strategy: ExcludeStrategy) -> None:
+    if strategy not in get_args(ExcludeStrategy):
+        raise ValueError(f"Unknown exclusion strategy: {strategy}")
+
+
+def validate_norm_strategy(strategy: NormaliseStrategy) -> None:
+    if strategy not in get_args(NormaliseStrategy):
+        raise ValueError(f"Unknown normalisation strategy: {strategy}")
+
+
+def validate_fib_status_incl(fibre_status_include: tuple[FibreStatus]) -> None:
+    # if not isinstance(fibre_status_include, tuple):
+    # raise TypeError("fibre_status_include must be a tuple.")
+    for fs in fibre_status_include:
+        if fs not in get_args(FibreStatus):
+            raise ValueError(f"Unknown fibre status: {fs}")
+
+
+def validate_offset(offset: float) -> None:
+    if not isinstance(offset, (float, np.floating)):
+        raise TypeError("offset must be float.")
+    if not np.isfinite(offset):
+        raise Exception("Bad offset (nan or infty).")
+
+
+def validate_scale(scale: float) -> None:
+    if not isinstance(scale, (float, np.floating)):
+        raise TypeError("scale must be float.")
+    if not np.isfinite(scale):
+        raise Exception("Bad scale (nan or infty).")
+    if scale <= 0:
+        raise Exception("Scale is not positive, but it must be.")
+
+
+def validate_apply_mask(apply_mask: bool) -> None:
+    if not isinstance(apply_mask, bool):
+        raise TypeError("apply_mask must be a boolean.")

lvm_tools/data/__init__.py

@@ -0,0 +1 @@
+"""data - subpackage for reading and encapsulating LVM data."""

lvm_tools/data/coordinates.py

@@ -0,0 +1,73 @@
+"""coordinates.py - observation time and location extraction for LVM data processing."""
+
+# NOTE: Code is generated by an LLM and may not be fully robust.
+
+import astropy.units as u
+from astropy.coordinates import EarthLocation
+from astropy.io.fits import Header
+from astropy.time import Time
+
+
+def get_mjd(header: Header) -> float:
+    # Method 1: Use INTSTART and INTEND if available (most precise)
+    if "INTSTART" in header and "INTEND" in header:
+        start_time = Time(header["INTSTART"], format="isot")
+        end_time = Time(header["INTEND"], format="isot")
+        mid_time = start_time + (end_time - start_time) / 2
+        # print(header["MJD"])
+        # mid_time = Time(header["MJD"], format="mjd")
+        # print(mid_time.mjd)
+        # print()
+
+        # Validation: check against header EXPTIME
+        # calculated_exptime = (end_time - start_time).to(u.second).value
+        # header_exptime = header.get("EXPTIME", 0.0)
+        # if abs(calculated_exptime - header_exptime) > 1.0:  # Allow 1s tolerance
+        #     print(
+        #         f"  WARNING: Calculated exptime ({calculated_exptime:.1f}s) differs from header EXPTIME ({header_exptime}s)"
+        #     )
+
+        return mid_time.mjd
+
+    # # Method 2: Use OBSTIME + EXPTIME/2 as fallback
+    # elif "OBSTIME" in header and "EXPTIME" in header:
+    #     start_time = Time(header["OBSTIME"], format="isot")
+    #     exptime = header["EXPTIME"] * u.second
+    #     mid_time = start_time + exptime / 2
+
+    #     return mid_time.mjd
+
+    # # Method 3: Use header MJD + EXPTIME/2 (least precise, integer MJD)
+    # elif "MJD" in header and "EXPTIME" in header:
+    #     mjd_start = header["MJD"]  # This appears to be integer MJD
+    #     exptime_days = header["EXPTIME"] / 86400.0  # Convert seconds to days
+    #     mjd_mid = mjd_start + exptime_days / 2
+
+    #     return mjd_mid
+
+    else:
+        raise ValueError("Could not find sufficient time information in header")
+
+
+def get_observatory_code(header: Header) -> str:
+    observatory = header.get("OBSERVAT", "").strip()
+
+    # Just return the observatory code string
+    # You can convert to EarthLocation later when needed
+    known_observatories = ["LCO"]  # Add other LVM observatory codes as needed
+
+    if observatory in known_observatories:
+        return observatory
+    else:
+        raise ValueError(
+            f"Unknown observatory: {observatory}. Known observatories: {known_observatories}"
+        )
+
+
+def get_observatory_location(observatory: str) -> EarthLocation:
+    # LCO = Las Campanas Observatory
+    if observatory == "LCO":
+        return EarthLocation.of_site("Las Campanas Observatory")
+    else:
+        # Add other observatories as needed
+        raise ValueError(f"Unknown observatory: {observatory}")

lvm_tools/data/helper.py

@@ -0,0 +1,56 @@
+"""helper.py - helper functions for LVM data processing."""
+
+import dask.array as da
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+from xarray import Dataset
+
+
+def daskify_native(array: ArrayLike, chunks: str | int | tuple) -> da.Array:
+    """Convert input to a Dask array with native byte order."""
+    arr = np.asarray(array)
+    if arr.dtype.byteorder not in ("=", "|"):
+        arr = arr.astype(arr.dtype.newbyteorder("="))
+    return da.from_array(arr, chunks)  # type: ignore[no-any-return]
+
+
+def numpyfy_native(array: ArrayLike) -> NDArray:
+    """Convert input to a NumPy array with native byte order."""
+    arr = np.asarray(array)
+    if arr.dtype.byteorder not in ("=", "|"):
+        arr = arr.astype(arr.dtype.newbyteorder("="))
+    return arr
+
+
+def summarize_with_units(ds: Dataset) -> str:
+    lines = [f"    Data size:        {ds.nbytes // 1024**2}MB"]
+    lines.append(f"    Dimensions:       {', '.join(f'{k}: {v}' for k, v in ds.sizes.items())}")
+
+    # Coordinates
+    lines.append("    Coordinates:")
+    for name, coord in ds.coords.items():
+        dims = f"({', '.join(coord.sizes)})"
+        dtype = str(coord.dtype)
+        size = f"{coord.nbytes // 1024}kB"
+        units = coord.attrs.get("units", "")
+        lines.append(f"        {name:<13} {dims:<28} {dtype:<8} {size:<6} [{units}]")
+
+    # Data variables
+    lines.append("    Data:")
+    for name, var in ds.data_vars.items():
+        dims = f"({', '.join(var.sizes)})"
+        dtype = str(var.dtype)
+        size = f"{var.nbytes // 1024 // 1024}MB"
+        if hasattr(var.data, "chunks") and var.data.chunks is not None:
+            chunks = f"DaskArray<chunksize={var.data.chunks}>"
+        else:
+            chunks = "NDArray"
+        units = var.attrs.get("units", "")
+        lines.append(f"        {name:<13} {dims:<28} {dtype:<8} {size:<6} {chunks} [{units}]")
+
+    return "\n".join(lines)
+
+
+def convert_sci_to_int(arr: ArrayLike) -> NDArray:
+    mapping = {"Sci1": 0, "Sci2": 1, "Sci3": 2}
+    return np.array([mapping[item] for item in arr], dtype=int)

lvm_tools/data/tile.py

@@ -0,0 +1,168 @@
+"""tile.py - Tile classes for LVM data processing."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Mapping
+
+import astropy.units as u  # type: ignore[import]
+import dask.array as da
+import numpy as np
+from astropy.io import fits  # type: ignore[import]
+from astropy.io.fits import FITS_rec, HDUList  # type: ignore[import]
+from astropy.units import Unit  # type: ignore[import]
+from numpy.typing import NDArray
+from xarray import Dataset, concat
+
+from lvm_tools.data.coordinates import get_mjd
+from lvm_tools.data.helper import daskify_native, numpyfy_native, summarize_with_units
+
+# Conversions between FWHM and Gaussian sigma
+SIGMA_TO_FWHM: float = 2.0 * np.sqrt(2.0 * np.log(2))
+FWHM_TO_SIGMA: float = 1.0 / SIGMA_TO_FWHM
+
+# Physical units for the data
+FLUX_UNIT: Unit = u.erg * u.cm**-2 * u.s**-1 * u.angstrom**-1
+SPECTRAL_UNIT: Unit = u.angstrom
+SPATIAL_UNIT: Unit = u.degree
+
+# Default chunk size for Dask arrays
+CHUNKSIZE: str = "auto"
+
+
+def get_science_inds(slitmap: FITS_rec) -> NDArray:
+    return np.where(slitmap.field("targettype") == "science")[0]
+
+
+@dataclass(frozen=True)
+class LVMTileMeta:
+    filename: str
+    tile_id: int
+    exp_num: int
+    drp_ver: str
+
+
+@dataclass(frozen=True)
+class LVMTile:
+    data: Dataset
+    meta: LVMTileMeta
+
+    @classmethod
+    def from_file(cls, drp_file: Path | str) -> LVMTile:
+        file = Path(drp_file)
+        if not file.exists():
+            raise FileNotFoundError("Could not find DRP file.")
+
+        with fits.open(file, memmap=True) as hdul:
+            tile_id, exp_num, drp_ver, mjd = cls.get_metadata(hdul)
+            (flux, i_var, mask, lsf), (wave, ra, dec, fibre_id, fibre_status, ifu_label) = (
+                cls.get_science_data(hdul)
+            )
+
+        # Conver the lsf from full width at half maximum (FWHM) to sigma
+        lsf *= FWHM_TO_SIGMA
+
+        # Common dimensions for cube data
+        pixel_dims = ("tile", "spaxel", "wavelength")
+        spaxel_dims = ("tile", "spaxel")
+
+        # Assemble data into xarray Dataset, containing both dask arrays and numpy arrays
+        data = Dataset(
+            data_vars={
+                "flux": (pixel_dims, flux[None, :, :], {"units": str(FLUX_UNIT)}),
+                "i_var": (pixel_dims, i_var[None, :, :], {"units": str(FLUX_UNIT**-2)}),
+                "lsf_sigma": (pixel_dims, lsf[None, :, :], {"units": str(SPECTRAL_UNIT)}),
+                "mask": (pixel_dims, mask[None, :, :]),
+            },
+            coords={
+                # Main dimensions/coordinates
+                "tile": ("tile", [exp_num]),
+                "spaxel": ("spaxel", np.arange(len(fibre_id))),
+                "wavelength": ("wavelength", wave, {"units": str(SPECTRAL_UNIT)}),
+                # More coordinates
+                "mjd": ("tile", [mjd], {"units": "day"}),
+                "ra": (spaxel_dims, ra[None, :], {"units": str(SPATIAL_UNIT)}),
+                "dec": (spaxel_dims, dec[None, :], {"units": str(SPATIAL_UNIT)}),
+                "fibre_id": (spaxel_dims, fibre_id[None, :]),
+                "ifu_label": (spaxel_dims, ifu_label[None, :]),
+                "fibre_status": (spaxel_dims, fibre_status[None, :]),
+            },
+        )
+
+        # Assemble metadata
+        meta = LVMTileMeta(
+            filename=file.name,
+            tile_id=tile_id,
+            exp_num=exp_num,
+            drp_ver=drp_ver,
+        )
+
+        return cls(data=data, meta=meta)
+
+    def __repr__(self) -> str:
+        prefix = f"LVMTile ({hex(id(self))}):"
+        prefix += f"\n    Filename:        {self.meta.filename}"
+        prefix += f"\n    Exposure:        {self.meta.exp_num}"
+        prefix += f"\n    DRP version:     {self.meta.drp_ver}"
+        prefix += f"\n    Tile ID:         {self.meta.tile_id}"
+        return f"{prefix}\n{summarize_with_units(self.data)}"
+
+    @staticmethod
+    def get_science_data(drp_hdulist: HDUList) -> tuple[tuple, tuple]:
+        slitmap = drp_hdulist[-1].data
+        science_inds = get_science_inds(slitmap)
+        # Lazily load cubes
+        flux: da.Array = daskify_native(drp_hdulist[1].data, CHUNKSIZE)[science_inds, :]
+        i_var: da.Array = daskify_native(drp_hdulist[2].data, CHUNKSIZE)[science_inds, :]
+        mask: da.Array = daskify_native(drp_hdulist[3].data, CHUNKSIZE)[science_inds, :]
+        lsf: da.Array = daskify_native(drp_hdulist[5].data, CHUNKSIZE)[science_inds, :]
+        # Eagerly coordinates
+        wave: NDArray = numpyfy_native(drp_hdulist[4].data)
+        ra: NDArray = numpyfy_native((slitmap["ra"])[science_inds])
+        dec: NDArray = numpyfy_native((slitmap["dec"])[science_inds])
+        fibre_id: NDArray = numpyfy_native((slitmap["fiberid"])[science_inds])
+        fibre_status: NDArray = numpyfy_native((slitmap["fibstatus"])[science_inds])
+        ifu_label: NDArray = numpyfy_native((slitmap["ifulabel"])[science_inds])
+        return (flux, i_var, mask, lsf), (wave, ra, dec, fibre_id, fibre_status, ifu_label)
+
+    @staticmethod
+    def get_metadata(drp_hdulist: HDUList) -> tuple[int, int, str]:
+        try:
+            tile_id = int(drp_hdulist[0].header["OBJECT"].split("=")[1])
+        except IndexError:
+            try:
+                tile_id = int(drp_hdulist[0].header["OBJECT"])
+            except ValueError:
+                tile_id = str(drp_hdulist[0].header["OBJECT"])
+        exp_num = int(drp_hdulist[0].header["EXPOSURE"])
+        drp_ver = str(drp_hdulist[0].header["DRPVER"])
+        mjd = float(get_mjd(drp_hdulist[0].header))
+        return tile_id, exp_num, drp_ver, mjd
+
+
+@dataclass(frozen=True)
+class LVMTileCollection:
+    data: Dataset
+    meta: Mapping[int, LVMTileMeta]
+
+    @classmethod
+    def from_tiles(cls, tiles: list[LVMTile]) -> LVMTileCollection:
+        # Concatenate tile datasets along the 'tile' dimension
+        combined_data = concat([tile.data for tile in tiles], dim="tile")
+
+        # Construct metadata dictionary keyed by exposure number
+        meta_dict = {tile.meta.exp_num: tile.meta for tile in tiles}
+
+        return cls(data=combined_data, meta=meta_dict)
+
+    def __repr__(self) -> str:
+        prefix = f"LVMTileCollection ({hex(id(self))}):"
+        prefix += f"\n    Tiles:            {len(self.meta)}"
+        prefix += f"\n    Exposures:        {set(meta.exp_num for meta in self.meta.values())}"
+        prefix += f"\n    DRP versions:     {set(meta.drp_ver for meta in self.meta.values())}"
+        prefix += f"\n    Tile IDs:         {set(meta.tile_id for meta in self.meta.values())}"
+        return f"{prefix}\n{summarize_with_units(self.data)}"
+
+
+LVMTileLike = LVMTile | LVMTileCollection

lvm_tools/fit_data/__init__.py

@@ -0,0 +1 @@
+"""fit_data - subpackage for filtering and otherwise preparing LVM data before fitting."""

lvm_tools/fit_data/builder.py

@@ -0,0 +1,51 @@
+"""builder.py - FitDataBuilder class for constructing FitData with reproducibility."""
+
+import json
+from dataclasses import asdict, dataclass
+from hashlib import sha256
+
+from lvm_tools.config.data_config import DataConfig
+from lvm_tools.data.tile import LVMTile, LVMTileLike
+from lvm_tools.fit_data.fit_data import FitData
+from lvm_tools.fit_data.processing import (
+    flatten_tile_coord,
+    get_normalisation_functions,
+    process_tile_data,
+)
+
+
+@dataclass(frozen=True)
+class FitDataBuilder:
+    tiles: LVMTileLike
+    config: DataConfig
+
+    def build(self) -> FitData:
+        return FitData(
+            flatten_tile_coord(process_tile_data(self.tiles, self.config)),
+            *get_normalisation_functions(self.config),
+        )
+
+    def hash(self) -> str:
+        data = {
+            "config": json.dumps(self._configdict, sort_keys=True),
+            "tiles": json.dumps(self._metadict, sort_keys=True),
+        }
+        serialised = json.dumps(data, sort_keys=True)
+        return sha256(serialised.encode()).hexdigest()
+
+    @property
+    def _configdict(self) -> dict:
+        return self.config.to_dict()
+
+    @property
+    def _metadict(self) -> dict:
+        # Ensure meta is always a dict of LVMTileMeta
+        if isinstance(self.tiles, LVMTile):
+            meta = {self.tiles.meta.exp_num: self.tiles.meta.copy()}
+        else:
+            meta = self.tiles.meta.copy()
+
+        for key, value in meta.items():
+            meta[key] = asdict(value)
+
+        return meta

lvm_tools/fit_data/clipping.py

@@ -0,0 +1,37 @@
+"""clipping.py - data clipping for data preparation."""
+
+from xarray import DataArray, Dataset
+
+
+def bounding_square(
+    x_min: float,
+    x_max: float,
+    y_min: float,
+    y_max: float,
+) -> tuple[tuple[float, float], tuple[float, float]]:
+    t_range = 1.01 * max(x_max - x_min, y_max - y_min)
+    x_mid = (x_min + x_max) / 2
+    y_mid = (y_min + y_max) / 2
+    x_min_ = x_mid - t_range / 2
+    x_max_ = x_mid + t_range / 2
+    y_min_ = y_mid - t_range / 2
+    y_max_ = y_mid + t_range / 2
+    return (x_min_, x_max_), (y_min_, y_max_)
+
+
+def slice_mask(arr: DataArray, x_min: float, x_max: float) -> DataArray:
+    return (arr >= x_min) & (arr <= x_max)
+
+
+def clip_dataset(
+    data: Dataset,
+    λ_range: tuple[float, float],
+    α_range: tuple[float, float],
+    δ_range: tuple[float, float],
+) -> Dataset:
+    # Clip to wavelength range (simple since wavelength is an indexed coordinate)
+    data = data.sel(wavelength=slice(*λ_range))
+    # Clip to ra, dec range. Less simple since spaxel is the indexed coordinate
+    α_slice = slice_mask(data["ra"], *α_range)
+    δ_slice = slice_mask(data["dec"], *δ_range)
+    return data.where(α_slice & δ_slice, drop=True)

lvm_tools/fit_data/filtering.py

@@ -0,0 +1,129 @@
+"""filtering.py - data filtering for data preparation."""
+
+import warnings
+from typing import Literal
+
+import numpy as np
+from xarray import DataArray, Dataset
+
+BAD_FLUX_THRESHOLD = -0.1e-13
+
+
+ExcludeStrategy = Literal[None, "pixel", "spaxel"]
+FibreStatus = Literal[0, 1, 2, 3]  # I have no idea what these mean, but they're in the data
+
+
+def get_where_nan(arr: DataArray) -> DataArray:
+    return arr.isnull()
+
+
+def get_where_bad(arr: DataArray, bad_range: tuple[float, float]) -> DataArray:
+    return ~(arr > bad_range[0]) & (arr < bad_range[1])
+
+
+def get_where_bad_median(arr: DataArray, bad_range: tuple[float, float]) -> DataArray:
+    where_bad_median_l = arr.median(dim="wavelength") < bad_range[0]
+    where_bad_median_u = arr.median(dim="wavelength") > bad_range[1]
+    all_nan = arr.isnull().all(dim="wavelength")
+    return where_bad_median_l | where_bad_median_u | all_nan
+
+
+def get_where_badfib(fib_stat_arr: DataArray, fibre_status_incl: tuple[FibreStatus]) -> DataArray:
+    return ~fib_stat_arr.isin(fibre_status_incl)
+
+
+def get_where_mask(arr_mask: DataArray) -> DataArray:
+    return arr_mask == 1
+
+
+def combine_wheres(list_where: list[DataArray]) -> DataArray:
+    combined_where = list_where[0]
+    for where in list_where[1:]:
+        combined_where = combined_where | where
+    return combined_where
+
+
+def filter_dataset(
+    data: Dataset,
+    nans_strategy: ExcludeStrategy,
+    F_bad_strategy: ExcludeStrategy,
+    F_bad_range: tuple[float, float],
+    fibre_status_include: tuple[FibreStatus],
+    apply_mask: bool,
+) -> Dataset:
+    where_bad = []
+
+    # Nans
+    if nans_strategy == "pixel":
+        pass  # no action needed
+    elif nans_strategy == "spaxel":
+        where_bad.append(get_where_nan(data["flux"]).any(dim="wavelength"))
+    else:
+        raise ValueError(f"Unknown nans strategy: {nans_strategy}")
+
+    # Fluxes
+    if F_bad_strategy == "pixel":
+        where_bad.append(get_where_bad(data["flux"], F_bad_range))
+    elif F_bad_strategy == "spaxel":
+        where_bad.append(get_where_bad_median(data["flux"], F_bad_range))
+    else:
+        raise ValueError(f"Unknown bad flux strategy: {F_bad_strategy}")
+
+    # Bad fibres
+    where_bad.append(get_where_badfib(data["fibre_status"], fibre_status_include))
+
+    # Filter using mask
+    if apply_mask:
+        where_bad.append(get_where_mask(data["mask"]))
+
+    return data.where(~combine_wheres(where_bad))
+
+
+def filter_inspector(
+    data: Dataset,
+    F_bad_range: tuple[float, float],
+    fibre_status_include: tuple[FibreStatus],
+):
+    # TODO: maybe plots instead of printing?
+
+    # ignore warnings about median of all nans
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=RuntimeWarning)
+
+        # nans:
+        where_nan = get_where_nan(data["flux"])
+        n_nans = int(np.sum(where_nan))
+        n_spaxels_nan = int(np.sum(where_nan.any(dim="wavelength")))
+
+        # bad flux (per pix):
+        where_Fbad = get_where_bad(data["flux"], F_bad_range)
+        n_Fbad = int(np.sum(where_Fbad))
+
+        # bad flux (per spaxel):
+        where_Fbad_median = get_where_bad_median(data["flux"], F_bad_range)
+        n_Fbad_median = int(np.sum(where_Fbad_median))
+
+        # fibre status:
+        where_badfib = get_where_badfib(data["fibre_status"], fibre_status_include)
+        n_spaxels_badfib = int(np.sum(where_badfib))
+
+        # mask:
+        where_mask = get_where_mask(data["mask"])
+        n_mask = int(np.sum(where_mask))
+        n_spaxels_mask = int(np.sum(where_mask.any(dim="wavelength")))
+
+        # anything is bad
+        where_anybad = where_nan | where_Fbad | where_badfib | where_mask
+        n_anybad = int(np.sum(where_anybad))
+
+        where_anybad_spaxel = where_nan | where_Fbad_median | where_badfib | where_mask
+        n_spaxels_anybad = int(np.sum(where_anybad_spaxel.any(dim="wavelength")))
+
+    return {
+        "nans": (n_nans, n_spaxels_nan),
+        "bad flux": (n_Fbad, None),
+        "bad flux median": (None, n_Fbad_median),
+        "fibre status": (None, n_spaxels_badfib),
+        "mask": (n_mask, n_spaxels_mask),
+        "any bad": (n_anybad, n_spaxels_anybad),
+    }

lvm_tools/fit_data/fit_data.py

@@ -0,0 +1,140 @@
+"""fit_data.py - FitData class for holding data ready to be fitted."""
+
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass
+from typing import Callable
+
+import jax.numpy as jnp
+import numpy as np
+from jax.numpy import pi as π
+from jaxtyping import Array as JaxArray
+from modelling_lib.model.data import SpatialDataLVM
+from xarray import DataArray, Dataset
+
+from lvm_tools.physical_properties.barycentric_corr import get_v_barycentric
+
+
+def to_π_domain(x):
+    # return x * 2 * π - π
+    return x * 2 * np.pi - np.pi
+
+
+def from_π_domain(x):
+    return (x + π) / (2 * π)
+
+
+def to_jax_array(arr: DataArray, dtype=np.float64) -> JaxArray:
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=UserWarning)
+        return jnp.array(arr, dtype=dtype)
+
+
+@dataclass(frozen=True)
+class FitData:
+    processed_data: Dataset
+    normalise_flux: Callable
+    predict_flux: Callable
+    normalise_ivar: Callable
+    predict_ivar: Callable
+    normalise_α: Callable
+    _predict_α: Callable
+    normalise_δ: Callable
+    _predict_δ: Callable
+
+    @property
+    def _flux(self) -> JaxArray:
+        return self.normalise_flux(to_jax_array(self.processed_data["flux"].values))
+
+    @property
+    def flux(self) -> JaxArray:
+        return jnp.nan_to_num(self._flux)
+
+    @property
+    def _i_var(self) -> JaxArray:
+        return self.normalise_ivar(to_jax_array(self.processed_data["i_var"].values))
+
+    @property
+    def i_var(self) -> JaxArray:
+        return jnp.nan_to_num(self._i_var, nan=1e-4)
+
+    @property
+    def _u_flux(self) -> JaxArray:
+        return self._i_var**-0.5
+
+    @property
+    def u_flux(self) -> JaxArray:
+        return jnp.nan_to_num(self._u_flux, nan=1e2)
+
+    @property
+    def α(self) -> JaxArray:
+        return to_π_domain(self.normalise_α(to_jax_array(self.processed_data["ra"].values)))
+
+    @property
+    def δ(self) -> JaxArray:
+        return to_π_domain(self.normalise_δ(to_jax_array(self.processed_data["dec"].values)))
+
+    def predict_α(self, x: JaxArray) -> JaxArray:
+        return self._predict_α(from_π_domain(x))
+
+    def predict_δ(self, x: JaxArray) -> JaxArray:
+        return self._predict_δ(from_π_domain(x))
+
+    @property
+    def αδ_data(self) -> SpatialDataLVM:
+        return SpatialDataLVM(self.α, self.δ, self.spaxel_idx, self.tile_idx, self.ifu_idx)
+
+    @property
+    def λ(self) -> JaxArray:
+        return to_jax_array(self.processed_data["wavelength"].values)
+
+    @property
+    def _lsf_σ(self) -> JaxArray:
+        return to_jax_array(self.processed_data["lsf_sigma"].values)
+
+    @property
+    def lsf_σ(self) -> JaxArray:
+        median_lsf_σ = jnp.nanmedian(self._lsf_σ)
+        return jnp.nan_to_num(self._lsf_σ, nan=median_lsf_σ)
+
+    @property
+    def mjd(self) -> JaxArray:
+        return to_jax_array(self.processed_data["mjd"].values)
+
+    @property
+    def mask(self) -> JaxArray:
+        return ~jnp.isnan(self._flux)
+
+    @property
+    def λ_idx(self) -> JaxArray:
+        return jnp.arange(len(self.λ), dtype=np.int64)
+
+    @property
+    def spaxel_idx(self) -> JaxArray:
+        return jnp.arange(len(self.α), dtype=np.int64)
+
+    @property
+    def tile_idx(self) -> JaxArray:
+        tile = to_jax_array(self.processed_data["tile"].values, dtype=np.int64)
+        return jnp.unique(tile, return_inverse=True)[1]
+
+    @property
+    def ifu_idx(self) -> JaxArray:
+        ifu = self.processed_data["ifu_label"].values
+        return to_jax_array(np.unique(ifu, return_inverse=True)[1], dtype=np.int64)
+
+    @property
+    def v_bary(self) -> JaxArray:
+        return to_jax_array(
+            get_v_barycentric(
+                mjd=self.mjd,
+                α=self.predict_α(self.α),
+                δ=self.predict_δ(self.δ),
+                unit="km/s",
+            )
+        )
+
+    def __repr__(self):
+        # TODO: add something here
+        raise NotImplementedError

lvm_tools/fit_data/normalisation.py

@@ -0,0 +1,48 @@
+"""normalisation.py - data normalisation for data preparation."""
+
+from functools import partial
+from typing import Callable, Literal
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+NORM_PADDING = 0.01
+
+
+NormaliseStrategy = Literal[None, "max only", "98 only", "extrema", "1σ", "2σ", "3σ", "padded"]
+
+
+def calc_normalisation(data: ArrayLike, strategy: NormaliseStrategy) -> tuple[float, float]:
+    offset = 0.0
+    scale = 1.0
+    if strategy is None:
+        pass
+    elif strategy == "max only":
+        scale = np.nanmax(data)
+    elif strategy == "98 only":
+        scale = np.nanpercentile(data, 98)
+    elif strategy == "extrema":
+        offset = np.nanmin(data)
+        scale = np.nanmax(data) - offset
+    elif strategy in ("1σ", "2σ", "3σ"):
+        offset = np.nanmean(data)
+        scale = 2.0 * int(strategy[0]) * np.nanstd(data)
+    elif strategy == "padded":
+        data_range = np.nanmax(data) - np.nanmin(data)
+        offset = np.nanmin(data) - NORM_PADDING * data_range
+        scale = (1 + 2 * NORM_PADDING) * data_range
+    else:
+        raise ValueError(f"Unknown normalisation strategy: {strategy}")
+    return float(offset), float(scale)
+
+
+def normalise(data: ArrayLike, offset: float, scale: float) -> ArrayLike:
+    return (data - offset) / scale
+
+
+def denormalise(data: ArrayLike, offset: float, scale: float) -> ArrayLike:
+    return data * scale + offset
+
+
+def get_norm_funcs(offset: float, scale: float) -> Callable:
+    return (partial(f, offset=offset, scale=scale) for f in (normalise, denormalise))

lvm_tools/fit_data/processing.py

@@ -0,0 +1,79 @@
+"""processing.py - convenience wrappers for filtering and clipping given LVMTileLike and DataConfig."""
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING, Callable
+
+from xarray import Dataset
+
+if TYPE_CHECKING:
+    from lvm_tools.config.data_config import DataConfig
+from lvm_tools.data.tile import LVMTileLike
+from lvm_tools.fit_data.clipping import bounding_square, clip_dataset
+from lvm_tools.fit_data.filtering import filter_dataset
+from lvm_tools.fit_data.normalisation import calc_normalisation, get_norm_funcs
+
+
+def clip_data(tile_data: Dataset, config: DataConfig) -> Dataset:
+    return clip_dataset(
+        tile_data,
+        config.λ_range,
+        config.α_range,
+        config.δ_range,
+    )
+
+
+def filter_tile_data(tile_data: Dataset, config: DataConfig) -> Dataset:
+    return filter_dataset(
+        tile_data,
+        config.nans_strategy,
+        config.F_bad_strategy,
+        config.F_range,
+        config.fibre_status_include,
+        config.apply_mask,
+    )
+
+
+def process_tile_data(tiles: LVMTileLike, config: DataConfig) -> Dataset:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=RuntimeWarning)
+        ds = clip_data(tiles.data, config)
+        return filter_tile_data(ds, config)
+
+
+def get_αδ_ranges(tiles: LVMTileLike) -> tuple[tuple[float, float], tuple[float, float]]:
+    return bounding_square(
+        tiles.data["ra"].values.min(),
+        tiles.data["ra"].values.max(),
+        tiles.data["dec"].values.min(),
+        tiles.data["dec"].values.max(),
+    )
+
+
+def get_normalisations(
+    ds: Dataset, config: DataConfig
+) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=RuntimeWarning)
+        return (
+            calc_normalisation(ds["flux"].values, config.normalise_F_strategy),
+            calc_normalisation(ds["ra"].values, config.normalise_αδ_strategy),
+            calc_normalisation(ds["dec"].values, config.normalise_αδ_strategy),
+        )
+
+
+def get_normalisation_functions(
+    config: DataConfig,
+) -> tuple[tuple[Callable, Callable], tuple[Callable, Callable], tuple[Callable, Callable]]:
+    return (
+        *get_norm_funcs(config.normalise_F_offset, config.normalise_F_scale),
+        *get_norm_funcs(0.0, config.normalise_F_scale**-2),
+        *get_norm_funcs(config.normalise_α_offset, config.normalise_α_scale),
+        *get_norm_funcs(config.normalise_δ_offset, config.normalise_δ_scale),
+    )
+
+
+def flatten_tile_coord(ds: Dataset) -> Dataset:
+    """Flatten the tile and spaxel coordinates into a single coordinate."""
+    return ds.stack(flat_spaxel=("tile", "spaxel")).reset_index("flat_spaxel")

lvm_tools/physical_properties/__init__.py

@@ -0,0 +1 @@
+"""physical_properties - subpackage for calculating physical properties like velocities from either LVM data or models."""

lvm_tools/physical_properties/barycentric_corr.py

@@ -0,0 +1,11 @@
+from astropy.coordinates import EarthLocation, SkyCoord
+from astropy.time import Time
+from numpy.typing import ArrayLike, NDArray
+
+
+# def get_v_barycentric(fit_data: FitData, unit="km/s") -> NDArray:
+def get_v_barycentric(mjd: ArrayLike, α: ArrayLike, δ: ArrayLike, unit="km/s") -> NDArray:
+    times = Time(mjd, format="mjd")
+    coords = SkyCoord(ra=α, dec=δ, obstime=times, unit="deg", frame="icrs")
+    location = EarthLocation.of_site("Las Campanas Observatory")
+    return coords.radial_velocity_correction("barycentric", location=location).to_value(unit)

lvm_tools/utils/__init__.py

@@ -0,0 +1 @@
+"""utils - Dump for stuff that I need for plots/data manipulation like masking near points etc.."""

lvm_tools/utils/mask.py

@@ -0,0 +1,40 @@
+import numpy as np
+from scipy.spatial import cKDTree
+
+
+def mask_near_points(xgrid, ygrid, xpoints, ypoints, threshold=None):
+    """
+    Generate a boolean mask for a 2D grid, where True means the grid cell is close to at least one (xpoint, ypoint).
+
+    Parameters
+    ----------
+    xgrid : 1D array
+        Grid coordinates along the x-axis (must be monotonically increasing).
+    ygrid : 1D array
+        Grid coordinates along the y-axis (must be monotonically increasing).
+    xpoints : 1D array
+        X-coordinates of the data points.
+    ypoints : 1D array
+        Y-coordinates of the data points.
+    threshold : float, optional
+        Maximum distance from a grid cell center to be considered "near" a data point.
+        If None, uses 1.5 × max(mean grid spacing in x and y).
+
+    Returns
+    -------
+    mask : 2D boolean array
+        Mask array with shape (len(ygrid), len(xgrid)), where True means "keep" (near a point).
+    """
+    xx, yy = np.meshgrid(xgrid, ygrid, indexing="xy")
+    grid_centers = np.column_stack([xx.ravel(), yy.ravel()])
+
+    tree = cKDTree(np.column_stack([xpoints, ypoints]))
+    dists, _ = tree.query(grid_centers, k=1)
+
+    if threshold is None:
+        dx = np.mean(np.diff(xgrid))
+        dy = np.mean(np.diff(ygrid))
+        threshold = 1.5 * max(dx, dy)
+
+    mask = (dists < threshold).reshape(xx.shape)
+    return mask

lvm_tools-0.0.2.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: lvm_tools
+Version: 0.0.2
+Summary: Lazily read/encapsulate LVM DRP data in a modular way
+Author-email: Tom Hilder <Thomas.Hilder@monash.edu>
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: astropy>=7.1.0
+Requires-Dist: dask>=2025.7.0
+Requires-Dist: numpy>=2.3.2
+Requires-Dist: scipy>=1.16.1
+Requires-Dist: xarray>=2025.7.1
+Description-Content-Type: text/markdown
+
+# lvm_tools
+
+Lightweight wrapper of [LVM DRP](https://github.com/sdss/lvmdrp) data with an emphasis on modularity. Allows for lazy reading via [`dask`](https://www.dask.org), especially useful for fitting large models. Designed for use with spectrospatial models via [`spectracles`](https://github.com/TomHilder/spectracles) but probably useful for other things too.
+
+Feel free to contact me personally if you have any questions at all.
+
+## Installation
+
+TODO
+
+## Usage
+
+TODO
+
+## Citation
+
+TODO
+
+## Help
+
+TODO
+
+## TODO
+
+- [ ] repr for FitData
+- [ ] Logging/hashing
+- [ ] Cache
+- [ ] OptConfig

lvm_tools-0.0.2.dist-info/RECORD

@@ -0,0 +1,25 @@
+lvm_tools/__init__.py,sha256=iiZnberiJmfIQLJYFPi9fAVmJ5JSYNFQ0LSgxKkQQQU,260
+lvm_tools/_version.py,sha256=wO7XWlZte1hxA4mMvRc6zhNdGm74Nhhn2bfWRAxaKbI,511
+lvm_tools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lvm_tools/config/__init__.py,sha256=KsDaLtZeYt9I867wbB068Li8YSXu1wHH-hcsQw20zYQ,85
+lvm_tools/config/data_config.py,sha256=QJ1Vu2c_YPp9qQ7qF13ohXT3NS5dxh2VgLCblZvXdfk,8648
+lvm_tools/config/validation.py,sha256=PKf4JprRHiLzmtJtzrpj57ccR8g3wU6zAHgCwvmh2Tg,2076
+lvm_tools/data/__init__.py,sha256=m6SJxMoR7PlvHdvL0Ly21xtw0IUl3dpTDDnIsUuZoiQ,64
+lvm_tools/data/coordinates.py,sha256=Rtc3YvNr68aE9xTYOynekY5NhKMm2r-dNNC7OrOWVoo,2778
+lvm_tools/data/helper.py,sha256=EA4U13nvzX8b2ZnK9FzOkOz14nEUKM06-y2TykEip40,2063
+lvm_tools/data/tile.py,sha256=5IvXb2JRANE0LSvmr35mevAT7EFtz2uOYOaL-j0SLXA,6646
+lvm_tools/fit_data/__init__.py,sha256=EJ08IcqxOLaC5tnT5B1TbOhBBn1VmHMQfpXIzSYzmpI,91
+lvm_tools/fit_data/builder.py,sha256=B3j_UjwoxsvU-VMCXnIn0o4_3GVeN1KW04BbgUeNH0w,1496
+lvm_tools/fit_data/clipping.py,sha256=M1yltDQ7OOiZiyihAgyYKzFww9d9CqjfM20Fbv7CYPM,1181
+lvm_tools/fit_data/filtering.py,sha256=5ODMcrx6HO20DgeVfAaY1Zl8UOqWhjy_wA2nlwND34Y,4147
+lvm_tools/fit_data/fit_data.py,sha256=yldItAVzgL4S1E2kmv-kJKRPfv3qsf-zs8_lCFwk-0c,3945
+lvm_tools/fit_data/normalisation.py,sha256=fJxpBhxb5bsmttoN1SIyQRT_WB0pKFzmoLOPSxDbJX4,1549
+lvm_tools/fit_data/processing.py,sha256=BEJCtV1-_Wm0rhe2BxS-6_GfggT-6Q15BDeR9NGmJ0o,2754
+lvm_tools/physical_properties/__init__.py,sha256=3la3E4O5z0dmp5cHPuuhBVOhrncNnxUnjzFLibwhx5k,123
+lvm_tools/physical_properties/barycentric_corr.py,sha256=9FFN_eufKpv7nL2cV0vErDHbf0QKMNtldwBUwoYr81U,566
+lvm_tools/utils/__init__.py,sha256=0t3biRCVmk6mpj5aRk8mYdxilxbBNos0Qluw3zRccd8,100
+lvm_tools/utils/mask.py,sha256=vS4Kz0S6o9tKOt-h0X2Wpjj3gqkAJpiXqiz-l9z12Vc,1371
+lvm_tools-0.0.2.dist-info/METADATA,sha256=l6dxghjDftxgjAWrpi0S78YuJeEAUzLB-c79LhsGQ1k,997
+lvm_tools-0.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lvm_tools-0.0.2.dist-info/licenses/LICENSE,sha256=sYg7u4aQzHWXxn0DBeMqndugw8BXcbUEZvIVKEq_PCE,1070
+lvm_tools-0.0.2.dist-info/RECORD,,

lvm_tools-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

lvm_tools-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Thomas Hilder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.