specmangle 0.1.0b1__py3-none-any.whl

specmangle/__init__.py

@@ -0,0 +1,22 @@
+"""Photometry-constrained mangling of astronomical spectra."""
+
+from .bandpasses import Bandpass
+from .mangling import MangleResult, mangle
+from .photometry import (
+    InsufficientCoverageError,
+    SyntheticPhotometry,
+    spectrum_to_magnitude,
+    synthetic_ab_magnitude,
+)
+
+__version__ = "0.1.0b1"
+
+__all__ = [
+    "Bandpass",
+    "InsufficientCoverageError",
+    "MangleResult",
+    "SyntheticPhotometry",
+    "mangle",
+    "spectrum_to_magnitude",
+    "synthetic_ab_magnitude",
+]

specmangle/bandpasses.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+import astropy.units as u
+import numpy as np
+from scipy.integrate import trapezoid
+
+
+DetectorType = Literal["photon", "energy"]
+
+
+@dataclass(frozen=True)
+class Bandpass:
+    """A bandpass response curve."""
+
+    filter_id: str
+    wavelength: u.Quantity
+    transmission: np.ndarray
+    detector_type: DetectorType
+    components: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        transmission = np.asarray(self.transmission, dtype=float)
+        object.__setattr__(self, "transmission", transmission)
+
+        if not self.filter_id:
+            raise ValueError("filter_id must not be empty")
+        if self.wavelength.ndim != 1 or transmission.ndim != 1:
+            raise ValueError("bandpass wavelength and transmission must be one-dimensional")
+        if len(self.wavelength) != len(transmission):
+            raise ValueError("bandpass wavelength and transmission must have the same length")
+        if len(self.wavelength) < 2:
+            raise ValueError("a bandpass must contain at least two samples")
+        if not self.wavelength.unit.is_equivalent(u.AA):
+            raise u.UnitConversionError("bandpass wavelength must have units of length")
+        if self.detector_type not in ("photon", "energy"):
+            raise ValueError("detector_type must be either \"photon\" or \"energy\"")
+        if not np.all(np.isfinite(transmission)):
+            raise ValueError("bandpass transmission must be finite")
+        if np.any(transmission < 0.0):
+            raise ValueError("bandpass transmission must not be negative")
+        if not np.any(transmission > 0.0):
+            raise ValueError("bandpass transmission must contain a positive value")
+
+        wavelength = self.wavelength.to_value(u.AA)
+        if not np.all(np.isfinite(wavelength)) or np.any(wavelength <= 0.0):
+            raise ValueError("bandpass wavelengths must be positive and finite")
+        if np.any(np.diff(wavelength) <= 0.0):
+            raise ValueError("bandpass wavelengths must be strictly increasing")
+
+    @classmethod
+    def from_svo(
+        cls,
+        filter_id: str,
+        *,
+        detector_type: DetectorType | None = None,
+    ) -> Bandpass:
+        """
+        Retrieve a bandpass from the SVO Filter Profile Service.
+
+        Astroquery's own query caching is used; specmangle does not implement
+        an additional cache.
+        """
+        from astroquery.svo_fps import SvoFps
+
+        table = SvoFps.get_transmission_data(filter_id)
+        wavelength = u.Quantity(table["Wavelength"])
+        transmission = np.asarray(table["Transmission"], dtype=float)
+
+        metadata = SvoFps.get_filter_metadata(filter_id)
+        components = _parse_svo_components(metadata.get("components"))
+        if detector_type is None:
+            detector_type = _normalize_svo_detector_type(metadata["DetectorType"])
+
+        order = np.argsort(wavelength.to_value(u.AA))
+        return cls(
+            filter_id=filter_id,
+            wavelength=wavelength[order],
+            transmission=transmission[order],
+            detector_type=detector_type,
+            components=components,
+        )
+
+    @property
+    def includes_atmosphere(self) -> bool:
+        """Whether the response includes an atmospheric component."""
+        return any("atmospher" in component.casefold() for component in self.components)
+
+    def with_atmosphere(
+        self,
+        wavelength: u.Quantity,
+        transmission: np.ndarray,
+    ) -> Bandpass:
+        """Return a copy of the bandpass including atmospheric transmission.
+
+        The output grid is the union of the bandpass and atmospheric wavelength
+        samples so that structure in either response curve is retained.
+        """
+        if self.includes_atmosphere:
+            raise ValueError(f"bandpass {self.filter_id} already includes atmosphere")
+
+        atmosphere_wavelength = u.Quantity(wavelength)
+        atmosphere_transmission = np.asarray(transmission, dtype=float)
+
+        if atmosphere_wavelength.ndim != 1 or atmosphere_transmission.ndim != 1:
+            raise ValueError(
+                "atmospheric wavelength and transmission must be one-dimensional"
+            )
+        if len(atmosphere_wavelength) != len(atmosphere_transmission):
+            raise ValueError(
+                "atmospheric wavelength and transmission must have the same length"
+            )
+        if len(atmosphere_wavelength) < 2:
+            raise ValueError("atmospheric transmission must contain at least two samples")
+        if not atmosphere_wavelength.unit.is_equivalent(u.AA):
+            raise u.UnitConversionError("atmospheric wavelength must have units of length")
+        if not np.all(np.isfinite(atmosphere_transmission)):
+            raise ValueError("atmospheric transmission must be finite")
+        if np.any(atmosphere_transmission < 0.0):
+            raise ValueError("atmospheric transmission must not be negative")
+
+        unit = self.wavelength.unit
+        band_wavelength = self.wavelength.to_value(unit)
+        atmosphere_wavelength_value = atmosphere_wavelength.to_value(unit)
+        if (
+            not np.all(np.isfinite(atmosphere_wavelength_value))
+            or np.any(atmosphere_wavelength_value <= 0.0)
+        ):
+            raise ValueError("atmospheric wavelengths must be positive and finite")
+        if np.any(np.diff(atmosphere_wavelength_value) <= 0.0):
+            raise ValueError("atmospheric wavelengths must be strictly increasing")
+
+        positive = np.flatnonzero(self.transmission > 0.0)
+        lower_index = max(positive[0] - 1, 0)
+        upper_index = min(positive[-1] + 1, len(band_wavelength) - 1)
+        if (
+            atmosphere_wavelength_value[0] > band_wavelength[lower_index]
+            or atmosphere_wavelength_value[-1] < band_wavelength[upper_index]
+        ):
+            raise ValueError(
+                "atmospheric transmission must cover the nonzero bandpass response"
+            )
+
+        atmosphere_samples = atmosphere_wavelength_value[
+            (atmosphere_wavelength_value >= band_wavelength[0])
+            & (atmosphere_wavelength_value <= band_wavelength[-1])
+        ]
+        combined_wavelength = np.unique(
+            np.concatenate((band_wavelength, atmosphere_samples))
+        )
+        combined_transmission = np.interp(
+            combined_wavelength,
+            band_wavelength,
+            self.transmission,
+        ) * np.interp(
+            combined_wavelength,
+            atmosphere_wavelength_value,
+            atmosphere_transmission,
+        )
+
+        return Bandpass(
+            filter_id=self.filter_id,
+            wavelength=combined_wavelength * unit,
+            transmission=combined_transmission,
+            detector_type=self.detector_type,
+            components=(*self.components, "Atmosphere"),
+        )
+
+    @property
+    def pivot_wavelength(self) -> u.Quantity:
+        """Return the pivot wavelength of the response curve."""
+        wavelength = self.wavelength.to_value(u.AA)
+
+        if self.detector_type == "photon":
+            numerator = trapezoid(self.transmission * wavelength, wavelength)
+            denominator = trapezoid(self.transmission / wavelength, wavelength)
+        else:
+            numerator = trapezoid(self.transmission, wavelength)
+            denominator = trapezoid(self.transmission / wavelength**2, wavelength)
+
+        return np.sqrt(numerator / denominator) * u.AA
+
+
+def _parse_svo_components(value: object | None) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    return tuple(
+        component.strip()
+        for component in str(value).split("+")
+        if component.strip()
+    )
+
+
+def _normalize_svo_detector_type(value: object) -> DetectorType:
+    text = str(value).strip().lower()
+    if text in ("photon", "photon counter", "photon-counter"):
+        return "photon"
+    if text in ("energy", "energy counter", "energy-counter"):
+        return "energy"
+
+    try:
+        numeric = int(value)
+    except (TypeError, ValueError):
+        numeric = None
+
+    # IVOA Photometry Data Model convention: 0 = energy counter, 1 = photon counter.
+    if numeric == 0:
+        return "energy"
+    if numeric == 1:
+        return "photon"
+
+    raise ValueError(f"unrecognized SVO DetectorType value: {value!r}")

specmangle/mangling.py

@@ -0,0 +1,459 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Mapping
+
+import astropy.units as u
+from astropy.nddata import InverseVariance, StdDevUncertainty, VarianceUncertainty
+from astropy.table import Table
+import numpy as np
+from scipy.interpolate import CubicSpline
+from scipy.optimize import OptimizeResult, least_squares
+from specutils import Spectrum
+
+from .bandpasses import Bandpass
+from .photometry import (
+    SyntheticPhotometry,
+    InsufficientCoverageError,
+    synthetic_ab_magnitude,
+)
+
+
+@dataclass(frozen=True)
+class MangleResult:
+    """Result of a photometry-constrained spectral mangling fit."""
+
+    spectrum: Spectrum
+    correction: np.ndarray
+    correction_uncertainty: np.ndarray | None
+    anchor_wavelengths: u.Quantity
+    log_correction_parameters: np.ndarray
+    parameter_covariance: np.ndarray | None
+    photometry: Table
+    bandpasses: dict[str, Bandpass]
+    optimizer: OptimizeResult
+
+    def correction_at(self, wavelength: u.Quantity) -> float | np.ndarray:
+        """Evaluate the fitted multiplicative correction at arbitrary wavelengths."""
+        try:
+            wavelength_values = np.asarray(wavelength.to_value(u.AA), dtype=float)
+        except AttributeError as exc:
+            raise TypeError("wavelength must be an Astropy Quantity") from exc
+
+        if (
+            np.any(~np.isfinite(wavelength_values))
+            or np.any(wavelength_values <= 0.0)
+        ):
+            raise ValueError("wavelength must be positive and finite")
+
+        scalar = wavelength_values.ndim == 0
+        values = np.atleast_1d(wavelength_values)
+        correction = np.exp(
+            _evaluate_log_correction(
+                values,
+                self.anchor_wavelengths.to_value(u.AA),
+                self.log_correction_parameters,
+            )
+        )
+        if scalar:
+            return float(correction[0])
+        return correction
+
+
+@dataclass(frozen=True)
+class _PhotometryRow:
+    band: str
+    mag: float
+    mag_err: float | None
+
+
+def mangle(
+    spectrum: Spectrum,
+    photometry: Table,
+    *,
+    bandpasses: Mapping[str, Bandpass] | None = None,
+    min_coverage: float = 0.98,
+    smoothness: float = 0.0,
+    max_nfev: int | None = None,
+) -> MangleResult:
+    """
+    Mangle a spectrum to match contemporaneous AB photometry.
+
+    ``photometry`` must contain ``band`` and ``mag`` columns and may contain a
+    ``mag_err`` column. Each ``band`` value is interpreted as an SVO filter ID
+    unless a matching :class:`~specmangle.Bandpass` is supplied through
+    ``bandpasses``. All magnitudes are interpreted as AB magnitudes.
+
+    The positive multiplicative correction is represented by a natural cubic
+    spline in log wavelength and log flux scale, with one free anchor per
+    unique passband. Outside the bluest and reddest anchors the correction is
+    held constant. Repeated measurements in a passband are supported.
+
+    Photometric and synthetic-photometry uncertainties, when available, are
+    combined in quadrature when weighting residuals. The uncertainty attached
+    to ``result.spectrum`` contains only the input spectral uncertainty scaled
+    by the best-fit correction. Uncertainty in the mangling function itself is
+    returned separately in ``result.correction_uncertainty`` because it is
+    correlated with wavelength.
+    """
+    rows = _photometry_rows(photometry)
+    if smoothness < 0.0 or not np.isfinite(smoothness):
+        raise ValueError("smoothness must be finite and non-negative")
+    if not 0.0 < min_coverage <= 1.0:
+        raise ValueError("min_coverage must be in the interval (0, 1]")
+    if not isinstance(spectrum, Spectrum):
+        raise TypeError("spectrum must be a specutils.Spectrum")
+    if spectrum.flux.ndim != 1:
+        raise ValueError("only one-dimensional Spectrum objects are supported")
+
+    supplied_bandpasses = {} if bandpasses is None else dict(bandpasses)
+    filter_ids = list(dict.fromkeys(row.band for row in rows))
+
+    loaded_bandpasses: dict[str, Bandpass] = {}
+    for filter_id in filter_ids:
+        if filter_id in supplied_bandpasses:
+            loaded_bandpasses[filter_id] = supplied_bandpasses[filter_id]
+        else:
+            loaded_bandpasses[filter_id] = Bandpass.from_svo(filter_id)
+
+    original_synthetic = {}
+    coverage_by_filter = {}
+    skip_reason_by_filter = {}
+    usable_filter_ids = []
+    for filter_id in filter_ids:
+        try:
+            original_synthetic[filter_id] = synthetic_ab_magnitude(
+                spectrum,
+                loaded_bandpasses[filter_id],
+                min_coverage=min_coverage,
+            )
+        except InsufficientCoverageError as exc:
+            coverage_by_filter[filter_id] = exc.coverage
+            skip_reason_by_filter[filter_id] = str(exc)
+            continue
+        coverage_by_filter[filter_id] = original_synthetic[filter_id].coverage
+        usable_filter_ids.append(filter_id)
+
+    if not usable_filter_ids:
+        reasons = "; ".join(skip_reason_by_filter.values())
+        raise ValueError(
+            "no photometric passbands have sufficient spectral coverage: " + reasons
+        )
+
+    filter_ids = usable_filter_ids
+    rows_for_fit = [row for row in rows if row.band in original_synthetic]
+    loaded_bandpasses = {
+        filter_id: loaded_bandpasses[filter_id] for filter_id in filter_ids
+    }
+
+    anchor_pairs = sorted(
+        (
+            loaded_bandpasses[filter_id].pivot_wavelength.to_value(u.AA),
+            filter_id,
+        )
+        for filter_id in filter_ids
+    )
+    anchor_wavelength_values = np.array([pair[0] for pair in anchor_pairs])
+    ordered_filter_ids = [pair[1] for pair in anchor_pairs]
+
+    if np.any(np.diff(anchor_wavelength_values) <= 0.0):
+        raise ValueError(
+            "two passbands have identical pivot wavelengths; independent mangling "
+            "anchors require distinct pivot wavelengths"
+        )
+
+    parameter_index = {
+        filter_id: index for index, filter_id in enumerate(ordered_filter_ids)
+    }
+
+    initial_parameters = np.zeros(len(ordered_filter_ids), dtype=float)
+    for filter_id in ordered_filter_ids:
+        estimates = []
+        weights = []
+        synthetic = original_synthetic[filter_id]
+        for row in rows_for_fit:
+            if row.band != filter_id:
+                continue
+            estimates.append(0.4 * np.log(10.0) * (synthetic.magnitude - row.mag))
+            sigma = _combined_magnitude_uncertainty(row, synthetic)
+            weights.append(1.0 if sigma is None else 1.0 / sigma**2)
+        initial_parameters[parameter_index[filter_id]] = np.average(
+            estimates,
+            weights=weights,
+        )
+
+    spectrum_wave = spectrum.wavelength.to_value(u.AA)
+    if len(spectrum_wave) != len(spectrum.flux):
+        raise ValueError("spectral axis must specify one coordinate per flux sample")
+    if np.any(~np.isfinite(spectrum_wave)) or np.any(spectrum_wave <= 0.0):
+        raise ValueError("spectrum wavelengths must be positive and finite")
+
+    def residual_function(parameters: np.ndarray) -> np.ndarray:
+        correction = np.exp(
+            _evaluate_log_correction(
+                spectrum_wave,
+                anchor_wavelength_values,
+                parameters,
+            )
+        )
+        corrected_spectrum = _apply_correction(spectrum, correction)
+        synthetic_by_filter = {
+            filter_id: synthetic_ab_magnitude(
+                corrected_spectrum,
+                loaded_bandpasses[filter_id],
+                min_coverage=min_coverage,
+            )
+            for filter_id in filter_ids
+        }
+
+        residuals = []
+        for row in rows_for_fit:
+            synthetic = synthetic_by_filter[row.band]
+            sigma = _combined_magnitude_uncertainty(row, synthetic)
+            scale = 1.0 if sigma is None else sigma
+            residuals.append((synthetic.magnitude - row.mag) / scale)
+
+        if smoothness > 0.0 and len(parameters) >= 3:
+            log_anchor = np.log(anchor_wavelength_values)
+            slopes = np.diff(parameters) / np.diff(log_anchor)
+            residuals.extend(np.sqrt(smoothness) * np.diff(slopes))
+
+        return np.asarray(residuals, dtype=float)
+
+    optimizer = least_squares(
+        residual_function,
+        initial_parameters,
+        max_nfev=max_nfev,
+    )
+    if not optimizer.success:
+        raise RuntimeError(f"spectral mangling fit failed: {optimizer.message}")
+
+    best_log_correction = _evaluate_log_correction(
+        spectrum_wave,
+        anchor_wavelength_values,
+        optimizer.x,
+    )
+    correction = np.exp(best_log_correction)
+    corrected_spectrum = _apply_correction(spectrum, correction)
+
+    final_synthetic_by_filter = {
+        filter_id: synthetic_ab_magnitude(
+            corrected_spectrum,
+            loaded_bandpasses[filter_id],
+            min_coverage=min_coverage,
+        )
+        for filter_id in filter_ids
+    }
+
+    parameter_covariance = _parameter_covariance(optimizer, spectrum, rows_for_fit)
+    correction_uncertainty = None
+    if parameter_covariance is not None:
+        basis = _correction_basis(
+            spectrum_wave,
+            anchor_wavelength_values,
+        )
+        log_variance = np.einsum(
+            "ij,jk,ik->i",
+            basis,
+            parameter_covariance,
+            basis,
+        )
+        correction_uncertainty = correction * np.sqrt(
+            np.clip(log_variance, 0.0, None)
+        )
+
+    diagnostics = photometry.copy(copy_data=True)
+    diagnostics["used"] = [row.band in final_synthetic_by_filter for row in rows]
+    diagnostics["coverage"] = [coverage_by_filter[row.band] for row in rows]
+    diagnostics["skip_reason"] = [
+        skip_reason_by_filter.get(row.band, "") for row in rows
+    ]
+    diagnostics["synthetic_mag"] = [
+        np.nan
+        if row.band not in final_synthetic_by_filter
+        else final_synthetic_by_filter[row.band].magnitude
+        for row in rows
+    ]
+    diagnostics["synthetic_mag_err"] = [
+        np.nan
+        if (
+            row.band not in final_synthetic_by_filter
+            or final_synthetic_by_filter[row.band].uncertainty is None
+        )
+        else final_synthetic_by_filter[row.band].uncertainty
+        for row in rows
+    ]
+    diagnostics["residual"] = diagnostics["synthetic_mag"] - np.array(
+        [row.mag for row in rows]
+    )
+
+    return MangleResult(
+        spectrum=corrected_spectrum,
+        correction=correction,
+        correction_uncertainty=correction_uncertainty,
+        anchor_wavelengths=anchor_wavelength_values * u.AA,
+        log_correction_parameters=np.array(optimizer.x, copy=True),
+        parameter_covariance=parameter_covariance,
+        photometry=diagnostics,
+        bandpasses=loaded_bandpasses,
+        optimizer=optimizer,
+    )
+
+
+def _photometry_rows(photometry: Table) -> list[_PhotometryRow]:
+    if not isinstance(photometry, Table):
+        raise TypeError("photometry must be an astropy.table.Table")
+    if len(photometry) == 0:
+        raise ValueError("at least one photometry measurement is required")
+
+    missing = {"band", "mag"} - set(photometry.colnames)
+    if missing:
+        missing_text = ", ".join(sorted(missing))
+        raise ValueError(f"photometry is missing required column(s): {missing_text}")
+
+    rows = []
+    for index in range(len(photometry)):
+        band_value = photometry["band"][index]
+        if np.ma.is_masked(band_value):
+            raise ValueError(f"photometry band is masked at row {index}")
+        band = str(band_value).strip()
+        if not band:
+            raise ValueError(f"photometry band is empty at row {index}")
+
+        mag_value = photometry["mag"][index]
+        if np.ma.is_masked(mag_value):
+            raise ValueError(f"photometry mag is masked at row {index}")
+        if isinstance(mag_value, u.Quantity):
+            mag_value = mag_value.value
+        mag = float(mag_value)
+        if not np.isfinite(mag):
+            raise ValueError(f"photometry mag must be finite at row {index}")
+
+        mag_err = None
+        if "mag_err" in photometry.colnames:
+            mag_err_value = photometry["mag_err"][index]
+            if not np.ma.is_masked(mag_err_value):
+                if isinstance(mag_err_value, u.Quantity):
+                    mag_err_value = mag_err_value.value
+                mag_err = float(mag_err_value)
+                if not np.isfinite(mag_err) or mag_err <= 0.0:
+                    raise ValueError(
+                        f"photometry mag_err must be positive and finite at row {index}"
+                    )
+
+        rows.append(_PhotometryRow(band=band, mag=mag, mag_err=mag_err))
+
+    return rows
+
+
+def _apply_correction(spectrum: Spectrum, correction: np.ndarray) -> Spectrum:
+    if correction.shape != spectrum.flux.shape:
+        raise ValueError("correction must match the one-dimensional spectrum shape")
+
+    uncertainty = _scale_uncertainty(spectrum.uncertainty, correction)
+    mask = None if spectrum.mask is None else np.array(spectrum.mask, copy=True)
+
+    return Spectrum(
+        spectral_axis=spectrum.spectral_axis,
+        flux=spectrum.flux * correction,
+        uncertainty=uncertainty,
+        mask=mask,
+        meta=deepcopy(spectrum.meta),
+    )
+
+
+def _scale_uncertainty(uncertainty, correction: np.ndarray):
+    if uncertainty is None:
+        return None
+
+    unit = uncertainty.unit
+    if isinstance(uncertainty, StdDevUncertainty):
+        return StdDevUncertainty(uncertainty.array * correction, unit=unit)
+    if isinstance(uncertainty, VarianceUncertainty):
+        return VarianceUncertainty(uncertainty.array * correction**2, unit=unit)
+    if isinstance(uncertainty, InverseVariance):
+        return InverseVariance(uncertainty.array / correction**2, unit=unit)
+
+    raise TypeError(
+        "spectrum uncertainty must be StdDevUncertainty, VarianceUncertainty, "
+        "or InverseVariance"
+    )
+
+
+def _evaluate_log_correction(
+    wavelength_angstrom: np.ndarray,
+    anchor_wavelength_angstrom: np.ndarray,
+    parameters: np.ndarray,
+) -> np.ndarray:
+    if len(parameters) == 1:
+        return np.full_like(wavelength_angstrom, parameters[0], dtype=float)
+
+    log_anchor = np.log(anchor_wavelength_angstrom)
+    log_wavelength = np.log(wavelength_angstrom)
+    spline = CubicSpline(log_anchor, parameters, bc_type="natural")
+    result = spline(np.clip(log_wavelength, log_anchor[0], log_anchor[-1]))
+    result[log_wavelength < log_anchor[0]] = parameters[0]
+    result[log_wavelength > log_anchor[-1]] = parameters[-1]
+    return result
+
+
+def _correction_basis(
+    wavelength_angstrom: np.ndarray,
+    anchor_wavelength_angstrom: np.ndarray,
+) -> np.ndarray:
+    basis = np.empty(
+        (len(wavelength_angstrom), len(anchor_wavelength_angstrom)),
+        dtype=float,
+    )
+    for index in range(len(anchor_wavelength_angstrom)):
+        parameter = np.zeros(len(anchor_wavelength_angstrom), dtype=float)
+        parameter[index] = 1.0
+        basis[:, index] = _evaluate_log_correction(
+            wavelength_angstrom,
+            anchor_wavelength_angstrom,
+            parameter,
+        )
+    return basis
+
+
+def _combined_magnitude_uncertainty(
+    row: _PhotometryRow,
+    synthetic: SyntheticPhotometry,
+) -> float | None:
+    variance = 0.0
+    has_uncertainty = False
+
+    if row.mag_err is not None:
+        variance += row.mag_err**2
+        has_uncertainty = True
+    if synthetic.uncertainty is not None:
+        variance += synthetic.uncertainty**2
+        has_uncertainty = True
+
+    if not has_uncertainty or variance == 0.0:
+        return None
+    return float(np.sqrt(variance))
+
+
+def _parameter_covariance(
+    optimizer: OptimizeResult,
+    spectrum: Spectrum,
+    rows: list[_PhotometryRow],
+) -> np.ndarray | None:
+    has_spectral_uncertainty = (
+        spectrum.uncertainty is not None
+        and np.any(np.asarray(spectrum.uncertainty.array) > 0.0)
+    )
+    has_absolute_uncertainties = all(
+        row.mag_err is not None or has_spectral_uncertainty
+        for row in rows
+    )
+    if not has_absolute_uncertainties:
+        return None
+
+    jacobian = np.asarray(optimizer.jac, dtype=float)
+    information = jacobian.T @ jacobian
+    if np.linalg.matrix_rank(information) < information.shape[0]:
+        return None
+    return np.linalg.inv(information)

specmangle/photometry.py

@@ -0,0 +1,384 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import astropy.units as u
+from astropy.nddata import StdDevUncertainty
+import numpy as np
+from scipy.integrate import trapezoid
+from specutils import Spectrum
+
+from .bandpasses import Bandpass, DetectorType
+
+
+FLAM = u.erg / (u.s * u.cm**2 * u.AA)
+AB_ZERO_FNU = (0. * u.ABmag).to(u.Jy)
+
+
+class InsufficientCoverageError(ValueError):
+    """Raised when a bandpass lacks sufficient coverage for some operation."""
+
+    def __init__(self, message: str, coverage: float) -> None:
+        super().__init__(message)
+        self.coverage = coverage
+
+
+@dataclass(frozen=True)
+class SyntheticPhotometry:
+    """Synthetic AB magnitude and associated diagnostics."""
+
+    magnitude: float
+    uncertainty: float | None
+    coverage: float
+
+
+def spectrum_to_magnitude(
+    spectrum: Spectrum,
+    band: str | Bandpass,
+    *,
+    min_coverage: float = 0.98,
+) -> u.Magnitude | tuple[u.Magnitude, u.Magnitude]:
+    """Compute synthetic AB photometry for a spectrum in an SVO bandpass.
+
+    Parameters
+    ----------
+    spectrum
+        Input spectrum. If it includes an uncertainty, the propagated
+        magnitude uncertainty is returned as well.
+    band
+        SVO FPS filter identifier or an already loaded `Bandpass`.
+    min_coverage
+        Minimum fraction of the bandpass reference signal that must overlap
+        the valid spectrum.
+
+    Returns
+    -------
+    magnitude
+        Synthetic AB magnitude. If the input spectrum has an uncertainty,
+        returns ``(magnitude, magnitude_uncertainty)`` instead.
+    """
+    if isinstance(band, str):
+        bandpass = Bandpass.from_svo(band)
+    elif isinstance(band, Bandpass):
+        bandpass = band
+    else:
+        raise TypeError("band must be an SVO FPS filter ID or Bandpass")
+
+    synthetic = synthetic_ab_magnitude(
+        spectrum,
+        bandpass,
+        min_coverage=min_coverage,
+    )
+    magnitude = synthetic.magnitude * u.ABmag
+    if synthetic.uncertainty is None:
+        return magnitude
+
+    return magnitude, synthetic.uncertainty * u.mag
+
+
+def synthetic_ab_magnitude(
+    spectrum: Spectrum,
+    bandpass: Bandpass,
+    *,
+    min_coverage: float = 0.98,
+) -> SyntheticPhotometry:
+    """
+    Compute synthetic AB photometry for a spectrum through a bandpass.
+
+    The calculation compares the integrated detector signal from the spectrum
+    with that from a zero-magnitude AB reference spectrum. Photon-counting
+    response curves include the expected additional factor of wavelength in
+    the signal integral; energy-counting response curves do not.
+
+    Masked spectral samples are omitted. Spectral uncertainties, if present,
+    are converted to standard deviations and assumed to be independent between
+    input wavelength samples. Wavelength cells around masked samples are
+    excluded from the coverage and signal integrals.
+    """
+    if not 0.0 < min_coverage <= 1.0:
+        raise ValueError("min_coverage must be in the interval (0, 1]")
+
+    wavelength, flux, uncertainty, masked_intervals = _spectrum_samples(spectrum)
+    wave_value = wavelength.to_value(u.AA)
+
+    band_wave = bandpass.wavelength.to_value(u.AA)
+    response = bandpass.transmission
+
+    lower = max(wave_value[0], band_wave[0])
+    upper = min(wave_value[-1], band_wave[-1])
+    if lower >= upper:
+        raise InsufficientCoverageError(
+            f"spectrum does not overlap passband {bandpass.filter_id}",
+            coverage=0.0,
+        )
+
+    integration_segments = []
+    segment_start = lower
+    for gap_start, gap_end in masked_intervals:
+        if gap_end <= lower or gap_start >= upper:
+            continue
+        gap_start = max(gap_start, lower)
+        gap_end = min(gap_end, upper)
+        if segment_start < gap_start:
+            integration_segments.append((segment_start, gap_start))
+        segment_start = max(segment_start, gap_end)
+    if segment_start < upper:
+        integration_segments.append((segment_start, upper))
+
+    # Use the same resolved wavelength grid for the source and AB reference.
+    integration_knots = np.unique(
+        np.concatenate((band_wave, wave_value, np.ravel(integration_segments)))
+    )
+    integration_knots = integration_knots[
+        (integration_knots >= band_wave[0]) & (integration_knots <= band_wave[-1])
+    ]
+    full_reference_signal = _reference_signal(
+        integration_knots,
+        np.interp(integration_knots, band_wave, response),
+        bandpass.detector_type,
+    )
+
+    overlap_reference_signal = 0.0
+    source_signal = 0.0
+    coefficients = np.zeros(len(wavelength), dtype=float)
+    flux_values = flux.to_value(FLAM)
+    reference_flux_values = _reference_flux(wave_value)
+    source_ratio = flux_values / reference_flux_values
+    for segment_start, segment_end in integration_segments:
+        interior = integration_knots[
+            (integration_knots > segment_start) & (integration_knots < segment_end)
+        ]
+        integration_wave = np.unique(
+            np.concatenate(([segment_start], interior, [segment_end]))
+        )
+        integration_response = np.interp(integration_wave, band_wave, response)
+
+        overlap_reference_signal += _reference_signal(
+            integration_wave,
+            integration_response,
+            bandpass.detector_type,
+        )
+
+        reference_flux = _reference_flux(integration_wave)
+        interpolated_ratio = np.interp(
+            integration_wave,
+            wave_value,
+            source_ratio,
+        )
+        detector_weight = _detector_weight(
+            integration_wave,
+            bandpass.detector_type,
+        )
+        source_signal += trapezoid(
+            interpolated_ratio
+            * reference_flux
+            * integration_response
+            * detector_weight,
+            integration_wave,
+        )
+        if uncertainty is not None:
+            coefficients += _linear_interpolation_integral_coefficients(
+                wave_value,
+                integration_wave,
+                reference_flux * integration_response * detector_weight,
+            )
+
+    coverage = overlap_reference_signal / full_reference_signal
+    if coverage < min_coverage:
+        raise InsufficientCoverageError(
+            f"spectrum covers only {coverage:.3f} of passband "
+            f"{bandpass.filter_id}; required coverage is {min_coverage:.3f}",
+            coverage=float(coverage),
+        )
+
+    if not np.isfinite(source_signal) or source_signal <= 0.0:
+        raise ValueError(
+            f"integrated flux through passband {bandpass.filter_id} is not positive"
+        )
+
+    magnitude = -2.5 * np.log10(source_signal / overlap_reference_signal)
+
+    magnitude_uncertainty = None
+    if uncertainty is not None:
+        signal_uncertainty = np.sqrt(
+            np.sum(
+                (
+                    coefficients
+                    / reference_flux_values
+                    * uncertainty.to_value(FLAM)
+                )
+                ** 2
+            )
+        )
+        magnitude_uncertainty = (
+            2.5 / np.log(10.0) * signal_uncertainty / source_signal
+        )
+
+    return SyntheticPhotometry(
+        magnitude=float(magnitude),
+        uncertainty=(
+            None if magnitude_uncertainty is None else float(magnitude_uncertainty)
+        ),
+        coverage=float(coverage),
+    )
+
+
+def _spectrum_samples(
+    spectrum: Spectrum,
+) -> tuple[u.Quantity, u.Quantity, u.Quantity | None, list[tuple[float, float]]]:
+    if not isinstance(spectrum, Spectrum):
+        raise TypeError("spectrum must be a specutils.Spectrum")
+    if spectrum.flux.ndim != 1:
+        raise ValueError("only one-dimensional Spectrum objects are supported")
+    if len(spectrum.flux) < 2:
+        raise ValueError("a spectrum must contain at least two samples")
+
+    wavelength = spectrum.wavelength.to(u.AA)
+    if len(wavelength) != len(spectrum.flux):
+        raise ValueError("spectral axis must specify one coordinate per flux sample")
+
+    flux = spectrum.flux.to(FLAM, equivalencies=u.spectral_density(wavelength))
+    uncertainty = _standard_deviation(spectrum, wavelength)
+
+    valid = np.ones(len(flux), dtype=bool)
+    if spectrum.mask is not None:
+        mask = np.asarray(spectrum.mask, dtype=bool)
+        if mask.shape != flux.shape:
+            raise ValueError("spectrum mask must match the one-dimensional flux shape")
+        valid &= ~mask
+
+    wave_values = wavelength.to_value(u.AA)
+    flux_values = flux.to_value(FLAM)
+    if np.any(~np.isfinite(wave_values)) or np.any(wave_values <= 0.0):
+        raise ValueError("spectrum wavelengths must be positive and finite")
+    if np.any(~np.isfinite(flux_values[valid])):
+        raise ValueError("unmasked spectrum flux must be finite")
+
+    if uncertainty is not None:
+        uncertainty_values = uncertainty.to_value(FLAM)
+        if np.any(~np.isfinite(uncertainty_values[valid])):
+            raise ValueError("unmasked spectrum uncertainty must be finite")
+        if np.any(uncertainty_values[valid] < 0.0):
+            raise ValueError("spectrum uncertainty must not be negative")
+
+    if np.count_nonzero(valid) < 2:
+        raise ValueError("spectrum must contain at least two valid, unmasked samples")
+
+    order = np.argsort(wave_values)
+    wave_values = wave_values[order]
+    sorted_mask = ~valid[order]
+    if np.any(np.diff(wave_values) <= 0.0):
+        raise ValueError("spectrum wavelengths must be unique")
+
+    masked_intervals = []
+    for index in np.flatnonzero(sorted_mask):
+        left = wave_values[index - 1] if index > 0 else wave_values[index]
+        right = (
+            wave_values[index + 1]
+            if index + 1 < len(wave_values)
+            else wave_values[index]
+        )
+        masked_intervals.append(
+            (
+                0.5 * (left + wave_values[index]),
+                0.5 * (wave_values[index] + right),
+            )
+        )
+
+    wavelength = wavelength[valid]
+    flux = flux[valid]
+    if uncertainty is not None:
+        uncertainty = uncertainty[valid]
+
+    valid_order = np.argsort(wavelength.to_value(u.AA))
+    wavelength = wavelength[valid_order]
+    flux = flux[valid_order]
+    if uncertainty is not None:
+        uncertainty = uncertainty[valid_order]
+
+    return wavelength, flux, uncertainty, masked_intervals
+
+
+def _standard_deviation(
+    spectrum: Spectrum,
+    wavelength: u.Quantity,
+) -> u.Quantity | None:
+    if spectrum.uncertainty is None:
+        return None
+
+    try:
+        uncertainty = spectrum.uncertainty.represent_as(StdDevUncertainty)
+    except (AttributeError, TypeError) as exc:
+        raise TypeError(
+            "spectrum uncertainty must support conversion to StdDevUncertainty"
+        ) from exc
+
+    if uncertainty.unit is None:
+        quantity = u.Quantity(uncertainty.array, spectrum.flux.unit)
+    else:
+        quantity = uncertainty.quantity
+
+    return quantity.to(FLAM, equivalencies=u.spectral_density(wavelength))
+
+
+def _detector_weight(
+    wavelength_angstrom: np.ndarray,
+    detector_type: DetectorType,
+) -> np.ndarray:
+    if detector_type == "photon":
+        return wavelength_angstrom
+    return np.ones_like(wavelength_angstrom)
+
+
+def _reference_signal(
+    wavelength_angstrom: np.ndarray,
+    response: np.ndarray,
+    detector_type: DetectorType,
+) -> float:
+    reference_flam = _reference_flux(wavelength_angstrom)
+    detector_weight = _detector_weight(wavelength_angstrom, detector_type)
+    return float(
+        trapezoid(
+            reference_flam * response * detector_weight,
+            wavelength_angstrom,
+        )
+    )
+
+
+def _reference_flux(wavelength_angstrom: np.ndarray) -> np.ndarray:
+    wavelength = u.Quantity(wavelength_angstrom, u.AA)
+    return AB_ZERO_FNU.to(
+        FLAM,
+        equivalencies=u.spectral_density(wavelength),
+    ).value
+
+
+def _trapezoid_weights(x: np.ndarray) -> np.ndarray:
+    weights = np.empty_like(x, dtype=float)
+    weights[0] = 0.5 * (x[1] - x[0])
+    weights[-1] = 0.5 * (x[-1] - x[-2])
+    if len(x) > 2:
+        weights[1:-1] = 0.5 * (x[2:] - x[:-2])
+    return weights
+
+
+def _linear_interpolation_integral_coefficients(
+    source_x: np.ndarray,
+    integration_x: np.ndarray,
+    kernel: np.ndarray,
+) -> np.ndarray:
+    integration_weights = _trapezoid_weights(integration_x) * kernel
+
+    left = np.searchsorted(source_x, integration_x, side="right") - 1
+    left = np.clip(left, 0, len(source_x) - 2)
+    right = left + 1
+
+    fraction = (
+        (integration_x - source_x[left])
+        / (source_x[right] - source_x[left])
+    )
+
+    coefficients = np.zeros(len(source_x), dtype=float)
+    np.add.at(coefficients, left, integration_weights * (1.0 - fraction))
+    np.add.at(coefficients, right, integration_weights * fraction)
+    return coefficients

specmangle-0.1.0b1.dist-info/METADATA

@@ -0,0 +1,252 @@
+Metadata-Version: 2.4
+Name: specmangle
+Version: 0.1.0b1
+Summary: Photometry-based 'mangling' (calibration) of astronomical spectra
+Author-email: Caden Gobat <cgobat@sdsu.edu>
+License-Expression: BSD-3-Clause
+Project-URL: Documentation, https://specmangle.readthedocs.io/
+Project-URL: Repository, https://github.com/cgobat/specmangle
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astropy
+Requires-Dist: astroquery>=0.4.12.dev10784
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: specutils
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx-astropy[confv3]>=1.11; extra == "docs"
+Requires-Dist: sphinx-design; extra == "docs"
+Dynamic: license-file
+
+# specmangle
+
+[![CI status](https://github.com/cgobat/specmangle/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/cgobat/specmangle/actions/workflows/tests.yml) [![Documentation Status](https://app.readthedocs.org/projects/specmangle/badge/?version=latest)](https://specmangle.readthedocs.io/en/latest/)
+
+`specmangle` applies a smooth, wavelength-dependent multiplicative correction to
+an observed astronomical spectrum such that synthetic broadband photometry based
+on that spectrum matches contemporaneous observations.
+
+The package is deliberately narrow in scope, and uses existing
+Astropy-ecosystem data structures and APIs:
+
+- spectra are [`specutils.Spectrum`](https://specutils.readthedocs.io/en/stable/types_of_spectra.html) objects
+- photometric measurements are stored in [`astropy.table.Table`](https://docs.astropy.org/en/stable/table/index.html) objects
+- passband profiles are retrieved from the [SVO Filter Profile Service](https://svo2.cab.inta-csic.es/theory/fps/index.php) via [`astroquery.svo_fps`](https://astroquery.readthedocs.io/en/latest/svo_fps/svo_fps.html), or user-defined
+
+## Installation
+
+From the project directory:
+
+```bash
+python -m pip install .
+```
+
+For development:
+
+```bash
+python -m pip install -e .
+```
+
+## Basic use
+
+```python
+import astropy.units as u
+from astropy.nddata import StdDevUncertainty
+from astropy.table import Table
+from specutils import Spectrum
+
+from specmangle import mangle
+
+spectrum = Spectrum(
+    spectral_axis=wavelength * u.AA,
+    flux=flux * u.erg / u.s / u.cm**2 / u.AA,
+    uncertainty=StdDevUncertainty(
+        flux_error,
+        unit=u.erg / u.s / u.cm**2 / u.AA,
+    ),
+)
+
+photometry = Table(
+    rows=[
+        ("SLOAN/SDSS.g", 18.42, 0.03),
+        ("SLOAN/SDSS.r", 18.17, 0.02),
+        ("SLOAN/SDSS.i", 18.05, 0.04),
+    ],
+    names=("band", "mag", "mag_err"),
+)
+
+result = mangle(spectrum, photometry)
+
+mangled = result.spectrum
+correction = result.correction
+print(result.photometry)
+```
+
+The input photometry table must contain:
+
+- `band`: passband identifier, normally an SVO FPS filter ID
+- `mag`: AB magnitude
+
+It may additionally contain:
+
+- `mag_err`: 1-sigma magnitude uncertainty. Masked values are treated as missing
+uncertainties.
+
+Additional columns are preserved in `result.photometry`, which adds `used`,
+`coverage`, `skip_reason`, `synthetic_mag`, `synthetic_mag_err`, and `residual`
+columns. Bands that do not meet `min_coverage` are excluded from the fit and
+reported explicitly in these diagnostic columns.
+
+## Mangling model
+
+The correction is positive and multiplicative. It is represented by a natural
+cubic spline in log wavelength and log flux scale, with one free anchor at the
+pivot wavelength of each unique passband. The correction is held constant
+beyond the bluest and reddest anchors rather than extrapolating the spline.
+
+The fit minimizes the difference between the mangled spectrum's synthetic AB
+magnitudes and the supplied photometry. When uncertainties are available,
+photometric uncertainties and synthetic-photometry uncertainties propagated from
+the spectrum are combined in quadrature.
+
+A nonzero `smoothness` can be supplied to penalize changes in slope between
+neighboring spline anchors:
+
+```python
+result = mangle(spectrum, photometry, smoothness=0.1)
+```
+
+The default is `smoothness=0.0`, so no additional regularization is imposed.
+
+The fitted correction can be evaluated on any wavelength grid:
+
+```python
+correction = result.correction_at(new_wavelength)
+```
+
+## History & heritage
+
+The term "spectral mangling" is commonly used for smooth wavelength-dependent
+corrections that are applied to a spectrum to make it reproduce contemporaneous
+broadband photometry. The approach has roots in earlier spectral "warping"
+methods (e.g.
+[Tonry *et al.* 2003](https://scixplorer.org/abs/2003ApJ...594....1T)), was
+formalized under the "mangling" nomenclature by
+[Hsiao *et al.* (2007)](https://scixplorer.org/abs/2007ApJ...663.1187H) and
+[Conley *et al.* (2008)](https://scixplorer.org/abs/2008ApJ...681..482C), and
+was later applied directly to spectrophotometric calibration of observed
+core-collapse supernova spectra by
+[Vincenzi *et al.* (2019)](https://scixplorer.org/abs/2019MNRAS.489.5802V).
+
+## Spectral uncertainties
+
+`specmangle` supports the same uncertainty representations supported by
+`specutils` for arithmetic propagation:
+
+- `astropy.nddata.StdDevUncertainty`;
+- `astropy.nddata.VarianceUncertainty`;
+- `astropy.nddata.InverseVariance`.
+
+For synthetic photometry, uncertainties are converted to standard deviations and
+spectral samples are assumed to be statistically independent. Masked spectral
+samples are omitted.
+
+The uncertainty stored on `result.spectrum` is the input spectral uncertainty
+scaled by the best-fit mangling correction. Uncertainty in the correction
+itself is returned separately as `result.correction_uncertainty`, because errors
+in the fitted correction are correlated across wavelength.
+
+## Bandpasses
+
+By default, values in the `band` column are passed to the SVO Filter Profile
+Service:
+
+```python
+from specmangle import Bandpass
+
+bandpass = Bandpass.from_svo("SLOAN/SDSS.g")
+```
+
+Custom response curves can be supplied instead:
+
+```python
+import astropy.units as u
+from specmangle import Bandpass, mangle
+
+custom = Bandpass(
+    filter_id="my/filter",
+    wavelength=filter_wavelength * u.AA,
+    transmission=filter_transmission,
+    detector_type="photon",
+)
+
+result = mangle(
+    spectrum,
+    photometry,
+    bandpasses={"my/filter": custom},
+)
+```
+
+The synthetic-photometry calculation distinguishes photon-counting and
+energy-counting response curves. SVO's `DetectorType` metadata is used
+automatically for SVO filters.
+
+## Passband coverage
+
+By default, at least 98% of the passband's AB-reference signal must fall within
+the wavelength range covered by the valid spectrum samples. This prevents a
+synthetic magnitude from silently relying on a substantially incomplete
+bandpass.
+
+The threshold can be changed with `min_coverage`:
+
+```python
+result = mangle(spectrum, photometry, min_coverage=0.95)
+```
+
+## Direct synthetic photometry
+
+For the common/general case of computing an AB magnitude directly from an SVO
+FPS identifier:
+
+```python
+from specmangle import spectrum_to_magnitude
+
+mag = spectrum_to_magnitude(spectrum, "SLOAN/SDSS.r")
+```
+
+If the input `Spectrum` includes an uncertainty, the function returns
+`(mag, mag_err)`. Both values carry Astropy magnitude units. An already loaded
+`Bandpass` can be supplied instead of an SVO identifier.
+
+The lower-level synthetic-photometry result is also exposed when coverage and
+other diagnostics are useful:
+
+```python
+from specmangle import Bandpass, synthetic_ab_magnitude
+
+bandpass = Bandpass.from_svo("SLOAN/SDSS.r")
+synthetic = synthetic_ab_magnitude(spectrum, bandpass)
+
+print(synthetic.magnitude)
+print(synthetic.uncertainty)
+print(synthetic.coverage)
+```
+
+## Result object
+
+`mangle` returns a `MangleResult` containing:
+
+- `spectrum`: the mangled `specutils.Spectrum`
+- `correction`: multiplicative correction evaluated at each input spectral sample
+- `correction_at(wavelength)`: evaluate the fitted correction at arbitrary wavelengths
+- `correction_uncertainty`: estimated 1-sigma uncertainty in that correction, when identifiable
+- `anchor_wavelengths`: spline-anchor pivot wavelengths
+- `log_correction_parameters`: fitted log-correction values at the anchors
+- `parameter_covariance`: fitted parameter covariance when absolute uncertainties are available
+- `photometry`: the input table with synthetic-photometry diagnostics appended
+- `bandpasses`: the bandpasses used in the fit
+- `optimizer`: the underlying `scipy.optimize.OptimizeResult`

specmangle-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,9 @@
+specmangle/__init__.py,sha256=7V3k3GutZSwtJt6xZfHMW1GWH8DbzxrVoD4UyNaPMnE,488
+specmangle/bandpasses.py,sha256=u4fr6m7J4aubrRniCYkfDHRdr_q-XoTTuFY11pem5Uo,8378
+specmangle/mangling.py,sha256=DhYKvDVMgKkWzPC3V-sHQKfZxgntKiqHYyRQtUOzo24,16364
+specmangle/photometry.py,sha256=E_4h_HOPecZZbKmckuBuRRCxSXdnYGpkB_P3xAsZjUs,12758
+specmangle-0.1.0b1.dist-info/licenses/LICENSE,sha256=pIcUbfsbuKN2xzSZmJCGKEvJxCOh_EWu5Yk7D0QQXEc,1519
+specmangle-0.1.0b1.dist-info/METADATA,sha256=Ohc2YJS4DSljrJGC7spI_KV90uPxeM2f7AG-M-yq1NI,8465
+specmangle-0.1.0b1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+specmangle-0.1.0b1.dist-info/top_level.txt,sha256=SlMKojoe8ukDy_Yje-ukZPEiaLulnVIKWKfr8e2DGm8,11
+specmangle-0.1.0b1.dist-info/RECORD,,

specmangle-0.1.0b1.dist-info/WHEEL

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

specmangle-0.1.0b1.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Caden Gobat
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

specmangle-0.1.0b1.dist-info/top_level.txt

@@ -0,0 +1 @@
+specmangle