ExoIris 0.19.2__py3-none-any.whl → 0.21.0__py3-none-any.whl

exoiris/exoiris.py

@@ -32,7 +32,8 @@ from emcee import EnsembleSampler
 from matplotlib.pyplot import subplots, setp, figure, Figure, Axes
 from numpy import (any, where, sqrt, clip, percentile, median, squeeze, floor, ndarray, isfinite,
                    array, inf, arange, argsort, concatenate, full, nan, r_, nanpercentile, log10,
-                   ceil, unique)
+                   ceil, unique, zeros)
+from numpy.typing import ArrayLike
 from numpy.random import normal
 from pytransit import UniformPrior, NormalPrior
 from pytransit.param import ParameterSet
@@ -44,6 +45,7 @@ from .ldtkld import LDTkLD
 from .tsdata import TSData, TSDataGroup
 from .tslpf import TSLPF
 from .wlpf import WhiteLPF
+from .loglikelihood import LogLikelihood
 
 
 def load_model(fname: Path | str, name: str | None = None):
@@ -71,28 +73,38 @@ def load_model(fname: Path | str, name: str | None = None):
     """
     with pf.open(fname) as hdul:
         data = TSDataGroup.import_fits(hdul)
+        hdr = hdul[0].header
 
-        if hdul[0].header['LDMODEL'] == 'ldtk':
-            filters, teff, logg, metal, dataset = pickle.loads(codecs.decode(json.loads(hdul[0].header['LDTKLD']).encode(), "base64"))
+        # Read the limb darkening model.
+        # ==============================
+        if hdr['LDMODEL'] == 'ldtk':
+            filters, teff, logg, metal, dataset = pickle.loads(codecs.decode(json.loads(hdr['LDTKLD']).encode(), "base64"))
             ldm = LDTkLD(filters, teff, logg, metal, dataset=dataset)
         else:
-            ldm =  hdul[0].header['LDMODEL']
+            ldm =  hdr['LDMODEL']
 
+        # Read the interpolation model.
+        # =============================
         try:
-            ip = hdul[0].header['INTERP']
+            ip = hdr['INTERP']
         except KeyError:
             ip = 'bspline'
 
+        # Read the noise model.
+        # =====================
         try:
-            noise_model = hdul[0].header['NOISE']
+            noise_model = hdr['NOISE']
         except KeyError:
             noise_model = "white"
 
-        a = ExoIris(name or hdul[0].header['NAME'], ldmodel=ldm, data=data, noise_model=noise_model, interpolation=ip)
+        # Setup the analysis.
+        # ===================
+        a = ExoIris(name or hdr['NAME'], ldmodel=ldm, data=data, noise_model=noise_model, interpolation=ip)
         a.set_radius_ratio_knots(hdul['K_KNOTS'].data.astype('d'))
         a.set_limb_darkening_knots(hdul['LD_KNOTS'].data.astype('d'))
 
         # Read the white light curve models if they exist.
+        # ================================================
         try:
             tb = Table.read(hdul['WHITE_DATA'])
             white_ids = tb['id'].data
@@ -101,18 +113,28 @@ def load_model(fname: Path | str, name: str | None = None):
             a._white_fluxes = [tb['flux_obs'].data[white_ids == i] for i in uids]
             a._white_errors = [tb['flux_obs_err'].data[white_ids == i] for i in uids]
             a._white_models = [tb['flux_mod'].data[white_ids == i] for i in uids]
-
         except KeyError:
             pass
 
+        # Read the ephemeris if it exists.
+        # ================================
         try:
-            a.period = hdul[0].header['P']
-            a.zero_epoch = hdul[0].header['T0']
-            a.transit_duration = hdul[0].header['T14']
+            a.period = hdr['P']
+            a.zero_epoch = hdr['T0']
+            a.transit_duration = hdr['T14']
             [d.mask_transit(a.zero_epoch, a.period, a.transit_duration) for d in a.data]
-        except KeyError:
+        except (KeyError, ValueError):
             pass
 
+        # Read the spots if they exist.
+        # =============================
+        if 'SPOTS' in hdr and hdr['SPOTS'] is True:
+            a.initialize_spots(hdr["SP_TSTAR"], hdr["SP_REFWL"], hdr["SP_TLSE"])
+            for i in range(hdr['NSPOTS']):
+                a.add_spot(hdr[f'SP{i+1:02d}_EG'])
+
+        # Read the priors.
+        # ================
         priors = pickle.loads(codecs.decode(json.loads(hdul['PRIORS'].header['PRIORS']).encode(), "base64"))
         a._tsa.ps = ParameterSet([pickle.loads(p) for p in priors])
         a._tsa.ps.freeze()
@@ -132,7 +154,7 @@ class ExoIris:
 
     def __init__(self, name: str, ldmodel, data: TSDataGroup | TSData, nk: int = 50, nldc: int = 10, nthreads: int = 1,
                  tmpars: dict | None = None, noise_model: Literal["white", "fixed_gp", "free_gp"] = 'white',
-                 interpolation: Literal['bspline', 'pchip', 'makima'] = 'bspline'):
+                 interpolation: Literal['bspline', 'pchip', 'makima', 'nearest', 'linear'] = 'makima'):
         """
         Parameters
         ----------
@@ -343,6 +365,36 @@ class ExoIris:
         """
         self._tsa.set_gp_kernel(kernel)
 
+    def initialize_spots(self, tstar: float, wlref: float, include_tlse: bool = True):
+        """Initialize star spot model using given stellar and wavelength reference values.
+
+        Parameters
+        ----------
+        tstar
+            Effective stellar temperature [K].
+        wlref
+            Reference wavelength where spot amplitude matches the amplitude parameter.
+        """
+        self._tsa.initialize_spots(tstar, wlref, include_tlse)
+
+    def add_spot(self, epoch_group: int) -> None:
+        """Add a new star spot and associate it with an epoch group.
+
+        Parameters
+        ----------
+        epoch_group
+            Identifier for the epoch group to which the spot will be added.
+        """
+        self._tsa.add_spot(epoch_group)
+
+    @property
+    def nspots(self) -> int:
+        """Number of star spots."""
+        if self._tsa.spot_model is None:
+            return 0
+        else:
+            return self._tsa.spot_model.nspots
+
     @property
     def name(self) -> str:
         """Analysis name."""
@@ -1078,6 +1130,22 @@ class ExoIris:
                            median(ar, 0)[ix], ar.std(0)[ix]],
                      names = ['wavelength', 'radius_ratio', 'radius_ratio_e', 'area_ratio', 'area_ratio_e'])
 
+    def radius_ratio_spectrum(self, wavelengths: ArrayLike, knot_samples: ArrayLike | None = None) -> ndarray:
+        if knot_samples is None:
+            knot_samples = self.posterior_samples.iloc[:, self._tsa._sl_rratios].values
+        k_posteriors = zeros((knot_samples.shape[0], wavelengths.size))
+        for i, ks in enumerate(knot_samples):
+            k_posteriors[i, :] = self._tsa._ip(wavelengths, self._tsa.k_knots, ks)
+        return k_posteriors
+
+    def area_ratio_spectrum(self, wavelengths: ArrayLike, knot_samples: ArrayLike | None = None) -> ndarray:
+        if knot_samples is None:
+            knot_samples = self.posterior_samples.iloc[:, self._tsa._sl_rratios].values
+        d_posteriors = zeros((knot_samples.shape[0], wavelengths.size))
+        for i, ks in enumerate(knot_samples):
+            d_posteriors[i, :] = self._tsa._ip(wavelengths, self._tsa.k_knots, ks) ** 2
+        return d_posteriors
+
     def save(self, overwrite: bool = False) -> None:
         """Save the ExoIris analysis to a FITS file.
 
@@ -1095,10 +1163,14 @@ class ExoIris:
         pri.header['interp'] = self._tsa.interpolation
         pri.header['noise'] = self._tsa.noise_model
 
+        # Priors
+        # ======
         pr = pf.ImageHDU(name='priors')
         priors = [pickle.dumps(p) for p in self.ps]
         pr.header['priors'] = json.dumps(codecs.encode(pickle.dumps(priors), "base64").decode())
 
+        # Limb darkening
+        # ==============
         if isinstance(self._tsa.ldmodel, LDTkLD):
             ldm = self._tsa.ldmodel
             pri.header['ldmodel'] = 'ldtk'
@@ -1107,11 +1179,15 @@ class ExoIris:
         else:
             pri.header['ldmodel'] = self._tsa.ldmodel
 
+        # Knots
+        # =====
         k_knots = pf.ImageHDU(self._tsa.k_knots, name='k_knots')
         ld_knots = pf.ImageHDU(self._tsa.ld_knots, name='ld_knots')
         hdul = pf.HDUList([pri, k_knots, ld_knots, pr])
         hdul += self.data.export_fits()
 
+        # White light curve analysis
+        # ==========================
         if self._wa is not None and self._wa._local_minimization is not None:
             wa_data = pf.BinTableHDU(
                 Table(
@@ -1140,6 +1216,19 @@ class ExoIris:
             wa_params = pf.BinTableHDU(Table(self._wa._local_minimization.x, names=names), name='white_params')
             hdul.append(wa_params)
 
+        # Spots
+        # =====
+        if self._tsa.spot_model is not None:
+            pri.header['spots'] = True
+            pri.header["sp_tstar"] = self._tsa.spot_model.tphot
+            pri.header["sp_refwl"] = self._tsa.spot_model.wlref
+            pri.header["sp_tlse"] = self._tsa.spot_model.include_tlse
+            pri.header["nspots"] = self.nspots
+            for i in range(self.nspots):
+                pri.header[f"sp{i+1:02d}_eg"] = self._tsa.spot_model.spot_epoch_groups[i]
+
+        # Global optimization results
+        # ===========================
         if self._tsa.de is not None:
             de = pf.BinTableHDU(Table(self._tsa._de_population, names=self.ps.names), name='DE')
             de.header['npop'] = self._tsa.de.n_pop
@@ -1147,6 +1236,8 @@ class ExoIris:
             de.header['imin'] = self._tsa.de.minimum_index
             hdul.append(de)
 
+        # MCMC results
+        # ============
         if self._tsa.sampler is not None:
             mc = pf.BinTableHDU(Table(self._tsa.sampler.flatchain, names=self.ps.names), name='MCMC')
             mc.header['npop'] = self._tsa.sampler.nwalkers
@@ -1155,6 +1246,27 @@ class ExoIris:
 
         hdul.writeto(f"{self.name}.fits", overwrite=True)
 
+    def create_loglikelihood_function(self, wavelengths: ArrayLike, kind: Literal['radius_ratio', 'depth'] = 'depth') -> LogLikelihood:
+        """Create a reduced-rank Gaussian log-likelihood function for retrieval.
+
+        Parameters
+        ----------
+        wavelengths
+            The wavelength grid used in the theoretical transmission spectra.
+
+        kind
+            The transmission spectrum type. Can be either 'radius_ratio' or 'depth'.
+
+        Returns
+        -------
+        LogLikelihood
+            An instance of LogLikelihood for analyzing the consistency of the model
+            with the provided wavelengths and chosen log-likelihood kind.
+        """
+        if self.mcmc_chains is None:
+            raise ValueError("Cannot create log-likelihood function before running the MCMC sampler.")
+        return LogLikelihood(self, wavelengths, kind)
+
     def create_initial_population(self, n: int, source: str, add_noise: bool = True) -> ndarray:
         """Create an initial parameter vector population for the DE optimisation.
 

exoiris/loglikelihood.py

@@ -0,0 +1,144 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2025 Hannu Parviainen
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+from typing import Literal
+
+from numpy import full, cov, sqrt, sum
+from numpy.linalg import eigh
+from numpy.typing import ArrayLike
+
+
+class LogLikelihood:
+    def __init__(self, exoiris, wavelength: ArrayLike, kind: Literal['radius_ratio', 'depth'] = 'depth', eps: float = 1e-10):
+        """Reduced-rank Gaussian log-likelihood.
+
+        This class constructs a statistically correct reduced-rank Gaussian
+        log-likelihood function for comparing a theoretical transmission spectrum to the
+        posterior distribution inferred by ExoIris. Because the posterior
+        samples of the transmission spectrum are generated from a spline with
+        far fewer independent parameters than the number of wavelength bins, the
+        empirical covariance matrix is rank-deficient or strongly ill-conditioned.
+        Direct inversion of the full covariance is therefore numerically unstable
+        and produces incorrect likelihoods.
+
+        Parameters
+        ----------
+        exoiris
+            The ExoIris model object from which posterior samples of the knot
+            values and spline interpolation functions are obtained.
+
+        wavelength
+            Wavelength grid on which the radius ratio posterior samples and the
+            theoretical spectra will be evaluated.
+
+        kind
+            The type of the spectrum. Can be either ``radius_ratio`` for a radius ratio
+            spectrum, or ``depth`` for a transit depth spectrum.
+
+        eps
+            Relative tolerance factor used to determine which eigenvalues of
+            the covariance matrix are considered significant. Eigenvalues smaller
+            than ``eps * max_eigenvalue`` are discarded. Default is ``1e-10``.
+
+        Attributes
+        ----------
+        k_posteriors : ndarray of shape (n_samples, n_wavelengths)
+            Radius-ratio posterior samples evaluated on the wavelength grid.
+
+        k_mean : ndarray of shape (n_wavelengths,)
+            Posterior mean radius-ratio spectrum.
+
+        k_cov : ndarray of shape (n_wavelengths, n_wavelengths)
+            Empirical covariance matrix of the posterior samples.
+
+        lambda_r : ndarray of shape (k,)
+            Significant eigenvalues of the covariance matrix (``k`` = reduced
+            dimensionality).
+
+        u_r : ndarray of shape (n_wavelengths, k)
+            Eigenvectors corresponding to the significant eigenvalues.
+
+        sqrt_inv_lambda_r : ndarray of shape (k,)
+            Factors used to whiten the reduced-rank representation.
+
+        y_data : ndarray of shape (k,)
+            Whitened reduced-rank representation of the posterior mean spectrum.
+
+        Notes
+        -----
+         The class implements the reduced-rank likelihood method:
+
+        1. Posterior samples of the spline knot values are evaluated on the
+           user-specified wavelength grid to produce a matrix of radius-ratio
+           samples, ``k_posteriors``.
+
+        2. The empirical mean spectrum and covariance matrix are computed over
+           these samples.
+
+        3. An eigendecomposition of the covariance matrix is performed. All
+           eigenvalues below ``eps * max(eigenvalue)`` are discarded, ensuring that
+           only statistically meaningful directions (i.e., those supported by the
+           spline parameterization and the data) are retained.
+
+        4. The retained eigenvectors form an orthonormal basis for the true
+           low-dimensional subspace in which the posterior distribution lives.
+           Projection onto this basis, followed by whitening with
+           ``lambda_r**(-1/2)``, yields a representation where the posterior is a
+           standard multivariate normal with identity covariance.
+
+        5. The log-likelihood of a theoretical spectrum ``x`` is evaluated in this
+           reduced space as:
+
+               log L = -0.5 * sum_i (y_data[i] - y_model[i])^2
+
+           where ``y_data`` is the whitened reduced-space representation of the
+           posterior mean spectrum, and ``y_model`` is the whitened projection of
+           the model spectrum.
+
+        - This reduced-rank formulation is mathematically equivalent to computing
+          the Gaussian likelihood in knot space, and avoids the numerical
+          instabilities associated with inverting a nearly singular covariance
+          matrix in the oversampled wavelength space.
+
+        - If ``x`` is provided as a scalar, it is broadcast to a constant spectrum
+          over the wavelength grid. Otherwise, it must be an array of the same
+          wavelength length.
+        """
+        self.model = m = exoiris
+        self.wavelength = wavelength
+        self.eps = eps
+
+        if kind == 'radius_ratio':
+            self.spectrum = m.radius_ratio_spectrum(wavelength)
+        elif kind == 'depth':
+            self.spectrum = m.area_ratio_spectrum(wavelength)
+        else:
+            raise ValueError('Unknown spectrum type: {}'.format(kind))
+
+        self.spmean = self.spectrum.mean(0)
+        self.spcov = cov(self.spectrum, rowvar=False)
+
+        evals, u = eigh(self.spcov)
+        tol = eps * evals.max()
+        keep = evals > tol
+        self.lambda_r, self.u_r = evals[keep], u[:, keep]
+        self.sqrt_inv_lambda_r = 1.0 / sqrt(self.lambda_r)
+        self.y_data = (self.u_r.T @ self.spmean) * self.sqrt_inv_lambda_r
+
+    def __call__(self, x):
+        if isinstance(x, float):
+            x = full(self.wavelength.size, x)
+        y_model = (self.u_r.T @ x) * self.sqrt_inv_lambda_r
+        return -0.5*sum((self.y_data - y_model)**2)

exoiris/spotmodel.py

@@ -0,0 +1,176 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2025 Hannu Parviainen
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from copy import deepcopy
+
+from numpy import (
+    exp,
+    fabs,
+    log,
+    inf,
+    array,
+    vstack,
+    atleast_2d,
+    nan,
+    unique,
+    linspace,
+    floor,
+)
+from scipy.interpolate import RegularGridInterpolator
+from numba import njit
+
+from pytransit.stars import create_bt_settl_interpolator, create_husser2013_interpolator
+from pytransit.param import GParameter, UniformPrior as U
+
+from exoiris.tsdata import TSData
+from exoiris.util import bin2d
+
+
+@njit
+def spot_model(x, center, amplitude, fwhm, shape):
+    c = fwhm / 2*(2*log(2))**(1/shape)
+    return amplitude*exp(-(fabs(x-center) / c)**shape)
+
+
+@njit
+def interpolate_spectrum(teff, values, tgrid):
+    t0 = tgrid[0]
+    dt = tgrid[1] - tgrid[0]
+    k = (teff - t0) / dt
+    i = int(floor(k))
+    a = k - floor(k)
+    return (1.0-a)*values[i] + a*values[i+1]
+
+
+@njit
+def tlse(tphot, tspot, tfac, aspot, afac, spectra, tgrid):
+    fphot = interpolate_spectrum(tphot, spectra, tgrid)
+    fspot = interpolate_spectrum(tspot, spectra, tgrid)
+    ffac  = interpolate_spectrum(tfac, spectra, tgrid)
+    return 1.0 / (1.0 - aspot*(1.0 - fspot/fphot) - afac*(1.0 - ffac/fphot))
+
+
+def spot_contrast(tphot, tspot, spectra, spnorm):
+    fphot = interpolate_spectrum(tphot, spectra.values, spectra.grid[0])
+    fspot = interpolate_spectrum(tspot, spectra.values, spectra.grid[0])
+    norm = interpolate_spectrum(tspot, spnorm, spectra.grid[0])
+    return (fphot / fspot) / norm
+
+
+def bin_stellar_spectrum_model(sp: RegularGridInterpolator, data: TSData):
+    lrange = array(data.bbox_wl) * 1e3
+    ml = (sp.grid[1] >= lrange[0]) & (sp.grid[1] <= lrange[1])
+
+    teff = sp.grid[0]
+    wave = sp.grid[1][ml]
+    flux = sp.values[:, ml]
+
+    wl_l_edges = wave - 0.5
+    wl_r_edges = wave + 0.5
+
+    bflux = bin2d(flux.T, flux.T, wl_l_edges*1e-3, wl_r_edges*1e-3, vstack([data._wl_l_edges, data._wl_r_edges]).T)[0].T
+    return RegularGridInterpolator((teff, data.wavelength), bflux, bounds_error=False, fill_value=nan)
+
+
+class SpotModel:
+    def __init__(self, tsa, tphot: float, wlref: float, include_tlse: bool = True):
+        self.tsa = tsa
+        self.tphot = tphot
+        self.wlref = wlref
+        self.include_tlse = include_tlse
+
+        ms = create_bt_settl_interpolator()
+        new_teff_grid = linspace(*ms.grid[0][[0, -1]], 117)
+        new_spectrum = array([ms((t, ms.grid[1])) for t in new_teff_grid])
+        self.full_spectrum = ms = RegularGridInterpolator((new_teff_grid, ms.grid[1]), new_spectrum, bounds_error=False, fill_value=nan)
+
+        wave = ms.grid[1] / 1e3
+        m = (wave > wlref - 0.025) & (wave < wlref + 0.025)
+        spot_norm = ms.values[:, m].mean(1)
+        self.spot_norm = interpolate_spectrum(tphot, spot_norm, ms.grid[0]) / spot_norm
+
+        self.binned_spectra = []
+        for d in tsa.data:
+            self.binned_spectra.append(bin_stellar_spectrum_model(self.full_spectrum, d))
+
+        if self.include_tlse:
+            self._init_tlse_parameters()
+
+        self.nspots = 0
+        self.spot_epoch_groups = []
+        self.spot_data_ids = []
+        self.spot_pv_slices = []
+
+    def use_tlse(self):
+        if self.include_tlse is False:
+            self.include_tlse = True
+            self._init_tlse_parameters()
+
+    def _init_tlse_parameters(self):
+        ps = [GParameter('tlse_tspot', 'Effective temperature of unocculted spots', 'K', U(1200, 7000), (1200, 7000))]
+        ps.append(GParameter('tlse_tfac', 'Effective temperature of unocculted faculae', 'K', U(1200, 7000), (1200, 7000)))
+        for e in unique(self.tsa.data.epoch_groups):
+            ps.append(GParameter(f"tlse_aspot_e{e:02d}", "Area fraction covered by unocculted spots", "", U(0,1), (0,1)))
+            ps.append(GParameter(f"tlse_afac_e{e:02d}", "Area fraction covered by unocculted faculae", "", U(0,1), (0,1)))
+        self.tsa.ps.thaw()
+        self.tsa.ps.add_global_block(f'tlse', ps)
+        setattr(self.tsa, "_start_tlse", self.tsa.ps.blocks[-1].start)
+        setattr(self.tsa, "_sl_tlse", self.tsa.ps.blocks[-1].slice)
+        self.tlse_pv_slice = self.tsa.ps.blocks[-1].slice
+        self.tsa.ps.freeze()
+
+    def add_spot(self, epoch_group: int):
+        self.nspots += 1
+        self.spot_epoch_groups.append(epoch_group)
+        self.spot_data_ids.append([i for i, d in enumerate(self.tsa.data) if d.epoch_group == epoch_group])
+
+        i = self.nspots
+        pspot = [GParameter(f"spc_{i:02d}", 'spot {i:02d} center', "d", U(0, 1), (0, inf)),
+                 GParameter(f"spa_{i:02d}", 'spot {i:02d} amplitude', "", U(0, 1), (0, inf)),
+                 GParameter(f"spw_{i:02d}", 'spot {i:02d} FWHM', "d", U(0, 1), (0, inf)),
+                 GParameter(f"sps_{i:02d}", 'spot {i:02d} shape', "d", U(1, 5), (0, inf)),
+                 GParameter(f"spt_{i:02d}", 'spot {i:02d} temperature', "K", U(3000, 6000), (0, inf))]
+        ps = self.tsa.ps
+        ps.thaw()
+        ps.add_global_block(f'spot_{i:02d}', pspot)
+        setattr(self.tsa, f"_start_spot_{i:02d}", ps.blocks[-1].start)
+        setattr(self.tsa, f"_sl_spot_{i:02d}", ps.blocks[-1].slice)
+        self.spot_pv_slices.append(ps.blocks[-1].slice)
+        ps.freeze()
+
+    def apply_tlse(self, pvp, models):
+        pvp = atleast_2d(pvp)[:, self.tlse_pv_slice]
+        npv = pvp.shape[0]
+        for d, m, sp in zip(self.tsa.data, models, self.binned_spectra):
+            for i in range(npv):
+                tspot = pvp[i, 0]
+                tfac = pvp[i, 1]
+                fspot = pvp[i, 2+d.epoch_group*2]
+                ffac = pvp[i, 3+d.epoch_group*2]
+                m[i, :, :] = (m[i, :, :] - 1.0) * tlse(self.tphot, tspot, tfac, fspot, ffac, sp.values, sp.grid[0])[:, None] + 1
+
+    def apply_spots(self, pvp, models):
+        pvp = atleast_2d(pvp)
+        npv = pvp.shape[0]
+        if models[0].shape[0] != npv:
+            raise ValueError('The _spot_models array has a wrong shape, it has not been initialized properly.')
+
+        for isp in range(self.nspots):
+            for ipv in range(npv):
+                center, amplitude, fwhm, shape, tspot = pvp[ipv, self.spot_pv_slices[isp]]
+                for idata in self.spot_data_ids[isp]:
+                    models[idata][ipv, :, :] += (spot_model(self.tsa.data[idata].time, center, amplitude, fwhm, shape) *
+                                                 spot_contrast(self.tphot, tspot, self.binned_spectra[idata], self.spot_norm)[:, None])

exoiris/tsdata.py

@@ -274,7 +274,7 @@ class TSData:
             self.transit_mask = ones(self.fluxes.shape, bool)
             self.transit_mask[:, elims[0]:elims[1]] = False
         else:
-            raise ValueError("Transit masking requires either t0, pp, and t14, ephemeris, or transit limits in exposure indices.")
+            raise ValueError("Transit masking requires either t0, p, and t14, ephemeris, or transit limits in exposure indices.")
         return self
 
     def estimate_average_uncertainties(self):
@@ -568,8 +568,8 @@ class TSData:
         axx2.set_xlabel('Exposure index')
         axx2.xaxis.set_major_locator(LinearLocator())
         axx2.xaxis.set_major_formatter('{x:.0f}')
-        fig.axx2 = axx2
-        fig.axy2 = axy2
+        ax.axx2 = axx2
+        ax.axy2 = axy2
         return fig
 
     def plot_white(self, ax: Axes | None = None, figsize: tuple[float, float] | None = None) -> Figure:

exoiris/tslpf.py

@@ -28,11 +28,19 @@ from pytransit.lpf.logposteriorfunction import LogPosteriorFunction
 
 from pytransit.orbits import as_from_rhop, i_from_ba, fold, i_from_baew, d_from_pkaiews, epoch
 from pytransit.param import ParameterSet, UniformPrior as UP, NormalPrior as NP, GParameter
-from scipy.interpolate import pchip_interpolate, splrep, splev, Akima1DInterpolator
+from pytransit.stars import create_bt_settl_interpolator
+from scipy.interpolate import (
+    pchip_interpolate,
+    splrep,
+    splev,
+    Akima1DInterpolator,
+    interp1d,
+)
 
 from .tsmodel import TransmissionSpectroscopyModel as TSModel
 from .tsdata import TSDataGroup
 from .ldtkld import LDTkLD
+from .spotmodel import SpotModel
 
 NM_WHITE = 0
 NM_GP_FIXED = 1
@@ -81,10 +89,25 @@ def ip_makima(x, xk, yk):
     return Akima1DInterpolator(xk, yk, method='makima', extrapolate=True)(x)
 
 
+def ip_nearest(x, xk, yk):
+    return interp1d(xk, yk, kind='nearest', bounds_error=False, fill_value='extrapolate', assume_sorted=True)(x)
+
+
+def ip_linear(x, xk, yk):
+    return interp1d(xk, yk, kind='linear', bounds_error=False, fill_value='extrapolate', assume_sorted=True)(x)
+
+
 def add_knots(x_new, x_old):
     return sort(concatenate([x_new, x_old]))
 
 
+interpolator_choices = ("bspline", "pchip", "makima", "nearest", "linear")
+
+
+interpolators = {'bspline': ip_bspline, 'pchip': ip_pchip, 'makima': ip_makima,
+            'nearest': ip_nearest, 'linear': ip_linear}
+
+
 def clean_knots(knots, min_distance, lmin=0, lmax=inf):
     """Clean the knot table by replacing groups of adjacent knots with a single knot at the group mean.
 
@@ -126,7 +149,7 @@ def clean_knots(knots, min_distance, lmin=0, lmax=inf):
 class TSLPF(LogPosteriorFunction):
     def __init__(self, runner, name: str, ldmodel, data: TSDataGroup, nk: int = 50, nldc: int = 10, nthreads: int = 1,
                  tmpars = None, noise_model: Literal["white", "fixed_gp", "free_gp"] = 'white',
-                 interpolation: Literal['bspline', 'pchip', 'makima'] = 'bspline'):
+                 interpolation: Literal['bspline', 'pchip', 'makima', 'nearest', 'linear'] = 'makima'):
         super().__init__(name)
         self._runner = runner
         self._original_data: TSDataGroup | None = None
@@ -137,7 +160,10 @@ class TSLPF(LogPosteriorFunction):
         self._baseline_models: list[ndarray] | None = None
         self.interpolation: str = interpolation
 
-        self._ip = {'bspline': ip_bspline, 'pchip': ip_pchip, 'makima': ip_makima}[interpolation]
+        if interpolation not in interpolator_choices:
+            raise ValueError(f'interpolation must be one of {interpolator_choices}')
+        self._ip = interpolators[interpolation]
+        self._ip_ld = interpolators['bspline']
 
         self._gp: Optional[list[GP]] = None
         self._gp_time: Optional[list[ndarray]] = None
@@ -147,6 +173,9 @@ class TSLPF(LogPosteriorFunction):
         self.set_data(data)
         self.set_noise_model(noise_model)
 
+        self.spot_model: SpotModel | None = None
+        self.spot_model_fluxes = []
+
         self.ldmodel = ldmodel
         if isinstance(ldmodel, LDTkLD):
             for tm in self.tms:
@@ -211,6 +240,19 @@ class TSLPF(LogPosteriorFunction):
         self.ps.freeze()
         self.ndim = len(self.ps)
 
+    def initialize_spots(self, tstar: float, wlref: float, include_tlse: bool = True) -> None:
+        self.spot_model = SpotModel(self, tstar, wlref, include_tlse)
+
+    def add_spot(self, epoch_group: int) -> None:
+        """Adds a new star spot.
+
+        Parameters
+        ----------
+        epoch_group : int
+            The identifier of the epoch group to which the spot belongs.
+        """
+        self.spot_model.add_spot(epoch_group)
+
     def set_noise_model(self, noise_model: str) -> None:
         """Sets the noise model for the analysis.
 
@@ -434,6 +476,14 @@ class TSLPF(LogPosteriorFunction):
         sln = self._sl_rratios
         ndn = self.ndim
 
+        # Check if we have spots
+        # ----------------------
+        if self.spot_model is not None:
+            spots = self.spot_model
+            self.initialize_spots(spots.tphot, spots.wlref, spots.include_tlse)
+            for eg in spots.spot_epoch_groups:
+                self.spot_model.add_spot(eg)
+
         # Set the priors back as they were
         # --------------------------------
         for po in pso:
@@ -566,8 +616,8 @@ class TSLPF(LogPosteriorFunction):
             ldp = [zeros((pvp.shape[0], npb, 2)) for npb in self.npb]
             for ids in range(self.data.size):
                 for ipv in range(pvp.shape[0]):
-                    ldp[ids][ipv, :, 0] = self._ip(self.wavelengths[ids], self.ld_knots, ldk[ipv, :, 0])
-                    ldp[ids][ipv, :, 1] = self._ip(self.wavelengths[ids], self.ld_knots, ldk[ipv, :, 1])
+                    ldp[ids][ipv, :, 0] = self._ip_ld(self.wavelengths[ids], self.ld_knots, ldk[ipv, :, 0])
+                    ldp[ids][ipv, :, 1] = self._ip_ld(self.wavelengths[ids], self.ld_knots, ldk[ipv, :, 1])
             return ldp
 
     def transit_model(self, pv, copy=True):
@@ -642,6 +692,10 @@ class TSLPF(LogPosteriorFunction):
     def flux_model(self, pv):
         transit_models = self.transit_model(pv)
         baseline_models = self.baseline_model(pv)
+        if self.spot_model is not None:
+            self.spot_model.apply_spots(pv, transit_models)
+            if self.spot_model.include_tlse:
+                self.spot_model.apply_tlse(pv, transit_models)
         for i in range(self.data.size):
             transit_models[i][:, :, :] *= baseline_models[i][:, :, newaxis]
         return transit_models

exoiris/util.py

@@ -15,8 +15,10 @@
 #  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from numba import njit
-from numpy import zeros, sum, sqrt, linspace, vstack, concatenate, floor, dot, ndarray, nan
-
+from numpy import (zeros, sum, sqrt, linspace, vstack, concatenate, floor, dot, ndarray, nan, asarray, tile)
+from numpy._typing import ArrayLike
+from pytransit import TSModel
+from pytransit.orbits import i_from_ba
 
 @njit
 def bin2d(v, e, el, er, bins, estimate_errors: bool = False) -> tuple[ndarray, ndarray]:
@@ -116,4 +118,45 @@ def create_binning(ranges, bwidths):
         n = int(floor((r[1] - r[0]) / w))
         e = linspace(*r, num=n)
         bins.append(vstack([e[:-1], e[1:]]).T)
-    return concatenate(bins)
+    return concatenate(bins)
+
+
+def create_mock_model(ks: ArrayLike, times: ArrayLike = None, ldc: ArrayLike = None, t0: float = 0.0, p: float =2.0, a: float =8.0, b: float =0.0) -> ndarray:
+    """Create a mock transmission spectrum observation using given parameters.
+
+    Parameters
+    ----------
+    ks
+        Array of radius ratios, one radius ratio per wavelength.
+    times
+        Array of time values to set the data points. If None, defaults to a
+        linspace of 500 points in the range [-0.1, 0.1].
+    ldc
+        Array representing the limb darkening coefficients. If None, defaults to
+        a tile of [0.4, 0.4] for each wavelength element.
+    t0
+        Transit center.
+    p
+        Orbital period.
+    a
+        Semi-major axis.
+    b
+        Impact parameter.
+
+    Returns
+    -------
+    ndarray
+        Mock spectrophotometric light curves.
+
+    """
+    ks = asarray(ks)
+    if times is None:
+        times = linspace(-0.1, 0.1, 500)
+    if ldc is None:
+        ldc = tile([0.4, 0.4], (1, ks.size, 1))
+    inc = i_from_ba(b, a)
+
+    m1 = TSModel('power-2', ng=100, nzin=50, nzlimb=50)
+    m1.set_data(times)
+    f1 = m1.evaluate(ks, ldc, t0, p, a, inc)[0]
+    return f1

exoiris-0.21.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: ExoIris
+Version: 0.21.0
+Summary: Easy and robust exoplanet transmission spectroscopy.
+Author-email: Hannu Parviainen <hannu@iac.es>
+License: GPLv3
+Project-URL: homepage, https://github.com/hpparvi/ExoIris
+Keywords: astronomy,astrophysics,exoplanets
+Classifier: Topic :: Scientific/Engineering
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytransit>=2.6.15
+Requires-Dist: ldtk>=1.8.5
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: numba
+Requires-Dist: emcee
+Requires-Dist: matplotlib
+Requires-Dist: celerite2
+Requires-Dist: pandas
+Requires-Dist: xarray
+Requires-Dist: seaborn
+Requires-Dist: astropy
+Requires-Dist: uncertainties
+Dynamic: license-file
+
+# ExoIris: Fast and Flexible Transmission Spectroscopy in Python
+
+[![Docs](https://readthedocs.org/projects/exoiris/badge/)](https://exoiris.readthedocs.io)
+![Python package](https://github.com/hpparvi/ExoIris/actions/workflows/python-package.yml/badge.svg)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](CODE_OF_CONDUCT.md)
+[![Licence](http://img.shields.io/badge/license-GPLv3-blue.svg?style=flat)](http://www.gnu.org/licenses/gpl-3.0.html)
+[![PyPI version](https://badge.fury.io/py/exoiris.svg)](https://pypi.org/project/ExoIris/)
+
+**ExoIris** is a Python package for modeling exoplanet transmission spectroscopy. ExoIris removes the typical 
+limitations of the two-step workflow by modeling the full two-dimensional spectroscopic transit time series *directly*.
+It supports combining transmission spectroscopy datasets from multiple instruments observed in different epochs, yielding 
+self-consistent wavelength-independent and wavelength-dependent parameters, simplifying joint analyses, and delivering 
+results quickly.
+
+![](doc/source/examples/e01/example1.png)
+
+## Why ExoIris?
+
+Transmission spectroscopy is often done following a **two-step workflow**: (1) fit a white light curve to infer 
+wavelength-independent parameters; (2) fit each spectroscopic light curve independently, constrained by the white-light 
+solution. This split can introduce approximations and inconsistencies.
+
+**ExoIris takes a different approach.** It models spectrophotometric time series *end-to-end*, enabling:
+
+- Self-consistent inference of shared (wavelength-independent) and spectral (wavelength-dependent) parameters.
+- **Joint** modeling of multiple datasets from different instruments and epochs.
+- Accounting for **transit timing variations** and dataset-dependent offsets within a unified framework.
+
+This design is a natural fit for **JWST-class** data, where correlated noise, multi-epoch observations, and 
+cross-instrument combinations are the norm.
+
+## Documentation
+
+Full documentation and tutorials: <https://exoiris.readthedocs.io>
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install exoiris
+```
+
+Latest development version:
+
+```bash
+git clone https://github.com/hpparvi/ExoIris.git
+cd ExoIris
+pip install -e .
+```
+
+ExoIris supports Python 3.9+. See the docs for dependency details and optional extras.
+
+## Key Features
+
+- **Direct modelling of spectroscopic transit time series**  
+  Built on PyTransit’s `TSModel`, optimised for transmission spectroscopy; scales to hundreds–thousands of light curves simultaneously.
+
+- **Flexible limb darkening**  
+  Use standard analytical laws (quadratic, power-2, non-linear), numerical intensity profiles from stellar atmosphere models, or user-defined radially symmetric functions.
+
+- **Robust noise treatment**  
+  Choose white noise or **time-correlated** noise via a Gaussian Process likelihood, without changing the overall workflow.
+
+- **Full control of spectral resolution**  
+  The transmission spectrum is represented as a cubic spline with user-defined knots, allowing variable resolution across wavelength.
+
+- **Reproducible, incremental workflows**  
+  Save and reload models to refine a low-resolution run into a high-resolution analysis seamlessly.
+
+- **Joint multi-dataset analyses**  
+  Combine instruments and epochs in one fit, with support for transit timing variations and dataset-specific systematics and offsets.
+
+## Performance
+
+ExoIris is designed for speed and stability:
+
+- A transmission spectroscopy analysis of a single JWST/NIRISS dataset at **R ≈ 100** typically runs in **3–5 minutes** 
+  assuming white noise, or **5–15 minutes** with a GP noise model, on a standard desktop CPU.
+- A high-resolution analysis of the JWST/NIRISS **WASP-39 b** dataset (~3800 spectroscopic light curves; see Feinstein 
+  et al. 2023) can be optimised and sampled in about **1.5 hours** on an AMD Ryzen 7 5800X (8 cores, ~3-year-old desktop).
+
+---
+
+© 2025 Hannu Parviainen

exoiris-0.21.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+exoiris/__init__.py,sha256=LU5jAE7_OVPLHFO0UAOGS0e0wuWV6rdSD0Qveet11K8,1147
+exoiris/binning.py,sha256=-Y9hdK0jZj8DOS82keaprneid2lZ4rCx-keWlKi0LP8,6455
+exoiris/ephemeris.py,sha256=dthBkJztT5yAP6VnnO7jGvxikboFUQBUGPUfBCFrA3w,1316
+exoiris/exoiris.py,sha256=YRTieXTSXa4G0HBfKfDlFw52i3nKHa3OKrspfhJj5oE,55721
+exoiris/ldtkld.py,sha256=7H1r1xail3vSKdsNKorMTqivnRKU9WrOVH-uE4Ky2jM,3495
+exoiris/loglikelihood.py,sha256=AMssTs-lIMbnB5p9Y5z5Qb5XimP3TEfUUsHjW_n-MUM,6315
+exoiris/spotmodel.py,sha256=9-DxvVzGzxf6AjQfrzZreyJB4Htw0gsIAD3nWl0tQMc,7160
+exoiris/tsdata.py,sha256=WqId5rfZR08pFZ83UZiyO39-QjX6WcB1GrUYolZsM-4,35323
+exoiris/tslpf.py,sha256=VOMnAJuX_adnipk5T4rZ2V6KIeVrvfhj8agDRCHrYTA,31573
+exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
+exoiris/util.py,sha256=uNv_c3Kuv1lml8MuDAuyElO4s3f1tRIQ1QMlLaI7Yak,5921
+exoiris/wlpf.py,sha256=g6h1cLk2-nKD8u_FzwXNVVGFK4dry8fBr0A70LA5gJw,6281
+exoiris-0.21.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+exoiris-0.21.0.dist-info/METADATA,sha256=En9nJ-OKz5_H7W9XPVXjjPtBZepegbkhBsebaM8lvDQ,5056
+exoiris-0.21.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+exoiris-0.21.0.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
+exoiris-0.21.0.dist-info/RECORD,,

exoiris-0.19.2.dist-info/METADATA

@@ -1,81 +0,0 @@
-Metadata-Version: 2.4
-Name: ExoIris
-Version: 0.19.2
-Summary: Easy and robust exoplanet transmission spectroscopy.
-Author-email: Hannu Parviainen <hannu@iac.es>
-License: GPLv3
-Project-URL: homepage, https://github.com/hpparvi/ExoIris
-Keywords: astronomy,astrophysics,exoplanets
-Classifier: Topic :: Scientific/Engineering
-Classifier: Intended Audience :: Science/Research
-Classifier: Intended Audience :: Developers
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pytransit>=2.6.15
-Requires-Dist: ldtk>=1.8.5
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: numba
-Requires-Dist: emcee
-Requires-Dist: matplotlib
-Requires-Dist: celerite2
-Requires-Dist: pandas
-Requires-Dist: xarray
-Requires-Dist: seaborn
-Requires-Dist: astropy
-Requires-Dist: uncertainties
-Dynamic: license-file
-
-# ExoIris: Transmission Spectroscopy Made Easy
-
-[![Docs](https://readthedocs.org/projects/exoiris/badge/)](https://exoiris.readthedocs.io)
-![Python package](https://github.com/hpparvi/ExoIris/actions/workflows/python-package.yml/badge.svg)
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](CODE_OF_CONDUCT.md)
-[![Licence](http://img.shields.io/badge/license-GPLv3-blue.svg?style=flat)](http://www.gnu.org/licenses/gpl-3.0.html)
-[![PyPI version](https://badge.fury.io/py/exoiris.svg)](https://pypi.org/project/ExoIris/)
-
-**ExoIris** is a user-friendly Python package designed to simplify and accelerate the analysis of transmission 
-spectroscopy data for exoplanets. The package can estimate a self-consistent medium-resolution transmission spectrum 
-with uncertainties from JWST NIRISS data in minutes, even when using a Gaussian Process-based noise model.
-
-![](doc/source/examples/e01/example1.png)
-
-## Documentation
-
-Read the docs at [exoiris.readthedocs.io](https://exoiris.readthedocs.io).
-
-## Key Features
-
-- **Fast modelling of spectroscopic transit time series**: ExoIris uses PyTransit's advanced `TSModel` transit 
-  model that is specially tailored for fast and efficient modelling of spectroscopic transit (or eclipse) time series.
-- **Flexible handling of limb darkening**: The stellar limb darkening can be modelled freely either by any of the standard 
-  limb darkening laws (quadratic, power-2, non-linear, etc.), by numerical stellar intensity profiles obtained
-  directly from stellar atmosphere models, or by an arbitrary ser-defined radially symmetric function.
-- **Handling of Correlated noise**: The noise model can be chosen between white or time-correlated noise, where the
-  time-correlated noise is modelled as a Gaussian process.
-- **Model saving and loading**: Seamless model saving and loading allows one to create a high-resolution analysis starting
-  from a saved low-resolution analysis.
-- **Full control of resolution**: ExoIris represents the transmission spectrum as a cubic spline, with complete 
-  flexibility to set and modify the number and placement of spline knots, allowing variable resolution throughout the 
-  analysis.
-
-## Details
-
-ExoIris uses PyTransit's `TSModel`, a transit model that is specially optimised for transmission spectroscopy and allows
-for simultaneous modelling of hundreds to thousands of spectroscopic light curves 20-30 times faster than when using 
-standard transit models not explicitly designed for transmission spectroscopy. 
-
-A complete posterior solution for a low-resolution transmission spectrum with a data resolution of R=100 
-takes 3-5 minutes to estimate assuming white noise, or 5-15 minutes if using a Gaussian process-based likelihood
-model powered by the celerite2 package. A high-resolution spectrum of the JWST NIRISS WASP-39 b observations 
-by [Feinstein et al. (2023)](https://ui.adsabs.harvard.edu/abs/2023Natur.614..670F/abstract) with ~3800
-spectroscopic light curves (as shown above) takes about 1.5 hours to optimise and sample on a three-year-old 
-AMD Ryzen 7 5800X with eight cores.
-
----
-&copy; 2024 Hannu Parviainen

exoiris-0.19.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-exoiris/__init__.py,sha256=LU5jAE7_OVPLHFO0UAOGS0e0wuWV6rdSD0Qveet11K8,1147
-exoiris/binning.py,sha256=-Y9hdK0jZj8DOS82keaprneid2lZ4rCx-keWlKi0LP8,6455
-exoiris/ephemeris.py,sha256=dthBkJztT5yAP6VnnO7jGvxikboFUQBUGPUfBCFrA3w,1316
-exoiris/exoiris.py,sha256=s-q5QoV2Vj4qDHfocXrdZZo0C99E3iTr3g8OjTTgaug,51312
-exoiris/ldtkld.py,sha256=7H1r1xail3vSKdsNKorMTqivnRKU9WrOVH-uE4Ky2jM,3495
-exoiris/tsdata.py,sha256=jEaoz9EvUtbZ3GS-W9ymp07NR952gfiBPlhs4Olll6I,35326
-exoiris/tslpf.py,sha256=mpzYdubNXkeLAaQdUKKBuKJ6iDN_KEl4cOh4wcBB-g0,29734
-exoiris/tsmodel.py,sha256=6NaGY48fWHUT_7ti6Ao618PN-LgyoIhfQd8lZQqZ7hU,5160
-exoiris/util.py,sha256=5PynwYYHRrzyXJHskBtp2J-pcM59zsA1_VtDxencQm4,4630
-exoiris/wlpf.py,sha256=g6h1cLk2-nKD8u_FzwXNVVGFK4dry8fBr0A70LA5gJw,6281
-exoiris-0.19.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-exoiris-0.19.2.dist-info/METADATA,sha256=rmLHmfpXXera-ZGV_S3CHVi5oakrP317i-oeLrEaoYM,4214
-exoiris-0.19.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-exoiris-0.19.2.dist-info/top_level.txt,sha256=EoNxT6c5mQDcM0f_LUQB-ETsYg03lNaV3o2L_Yc6-aE,8
-exoiris-0.19.2.dist-info/RECORD,,