diff --git a/src/sp_validation/cosmo_val/psf_systematics.py b/src/sp_validation/cosmo_val/psf_systematics.py
index 465aa937..3fee6b33 100644
--- a/src/sp_validation/cosmo_val/psf_systematics.py
+++ b/src/sp_validation/cosmo_val/psf_systematics.py
@@ -209,15 +209,27 @@ def calculate_scale_dependent_leakage(self):
 
         self.print_done("Finished scale-dependent leakage calculation.")
 
-    def calculate_objectwise_leakage(self):
-        # TODO: Upgrade for tomography
-        if not hasattr(self.results[self.versions[0]], "alpha_leak_mean"):
-            self.calculate_scale_dependent_leakage()
+    def calculate_objectwise_leakage(self, tomography=False):
+        """Fit the object-wise PSF leakage, per version and tomographic bin.
+
+        Stores ``a11``, ``a22`` and ``aii_mean`` (as ufloats) in
+        ``self.leakage_coeff[ver]["tomo_bin_<id>"]``, with ``<id>`` ``all`` when
+        ``tomography`` is False. A version whose catalogue lacks a required
+        column is dropped from ``results_objectwise`` and ``leakage_coeff``.
+        """
+        tomo_bins = self._get_tomo_bins_for_versions(
+            self.versions, tomography=tomography
+        )
 
         self.print_start("Object-wise leakage:")
         mix = True
         order = "lin"
+        if not hasattr(self, "leakage_coeff"):
+            self.leakage_coeff = {}
         for ver in self.versions:
+            if ver not in self.results_objectwise:
+                # Dropped earlier for a missing catalogue column
+                continue
             self.print_magenta(ver)
 
             results_obj = self.results_objectwise[ver]
@@ -225,57 +237,62 @@ def calculate_objectwise_leakage(self):
             results_obj.update_params()
             results_obj.prepare_output()
 
-            # Skip read_data() and copy catalogue from scale leakage instance instead
-            # results_obj._dat = self.results[ver].dat_shear
+            coeff_ver = self.leakage_coeff.setdefault(ver, {})
+            try:
+                for tomo_bin_id in tomo_bins[ver]["ids"]:
+                    coeff_ver[f"tomo_bin_{tomo_bin_id}"] = self._objectwise_leakage_bin(
+                        results_obj, ver, tomo_bin_id, mix, order
+                    )
+            except KeyError as e:
+                print(f"{e}\nExpected key is missing from catalog.")
+                self.results_objectwise.pop(ver)
+                self.leakage_coeff.pop(ver)
+
+    def _objectwise_leakage_bin(self, results_obj, ver, tomo_bin_id, mix, order):
+        """Object-wise leakage coefficients of one tomographic bin."""
+        selection = (
+            None if tomo_bin_id == "all" else self._get_galaxy_mask(ver, tomo_bin_id)
+        )
+        suffix = f"tomo_bin_{tomo_bin_id}"
 
-            out_base = results_obj.get_out_base(mix, order)
-            out_path = f"{out_base}.pkl"
-            if os.path.exists(out_path):
-                self.print_green(
-                    f"Skipping object-wise leakage, file {out_path} exists"
+        out_path = f"{results_obj.get_out_base(mix, order, suffix=suffix)}.pkl"
+        if os.path.exists(out_path):
+            self.print_green(f"Skipping object-wise leakage, file {out_path} exists")
+            results_obj.par_best_fit = leakage.read_from_file(out_path)
+        else:
+            self.print_cyan(f"Computing object-wise leakage regression, {suffix}")
+            with results_obj.temporarily_read_data(selection=selection):
+                results_obj.PSF_leakage(mix=mix, order=order, suffix=suffix)
+
+        par_best_fit = results_obj.par_best_fit
+        a11 = ufloat(par_best_fit["a11"].value, par_best_fit["a11"].stderr)
+        a22 = ufloat(par_best_fit["a22"].value, par_best_fit["a22"].stderr)
+        return {"a11": a11, "a22": a22, "aii_mean": 0.5 * (a11 + a22)}
+
+    def calculate_alpha_leakage_summaries(self, tomography=False, cov_type=None):
+        """Summarise the scale-dependent leakage alpha(theta) = tau_0 / rho_0.
+
+        For each version in ``leakage_coeff`` and each of its tomographic bins,
+        stores ``alpha_mean``, ``alpha_1`` and ``alpha_0`` (see
+        `_alpha_summaries`) next to the object-wise coefficients in
+        ``self.leakage_coeff[ver]["tomo_bin_<id>"]``.
+        """
+        tomo_bins = self._get_tomo_bins_for_versions(
+            list(self.leakage_coeff), tomography=tomography
+        )
+        for ver, coeff_ver in self.leakage_coeff.items():
+            for tomo_bin_id in tomo_bins[ver]["ids"]:
+                theta, alpha, alpha_err = self._load_alpha_leakage(
+                    ver, tomo_bin_id, cov_type
+                )
+                coeff_ver.setdefault(f"tomo_bin_{tomo_bin_id}", {}).update(
+                    self._alpha_summaries(theta, alpha, alpha_err)
                 )
-                results_obj.par_best_fit = leakage.read_from_file(out_path)
-            else:
-                self.print_cyan("Computing object-wise leakage regression")
-
-            # Run
-            with results_obj.temporarily_read_data():
-                try:
-                    results_obj.PSF_leakage()
-                except KeyError as e:
-                    print(f"{e}\nExpected key is missing from catalog.")
-                    # remove the results object for this version
-                    self.results_objectwise.pop(ver)
-
-        # Gather coefficients
-        leakage_coeff = {}
-        for ver in self.results_objectwise:
-            results = self.results[ver]
-            par_best_fit = self.results_objectwise[ver].par_best_fit
-
-            # Object-wise leakage
-            a11 = ufloat(par_best_fit["a11"].value, par_best_fit["a11"].stderr)
-            a22 = ufloat(par_best_fit["a22"].value, par_best_fit["a22"].stderr)
-            leakage_coeff[ver] = {
-                "a11": a11,
-                "a22": a22,
-                "aii_mean": 0.5 * (a11 + a22),
-                # Scale-dependent leakage: mean
-                "alpha_mean": ufloat(results.alpha_leak_mean, results.alpha_leak_std),
-                # Scale-dependent leakage: value at smallest scale
-                "alpha_1": ufloat(results.alpha_leak[0], results.sig_alpha_leak[0]),
-                # Scale-dependent leakage: value extrapolated to 0 using affine model
-                "alpha_0": ufloat(
-                    results.alpha_affine_best_fit["c"].value,
-                    results.alpha_affine_best_fit["c"].stderr,
-                ),
-            }
-
-        self.leakage_coeff = leakage_coeff
 
     # --- utility functions ---
     def _get_galaxy_mask(self, ver, tomo_bin_id):
-        cat_gal = fits.getdata(self.cc[ver]["shear"]["path"])
+        # HDU 1 is the table LeakageObject.read_data reads, so masks align by row
+        cat_gal = fits.getdata(self.cc[ver]["shear"]["path"], ext=1)
         if tomo_bin_id != "all":
             gal_mask = cat_gal[self.cc[ver]["shear"]["tomo_bin_col"]] == tomo_bin_id
         else:
@@ -453,6 +470,191 @@ def get_xi_psf_sys_samples(self, ver, params, tomo_bin_a, tomo_bin_b):
 
         return xi_psf_sys_samples_plus, xi_psf_sys_samples_minus
 
+    def _load_alpha_leakage(self, ver, tomo_bin_id, cov_type=None, seed=0):
+        """Alpha(theta) of one version and tomographic bin from its rho/tau files.
+
+        With ``cov_type`` None the errors use the variances in the rho/tau
+        files; otherwise the ``cov_tau_*_<cov_type>.npy`` and jackknife
+        ``cov_rho_*_jk.npy`` covariances under ``rho_tau_stats/``.
+        """
+        base_rho = self.basename(ver)
+        base_tau = self.basename(ver, tomo_bin_a=tomo_bin_id)
+        self.rho_stat_handler.load_rho_stats(f"rho_stats_{base_rho}.fits")
+        self.tau_stat_handler.load_tau_stats(f"tau_stats_{base_tau}.fits")
+
+        if cov_type is not None:
+            out_dir = Path(self.cc["paths"]["output"]) / "rho_tau_stats"
+            cov_tau = np.load(out_dir / f"cov_tau_{base_tau}_{cov_type}.npy")
+            cov_rho = np.load(out_dir / f"cov_rho_{base_rho}_jk.npy")
+        else:
+            cov_tau = None
+            cov_rho = None
+
+        return self._get_alpha_leakage(
+            self.rho_stat_handler,
+            self.tau_stat_handler,
+            cov_rho,
+            cov_tau,
+            seed=seed,
+        )
+
+    def _get_alpha_leakage(
+        self,
+        rho_stat_handler,
+        tau_stat_handler,
+        cov_rho=None,
+        cov_tau=None,
+        n_samples=10_000,
+        seed=0,
+    ):
+        """
+        Compute the alpha leakage parameter from the rho and tau statistics.
+
+        alpha(theta) = tau_0,+(theta) / rho_0,+(theta); its error is the standard
+        deviation of that ratio over Gaussian draws of rho_0,+ and tau_0,+.
+
+        Parameters
+        ----------
+        rho_stat_handler : RhoStatHandler
+            The handler for the rho statistics.
+        tau_stat_handler : TauStatHandler
+            The handler for the tau statistics.
+        cov_rho : np.ndarray, optional
+            The covariance matrix for the rho statistics; its leading block is
+            the rho_0,+ covariance. If None, the variances in the rho-statistics
+            table are used.
+        cov_tau : np.ndarray, optional
+            The covariance matrix for the tau statistics; its leading block is
+            the tau_0,+ covariance. If None, the variances in the tau-statistics
+            table are used.
+        n_samples : int, optional
+            Number of Gaussian draws for the error.
+        seed : int or np.random.Generator, optional
+            Seed (or generator) for the draws, so that errors are reproducible.
+
+        Returns
+        -------
+        theta, alpha, alpha_err : np.ndarray
+            Angular scales, alpha leakage and its error.
+        """
+        if cov_rho is None:
+            cov_rho = np.diag(rho_stat_handler.rho_stats["varrho_0_p"])
+        if cov_tau is None:
+            cov_tau = np.diag(tau_stat_handler.tau_stats["vartau_0_p"])
+
+        theta = rho_stat_handler.rho_stats["theta"]
+        n_bins = len(theta)
+        alpha = (
+            tau_stat_handler.tau_stats["tau_0_p"]
+            / rho_stat_handler.rho_stats["rho_0_p"]
+        )
+
+        rng = np.random.default_rng(seed)
+        rho_samples = rng.multivariate_normal(
+            mean=rho_stat_handler.rho_stats["rho_0_p"],
+            cov=cov_rho[:n_bins, :n_bins],
+            size=n_samples,
+        )
+        tau_samples = rng.multivariate_normal(
+            mean=tau_stat_handler.tau_stats["tau_0_p"],
+            cov=cov_tau[:n_bins, :n_bins],
+            size=n_samples,
+        )
+
+        alpha_samples = tau_samples / rho_samples
+        alpha_err = np.std(alpha_samples, axis=0)
+
+        return theta, alpha, alpha_err
+
+    @staticmethod
+    def _alpha_summaries(theta, alpha, alpha_err):
+        """Scalar summaries of alpha(theta), as ufloats.
+
+        Returns
+        -------
+        dict
+            ``alpha_mean``: inverse-variance weighted mean of alpha(theta), with
+            the weighted standard deviation; ``alpha_1``: alpha and its error at
+            the smallest theta; ``alpha_0``: intercept c of the weighted
+            least-squares affine fit alpha(theta) = c + m theta, with its error
+            from the fit covariance (errors taken as absolute).
+        """
+        theta = np.asarray(theta, dtype=float)
+        alpha = np.asarray(alpha, dtype=float)
+        alpha_err = np.asarray(alpha_err, dtype=float)
+
+        weights = 1 / alpha_err**2
+        mean = np.average(alpha, weights=weights)
+        std = np.sqrt(np.average((alpha - mean) ** 2, weights=weights))
+
+        i_min = np.argmin(theta)
+
+        (_, c), cov = np.polyfit(theta, alpha, 1, w=1 / alpha_err, cov="unscaled")
+
+        return {
+            "alpha_mean": ufloat(mean, std),
+            "alpha_1": ufloat(alpha[i_min], alpha_err[i_min]),
+            "alpha_0": ufloat(c, np.sqrt(cov[1, 1])),
+        }
+
+    def _compute_scale_dependent_xi_psf_sys(
+        self,
+        rho_0,
+        tau_0_a,
+        tau_0_b,
+        cov_rho,
+        cov_tau_a,
+        cov_tau_b,
+        n_samples=10_000,
+        same_bin=False,
+        seed=0,
+    ):
+        """
+        Compute the scale-dependent xi_psf_sys from the rho and tau statistics.
+
+        xi_psf_sys = tau_0_a * tau_0_b / rho_0; its error is the standard
+        deviation over Gaussian draws of rho_0, tau_0_a and tau_0_b.
+
+        Parameters
+        ----------
+        rho_0 : np.ndarray
+            The rho_0 statistics.
+        tau_0_a : np.ndarray
+            The tau_0 statistics for tomographic bin a.
+        tau_0_b : np.ndarray
+            The tau_0 statistics for tomographic bin b.
+        cov_rho : np.ndarray
+            The covariance matrix for the rho statistics.
+        cov_tau_a : np.ndarray
+            The covariance matrix for the tau statistics for tomographic bin a.
+        cov_tau_b : np.ndarray
+            The covariance matrix for the tau statistics for tomographic bin b.
+        n_samples : int, optional
+            Number of Gaussian draws for the error.
+        same_bin : bool, optional
+            True when a and b are the same bin: tau_0_a and tau_0_b are then one
+            measurement, and each draw uses a single tau sample (tau^2 / rho).
+        seed : int or np.random.Generator, optional
+            Seed (or generator) for the draws, so that errors are reproducible.
+        """
+        xi_psf_sys = (tau_0_a * tau_0_b) / rho_0
+
+        rng = np.random.default_rng(seed)
+        rho_samples = rng.multivariate_normal(mean=rho_0, cov=cov_rho, size=n_samples)
+        tau_samples_a = rng.multivariate_normal(
+            mean=tau_0_a, cov=cov_tau_a, size=n_samples
+        )
+        if same_bin:
+            tau_samples_b = tau_samples_a
+        else:
+            tau_samples_b = rng.multivariate_normal(
+                mean=tau_0_b, cov=cov_tau_b, size=n_samples
+            )
+        xi_psf_sys_samples = (tau_samples_a * tau_samples_b) / rho_samples
+        xi_psf_sys_err = np.std(xi_psf_sys_samples, axis=0)
+
+        return xi_psf_sys, xi_psf_sys_err
+
     # --- plotting functions ---
     def plot_rho_stats(
         self,
@@ -901,213 +1103,257 @@ def plot_rho_tau_fits(
             **kwargs_x_y_plot_function,
         )
 
-        """
-        for mcmc_result, ver, flat_sample in zip(
-            self.rho_tau_fits["result_list"],
-            self.versions,
-            self.rho_tau_fits["flat_samples"],
-        ):
-            self.psf_fitter.load_rho_stat(f"rho_stats_{self.basename(ver)}.fits")
-            for yscale in ("linear", "log"):
-                out_path = os.path.abspath(
-                    f"{out_dir}/xi_psf_sys_terms_{yscale}_{ver}.png"
+    def plot_scale_dependent_leakage(
+        self,
+        tomography=False,
+        cov_type=None,
+        versions=None,
+        colors=None,
+        offset=0,
+        savefig=None,
+        show=True,
+        close=True,
+        plot_theta_times_tau=False,
+        ylim_alpha=False,
+        fmt="",
+        capsize=2,
+    ):
+        # First plot alpha leakage
+        self.plot_scale_dependent_alpha(
+            tomography=tomography,
+            cov_type=cov_type,
+            versions=versions,
+            colors=colors,
+            offset=offset,
+            savefig=savefig,
+            show=show,
+            close=close,
+            fmt=fmt,
+            capsize=capsize,
+            ylim_alpha=ylim_alpha,
+        )
+
+        # Second plot xi_sys
+        self.plot_2pcf_tomography(
+            self._scale_dependent_xi_psf_sys_x_y_plot_function,
+            x_label=r"$\theta$ [arcmin]",
+            y_label_plus=(r"$\theta$" if plot_theta_times_tau else "")
+            + r"$\xi^{\rm PSF, sys}_+(\theta)$",
+            y_label_minus=(r"$\theta$" if plot_theta_times_tau else "")
+            + r"$\xi^{\rm PSF, sys}_-(\theta)$",
+            tomo_bin_label_position=(0.05, 0.9)
+            if not plot_theta_times_tau
+            else (0.8, 0.95),
+            extract_text_offset=plot_theta_times_tau,
+            add_index_version_to_kwargs=True,
+            x_scale="log",
+            y_scale="linear" if plot_theta_times_tau else "log",
+            tomography=tomography,
+            versions=versions,
+            colors=colors,
+            savefig=savefig.replace(".png", "_xi_psf_sys.png")
+            if savefig is not None
+            else None,
+            show=show,
+            close=close,
+            offset=offset,
+            cov_type=cov_type,
+            times_theta=plot_theta_times_tau,
+            fmt=fmt,
+            capsize=capsize,
+        )
+
+    def plot_scale_dependent_alpha(
+        self,
+        tomography=False,
+        cov_type=None,
+        versions=None,
+        colors=None,
+        offset=0,
+        savefig=None,
+        show=True,
+        close=True,
+        fmt="",
+        capsize=2,
+        ylim_alpha=False,
+    ):
+        if versions is None:
+            versions = self.versions
+
+        if colors is None:
+            colors = [self.cc[ver]["colour"] for ver in versions]
+
+        if len(colors) != len(versions):
+            raise ValueError("Colors and versions must have the same length.")
+
+        if cov_type is None:
+            self.print_cyan("Using the error bars from the tau-statistics files")
+        else:
+            self.print_cyan(
+                f"Using the error bars from the covariance files of type: {cov_type}"
+            )
+
+        tomo_bins = self._get_tomo_bins_for_versions(versions, tomography=tomography)
+
+        n_tomo_bins_plot = max(len(bins["ids"]) for bins in tomo_bins.values())
+
+        fig, axs = plt.subplots(
+            n_tomo_bins_plot, 1, figsize=(8, 3 * n_tomo_bins_plot), sharex=True
+        )
+
+        # Iterate upon each version
+        for ver, color in zip(versions, colors):
+            label = self.cc[ver]["label"] if "label" in self.cc[ver] else ver
+            # Iterate upon each tomographic bin
+            for tomo_bin_id in tomo_bins[ver]["ids"]:
+                theta, alpha, alpha_err = self._load_alpha_leakage(
+                    ver, tomo_bin_id, cov_type
                 )
-                self.psf_fitter.plot_xi_psf_sys_terms(
-                    ver, mcmc_result[1], out_path, yscale=yscale, show=True
+
+                jittered_theta = self._get_jittered_theta(
+                    theta, versions.index(ver), len(versions), offset
                 )
-                self.print_done(
-                    f"{yscale}-scale xi_psf_sys terms plot saved to {out_path}"
+
+                if tomo_bin_id == "all":
+                    ax = axs
+                else:
+                    ax = axs[tomo_bin_id - 1]
+
+                ax.errorbar(
+                    jittered_theta,
+                    alpha,
+                    yerr=alpha_err,
+                    fmt=fmt,
+                    label=f"{label}",
+                    capsize=capsize,
+                    color=color,
                 )
-        """
 
-    def plot_scale_dependent_leakage(self):
-        if not hasattr(self.results[self.versions[0]], "r_corr_gp"):
-            self.calculate_scale_dependent_leakage()
+        if tomography:
+            for i, ax in enumerate(axs):
+                ax.set_xscale("log")
+                ax.set_xlim(self.theta_min_plot, self.theta_max_plot)
+                if ylim_alpha:
+                    ax.set_ylim(self.ylim_alpha)
+                ax.set_ylabel(rf"$\alpha_{i + 1}(\theta)$")
+                if i == len(axs) - 1:
+                    ax.set_xlabel(r"$\theta$ [arcmin]")
+                ax.text(0.05, 0.9, f"Tomo bin {i + 1}", transform=ax.transAxes)
+        else:
+            axs.set_xscale("log")
+            axs.set_xlim(self.theta_min_plot, self.theta_max_plot)
+            if ylim_alpha:
+                axs.set_ylim(self.ylim_alpha)
+            axs.set_ylabel(r"$\alpha_{\rm all}(\theta)$")
+            axs.set_xlabel(r"$\theta$ [arcmin]")
+            axs.text(0.05, 0.9, "All tomographic bins", transform=axs.transAxes)
 
-        theta = []
-        y = []
-        yerr = []
-        labels = []
-        colors = []
-        linestyles = []
-        markers = []
+        if tomography:
+            handles, labels = axs[0].get_legend_handles_labels()
+        else:
+            handles, labels = axs.get_legend_handles_labels()
+
+        fig.legend(
+            handles,
+            labels,
+            loc="upper center",
+            bbox_to_anchor=(0.5, -0.02),
+            ncol=3,
+            frameon=False,
+        )
 
-        for ver in self.versions:
-            if hasattr(self.results[ver], "r_corr_gp"):
-                theta.append(self.results[ver].r_corr_gp.meanr)
-                y.append(self.results[ver].alpha_leak)
-                yerr.append(self.results[ver].sig_alpha_leak)
-                labels.append(ver)
-                colors.append(self.cc[ver]["colour"])
-                linestyles.append(self.cc[ver]["ls"])
-                markers.append(self.cc[ver]["marker"])
-
-        if len(theta) > 0:
-            # Log x
-            out_path = self._output_path("alpha_leak_log.png")
-
-            title = r"$\alpha$ leakage"
-            xlabel = r"$\theta$ [arcmin]"
-            ylabel = r"$\alpha(\theta)$"
-            cs_plots.plot_data_1d(
-                theta,
-                y,
-                yerr,
-                title,
-                xlabel,
-                ylabel,
-                out_path=None,
-                xlog=True,
-                xlim=[self.theta_min_plot, self.theta_max_plot],
-                ylim=self.ylim_alpha,
-                labels=labels,
-                colors=colors,
-                linestyles=linestyles,
-                shift_x=True,
-            )
-            cs_plots.savefig(out_path, close_fig=False)
-            cs_plots.show()
-            self.print_done(f"Log-scale alpha leakage plot saved to {out_path}")
-
-            # Lin x
-            out_path = self._output_path("alpha_leak_lin.png")
-
-            title = r"$\alpha$ leakage"
-            xlabel = r"$\theta$ [arcmin]"
-            ylabel = r"$\alpha(\theta)$"
-            cs_plots.plot_data_1d(
-                theta,
-                y,
-                yerr,
-                title,
-                xlabel,
-                ylabel,
-                out_path=None,
-                xlog=False,
-                xlim=[-10, self.theta_max_plot],
-                ylim=self.ylim_alpha,
-                labels=labels,
-                colors=colors,
-                linestyles=linestyles,
-                shift_x=False,
-            )
-            cs_plots.savefig(out_path, close_fig=False)
-            cs_plots.show()
-            self.print_done(f"Lin-scale alpha leakage plot saved to {out_path}")
+        if savefig is not None:
+            plt.savefig(savefig, dpi=300, bbox_inches="tight")
+            self.print_done(f"Scale-dependent alpha leakage plot saved to {savefig}")
 
-        # Plot xi_sys
-        y = []
-        yerr = []
-        colors = []
-        linestyles = []
+        if show:
+            plt.show()
 
-        for ver in self.versions:
-            if hasattr(self.results[ver], "C_sys_p"):
-                y.append(self.results[ver].C_sys_p)
-                yerr.append(self.results[ver].C_sys_std_p)
-                labels.append(ver)
-                colors.append(self.cc[ver]["colour"])
-                linestyles.append(self.cc[ver]["ls"])
-
-        if len(y) > 0:
-            xlabel = r"$\theta$ [arcmin]"
-            ylabel = r"$\xi^{\rm sys}_+(\theta)$"
-            title = "Cross-correlation leakage"
-            out_path = self._output_path("xi_sys_p.png")
-            cs_plots.plot_data_1d(
-                theta,
-                y,
-                yerr,
-                title,
-                xlabel,
-                ylabel,
-                out_path=None,
-                labels=labels,
-                xlog=True,
-                xlim=[self.theta_min_plot, self.theta_max_plot],
-                colors=colors,
-                linestyles=linestyles,
-                # shift_x=True,
-            )
-            cs_plots.savefig(out_path, close_fig=False)
-            cs_plots.show()
-            self.print_done(f"xi_sys_plus plot saved to {out_path}")
+        if close:
+            plt.close()
 
-        y = []
-        yerr = []
-        for ver in self.versions:
-            if hasattr(self.results[ver], "C_sys_m"):
-                y.append(self.results[ver].C_sys_m)
-                yerr.append(self.results[ver].C_sys_std_m)
-
-        if len(y) > 0:
-            xlabel = r"$\theta$ [arcmin]"
-            ylabel = r"$\xi^{\rm sys}_-(\theta)$"
-            title = "Cross-correlation leakage"
-            out_path = self._output_path("xi_sys_m.png")
-            cs_plots.plot_data_1d(
-                theta,
-                y,
-                yerr,
-                title,
-                xlabel,
-                ylabel,
-                out_path=None,
-                labels=labels,
-                xlog=True,
-                xlim=[self.theta_min_plot, self.theta_max_plot],
-                ylim=[-1e-7, 1e-6],
-                colors=colors,
-                linestyles=linestyles,
-                # shift_x=True,
-            )
-            cs_plots.savefig(out_path, close_fig=False)
-            cs_plots.show()
-            self.print_done(f"xi_sys_minus plot saved to {out_path}")
+    def plot_objectwise_leakage(self, tomography=False, cov_type=None):
+        """Plot object-wise leakage against the scale-dependent alpha.
 
-    def plot_objectwise_leakage(self):
-        if not hasattr(self, "leakage_coeff"):
-            self.calculate_objectwise_leakage()
+        x is the object-wise <a_ii>, y the alpha(theta) summaries from the
+        rho/tau products (fill style: mean, smallest scale, affine intercept).
+        Marker shape is the version; colour is the version (non-tomographic) or
+        the tomographic bin. Saved to ``leakage_coefficients.png``, or
+        ``leakage_coefficients_tomo.png`` when ``tomography`` is True.
+        """
+        tomo_bins = self._get_tomo_bins_for_versions(
+            self.versions, tomography=tomography
+        )
+        existing = getattr(self, "leakage_coeff", {})
+        if any(
+            ver in self.results_objectwise
+            and any(f"tomo_bin_{i}" not in existing.get(ver, {}) for i in bins["ids"])
+            for ver, bins in tomo_bins.items()
+        ):
+            self.calculate_objectwise_leakage(tomography=tomography)
+        self.calculate_alpha_leakage_summaries(tomography=tomography, cov_type=cov_type)
 
         self.print_start("Plotting object-wise leakage:")
         cs_plots.figure(figsize=(15, 15))
 
-        linestyles = ["-", "--", ":"]
-        fillstyles = ["full", "none", "left", "right", "bottom", "top"]
-
-        for ver in self.results_objectwise:
-            label = ver
-            for key, ls, fs in zip(
-                ["alpha_mean", "alpha_1", "alpha_0"], linestyles, fillstyles
-            ):
-                x = self.leakage_coeff[ver]["aii_mean"].nominal_value
-                dx = self.leakage_coeff[ver]["aii_mean"].std_dev
-                y = self.leakage_coeff[ver][key].nominal_value
-                dy = self.leakage_coeff[ver][key].std_dev
-
-                eb = plt.errorbar(
-                    x,
-                    y,
-                    xerr=dx,
-                    yerr=dy,
-                    fmt=self.cc[ver]["marker"],
-                    color=self.cc[ver]["colour"],
-                    fillstyle=fs,
-                    label=label,
+        summaries = {
+            "alpha_mean": (r"$\bar\alpha$", "-", "full"),
+            "alpha_1": (r"$\alpha(\theta_{\rm min})$", "--", "none"),
+            "alpha_0": (r"$\alpha(0)$", ":", "left"),
+        }
+        max_bins = max(len(bins["ids"]) for bins in tomo_bins.values())
+        bin_colours = plt.get_cmap("viridis")(np.linspace(0, 0.9, max_bins))
+
+        handles = []
+        for ver in self.leakage_coeff:
+            marker = self.cc[ver]["marker"]
+            ver_colour = "k" if tomography else self.cc[ver]["colour"]
+            for i_bin, tomo_bin_id in enumerate(tomo_bins[ver]["ids"]):
+                coeff = self.leakage_coeff[ver][f"tomo_bin_{tomo_bin_id}"]
+                colour = bin_colours[i_bin] if tomography else ver_colour
+                for key, (_, ls, fs) in summaries.items():
+                    eb = plt.errorbar(
+                        coeff["aii_mean"].nominal_value,
+                        coeff[key].nominal_value,
+                        xerr=coeff["aii_mean"].std_dev,
+                        yerr=coeff[key].std_dev,
+                        fmt=marker,
+                        color=colour,
+                        fillstyle=fs,
+                    )
+                    eb[-1][0].set_linestyle(ls)
+            handles.append(
+                plt.Line2D(
+                    [],
+                    [],
+                    marker=marker,
+                    ls="",
+                    color=ver_colour,
+                    label=self.cc[ver].get("label", ver),
                 )
-                label = None
-                eb[-1][0].set_linestyle(ls)
+            )
+
+        if tomography:
+            handles += [
+                plt.Line2D([], [], marker="s", ls="", color=c, label=f"bin {i + 1}")
+                for i, c in enumerate(bin_colours)
+            ]
+        handles += [
+            plt.Line2D([], [], marker="o", ls=ls, color="grey", fillstyle=fs, label=lab)
+            for lab, ls, fs in summaries.values()
+        ]
 
         # y=x line
         xlim = 0.02
         x = [-xlim, xlim]
-        y = x
-        plt.plot(x, y, "k:", linewidth=0.5)
+        plt.plot(x, x, "k:", linewidth=0.5)
 
-        plt.legend()
-        plt.xlabel(r"tr $a$ (object-wise)")
-        plt.ylabel(r"$\alpha$ (scale-dependent)")
-        out_path = self._output_path("leakage_coefficients.png")
+        plt.legend(handles=handles)
+        plt.xlabel(r"$\langle a_{ii} \rangle$ (object-wise)")
+        plt.ylabel(r"$\alpha$ (scale-dependent, $\tau_0 / \rho_0$)")
+        out_path = self._output_path(
+            f"leakage_coefficients{'_tomo' if tomography else ''}.png"
+        )
         cs_plots.savefig(out_path, close_fig=False)
         cs_plots.show()
         self.print_done(f"Object-wise leakage coefficients plot saved to {out_path}")
@@ -1224,6 +1470,110 @@ def plot_axis(ax, ax_type):
         # Plot the minus axis
         plot_axis(ax_minus, "minus")
 
+    def _scale_dependent_xi_psf_sys_x_y_plot_function(
+        self,
+        ax_plus,
+        ax_minus,
+        version,
+        tomo_bin_a,
+        tomo_bin_b,
+        idx,
+        versions,
+        color,
+        offset,
+        cov_type,
+        times_theta,
+        fmt,
+        capsize,
+    ):
+        # Load the rho-stats and the tau-stats
+        base_rho = self.basename(version)
+        base_tau_a = self.basename(version, tomo_bin_a=tomo_bin_a)
+        base_tau_b = self.basename(version, tomo_bin_a=tomo_bin_b)
+        self.rho_stat_handler.load_rho_stats(f"rho_stats_{base_rho}.fits")
+
+        theta = self.rho_stat_handler.rho_stats["theta"]
+        n_bins = len(theta)
+        rho_0_p = self.rho_stat_handler.rho_stats["rho_0_p"]
+        rho_0_m = self.rho_stat_handler.rho_stats["rho_0_m"]
+
+        tau_stats = {}
+        for key, base_tau in (("a", base_tau_a), ("b", base_tau_b)):
+            self.tau_stat_handler.load_tau_stats(f"tau_stats_{base_tau}.fits")
+            tau_stats[key] = {
+                col: self.tau_stat_handler.tau_stats[col]
+                for col in ("tau_0_p", "tau_0_m", "vartau_0_p", "vartau_0_m")
+            }
+        tau_0_p_a = tau_stats["a"]["tau_0_p"]
+        tau_0_m_a = tau_stats["a"]["tau_0_m"]
+        tau_0_p_b = tau_stats["b"]["tau_0_p"]
+        tau_0_m_b = tau_stats["b"]["tau_0_m"]
+
+        if cov_type is not None:
+            outdir = f"{self.cc['paths']['output']}/rho_tau_stats"
+            cov_tau_path = Path(outdir) / f"cov_tau_{base_tau_a}_{cov_type}.npy"
+            cov_tau_p_a = np.load(cov_tau_path)[:n_bins, :n_bins]
+            cov_tau_path = Path(outdir) / f"cov_tau_{base_tau_b}_{cov_type}.npy"
+            cov_tau_p_b = np.load(cov_tau_path)[:n_bins, :n_bins]
+            cov_rho_path = Path(outdir) / f"cov_rho_{base_rho}_jk.npy"
+            cov_rho_p = np.load(cov_rho_path)[:n_bins, :n_bins]
+        else:
+            cov_tau_p_a = np.diag(tau_stats["a"]["vartau_0_p"])
+            cov_tau_p_b = np.diag(tau_stats["b"]["vartau_0_p"])
+            cov_rho_p = np.diag(self.rho_stat_handler.rho_stats["varrho_0_p"])
+
+        cov_tau_m_a = np.diag(tau_stats["a"]["vartau_0_m"])
+        cov_tau_m_b = np.diag(tau_stats["b"]["vartau_0_m"])
+        cov_rho_m = np.diag(self.rho_stat_handler.rho_stats["varrho_0_m"])
+
+        # Compute the scale-dependent xi_psf_sys and its error bars
+        same_bin = tomo_bin_a == tomo_bin_b
+        xi_psf_sys_plus, xi_psf_sys_plus_err = self._compute_scale_dependent_xi_psf_sys(
+            rho_0_p,
+            tau_0_p_a,
+            tau_0_p_b,
+            cov_rho_p,
+            cov_tau_p_a,
+            cov_tau_p_b,
+            same_bin=same_bin,
+        )
+        xi_psf_sys_minus, xi_psf_sys_minus_err = (
+            self._compute_scale_dependent_xi_psf_sys(
+                rho_0_m,
+                tau_0_m_a,
+                tau_0_m_b,
+                cov_rho_m,
+                cov_tau_m_a,
+                cov_tau_m_b,
+                same_bin=same_bin,
+            )
+        )
+
+        jittered_theta = self._get_jittered_theta(theta, idx, len(versions), offset)
+
+        y_plus = xi_psf_sys_plus * (theta if times_theta else 1)
+        y_plus_err = xi_psf_sys_plus_err * (theta if times_theta else 1)
+        y_minus = xi_psf_sys_minus * (theta if times_theta else 1)
+        y_minus_err = xi_psf_sys_minus_err * (theta if times_theta else 1)
+
+        ax_plus.errorbar(
+            jittered_theta,
+            y_plus,
+            yerr=y_plus_err,
+            fmt=fmt,
+            capsize=capsize,
+            color=color,
+        )
+
+        ax_minus.errorbar(
+            jittered_theta,
+            y_minus,
+            yerr=y_minus_err,
+            fmt=fmt,
+            capsize=capsize,
+            color=color,
+        )
+
     def _get_jittered_theta(self, theta, idx, n_versions, offset):
         """Get the jittered theta values for better visualisation."""
         theta_widths = np.diff(theta)
@@ -1265,3 +1615,6 @@ def _set_ax_visibility_to_false(self, axs, n_tomo_bins_plot):
         else:
             for i in range(n_tomo_bins_plot):
                 axs[i, n_tomo_bins_plot - i].set_visible(False)
+
+
+# %%
diff --git a/src/sp_validation/tests/test_psf_leakage.py b/src/sp_validation/tests/test_psf_leakage.py
new file mode 100644
index 00000000..bef99e32
--- /dev/null
+++ b/src/sp_validation/tests/test_psf_leakage.py
@@ -0,0 +1,242 @@
+"""PSF-leakage helpers of the cosmology validation: alpha, xi_psf_sys, summaries.
+
+Synthetic inputs only. The object-wise smoke test runs the real
+shear_psf_leakage regression on a toy catalogue and therefore needs the
+scientific stack (the container).
+"""
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import yaml
+
+from sp_validation.cosmo_val.psf_systematics import PSFSystematicsMixin
+
+mixin = PSFSystematicsMixin()
+
+N_THETA = 5
+RHO = np.full(N_THETA, 2.0)
+TINY = np.diag(np.full(N_THETA, 1e-16))
+
+
+def _xi_sys(tau_a, tau_b, sig_a, sig_b, same_bin, seed=0, n_samples=40_000):
+    return mixin._compute_scale_dependent_xi_psf_sys(
+        RHO,
+        tau_a,
+        tau_b,
+        TINY,
+        np.diag(np.full(N_THETA, sig_a**2)),
+        np.diag(np.full(N_THETA, sig_b**2)),
+        n_samples=n_samples,
+        same_bin=same_bin,
+        seed=seed,
+    )
+
+
+def test_xi_sys_central_value():
+    tau_a = np.linspace(1.0, 2.0, N_THETA)
+    tau_b = np.linspace(0.5, 3.0, N_THETA)
+    xi, _ = _xi_sys(tau_a, tau_b, 0.01, 0.02, same_bin=False)
+    np.testing.assert_allclose(xi, tau_a * tau_b / RHO)
+
+
+def test_xi_sys_auto_pair_reuses_tau_draw():
+    mu, sig = 1.0, 0.01
+    tau = np.full(N_THETA, mu)
+    _, err = _xi_sys(tau, tau, sig, sig, same_bin=True)
+    np.testing.assert_allclose(err, 2 * mu * sig / RHO, rtol=0.03)
+
+
+def test_xi_sys_cross_pair_uses_both_variances():
+    mu_a, mu_b, sig_a, sig_b = 1.0, 3.0, 0.01, 0.03
+    _, err = _xi_sys(
+        np.full(N_THETA, mu_a), np.full(N_THETA, mu_b), sig_a, sig_b, same_bin=False
+    )
+    expected = np.sqrt(mu_b**2 * sig_a**2 + mu_a**2 * sig_b**2) / RHO
+    np.testing.assert_allclose(err, expected, rtol=0.03)
+
+
+def test_xi_sys_errors_reproducible():
+    tau = np.full(N_THETA, 1.0)
+    _, err_1 = _xi_sys(tau, tau, 0.1, 0.1, same_bin=False, seed=7)
+    _, err_2 = _xi_sys(tau, tau, 0.1, 0.1, same_bin=False, seed=7)
+    _, err_3 = _xi_sys(tau, tau, 0.1, 0.1, same_bin=False, seed=8)
+    np.testing.assert_array_equal(err_1, err_2)
+    assert not np.array_equal(err_1, err_3)
+
+
+def _handlers(rho, tau, var_rho, var_tau):
+    theta = np.geomspace(1, 100, len(rho))
+    rho_h = SimpleNamespace(
+        rho_stats={"theta": theta, "rho_0_p": rho, "varrho_0_p": var_rho}
+    )
+    tau_h = SimpleNamespace(tau_stats={"tau_0_p": tau, "vartau_0_p": var_tau})
+    return rho_h, tau_h
+
+
+def test_alpha_leakage_central_value_and_reproducible():
+    rho = np.linspace(1.0, 2.0, N_THETA)
+    tau = np.linspace(0.01, 0.03, N_THETA)
+    rho_h, tau_h = _handlers(rho, tau, np.full(N_THETA, 1e-4), np.full(N_THETA, 1e-6))
+    theta, alpha, err = mixin._get_alpha_leakage(rho_h, tau_h, seed=3)
+    np.testing.assert_array_equal(theta, rho_h.rho_stats["theta"])
+    np.testing.assert_allclose(alpha, tau / rho)
+    _, _, err_again = mixin._get_alpha_leakage(rho_h, tau_h, seed=3)
+    np.testing.assert_array_equal(err, err_again)
+    assert np.all(err > 0)
+
+
+def test_alpha_summaries_recover_affine_model():
+    c, m = 0.01, 2e-4
+    theta = np.geomspace(1, 100, 12)
+    alpha_err = np.linspace(1e-3, 3e-3, theta.size)
+    alpha = c + m * theta
+
+    out = PSFSystematicsMixin._alpha_summaries(theta, alpha, alpha_err)
+
+    assert out["alpha_0"].nominal_value == pytest.approx(c, rel=1e-8)
+    assert 0 < out["alpha_0"].std_dev < alpha_err.max()
+    assert out["alpha_1"].nominal_value == pytest.approx(alpha[0])
+    assert out["alpha_1"].std_dev == pytest.approx(alpha_err[0])
+    w = 1 / alpha_err**2
+    mean = np.sum(w * alpha) / np.sum(w)
+    assert out["alpha_mean"].nominal_value == pytest.approx(mean)
+    std = np.sqrt(np.sum(w * (alpha - mean) ** 2) / np.sum(w))
+    assert out["alpha_mean"].std_dev == pytest.approx(std)
+
+
+def _objectwise_config(tmp_path, n_gal=3000, seed=11):
+    """Toy shear catalogue with PSF columns and two tomographic bins."""
+    from astropy.table import Table
+
+    rng = np.random.default_rng(seed)
+    cat_dir = tmp_path / "catalog"
+    cat_dir.mkdir()
+    output_dir = tmp_path / "output"
+    output_dir.mkdir()
+
+    e1_psf = rng.normal(0, 0.03, n_gal)
+    e2_psf = rng.normal(0, 0.03, n_gal)
+    tomo_bin = rng.integers(1, 3, n_gal)
+    leak = np.where(tomo_bin == 1, 0.05, 0.15)
+    Table(
+        {
+            "RA": rng.uniform(10, 12, n_gal),
+            "Dec": rng.uniform(10, 12, n_gal),
+            "e1": leak * e1_psf + rng.normal(0, 0.02, n_gal),
+            "e2": leak * e2_psf + rng.normal(0, 0.02, n_gal),
+            "w": np.ones(n_gal),
+            "e1_PSF": e1_psf,
+            "e2_PSF": e2_psf,
+            "fwhm_PSF": rng.uniform(0.6, 0.8, n_gal),
+            "tomo_bin": tomo_bin,
+        }
+    ).write(cat_dir / "shear.fits")
+
+    version = "TestCatalog"
+    config = {
+        "nz": {"subdir": str(cat_dir), "dndz": {"blind": "A", "path": "dndz"}},
+        "paths": {"output": str(output_dir)},
+        version: {
+            "subdir": str(cat_dir),
+            "pipeline": "SP",
+            "colour": "C0",
+            "marker": "o",
+            "shear": {
+                "path": "shear.fits",
+                "w_col": "w",
+                "e1_col": "e1",
+                "e2_col": "e2",
+                "e1_PSF_col": "e1_PSF",
+                "e2_PSF_col": "e2_PSF",
+                "tomo_bin_col": "tomo_bin",
+                "R": 1.0,
+            },
+        },
+    }
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(yaml.dump(config, sort_keys=False))
+    return version, {
+        "catalog_config": str(config_path),
+        "output_dir": str(output_dir),
+    }
+
+
+def test_objectwise_leakage_and_plot_smoke(tmp_path, monkeypatch):
+    """Object-wise fit per bin and the comparison plot, alpha(theta) stubbed.
+
+    The rho/tau products are replaced by a synthetic alpha(theta), so this
+    covers the object-wise regression, the per-bin storage and the plot, not
+    the rho/tau loading.
+    """
+    pytest.importorskip("shear_psf_leakage")
+    import matplotlib
+
+    matplotlib.use("Agg")
+    # TeX text rendering dominates the run time of the ~20 diagnostic figures
+    monkeypatch.setitem(matplotlib.rcParams, "text.usetex", False)
+    from sp_validation.cosmo_val import CosmologyValidation
+
+    version, params = _objectwise_config(tmp_path)
+    cv = CosmologyValidation(versions=[version], npatch=1, **params)
+
+    theta = np.geomspace(1, 100, 6)
+    monkeypatch.setattr(
+        cv,
+        "_load_alpha_leakage",
+        lambda ver, tomo_bin_id, cov_type=None: (
+            theta,
+            0.01 + 1e-4 * theta,
+            np.full(theta.size, 1e-3),
+        ),
+    )
+
+    cv.plot_objectwise_leakage()
+    coeff = cv.leakage_coeff[version]["tomo_bin_all"]
+    assert {"a11", "a22", "aii_mean", "alpha_mean", "alpha_1", "alpha_0"} <= set(coeff)
+    assert coeff["alpha_0"].nominal_value == pytest.approx(0.01)
+    assert (tmp_path / "output" / "leakage_coefficients.png").exists()
+
+    cv.plot_objectwise_leakage(tomography=True)
+    for tomo_bin_id, expected in ((1, 0.05), (2, 0.15)):
+        bin_coeff = cv.leakage_coeff[version][f"tomo_bin_{tomo_bin_id}"]
+        assert bin_coeff["aii_mean"].nominal_value == pytest.approx(expected, abs=0.03)
+        assert "alpha_mean" in bin_coeff
+    assert (tmp_path / "output" / "leakage_coefficients_tomo.png").exists()
+
+
+class _ObjectwiseControlFlow(PSFSystematicsMixin):
+    """Two versions, one of which lacks a catalogue column."""
+
+    def __init__(self):
+        self.versions = ["good", "bad"]
+        obj = SimpleNamespace(
+            check_params=lambda: None,
+            update_params=lambda: None,
+            prepare_output=lambda: None,
+        )
+        self.results_objectwise = {"good": obj, "bad": obj}
+
+    def _get_tomo_bins_for_versions(self, versions, tomography):
+        return {v: {"ids": [1, 2] if tomography else ["all"]} for v in versions}
+
+    def _objectwise_leakage_bin(self, obj, ver, *args):
+        if ver == "bad":
+            raise KeyError("fwhm_PSF")
+        return {"aii_mean": 0.1}
+
+    def print_start(self, *args):
+        pass
+
+    def print_magenta(self, *args):
+        pass
+
+
+def test_version_missing_a_column_stays_dropped():
+    cv = _ObjectwiseControlFlow()
+    cv.calculate_objectwise_leakage()
+    assert set(cv.results_objectwise) == {"good"}
+    assert set(cv.leakage_coeff) == {"good"}
+    cv.calculate_objectwise_leakage(tomography=True)
+    assert "tomo_bin_1" in cv.leakage_coeff["good"]
diff --git a/uv.lock b/uv.lock
index bef8072e..0c7fa3bc 100644
--- a/uv.lock
+++ b/uv.lock
@@ -14,9 +14,9 @@ name = "adjusttext"
 version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "matplotlib", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "scipy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b5/5c/496e506ad3313664df24a79f801719cadcd62af5999fcb299c9b08ff0d4b/adjusttext-1.4.0.tar.gz", hash = "sha256:1f73860ced8cccce3f85ee6989ca133c2579b67a7453f63dbeb38f39bf123154", size = 15852, upload-time = "2026-06-08T16:48:32.726Z" }
 wheels = [
@@ -55,8 +55,8 @@ name = "anyio"
 version = "4.14.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "idna", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13' and sys_platform == 'linux'" },
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/3b/72/5562aabb8dd7181e8e860622a38bea08d17842b99ecd4c91f84ac95251b0/anyio-4.14.1.tar.gz", hash = "sha256:8d648a3544c1a700e3ff78615cd679e4c5c3f149904287e73687b2596963629e", size = 254831, upload-time = "2026-06-24T20:56:06.017Z" }
 wheels = [
@@ -68,7 +68,7 @@ name = "argon2-cffi"
 version = "25.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "argon2-cffi-bindings", marker = "sys_platform == 'linux'" },
+    { name = "argon2-cffi-bindings" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" }
 wheels = [
@@ -80,7 +80,7 @@ name = "argon2-cffi-bindings"
 version = "25.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cffi", marker = "sys_platform == 'linux'" },
+    { name = "cffi" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" }
 wheels = [
@@ -112,13 +112,25 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/86/16/1a8fd2b19544b84575cf84ef7aa3ad4c173b756d5f087c91f85d1b295777/array_api_compat-1.15.0-py3-none-any.whl", hash = "sha256:7b1b9c53269061403fd5f45a8de349f16e7887653328bfa0c5f2d45299ff0a8e", size = 79113, upload-time = "2026-06-07T20:53:23.621Z" },
 ]
 
+[[package]]
+name = "array-api-extra"
+version = "0.11.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "array-api-compat" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/63/eb18bc7d039c954da3cfb11293c7e461b03eb9682bb0b22733be43f75501/array_api_extra-0.11.4.tar.gz", hash = "sha256:66236f72aaa4cdf97a3c5581696e3a9c89513714612a9bc6010e19fad1a22012", size = 112368, upload-time = "2026-09-07T18:50:34.068Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/b3/fcf70b2ed935f26fc15dfd81f72f781d395b09e302af5c86ec285d63524e/array_api_extra-0.11.4-py3-none-any.whl", hash = "sha256:b2d5bd31b3072249fd3f90a2b1f7b398c78e3ccb7575e04e9e3348ae894da60f", size = 120196, upload-time = "2026-09-07T18:50:32.88Z" },
+]
+
 [[package]]
 name = "arrow"
 version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "python-dateutil", marker = "sys_platform == 'linux'" },
-    { name = "tzdata", marker = "sys_platform == 'linux'" },
+    { name = "python-dateutil" },
+    { name = "tzdata" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" }
 wheels = [
@@ -139,11 +151,11 @@ name = "astropy"
 version = "8.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy-iers-data", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pyerfa", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "astropy-iers-data" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pyerfa" },
+    { name = "pyyaml" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0e/c4/21be4313ddfde5f60e0607fd307f367b9e0f0bf153a89b10cbd036dd8cfd/astropy-8.0.1.tar.gz", hash = "sha256:45ca31d5b91fa294cd590a4791a32db94de7f9c8a343155f4d5877baa82351da", size = 7152500, upload-time = "2026-07-05T07:24:48.482Z" }
 wheels = [
@@ -157,8 +169,8 @@ name = "astropy-healpix"
 version = "2.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/06/bb/fb3dcca212b1d57ed26b33eabb9e1cc18fcadbfc2f2976b20530b7d80b90/astropy_healpix-2.0.0.tar.gz", hash = "sha256:6ce7646dc5b1c09a7ed24b1f23d3e2fce8e3570387220d26a24487ab001b3b0b", size = 112064, upload-time = "2026-06-29T20:02:46.407Z" }
 wheels = [
@@ -220,8 +232,8 @@ name = "beautifulsoup4"
 version = "4.15.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "soupsieve", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "soupsieve" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" }
 wheels = [
@@ -233,7 +245,7 @@ name = "bleach"
 version = "6.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "webencodings", marker = "sys_platform == 'linux'" },
+    { name = "webencodings" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/48/3c/e12ac860709702bd5ebeb9b56a4fe334f1001246ee1b8f2b7ee28912df7d/bleach-6.4.0.tar.gz", hash = "sha256:4202482733d85cedd04e59fcb2f89f4e4c7c385a78d3c3c23c30446843a37452", size = 204857, upload-time = "2026-06-05T13:01:13.734Z" }
 wheels = [
@@ -242,7 +254,7 @@ wheels = [
 
 [package.optional-dependencies]
 css = [
-    { name = "tinycss2", marker = "sys_platform == 'linux'" },
+    { name = "tinycss2" },
 ]
 
 [[package]]
@@ -250,14 +262,14 @@ name = "blosc2"
 version = "4.8.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "httpx", extra = ["http2"], marker = "sys_platform == 'linux'" },
-    { name = "msgpack", marker = "sys_platform == 'linux'" },
-    { name = "ndindex", marker = "sys_platform == 'linux'" },
-    { name = "numexpr", marker = "platform_machine != 'wasm32' and sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pydantic", marker = "sys_platform == 'linux'" },
-    { name = "rich", marker = "sys_platform == 'linux'" },
-    { name = "threadpoolctl", marker = "platform_machine != 'wasm32' and sys_platform == 'linux'" },
+    { name = "httpx", extra = ["http2"] },
+    { name = "msgpack" },
+    { name = "ndindex" },
+    { name = "numexpr", marker = "platform_machine != 'wasm32'" },
+    { name = "numpy" },
+    { name = "pydantic" },
+    { name = "rich" },
+    { name = "threadpoolctl", marker = "platform_machine != 'wasm32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/c1/26/c5b32a553f002e91886213ec91ff56a2dd8555e5e78eb4c289addb208642/blosc2-4.8.0.tar.gz", hash = "sha256:9789c3248052be59e63d6debafec4cd59d0eb4a6fd1cbaced36865d5d40ffa63", size = 5681856, upload-time = "2026-07-10T09:38:33.592Z" }
 wheels = [
@@ -273,17 +285,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/07/5a/012f58a518bebf0d11931a5a12ba08955aa959cca59764ad38a8d82c9a1b/blosc2-4.8.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9f8b459e22059a3a794480df2c72ff008ab6c95b9799fa2979c1dd7830cf44e2", size = 7186485, upload-time = "2026-07-10T09:38:29.411Z" },
 ]
 
+[[package]]
+name = "cached-property"
+version = "2.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/4b/3d870836119dbe9a5e3c9a61af8cc1a8b69d75aea564572e385882d5aefb/cached_property-2.0.1.tar.gz", hash = "sha256:484d617105e3ee0e4f1f58725e72a8ef9e93deee462222dbd51cd91230897641", size = 10574, upload-time = "2024-10-25T15:43:55.667Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/0e/7d8225aab3bc1a0f5811f8e1b557aa034ac04bdf641925b30d3caf586b28/cached_property-2.0.1-py3-none-any.whl", hash = "sha256:f617d70ab1100b7bcf6e42228f9ddcb78c676ffa167278d9f730d1c2fba69ccb", size = 7428, upload-time = "2024-10-25T15:43:54.711Z" },
+]
+
 [[package]]
 name = "cadcutils"
 version = "1.6.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "distro", marker = "sys_platform == 'linux'" },
-    { name = "lxml", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pyopenssl", marker = "sys_platform == 'linux'" },
-    { name = "requests", marker = "sys_platform == 'linux'" },
-    { name = "setuptools", marker = "sys_platform == 'linux'" },
+    { name = "distro" },
+    { name = "lxml" },
+    { name = "packaging" },
+    { name = "pyopenssl" },
+    { name = "requests" },
+    { name = "setuptools" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/fe/44/4964823c72c9e6a93e26de0118cead37fa3c3600b4677f0c06788c903c80/cadcutils-1.6.2.tar.gz", hash = "sha256:6e2d7822756d48a363bc5f857cd717f80aab760554df86518b957f8826a7a906", size = 94673, upload-time = "2026-06-22T17:35:47.303Z" }
 wheels = [
@@ -295,10 +316,10 @@ name = "camb"
 version = "1.6.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
-    { name = "sympy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "scipy" },
+    { name = "sympy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6d/ad/f2e6446fbd94f7adc1474e1f4e40d2e7fa7e5e7143640cb8557d492f0a73/camb-1.6.6.tar.gz", hash = "sha256:9856202a5c05570256e52377b20431891c7b08b2e9c334e141fd08d2a085516f", size = 799344, upload-time = "2026-03-11T16:46:55.819Z" }
 wheels = [
@@ -320,7 +341,7 @@ name = "cffi"
 version = "2.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pycparser", marker = "implementation_name != 'PyPy' and sys_platform == 'linux'" },
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/57/5f/ff100cae70ebe9d8df1c01a00e510e45d9adb5c1fdda84791b199141de97/cffi-2.1.0.tar.gz", hash = "sha256:efc1cdd798b1aaf39b4610bba7aad28c9bea9b910f25c784ccf9ec1fa719d1f9", size = 531036, upload-time = "2026-07-06T21:34:30.382Z" }
 wheels = [
@@ -429,12 +450,12 @@ name = "clmm"
 version = "1.16.10"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "healpy", marker = "sys_platform == 'linux'" },
-    { name = "matplotlib", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "qp-prob", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "healpy" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "qp-prob" },
+    { name = "scipy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/db/73/7ff76d487cdbcddb9c80ec03313db1b11f48fe4fcb5e1609b6eca5a73159/clmm-1.16.10.tar.gz", hash = "sha256:48273784419c038a89619b798a140153ad1e451390ff56074f3b6825c91ebe32", size = 72475, upload-time = "2025-12-04T17:30:11.47Z" }
 wheels = [
@@ -473,7 +494,7 @@ name = "conda-inject"
 version = "1.3.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b1/a8/8dc86113c65c949cc72d651461d6e4c544b3302a85ed14a5298829e6a419/conda_inject-1.3.2.tar.gz", hash = "sha256:0b8cde8c47998c118d8ff285a04977a3abcf734caf579c520fca469df1cd0aac", size = 3635, upload-time = "2024-05-27T12:20:58.873Z" }
 wheels = [
@@ -500,7 +521,7 @@ name = "contourpy"
 version = "1.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
 wheels = [
@@ -541,12 +562,12 @@ name = "cosmo-numba"
 version = "1.0.1.dev6+g188d272c6"
 source = { git = "https://github.com/aguinot/cosmo-numba.git?rev=main#188d272c67d6d699d7cff7a7a53ded8dec759bb0" }
 dependencies = [
-    { name = "mpmath", marker = "sys_platform == 'linux'" },
-    { name = "numba", marker = "sys_platform == 'linux'" },
-    { name = "numbaquadpack", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "rocket-fft", marker = "sys_platform == 'linux'" },
-    { name = "sympy", marker = "sys_platform == 'linux'" },
+    { name = "mpmath" },
+    { name = "numba" },
+    { name = "numbaquadpack" },
+    { name = "numpy" },
+    { name = "rocket-fft" },
+    { name = "sympy" },
 ]
 
 [[package]]
@@ -554,13 +575,34 @@ name = "cosmology"
 version = "2022.10.9"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/c9/38/04099bb2b6a626bd69a3f117afc60f2c47c08899e0730e0e48c898bf4745/cosmology-2022.10.9.tar.gz", hash = "sha256:0c2857c9bf1fdd09f1f11ab5765df0389a4101f3a900fa11251c3f37696f02d4", size = 8488, upload-time = "2022-10-10T10:18:16.229Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/2e/2c/c80db37593ad593e3f6c60705fbdf690b33f22c89edd5507d2731346cd87/cosmology-2022.10.9-py3-none-any.whl", hash = "sha256:3903658c2474177a1a1c75771ae14458d93200c516f8fc6c3f4d776f3287b288", size = 9341, upload-time = "2022-10-10T10:18:14.928Z" },
 ]
 
+[[package]]
+name = "cosmology-api"
+version = "0.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/f4/801cab91dab5b2e8102ed54cc4e2bd257f319c9047db182fcaf53706df6a/cosmology_api-0.3.2.tar.gz", hash = "sha256:7ccdfdf20f91dfc2282aee059adf2530bea6e194a0f8d01487e15a7497cf4694", size = 17338, upload-time = "2025-05-15T13:29:52.355Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bf/8c/6cc73fafff9f4d75e77a9c3cf5b9c34aa42841cfc7da5c89737daa2c3bd7/cosmology_api-0.3.2-py3-none-any.whl", hash = "sha256:9391ef0b2616bbf4217fefdb94a72370766d59a2f0558b5ade224a92ea093a61", size = 18685, upload-time = "2025-05-15T13:29:50.833Z" },
+]
+
+[[package]]
+name = "cosmology-compat-camb"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/08/2e/a637aae1677d02337be371c9a7b7e9d5051199bb58a2386781230adcee45/cosmology_compat_camb-0.2.0.tar.gz", hash = "sha256:e36fda04a78e16fc1a5c4aa22c30ec1bf64bbe0b092aa1b894ca746ce5e5551b", size = 4562, upload-time = "2025-05-08T10:31:43.226Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/42/1a657f9b3540f355f34af735d8643aae1480620689a72423fe69aeeb78e5/cosmology_compat_camb-0.2.0-py3-none-any.whl", hash = "sha256:eb6e74290bb6a6a60a47d1338fc233ba1697058ed7f01a01de1180dbee1bd75d", size = 3903, upload-time = "2025-05-08T10:31:41.997Z" },
+]
+
 [[package]]
 name = "coverage"
 version = "7.15.0"
@@ -615,7 +657,7 @@ name = "cryptography"
 version = "49.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cffi", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'linux'" },
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/1f/99/d1c90d6041656cc6ee229dc99cd67fd0cd5aec3c5f7d72fffc27cc750054/cryptography-49.0.0.tar.gz", hash = "sha256:f89660a348f4f78a92366240a61404e337586ef7f5909a2fef59ca88ef505493", size = 854345, upload-time = "2026-06-12T20:02:30.512Z" }
 wheels = [
@@ -659,18 +701,18 @@ name = "cs-util"
 version = "0.2.2"
 source = { git = "https://github.com/CosmoStat/cs_util.git?rev=develop#bedcdbf50ac57fc4d0b72a62b251373cd1807824" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "camb", marker = "sys_platform == 'linux'" },
-    { name = "datetime", marker = "sys_platform == 'linux'" },
-    { name = "healpy", marker = "sys_platform == 'linux'" },
-    { name = "healsparse", marker = "sys_platform == 'linux'" },
-    { name = "keyring", marker = "sys_platform == 'linux'" },
-    { name = "matplotlib", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pyccl", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
-    { name = "swig", marker = "sys_platform == 'linux'" },
-    { name = "vos", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "camb" },
+    { name = "datetime" },
+    { name = "healpy" },
+    { name = "healsparse" },
+    { name = "keyring" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pyccl" },
+    { name = "scipy" },
+    { name = "swig" },
+    { name = "vos" },
 ]
 
 [[package]]
@@ -687,13 +729,13 @@ name = "dask"
 version = "2026.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "click", marker = "sys_platform == 'linux'" },
-    { name = "cloudpickle", marker = "sys_platform == 'linux'" },
-    { name = "fsspec", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "partd", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "toolz", marker = "sys_platform == 'linux'" },
+    { name = "click" },
+    { name = "cloudpickle" },
+    { name = "fsspec" },
+    { name = "packaging" },
+    { name = "partd" },
+    { name = "pyyaml" },
+    { name = "toolz" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/4d/b5/aa50877159f1efd65a744107e0662a15d2b80fa0c427d980313367f49493/dask-2026.7.0.tar.gz", hash = "sha256:b039970642ce97a063070bae2763dada8aae27e3cbd8ff6d894072f920a1e252", size = 11548914, upload-time = "2026-07-06T16:58:36.496Z" }
 wheels = [
@@ -702,7 +744,7 @@ wheels = [
 
 [package.optional-dependencies]
 array = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 
 [[package]]
@@ -710,11 +752,11 @@ name = "dask-image"
 version = "2026.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "dask", extra = ["array"], marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pims", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
-    { name = "tifffile", marker = "sys_platform == 'linux'" },
+    { name = "dask", extra = ["array"] },
+    { name = "numpy" },
+    { name = "pims" },
+    { name = "scipy" },
+    { name = "tifffile" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cc/49/e592a13a5e1efdcdb8f1faab7c4e309c61648792e276f9ced5fb79381b33/dask_image-2026.5.0.tar.gz", hash = "sha256:ed6b462277e691b2c12b0890ba801a0f9a00cc1894b0aa71b195a7a1419b2b00", size = 80457, upload-time = "2026-05-27T14:05:57.383Z" }
 wheels = [
@@ -726,8 +768,8 @@ name = "datetime"
 version = "6.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pytz", marker = "sys_platform == 'linux'" },
-    { name = "zope-interface", marker = "sys_platform == 'linux'" },
+    { name = "pytz" },
+    { name = "zope-interface" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/77/32/decbfd165e9985ba9d8c2d34a39afe5aeba2fc3fe390eb6e9ef1aab98fa8/datetime-6.0.tar.gz", hash = "sha256:c1514936d2f901e10c8e08d83bf04e6c9dbd7ca4f244da94fec980980a3bc4d5", size = 64167, upload-time = "2025-11-25T08:00:34.586Z" }
 wheels = [
@@ -769,13 +811,25 @@ name = "deprecated"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "wrapt", marker = "sys_platform == 'linux'" },
+    { name = "wrapt" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" },
 ]
 
+[[package]]
+name = "deprecation"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5a/d3/8ae2869247df154b64c1884d7346d412fed0c49df84db635aab2d1c40e62/deprecation-2.1.0.tar.gz", hash = "sha256:72b3bde64e5d778694b0cf68178aed03d15e15477116add3fb773e581f9518ff", size = 173788, upload-time = "2020-04-20T14:23:38.738Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/c3/253a89ee03fc9b9682f1541728eb66db7db22148cd94f89ab22528cd1e1b/deprecation-2.1.0-py2.py3-none-any.whl", hash = "sha256:a10811591210e1fb0e768a8c25517cabeabcba6f0bf96564f8ff45189f90b14a", size = 11178, upload-time = "2020-04-20T14:23:36.581Z" },
+]
+
 [[package]]
 name = "dill"
 version = "0.4.1"
@@ -817,7 +871,7 @@ name = "donfig"
 version = "0.8.1.post1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/25/71/80cc718ff6d7abfbabacb1f57aaa42e9c1552bfdd01e64ddd704e4a03638/donfig-0.8.1.post1.tar.gz", hash = "sha256:3bef3413a4c1c601b585e8d297256d0c1470ea012afa6e8461dc28bfb7c23f52", size = 19506, upload-time = "2024-05-23T14:14:31.513Z" }
 wheels = [
@@ -838,7 +892,7 @@ name = "ducc0"
 version = "0.41.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cf/e7/849dd1a079b994184fa53905d47278f86d0dd3dcfb6ff2b0e3eb7d6a1c1b/ducc0-0.41.0.tar.gz", hash = "sha256:bac084745bbdb243482a4aec3ecc857bdd46faec298c67e48bc0bb90350dbabd", size = 353129, upload-time = "2026-03-26T18:56:04.669Z" }
 wheels = [
@@ -857,7 +911,7 @@ name = "emcee"
 version = "3.1.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cb/53/1045ee878cb24281387079f8ee4f0ade1622c6aae1ed1fd91a53e4fa5b19/emcee-3.1.6.tar.gz", hash = "sha256:11af4daf6ab8f9ca69681e3c29054665db7bbd87fd4eb8e437d2c3a1248c637d", size = 2871117, upload-time = "2024-04-19T10:03:19.555Z" }
 wheels = [
@@ -887,7 +941,7 @@ name = "fitsio"
 version = "1.4.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/34/6b/5658778e070faaa194f1a1133527cedfa948d173daed29d61f25c5487ab6/fitsio-1.4.1.tar.gz", hash = "sha256:2b2bf0bfd37790114b44283931c59a14b1fec25a653bf65c4fc555b8d3b24de9", size = 4148217, upload-time = "2026-07-10T21:21:31.585Z" }
 wheels = [
@@ -906,7 +960,7 @@ name = "flt"
 version = "2026.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/80/66/538256582e373d81a944c0ee3a12fd0e4dd0f39d10136353c4ce914d7061/flt-2026.1.tar.gz", hash = "sha256:4bf2818d4a9137f5f715fd2ff13acfbf0175639373155cd89ea2b788edf00093", size = 12817, upload-time = "2026-03-20T22:47:29.754Z" }
 wheels = [
@@ -977,11 +1031,11 @@ name = "getdist"
 version = "1.6.1"
 source = { git = "https://github.com/benabed/getdist.git?rev=113cd22a9a0d013b6f72fe734be81f260f3d3be5#113cd22a9a0d013b6f72fe734be81f260f3d3be5" }
 dependencies = [
-    { name = "matplotlib", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "scipy" },
 ]
 
 [[package]]
@@ -989,7 +1043,7 @@ name = "gitdb"
 version = "4.0.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "smmap", marker = "sys_platform == 'linux'" },
+    { name = "smmap" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" }
 wheels = [
@@ -1001,7 +1055,7 @@ name = "gitpython"
 version = "3.1.50"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "gitdb", marker = "sys_platform == 'linux'" },
+    { name = "gitdb" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/33/f6/354ae6491228b5eb40e10d89c4d13c651fe1cf7556e35ebdded50cff57ce/gitpython-3.1.50.tar.gz", hash = "sha256:80da2d12504d52e1f998772dc5baf6e553f8d2fcfe1fcc226c9d9a2ee3372dcc", size = 219798, upload-time = "2026-05-06T04:01:26.571Z" }
 wheels = [
@@ -1010,18 +1064,28 @@ wheels = [
 
 [[package]]
 name = "glass"
-version = "2025.1"
+version = "2026.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cosmology", marker = "sys_platform == 'linux'" },
-    { name = "healpix", marker = "sys_platform == 'linux'" },
-    { name = "healpy", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "transformcl", marker = "sys_platform == 'linux'" },
+    { name = "array-api-compat" },
+    { name = "array-api-extra" },
+    { name = "healpix" },
+    { name = "healpy" },
+    { name = "transformcl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a5/d6/26cd58e75834671259f26b9287a584d726e6023da35ddf7ca3b7f2c393fb/glass-2025.1.tar.gz", hash = "sha256:7b1aa2394e16010f7f1b4243f49e7e12d7a4dd28fcbf3e3f7cf25ce4905a8615", size = 48533, upload-time = "2025-02-21T18:43:48.046Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/c3/3b7d18cca8d0fa41dbb646ce16935804b380dcf766e7385799f44829b419/glass-2026.2.tar.gz", hash = "sha256:cf5ef6cb76b4738f8dc05ddfc18c359c558bb36e9cd09ca0115fa3ca3deb491f", size = 66236, upload-time = "2026-06-04T15:18:39.155Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/e7/3e89bc5147a3e84245c783098afffbbacbcdf5678ba1aacc2c9c035434da/glass-2025.1-py3-none-any.whl", hash = "sha256:d7919a7d19e05ab8da4e52dbfbcfb5bd1ed2b72e0cc3afde39ec94ced22883c5", size = 47185, upload-time = "2025-02-21T18:43:46.649Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/d1/55ea5e63e81db82806e92ba9f9c2b7277c0c2afe57bf8c1d3763e18005b2/glass-2026.2-py3-none-any.whl", hash = "sha256:0af0b5cd8708040925699c307076fb1c79bbb7e6cba4522764bcc21dd3bdadb8", size = 63746, upload-time = "2026-06-04T15:18:37.895Z" },
+]
+
+[package.optional-dependencies]
+examples = [
+    { name = "camb" },
+    { name = "cosmology-api" },
+    { name = "cosmology-compat-camb" },
+    { name = "glass-ext-camb" },
+    { name = "jupyter" },
+    { name = "matplotlib" },
 ]
 
 [[package]]
@@ -1029,9 +1093,9 @@ name = "glass-ext-camb"
 version = "2023.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "camb", marker = "sys_platform == 'linux'" },
-    { name = "glass", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "camb" },
+    { name = "glass" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b7/1a/18bb47c0f7cc267c2f8c95273055b82b1975e4dccbfea6051e82a4d1f513/glass.ext.camb-2023.6.tar.gz", hash = "sha256:f7b6e521b2d45d3b68400353ce6ab1747c772631832a257567de028aa2060509", size = 2989, upload-time = "2023-06-30T22:27:31.511Z" }
 wheels = [
@@ -1113,8 +1177,8 @@ name = "h2"
 version = "4.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "hpack", marker = "sys_platform == 'linux'" },
-    { name = "hyperframe", marker = "sys_platform == 'linux'" },
+    { name = "hpack" },
+    { name = "hyperframe" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/1d/17/afa56379f94ad0fe8defd37d6eb3f89a25404ffc71d4d848893d270325fc/h2-4.3.0.tar.gz", hash = "sha256:6c59efe4323fa18b47a632221a1888bd7fde6249819beda254aeca909f221bf1", size = 2152026, upload-time = "2025-08-23T18:12:19.778Z" }
 wheels = [
@@ -1126,7 +1190,7 @@ name = "h5py"
 version = "3.16.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/db/33/acd0ce6863b6c0d7735007df01815403f5589a21ff8c2e1ee2587a38f548/h5py-3.16.0.tar.gz", hash = "sha256:a0dbaad796840ccaa67a4c144a0d0c8080073c34c76d5a6941d6818678ef2738", size = 446526, upload-time = "2026-03-06T13:49:08.07Z" }
 wheels = [
@@ -1153,7 +1217,7 @@ name = "healpix"
 version = "2025.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/43/1a/c1af658a2d06cdd2734b085b0eee34d51646f091ed13b1669d3a596de57c/healpix-2025.1.tar.gz", hash = "sha256:733f16f30c15d911c8209f4045f0b0934e5fcafa63b8b39d62e425a036adccea", size = 22744, upload-time = "2025-07-07T16:38:42.402Z" }
 wheels = [
@@ -1168,8 +1232,8 @@ name = "healpy"
 version = "1.19.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/e3/4e/6f5328f375f88c8c38314f24f82b7e1486ec0358c557779500382db1503c/healpy-1.19.0.tar.gz", hash = "sha256:28e839cb885a23d36c77fc3423a3cb9271a07fda94085bd12fc329f941130ec5", size = 4075006, upload-time = "2025-12-02T08:27:19.766Z" }
 wheels = [
@@ -1192,14 +1256,34 @@ name = "healsparse"
 version = "1.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "hpgeom", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "hpgeom" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/e3/33/36520faabae128fe9a4a5cbeb0916be864d2eb34cf7410d52dc532af044e/healsparse-1.13.0.tar.gz", hash = "sha256:c21e4eb075c686bd306bdc1b40e039134c4ca60ccfa4e7e73845c107a5b16544", size = 133589, upload-time = "2026-07-07T18:33:05.481Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/b4/2f/7674b91031a12a9b3cd69f3bb675d3b1eac59657139e23bc528ed6d33d0a/healsparse-1.13.0-py3-none-any.whl", hash = "sha256:3b475a61d7701526246a592ed980758f94764caba4355429bf470a2f9b812964", size = 70673, upload-time = "2026-07-07T18:33:04.514Z" },
 ]
 
+[[package]]
+name = "hmf"
+version = "3.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "astropy" },
+    { name = "cached-property" },
+    { name = "camb" },
+    { name = "click" },
+    { name = "deprecation" },
+    { name = "numpy" },
+    { name = "rich" },
+    { name = "scipy" },
+    { name = "toml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/3a/31fb85e524d07871f5083154d8a248aba508d6ebb811cc0058e608a32d81/hmf-3.6.3.tar.gz", hash = "sha256:c53b53a9c15a3671d84491c39a09b1d0b280f41724bd71901b7b627fb4ac18d1", size = 2382901, upload-time = "2026-09-11T13:59:23.145Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6f/34/f825393c1f13d38c0857c50605ad517b71b201988d415be715b5f95db61a/hmf-3.6.3-py3-none-any.whl", hash = "sha256:1b0881ea27c41660640669e80d021d894ab2c14feee9d37e1e21cbd27567e630", size = 80447, upload-time = "2026-09-11T13:59:21.958Z" },
+]
+
 [[package]]
 name = "hpack"
 version = "4.2.0"
@@ -1214,7 +1298,7 @@ name = "hpgeom"
 version = "1.5.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/07/72/27640de7d85a566b8ecd27e7894f371a19669c56c268756e18111a137df8/hpgeom-1.5.4.tar.gz", hash = "sha256:85ac73e267c11f3f248920d3541a0e6ffab821cae54f0d44414d1939dfb91200", size = 153906, upload-time = "2026-02-24T19:03:01.954Z" }
 wheels = [
@@ -1240,8 +1324,8 @@ name = "httpcore"
 version = "1.0.9"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "certifi", marker = "sys_platform == 'linux'" },
-    { name = "h11", marker = "sys_platform == 'linux'" },
+    { name = "certifi" },
+    { name = "h11" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
 wheels = [
@@ -1253,10 +1337,10 @@ name = "httpx"
 version = "0.28.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "anyio", marker = "sys_platform == 'linux'" },
-    { name = "certifi", marker = "sys_platform == 'linux'" },
-    { name = "httpcore", marker = "sys_platform == 'linux'" },
-    { name = "idna", marker = "sys_platform == 'linux'" },
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
 wheels = [
@@ -1265,7 +1349,7 @@ wheels = [
 
 [package.optional-dependencies]
 http2 = [
-    { name = "h2", marker = "sys_platform == 'linux'" },
+    { name = "h2" },
 ]
 
 [[package]]
@@ -1300,8 +1384,8 @@ name = "imageio"
 version = "2.37.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pillow", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
+    { name = "pillow" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b1/84/93bcd1300216ea50811cee96873b84a1bebf8d0489ffaf7f2a3756bab866/imageio-2.37.3.tar.gz", hash = "sha256:bbb37efbfc4c400fcd534b367b91fcd66d5da639aaa138034431a1c5e0a41451", size = 389673, upload-time = "2026-03-09T11:31:12.573Z" }
 wheels = [
@@ -1338,7 +1422,7 @@ name = "importlib-metadata"
 version = "9.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "zipp", marker = "sys_platform == 'linux'" },
+    { name = "zipp" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" }
 wheels = [
@@ -1368,18 +1452,18 @@ name = "ipykernel"
 version = "7.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "comm", marker = "sys_platform == 'linux'" },
-    { name = "debugpy", marker = "sys_platform == 'linux'" },
-    { name = "ipython", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-client", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "matplotlib-inline", marker = "sys_platform == 'linux'" },
-    { name = "nest-asyncio2", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "psutil", marker = "sys_platform == 'linux'" },
-    { name = "pyzmq", marker = "sys_platform == 'linux'" },
-    { name = "tornado", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "comm" },
+    { name = "debugpy" },
+    { name = "ipython" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "matplotlib-inline" },
+    { name = "nest-asyncio2" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pyzmq" },
+    { name = "tornado" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/3d/c4/e4a38f579de4225a561305666f7541cdabb30075def2aa1ac17bd73c1fb5/ipykernel-7.3.0.tar.gz", hash = "sha256:9acaaaf97d16355166e4085afe9d225bfbdf2b7ef520f9df3be8f2b248275e09", size = 184899, upload-time = "2026-06-10T08:41:25.481Z" }
 wheels = [
@@ -1391,16 +1475,16 @@ name = "ipython"
 version = "9.15.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "decorator", marker = "sys_platform == 'linux'" },
-    { name = "ipython-pygments-lexers", marker = "sys_platform == 'linux'" },
-    { name = "jedi", marker = "sys_platform == 'linux'" },
-    { name = "matplotlib-inline", marker = "sys_platform == 'linux'" },
-    { name = "pexpect", marker = "sys_platform == 'linux'" },
-    { name = "prompt-toolkit", marker = "sys_platform == 'linux'" },
-    { name = "psutil", marker = "sys_platform == 'linux'" },
-    { name = "pygments", marker = "sys_platform == 'linux'" },
-    { name = "stack-data", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "decorator" },
+    { name = "ipython-pygments-lexers" },
+    { name = "jedi" },
+    { name = "matplotlib-inline" },
+    { name = "pexpect" },
+    { name = "prompt-toolkit" },
+    { name = "psutil" },
+    { name = "pygments" },
+    { name = "stack-data" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/53/59/165d3b4d75cc34add3122c4417ecb229085140ac573103c223cd01dde96f/ipython-9.15.0.tar.gz", hash = "sha256:da2819ce2aa83135257df830660b1176d986c3d2876db24df01974fa955b2756", size = 4442580, upload-time = "2026-06-26T11:03:35.913Z" }
 wheels = [
@@ -1421,7 +1505,7 @@ name = "ipython-pygments-lexers"
 version = "1.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pygments", marker = "sys_platform == 'linux'" },
+    { name = "pygments" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" }
 wheels = [
@@ -1433,11 +1517,11 @@ name = "ipywidgets"
 version = "8.1.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "comm", marker = "sys_platform == 'linux'" },
-    { name = "ipython", marker = "sys_platform == 'linux'" },
-    { name = "jupyterlab-widgets", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
-    { name = "widgetsnbextension", marker = "sys_platform == 'linux'" },
+    { name = "comm" },
+    { name = "ipython" },
+    { name = "jupyterlab-widgets" },
+    { name = "traitlets" },
+    { name = "widgetsnbextension" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/4c/ae/c5ce1edc1afe042eadb445e95b0671b03cee61895264357956e61c0d2ac0/ipywidgets-8.1.8.tar.gz", hash = "sha256:61f969306b95f85fba6b6986b7fe45d73124d1d9e3023a8068710d47a22ea668", size = 116739, upload-time = "2025-11-01T21:18:12.393Z" }
 wheels = [
@@ -1449,7 +1533,7 @@ name = "isoduration"
 version = "20.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "arrow", marker = "sys_platform == 'linux'" },
+    { name = "arrow" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" }
 wheels = [
@@ -1461,7 +1545,7 @@ name = "jaraco-classes"
 version = "3.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "more-itertools", marker = "sys_platform == 'linux'" },
+    { name = "more-itertools" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" }
 wheels = [
@@ -1482,7 +1566,7 @@ name = "jaraco-functools"
 version = "4.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "more-itertools", marker = "sys_platform == 'linux'" },
+    { name = "more-itertools" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/36/cf/ea4ef2920830dea3f5ab2ea4da6fb67724e6dca80ee2553788c3607243d0/jaraco_functools-4.5.0.tar.gz", hash = "sha256:3bb5665ea4a020cf78a7040e89154c77edadb3ca74f366479669c5999aa70b03", size = 20272, upload-time = "2026-05-15T21:34:10.025Z" }
 wheels = [
@@ -1494,7 +1578,7 @@ name = "jedi"
 version = "0.20.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "parso", marker = "sys_platform == 'linux'" },
+    { name = "parso" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" }
 wheels = [
@@ -1515,7 +1599,7 @@ name = "jinja2"
 version = "3.1.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "markupsafe", marker = "sys_platform == 'linux'" },
+    { name = "markupsafe" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
 wheels = [
@@ -1545,7 +1629,7 @@ name = "jsonargparse"
 version = "4.49.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/87/0b/f012466077d803b546955bf827ab30a320ad1550e3167195432cc2d6bfad/jsonargparse-4.49.0.tar.gz", hash = "sha256:9e691a09d937fb4c6bc1f6d3bf6c3546efa03381ea1e64ee10759095f1b14da7", size = 125237, upload-time = "2026-05-15T06:48:44.807Z" }
 wheels = [
@@ -1554,8 +1638,8 @@ wheels = [
 
 [package.optional-dependencies]
 signatures = [
-    { name = "docstring-parser", marker = "sys_platform == 'linux'" },
-    { name = "typeshed-client", marker = "sys_platform == 'linux'" },
+    { name = "docstring-parser" },
+    { name = "typeshed-client" },
 ]
 
 [[package]]
@@ -1572,10 +1656,10 @@ name = "jsonschema"
 version = "4.26.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "attrs", marker = "sys_platform == 'linux'" },
-    { name = "jsonschema-specifications", marker = "sys_platform == 'linux'" },
-    { name = "referencing", marker = "sys_platform == 'linux'" },
-    { name = "rpds-py", marker = "sys_platform == 'linux'" },
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
 wheels = [
@@ -1584,15 +1668,15 @@ wheels = [
 
 [package.optional-dependencies]
 format-nongpl = [
-    { name = "fqdn", marker = "sys_platform == 'linux'" },
-    { name = "idna", marker = "sys_platform == 'linux'" },
-    { name = "isoduration", marker = "sys_platform == 'linux'" },
-    { name = "jsonpointer", marker = "sys_platform == 'linux'" },
-    { name = "rfc3339-validator", marker = "sys_platform == 'linux'" },
-    { name = "rfc3986-validator", marker = "sys_platform == 'linux'" },
-    { name = "rfc3987-syntax", marker = "sys_platform == 'linux'" },
-    { name = "uri-template", marker = "sys_platform == 'linux'" },
-    { name = "webcolors", marker = "sys_platform == 'linux'" },
+    { name = "fqdn" },
+    { name = "idna" },
+    { name = "isoduration" },
+    { name = "jsonpointer" },
+    { name = "rfc3339-validator" },
+    { name = "rfc3986-validator" },
+    { name = "rfc3987-syntax" },
+    { name = "uri-template" },
+    { name = "webcolors" },
 ]
 
 [[package]]
@@ -1600,7 +1684,7 @@ name = "jsonschema-specifications"
 version = "2025.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "referencing", marker = "sys_platform == 'linux'" },
+    { name = "referencing" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
 wheels = [
@@ -1612,12 +1696,12 @@ name = "jupyter"
 version = "1.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ipykernel", marker = "sys_platform == 'linux'" },
-    { name = "ipywidgets", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-console", marker = "sys_platform == 'linux'" },
-    { name = "jupyterlab", marker = "sys_platform == 'linux'" },
-    { name = "nbconvert", marker = "sys_platform == 'linux'" },
-    { name = "notebook", marker = "sys_platform == 'linux'" },
+    { name = "ipykernel" },
+    { name = "ipywidgets" },
+    { name = "jupyter-console" },
+    { name = "jupyterlab" },
+    { name = "nbconvert" },
+    { name = "notebook" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" }
 wheels = [
@@ -1629,8 +1713,8 @@ name = "jupyter-builder"
 version = "1.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "jupyter-core" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0d/df/db5efc4e28803a1421350445e53d85ec571a4e6928e3524ccc39f4e16584/jupyter_builder-1.1.0.tar.gz", hash = "sha256:b996e8af616900f18724fa34883169d869be2205497940bec78a3a1031eb897d", size = 971142, upload-time = "2026-07-11T07:24:02.4Z" }
 wheels = [
@@ -1642,12 +1726,12 @@ name = "jupyter-client"
 version = "8.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "python-dateutil", marker = "sys_platform == 'linux'" },
-    { name = "pyzmq", marker = "sys_platform == 'linux'" },
-    { name = "tornado", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "jupyter-core" },
+    { name = "python-dateutil" },
+    { name = "pyzmq" },
+    { name = "tornado" },
+    { name = "traitlets" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7d/dc/5512503b088997c2250b8bf18258fba9d9ce5ead641183700960d3c9d342/jupyter_client-8.9.1.tar.gz", hash = "sha256:a58f730dd9e728ba16ba1d62ebccf7ffe1ebbdbce4e95cfae941b7321ae1f4fa", size = 359256, upload-time = "2026-06-09T13:15:01.033Z" }
 wheels = [
@@ -1659,14 +1743,14 @@ name = "jupyter-console"
 version = "6.6.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ipykernel", marker = "sys_platform == 'linux'" },
-    { name = "ipython", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-client", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "prompt-toolkit", marker = "sys_platform == 'linux'" },
-    { name = "pygments", marker = "sys_platform == 'linux'" },
-    { name = "pyzmq", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "ipykernel" },
+    { name = "ipython" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "prompt-toolkit" },
+    { name = "pygments" },
+    { name = "pyzmq" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" }
 wheels = [
@@ -1678,8 +1762,8 @@ name = "jupyter-core"
 version = "5.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "platformdirs", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "platformdirs" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" }
 wheels = [
@@ -1691,14 +1775,14 @@ name = "jupyter-events"
 version = "0.12.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jsonschema", extra = ["format-nongpl"], marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "python-json-logger", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "referencing", marker = "sys_platform == 'linux'" },
-    { name = "rfc3339-validator", marker = "sys_platform == 'linux'" },
-    { name = "rfc3986-validator", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "jsonschema", extra = ["format-nongpl"] },
+    { name = "packaging" },
+    { name = "python-json-logger" },
+    { name = "pyyaml" },
+    { name = "referencing" },
+    { name = "rfc3339-validator" },
+    { name = "rfc3986-validator" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/18/f8/475c4241b2b75af0deaae453ed003c6c851766dbc44d332d8baf245dc931/jupyter_events-0.12.1.tar.gz", hash = "sha256:faff25f77218335752f35f23c5fe6e4a392a7bd99a5939ccb9b8fbf594636cf3", size = 62854, upload-time = "2026-04-20T23:17:50.66Z" }
 wheels = [
@@ -1710,7 +1794,7 @@ name = "jupyter-lsp"
 version = "2.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jupyter-server", marker = "sys_platform == 'linux'" },
+    { name = "jupyter-server" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/36/ff/1e4a61f5170a9a1d978f3ac3872449de6c01fc71eaf89657824c878b1549/jupyter_lsp-2.3.1.tar.gz", hash = "sha256:fdf8a4aa7d85813976d6e29e95e6a2c8f752701f926f2715305249a3829805a6", size = 55677, upload-time = "2026-04-02T08:10:06.749Z" }
 wheels = [
@@ -1722,23 +1806,23 @@ name = "jupyter-server"
 version = "2.20.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "anyio", marker = "sys_platform == 'linux'" },
-    { name = "argon2-cffi", marker = "sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-client", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-events", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-server-terminals", marker = "sys_platform == 'linux'" },
-    { name = "nbconvert", marker = "sys_platform == 'linux'" },
-    { name = "nbformat", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "prometheus-client", marker = "sys_platform == 'linux'" },
-    { name = "pyzmq", marker = "sys_platform == 'linux'" },
-    { name = "send2trash", marker = "sys_platform == 'linux'" },
-    { name = "terminado", marker = "sys_platform == 'linux'" },
-    { name = "tornado", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
-    { name = "websocket-client", marker = "sys_platform == 'linux'" },
+    { name = "anyio" },
+    { name = "argon2-cffi" },
+    { name = "jinja2" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "jupyter-events" },
+    { name = "jupyter-server-terminals" },
+    { name = "nbconvert" },
+    { name = "nbformat" },
+    { name = "packaging" },
+    { name = "prometheus-client" },
+    { name = "pyzmq" },
+    { name = "send2trash" },
+    { name = "terminado" },
+    { name = "tornado" },
+    { name = "traitlets" },
+    { name = "websocket-client" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6b/dc/db3a582633170186f8c8b31298d7eb26ad0eb031a1f53476c258b64eed05/jupyter_server-2.20.0.tar.gz", hash = "sha256:b5778ba337d8015a3dc2b80803ecdd5ac18d3797fddf61a50ea5fb472b4ebe14", size = 756523, upload-time = "2026-06-17T12:09:09.435Z" }
 wheels = [
@@ -1750,7 +1834,7 @@ name = "jupyter-server-terminals"
 version = "0.5.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "terminado", marker = "sys_platform == 'linux'" },
+    { name = "terminado" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" }
 wheels = [
@@ -1762,19 +1846,19 @@ name = "jupyterlab"
 version = "4.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "async-lru", marker = "sys_platform == 'linux'" },
-    { name = "httpx", marker = "sys_platform == 'linux'" },
-    { name = "ipykernel", marker = "sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-builder", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-lsp", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-server", marker = "sys_platform == 'linux'" },
-    { name = "jupyterlab-server", marker = "sys_platform == 'linux'" },
-    { name = "notebook-shim", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "tornado", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "async-lru" },
+    { name = "httpx" },
+    { name = "ipykernel" },
+    { name = "jinja2" },
+    { name = "jupyter-builder" },
+    { name = "jupyter-core" },
+    { name = "jupyter-lsp" },
+    { name = "jupyter-server" },
+    { name = "jupyterlab-server" },
+    { name = "notebook-shim" },
+    { name = "packaging" },
+    { name = "tornado" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/bc/2a/d6af53bfd45a43a5bfe7e40ba47ee7a8921a807daf4bb708e3a295bbb54d/jupyterlab-4.6.1.tar.gz", hash = "sha256:75315982ed28427edaa62bb85eadb5105e4043a757643c910efd787fe6ed0837", size = 28179125, upload-time = "2026-06-29T12:48:45.402Z" }
 wheels = [
@@ -1795,13 +1879,13 @@ name = "jupyterlab-server"
 version = "2.28.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "babel", marker = "sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'linux'" },
-    { name = "json5", marker = "sys_platform == 'linux'" },
-    { name = "jsonschema", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-server", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "requests", marker = "sys_platform == 'linux'" },
+    { name = "babel" },
+    { name = "jinja2" },
+    { name = "json5" },
+    { name = "jsonschema" },
+    { name = "jupyter-server" },
+    { name = "packaging" },
+    { name = "requests" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" }
 wheels = [
@@ -1822,11 +1906,11 @@ name = "jupytext"
 version = "1.19.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "markdown-it-py", marker = "sys_platform == 'linux'" },
-    { name = "mdit-py-plugins", marker = "sys_platform == 'linux'" },
-    { name = "nbformat", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "markdown-it-py" },
+    { name = "mdit-py-plugins" },
+    { name = "nbformat" },
+    { name = "packaging" },
+    { name = "pyyaml" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/3b/52/e014296ac8f40ca783aeb73dae52e65edbb0eaae0dcdc1ea41bfaa8aebf7/jupytext-1.19.4.tar.gz", hash = "sha256:739bcd4bc12aa4fe298a38017cdb5ae27b08a6ba3a5470728d2fe9e04b155db1", size = 4581977, upload-time = "2026-06-21T21:48:58.32Z" }
 wheels = [
@@ -1838,11 +1922,11 @@ name = "keyring"
 version = "25.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jaraco-classes", marker = "sys_platform == 'linux'" },
-    { name = "jaraco-context", marker = "sys_platform == 'linux'" },
-    { name = "jaraco-functools", marker = "sys_platform == 'linux'" },
-    { name = "jeepney", marker = "sys_platform == 'linux'" },
-    { name = "secretstorage", marker = "sys_platform == 'linux'" },
+    { name = "jaraco-classes" },
+    { name = "jaraco-context" },
+    { name = "jaraco-functools" },
+    { name = "jeepney" },
+    { name = "secretstorage" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" }
 wheels = [
@@ -1931,15 +2015,33 @@ name = "lenspack"
 version = "1.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "numpy" },
+    { name = "scipy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/73/de/18cfc64028334a1907d44ba2b40e233a2c7a06d7c1e827acfd1785c0b293/lenspack-1.0.0.tar.gz", hash = "sha256:e528a5409473eb996b39695cccb744db067341eb5fac6f240cd8d0aa669c85ec", size = 32632, upload-time = "2020-09-04T08:33:53.267Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/1b/3d/a93a1332b1412301ddb454f206507b5e0b3679e012471fbbb075ca3b0845/lenspack-1.0.0-py3-none-any.whl", hash = "sha256:f9c632697516bb681e16b3eff66a7210d6355926179b95aa7060c8936c2259cc", size = 37746, upload-time = "2020-09-04T08:33:50.114Z" },
 ]
 
+[[package]]
+name = "levin"
+version = "0.0.1"
+source = { git = "https://github.com/sachaguer/OneCovariance.git?rev=main#70265be3a4bffcfded7b9251a3c4cbe8159d793f" }
+dependencies = [
+    { name = "astropy" },
+    { name = "future" },
+    { name = "gsl" },
+    { name = "healpy" },
+    { name = "hmf" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pip" },
+    { name = "pyyaml" },
+    { name = "scipy" },
+    { name = "wget" },
+]
+
 [[package]]
 name = "llvmlite"
 version = "0.48.0"
@@ -1961,11 +2063,11 @@ name = "lmfit"
 version = "1.3.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "asteval", marker = "sys_platform == 'linux'" },
-    { name = "dill", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
-    { name = "uncertainties", marker = "sys_platform == 'linux'" },
+    { name = "asteval" },
+    { name = "dill" },
+    { name = "numpy" },
+    { name = "scipy" },
+    { name = "uncertainties" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5a/e5/a35942aed2de95e228728c34609b51fe3ec9182398eac50d288eef313aa2/lmfit-1.3.4.tar.gz", hash = "sha256:3c22c28c43f717f6c5b4a3bd81e893a2149739c26a592c046f2e33c23cfbe497", size = 630720, upload-time = "2025-07-19T20:09:01.876Z" }
 wheels = [
@@ -1986,8 +2088,8 @@ name = "lsstdesc-coord"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "future", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "future" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b8/e0/6806df4cfa54927a2d8e425407611b4fc031dd125bc952b4a31deb743305/lsstdesc_coord-1.3.1.tar.gz", hash = "sha256:60f878c29e1f30a9b50bf60dca3c466dc9cfb2cbc71f0a27c575ced969de57ab", size = 41647, upload-time = "2026-02-13T18:37:32.611Z" }
 wheels = [
@@ -2059,7 +2161,7 @@ name = "markdown-it-py"
 version = "4.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "mdurl", marker = "sys_platform == 'linux'" },
+    { name = "mdurl" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
 wheels = [
@@ -2109,15 +2211,15 @@ name = "matplotlib"
 version = "3.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "contourpy", marker = "sys_platform == 'linux'" },
-    { name = "cycler", marker = "sys_platform == 'linux'" },
-    { name = "fonttools", marker = "sys_platform == 'linux'" },
-    { name = "kiwisolver", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pillow", marker = "sys_platform == 'linux'" },
-    { name = "pyparsing", marker = "sys_platform == 'linux'" },
-    { name = "python-dateutil", marker = "sys_platform == 'linux'" },
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/1f/24/080c99d223d158d3a8902769269ab6da5b50f7a0e6e072513907e02b7a6c/matplotlib-3.11.0.tar.gz", hash = "sha256:68c0c7be01b30dcca3638934f7f591df73401235cbdbf0d1ab1c71e7db7f8b57", size = 33251176, upload-time = "2026-06-12T02:29:15.508Z" }
 wheels = [
@@ -2143,7 +2245,7 @@ name = "matplotlib-inline"
 version = "0.2.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" }
 wheels = [
@@ -2155,7 +2257,7 @@ name = "mdit-py-plugins"
 version = "0.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "markdown-it-py", marker = "sys_platform == 'linux'" },
+    { name = "markdown-it-py" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/59/fc/f8d0863f8862f25602c0404d75568e89fb6b4109804645e5cdfb1be5cf56/mdit_py_plugins-0.6.1.tar.gz", hash = "sha256:a2bca0f039f39dbd35fb74ae1b5f998608c437463371f0ff7f49a19a17a114d0", size = 56114, upload-time = "2026-05-13T09:03:38.91Z" }
 wheels = [
@@ -2255,12 +2357,12 @@ name = "myst-parser"
 version = "5.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "docutils", marker = "sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'linux'" },
-    { name = "markdown-it-py", marker = "sys_platform == 'linux'" },
-    { name = "mdit-py-plugins", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "sphinx", marker = "sys_platform == 'linux'" },
+    { name = "docutils" },
+    { name = "jinja2" },
+    { name = "markdown-it-py" },
+    { name = "mdit-py-plugins" },
+    { name = "pyyaml" },
+    { name = "sphinx" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/21/dc/603751677fff302f34396e206b610f556a59d7fe58b9a2145f54e96b48e8/myst_parser-5.1.0.tar.gz", hash = "sha256:ab69322dc6719dcc7f296479dbb70181b66df6ed315064f92dbc85c0e1bf2f02", size = 101182, upload-time = "2026-05-13T09:38:19.361Z" }
 wheels = [
@@ -2272,10 +2374,10 @@ name = "nbclient"
 version = "0.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jupyter-client", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "nbformat", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "nbformat" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", hash = "sha256:04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a", size = 62535, upload-time = "2026-06-05T07:52:41.746Z" }
 wheels = [
@@ -2287,20 +2389,20 @@ name = "nbconvert"
 version = "7.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "beautifulsoup4", marker = "sys_platform == 'linux'" },
-    { name = "bleach", extra = ["css"], marker = "sys_platform == 'linux'" },
-    { name = "defusedxml", marker = "sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "jupyterlab-pygments", marker = "sys_platform == 'linux'" },
-    { name = "markupsafe", marker = "sys_platform == 'linux'" },
-    { name = "mistune", marker = "sys_platform == 'linux'" },
-    { name = "nbclient", marker = "sys_platform == 'linux'" },
-    { name = "nbformat", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pandocfilters", marker = "sys_platform == 'linux'" },
-    { name = "pygments", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "beautifulsoup4" },
+    { name = "bleach", extra = ["css"] },
+    { name = "defusedxml" },
+    { name = "jinja2" },
+    { name = "jupyter-core" },
+    { name = "jupyterlab-pygments" },
+    { name = "markupsafe" },
+    { name = "mistune" },
+    { name = "nbclient" },
+    { name = "nbformat" },
+    { name = "packaging" },
+    { name = "pandocfilters" },
+    { name = "pygments" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" }
 wheels = [
@@ -2312,10 +2414,10 @@ name = "nbformat"
 version = "5.10.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "fastjsonschema", marker = "sys_platform == 'linux'" },
-    { name = "jsonschema", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "fastjsonschema" },
+    { name = "jsonschema" },
+    { name = "jupyter-core" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" }
 wheels = [
@@ -2364,19 +2466,19 @@ name = "notebook"
 version = "5.7.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ipykernel", marker = "sys_platform == 'linux'" },
-    { name = "ipython-genutils", marker = "sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-client", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-core", marker = "sys_platform == 'linux'" },
-    { name = "nbconvert", marker = "sys_platform == 'linux'" },
-    { name = "nbformat", marker = "sys_platform == 'linux'" },
-    { name = "prometheus-client", marker = "sys_platform == 'linux'" },
-    { name = "pyzmq", marker = "sys_platform == 'linux'" },
-    { name = "send2trash", marker = "sys_platform == 'linux'" },
-    { name = "terminado", marker = "sys_platform == 'linux'" },
-    { name = "tornado", marker = "sys_platform == 'linux'" },
-    { name = "traitlets", marker = "sys_platform == 'linux'" },
+    { name = "ipykernel" },
+    { name = "ipython-genutils" },
+    { name = "jinja2" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "nbconvert" },
+    { name = "nbformat" },
+    { name = "prometheus-client" },
+    { name = "pyzmq" },
+    { name = "send2trash" },
+    { name = "terminado" },
+    { name = "tornado" },
+    { name = "traitlets" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6e/22/b5dcce67559d63d0f22e46d806305710808c698a1b91c07eb09e389785e0/notebook-5.7.4.tar.gz", hash = "sha256:d908673a4010787625c8952e91a22adf737db031f2aa0793ad92f6558918a74a", size = 13389469, upload-time = "2018-12-17T10:06:00.805Z" }
 wheels = [
@@ -2388,7 +2490,7 @@ name = "notebook-shim"
 version = "0.2.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jupyter-server", marker = "sys_platform == 'linux'" },
+    { name = "jupyter-server" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" }
 wheels = [
@@ -2400,8 +2502,8 @@ name = "numba"
 version = "0.66.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "llvmlite", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "llvmlite" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ae/a0/570e3dc53e5602b49108f62a13e529f1eec8bfc7ef37d49c825924dcf546/numba-0.66.0.tar.gz", hash = "sha256:b900e63a0e26c05ea9a6d5a3a5a0a177cb64c5011887bf43edb8c3ed2c38d363", size = 2806181, upload-time = "2026-07-01T23:12:46.36Z" }
 wheels = [
@@ -2425,8 +2527,8 @@ name = "numcodecs"
 version = "0.16.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/44/bd/8a391e7c356366224734efd24da929cc4796fff468bfb179fe1af6548535/numcodecs-0.16.5.tar.gz", hash = "sha256:0d0fb60852f84c0bd9543cc4d2ab9eefd37fc8efcc410acd4777e62a1d300318", size = 6276387, upload-time = "2025-11-21T02:49:48.986Z" }
 wheels = [
@@ -2443,7 +2545,7 @@ name = "numexpr"
 version = "2.14.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cb/2f/fdba158c9dbe5caca9c3eca3eaffffb251f2fb8674bf8e2d0aed5f38d319/numexpr-2.14.1.tar.gz", hash = "sha256:4be00b1086c7b7a5c32e31558122b7b80243fe098579b170967da83f3152b48b", size = 119400, upload-time = "2025-10-13T16:17:27.351Z" }
 wheels = [
@@ -2502,7 +2604,7 @@ name = "numpydoc"
 version = "1.10.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "sphinx", marker = "sys_platform == 'linux'" },
+    { name = "sphinx" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/e9/3c/dfccc9e7dee357fb2aa13c3890d952a370dd0ed071e0f7ed62ed0df567c1/numpydoc-1.10.0.tar.gz", hash = "sha256:3f7970f6eee30912260a6b31ac72bba2432830cd6722569ec17ee8d3ef5ffa01", size = 94027, upload-time = "2025-12-02T16:39:12.937Z" }
 wheels = [
@@ -2514,7 +2616,7 @@ name = "opencv-python-headless"
 version = "5.0.0.93"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/1d/99/76b7c80252aa83c1af16393454aafd125a0287101afe8deb0a6821af0e30/opencv_python_headless-5.0.0.93.tar.gz", hash = "sha256:b82f9831daab90b725c7c1ee1b36cb5732c367096ac76d119e64e14eb70d5f3c", size = 81817738, upload-time = "2026-07-02T07:01:06.039Z" }
 wheels = [
@@ -2538,10 +2640,10 @@ name = "pandas"
 version = "2.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "python-dateutil", marker = "sys_platform == 'linux'" },
-    { name = "pytz", marker = "sys_platform == 'linux'" },
-    { name = "tzdata", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }
 wheels = [
@@ -2590,8 +2692,8 @@ name = "partd"
 version = "1.4.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "locket", marker = "sys_platform == 'linux'" },
-    { name = "toolz", marker = "sys_platform == 'linux'" },
+    { name = "locket" },
+    { name = "toolz" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b2/3a/3f06f34820a31257ddcabdfafc2672c5816be79c7e353b02c1f318daa7d4/partd-1.4.2.tar.gz", hash = "sha256:d022c33afbdc8405c226621b015e8067888173d85f7f5ecebb3cafed9a20f02c", size = 21029, upload-time = "2024-05-06T19:51:41.945Z" }
 wheels = [
@@ -2603,7 +2705,7 @@ name = "patsy"
 version = "1.0.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/be/44/ed13eccdd0519eff265f44b670d46fbb0ec813e2274932dc1c0e48520f7d/patsy-1.0.2.tar.gz", hash = "sha256:cdc995455f6233e90e22de72c37fcadb344e7586fb83f06696f54d92f8ce74c0", size = 399942, upload-time = "2025-10-20T16:17:37.535Z" }
 wheels = [
@@ -2615,7 +2717,7 @@ name = "pexpect"
 version = "4.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ptyprocess", marker = "sys_platform == 'linux'" },
+    { name = "ptyprocess" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
 wheels = [
@@ -2668,14 +2770,23 @@ name = "pims"
 version = "0.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "imageio", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "slicerator", marker = "sys_platform == 'linux'" },
-    { name = "tifffile", marker = "sys_platform == 'linux'" },
+    { name = "imageio" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "slicerator" },
+    { name = "tifffile" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b8/02/5bf3639f5b77e9b183011c08541c5039ba3d04f5316c70312b48a8e003a9/pims-0.7.tar.gz", hash = "sha256:55907a4c301256086d2aa4e34a5361b9109f24e375c2071e1117b9491e82946b", size = 87779, upload-time = "2024-06-10T19:20:42.842Z" }
 
+[[package]]
+name = "pip"
+version = "26.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/15/4500e320e6b101ec3b719ae85b697d9940b6cda672bc555bd6016fc60c6f/pip-26.2.1.tar.gz", hash = "sha256:f6ad667e89a1fe78046c8f13232b247200f5258d7828f3f7883d660878e0813f", size = 1848877, upload-time = "2026-08-04T22:51:14.148Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/6e/1736e5b4ae2b778ef2f81c47d797de9f891d4d8acb047a24ca37a60294dd/pip-26.2.1-py3-none-any.whl", hash = "sha256:71138adf1f4ca900cdb7d289c21b7494329f2332b6d85f0e1c42108c0384ed3e", size = 1816632, upload-time = "2026-08-04T22:51:12.472Z" },
+]
+
 [[package]]
 name = "platformdirs"
 version = "4.10.0"
@@ -2708,7 +2819,7 @@ name = "prompt-toolkit"
 version = "3.0.52"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "wcwidth", marker = "sys_platform == 'linux'" },
+    { name = "wcwidth" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
 wheels = [
@@ -2814,8 +2925,8 @@ name = "pybtex"
 version = "0.26.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "latexcodec", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "latexcodec" },
+    { name = "pyyaml" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/4d/f5/f30da9c93f0fa6d619332b2f69597219b625f35780473a05164a9981fd9a/pybtex-0.26.1.tar.gz", hash = "sha256:2e5543bea424e60e9e42eef70bff597be48649d8f68ba061a7a092b2477d5464", size = 692991, upload-time = "2026-04-03T13:05:39.014Z" }
 wheels = [
@@ -2827,8 +2938,8 @@ name = "pybtex-docutils"
 version = "1.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "docutils", marker = "sys_platform == 'linux'" },
-    { name = "pybtex", marker = "sys_platform == 'linux'" },
+    { name = "docutils" },
+    { name = "pybtex" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7e/84/796ea94d26188a853660f81bded39f8de4cfe595130aef0dea1088705a11/pybtex-docutils-1.0.3.tar.gz", hash = "sha256:3a7ebdf92b593e00e8c1c538aa9a20bca5d92d84231124715acc964d51d93c6b", size = 18348, upload-time = "2023-08-22T18:47:54.833Z" }
 wheels = [
@@ -2840,10 +2951,10 @@ name = "pyccl"
 version = "3.3.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "scipy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/57/40/ff357d61a20c21420f1fe7417ca6d889be2e07a67b3564775aeaf6c3f366/pyccl-3.3.4.tar.gz", hash = "sha256:a9d22557354fd161df909e8f4f199e4f1c434c080fd6cddb2246609ddbd70e7c", size = 16783719, upload-time = "2026-05-14T16:26:27.327Z" }
 wheels = [
@@ -2866,10 +2977,10 @@ name = "pydantic"
 version = "2.13.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "annotated-types", marker = "sys_platform == 'linux'" },
-    { name = "pydantic-core", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
-    { name = "typing-inspection", marker = "sys_platform == 'linux'" },
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
 wheels = [
@@ -2881,7 +2992,7 @@ name = "pydantic-core"
 version = "2.46.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
 wheels = [
@@ -2934,7 +3045,7 @@ name = "pyerfa"
 version = "2.0.1.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/71/39/63cc8291b0cf324ae710df41527faf7d331bce573899199d926b3e492260/pyerfa-2.0.1.5.tar.gz", hash = "sha256:17d6b24fe4846c65d5e7d8c362dcb08199dc63b30a236aedd73875cc83e1f6c0", size = 818430, upload-time = "2024-11-11T15:22:30.852Z" }
 wheels = [
@@ -2957,8 +3068,8 @@ name = "pymaster"
 version = "2.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ducc0", marker = "sys_platform == 'linux'" },
-    { name = "healpy", marker = "sys_platform == 'linux'" },
+    { name = "ducc0" },
+    { name = "healpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/95/45/470858f2a6a3f5133955bb87aed978a5e921d4052aea1c19718e6b72f0ae/pymaster-2.6.tar.gz", hash = "sha256:056a09bc8631cf338e93ef14d8c70272ad9554ef10498d919e920994531c57a2", size = 33707181, upload-time = "2025-12-16T09:18:28.905Z" }
 
@@ -2967,8 +3078,8 @@ name = "pyopenssl"
 version = "26.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cryptography", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13' and sys_platform == 'linux'" },
+    { name = "cryptography" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/74/b7/da07bae88f5a9506b4def6f2f4903cf4c3b8831e560dba8fa18ca08f758f/pyopenssl-26.3.0.tar.gz", hash = "sha256:589de7fae1c9ea670d18422ed00fc04da787bbde8e1454aea872aa57b49ad341", size = 182024, upload-time = "2026-06-12T20:28:07.458Z" }
 wheels = [
@@ -2989,10 +3100,10 @@ name = "pytest"
 version = "9.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "iniconfig", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pluggy", marker = "sys_platform == 'linux'" },
-    { name = "pygments", marker = "sys_platform == 'linux'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
 wheels = [
@@ -3004,9 +3115,9 @@ name = "pytest-cov"
 version = "7.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "coverage", marker = "sys_platform == 'linux'" },
-    { name = "pluggy", marker = "sys_platform == 'linux'" },
-    { name = "pytest", marker = "sys_platform == 'linux'" },
+    { name = "coverage" },
+    { name = "pluggy" },
+    { name = "pytest" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
 wheels = [
@@ -3018,7 +3129,7 @@ name = "python-dateutil"
 version = "2.9.0.post0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "six", marker = "sys_platform == 'linux'" },
+    { name = "six" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
 wheels = [
@@ -3076,7 +3187,7 @@ name = "pyzmq"
 version = "27.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cffi", marker = "implementation_name == 'pypy' and sys_platform == 'linux'" },
+    { name = "cffi", marker = "implementation_name == 'pypy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" }
 wheels = [
@@ -3105,10 +3216,10 @@ name = "qp-prob"
 version = "1.1.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "deprecated", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
-    { name = "tables-io", marker = "sys_platform == 'linux'" },
+    { name = "deprecated" },
+    { name = "numpy" },
+    { name = "scipy" },
+    { name = "tables-io" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b0/65/c54639ac63667800ee00d74c8851bd104ccaefcae95138073d6e77832d17/qp_prob-1.1.4.tar.gz", hash = "sha256:a68a3a3785d3ca57a2246c0524398338b7b7dffef0aef0722c231c64dde30107", size = 2460490, upload-time = "2026-06-25T20:08:34.63Z" }
 wheels = [
@@ -3120,9 +3231,9 @@ name = "referencing"
 version = "0.37.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "attrs", marker = "sys_platform == 'linux'" },
-    { name = "rpds-py", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13' and sys_platform == 'linux'" },
+    { name = "attrs" },
+    { name = "rpds-py" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
 wheels = [
@@ -3134,8 +3245,8 @@ name = "regions"
 version = "0.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/d3/86/44ff464efa2777247d6addc74416059f1872ab05c88588bbe1aadca27a7c/regions-0.12.tar.gz", hash = "sha256:1c9460770f250ef299e90a9d5c0b35941f7d05bbf879f6ffaa0538250c018ef9", size = 273609, upload-time = "2026-06-24T20:10:17.78Z" }
 wheels = [
@@ -3148,16 +3259,16 @@ name = "reproject"
 version = "0.21.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "astropy-healpix", marker = "sys_platform == 'linux'" },
-    { name = "dask", extra = ["array"], marker = "sys_platform == 'linux'" },
-    { name = "dask-image", marker = "sys_platform == 'linux'" },
-    { name = "fsspec", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pillow", marker = "sys_platform == 'linux'" },
-    { name = "pyavm", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
-    { name = "zarr", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "astropy-healpix" },
+    { name = "dask", extra = ["array"] },
+    { name = "dask-image" },
+    { name = "fsspec" },
+    { name = "numpy" },
+    { name = "pillow" },
+    { name = "pyavm" },
+    { name = "scipy" },
+    { name = "zarr" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cc/44/6fd820ba336484277a91a2f4808b60d6ec0b9f033f588c237e778f20fe89/reproject-0.21.0.tar.gz", hash = "sha256:01ede715a1993c29431f52ff74189ef30f5e7b2e8b4dc88c1b002145a971dc1c", size = 1622661, upload-time = "2026-06-25T15:11:34.886Z" }
 wheels = [
@@ -3170,10 +3281,10 @@ name = "requests"
 version = "2.34.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "certifi", marker = "sys_platform == 'linux'" },
-    { name = "charset-normalizer", marker = "sys_platform == 'linux'" },
-    { name = "idna", marker = "sys_platform == 'linux'" },
-    { name = "urllib3", marker = "sys_platform == 'linux'" },
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
 wheels = [
@@ -3185,7 +3296,7 @@ name = "rfc3339-validator"
 version = "0.1.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "six", marker = "sys_platform == 'linux'" },
+    { name = "six" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" }
 wheels = [
@@ -3206,7 +3317,7 @@ name = "rfc3987-syntax"
 version = "1.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "lark", marker = "sys_platform == 'linux'" },
+    { name = "lark" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" }
 wheels = [
@@ -3218,8 +3329,8 @@ name = "rich"
 version = "15.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "markdown-it-py", marker = "sys_platform == 'linux'" },
-    { name = "pygments", marker = "sys_platform == 'linux'" },
+    { name = "markdown-it-py" },
+    { name = "pygments" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
 wheels = [
@@ -3231,7 +3342,7 @@ name = "rocket-fft"
 version = "0.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numba", marker = "sys_platform == 'linux'" },
+    { name = "numba" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/44/b0/09cbec3177ecf56e5ceb789a69fbcdcbabe758cbb682e5d36b14aa8c05fb/rocket_fft-0.3.1.tar.gz", hash = "sha256:ddc902a361099aff9fc02fe9ea3b0d036c2f67f93df356c2b754f7627d7fa4f4", size = 74276, upload-time = "2025-12-26T00:30:54.083Z" }
 wheels = [
@@ -3345,9 +3456,9 @@ name = "sacc"
 version = "2.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "numpy" },
+    { name = "scipy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b6/82/5b603d960279b8eb7fac677ba3550c0903a8390f1bff2eee6fbfa59765da/sacc-2.4.tar.gz", hash = "sha256:a98fb4e59b3c742ddb492a15a10e1f8a4279ba36d56c0d3c35e1cd13cca1167b", size = 424905, upload-time = "2026-07-02T11:29:27.458Z" }
 wheels = [
@@ -3359,7 +3470,7 @@ name = "scipy"
 version = "1.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
 wheels = [
@@ -3390,9 +3501,9 @@ name = "seaborn"
 version = "0.13.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "matplotlib", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pandas", marker = "sys_platform == 'linux'" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pandas" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" }
 wheels = [
@@ -3404,8 +3515,8 @@ name = "secretstorage"
 version = "3.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cryptography", marker = "sys_platform == 'linux'" },
-    { name = "jeepney", marker = "sys_platform == 'linux'" },
+    { name = "cryptography" },
+    { name = "jeepney" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" }
 wheels = [
@@ -3433,31 +3544,18 @@ wheels = [
 [[package]]
 name = "shear-psf-leakage"
 version = "0.2.1"
-source = { git = "https://github.com/CosmoStat/shear_psf_leakage.git?rev=develop#0b3c17523b77760c9259be15ba5bbba99d575d0a" }
-dependencies = [
-    { name = "camb", marker = "sys_platform == 'linux'" },
-    { name = "cs-util", marker = "sys_platform == 'linux'" },
-    { name = "emcee", marker = "sys_platform == 'linux'" },
-    { name = "getdist", marker = "sys_platform == 'linux'" },
-    { name = "gsl", marker = "sys_platform == 'linux'" },
-    { name = "jupyter", marker = "sys_platform == 'linux'" },
-    { name = "jupyter-server", marker = "sys_platform == 'linux'" },
-    { name = "jupyterlab", marker = "sys_platform == 'linux'" },
-    { name = "jupytext", marker = "sys_platform == 'linux'" },
-    { name = "lenspack", marker = "sys_platform == 'linux'" },
-    { name = "lmfit", marker = "sys_platform == 'linux'" },
-    { name = "matplotlib", marker = "sys_platform == 'linux'" },
-    { name = "notebook", marker = "sys_platform == 'linux'" },
-    { name = "pandas", marker = "sys_platform == 'linux'" },
-    { name = "pyccl", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
-    { name = "stats", marker = "sys_platform == 'linux'" },
-    { name = "swig", marker = "sys_platform == 'linux'" },
-    { name = "tornado", marker = "sys_platform == 'linux'" },
-    { name = "tqdm", marker = "sys_platform == 'linux'" },
-    { name = "treecorr", marker = "sys_platform == 'linux'" },
-    { name = "uncertainties", marker = "sys_platform == 'linux'" },
+source = { git = "https://github.com/CosmoStat/shear_psf_leakage.git?rev=develop#f1a2c071872e8633010f9af69c7004df168ebb5a" }
+dependencies = [
+    { name = "cs-util" },
+    { name = "emcee" },
+    { name = "getdist" },
+    { name = "lmfit" },
+    { name = "matplotlib" },
+    { name = "pandas" },
+    { name = "scipy" },
+    { name = "tqdm" },
+    { name = "treecorr" },
+    { name = "uncertainties" },
 ]
 
 [[package]]
@@ -3474,11 +3572,11 @@ name = "skyproj"
 version = "2.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "healsparse", marker = "sys_platform == 'linux'" },
-    { name = "hpgeom", marker = "sys_platform == 'linux'" },
-    { name = "matplotlib", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "healsparse" },
+    { name = "hpgeom" },
+    { name = "matplotlib" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/90/cf/5158151ae6fc60459f430451b612a4bf2da07ebff2a9f52a37e73715a5ee/skyproj-2.5.0.tar.gz", hash = "sha256:cb8d5115927ca43cacdb6d92f00bb4fcc8563ee71028f755203ce1752e67c140", size = 8521587, upload-time = "2026-06-26T19:51:15.378Z" }
 wheels = [
@@ -3500,7 +3598,7 @@ name = "smart-open"
 version = "7.7.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "wrapt", marker = "sys_platform == 'linux'" },
+    { name = "wrapt" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/db/c6/22e7a2acd5d27941e85e0d7ede398da5abe2e4677d2265c924157247c32e/smart_open-7.7.1.tar.gz", hash = "sha256:9414ba5733e28309f29b28a303b0f1054ad23fe0275f1a1b600c80a724f4bd1a", size = 54952, upload-time = "2026-06-26T07:56:35.309Z" }
 wheels = [
@@ -3521,13 +3619,13 @@ name = "smokescreen"
 version = "1.5.6"
 source = { git = "https://github.com/UNIONS-WL/Smokescreen?rev=588a6b9b26560bd5ba3dd5ba342f3c40152644f9#588a6b9b26560bd5ba3dd5ba342f3c40152644f9" }
 dependencies = [
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "cryptography", marker = "sys_platform == 'linux'" },
-    { name = "jsonargparse", extra = ["signatures"], marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pyccl", marker = "sys_platform == 'linux'" },
-    { name = "sacc", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
+    { name = "astropy" },
+    { name = "cryptography" },
+    { name = "jsonargparse", extra = ["signatures"] },
+    { name = "numpy" },
+    { name = "pyccl" },
+    { name = "sacc" },
+    { name = "scipy" },
 ]
 
 [[package]]
@@ -3535,37 +3633,37 @@ name = "snakemake"
 version = "9.23.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "conda-inject", marker = "sys_platform == 'linux'" },
-    { name = "configargparse", marker = "sys_platform == 'linux'" },
-    { name = "connection-pool", marker = "sys_platform == 'linux'" },
-    { name = "docutils", marker = "sys_platform == 'linux'" },
-    { name = "dpath", marker = "sys_platform == 'linux'" },
-    { name = "gitpython", marker = "sys_platform == 'linux'" },
-    { name = "humanfriendly", marker = "sys_platform == 'linux'" },
-    { name = "immutables", marker = "sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'linux'" },
-    { name = "jsonschema", marker = "sys_platform == 'linux'" },
-    { name = "nbformat", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "platformdirs", marker = "sys_platform == 'linux'" },
-    { name = "psutil", marker = "sys_platform == 'linux'" },
-    { name = "pulp", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "referencing", marker = "sys_platform == 'linux'" },
-    { name = "requests", marker = "sys_platform == 'linux'" },
-    { name = "smart-open", marker = "sys_platform == 'linux'" },
-    { name = "snakemake-interface-common", marker = "sys_platform == 'linux'" },
-    { name = "snakemake-interface-executor-plugins", marker = "sys_platform == 'linux'" },
-    { name = "snakemake-interface-logger-plugins", marker = "sys_platform == 'linux'" },
-    { name = "snakemake-interface-report-plugins", marker = "sys_platform == 'linux'" },
-    { name = "snakemake-interface-scheduler-plugins", marker = "sys_platform == 'linux'" },
-    { name = "snakemake-interface-storage-plugins", marker = "sys_platform == 'linux'" },
-    { name = "sqlmodel", marker = "sys_platform == 'linux'" },
-    { name = "tabulate", marker = "sys_platform == 'linux'" },
-    { name = "tenacity", marker = "sys_platform == 'linux'" },
-    { name = "throttler", marker = "sys_platform == 'linux'" },
-    { name = "wrapt", marker = "sys_platform == 'linux'" },
-    { name = "yte", marker = "sys_platform == 'linux'" },
+    { name = "conda-inject" },
+    { name = "configargparse" },
+    { name = "connection-pool" },
+    { name = "docutils" },
+    { name = "dpath" },
+    { name = "gitpython" },
+    { name = "humanfriendly" },
+    { name = "immutables" },
+    { name = "jinja2" },
+    { name = "jsonschema" },
+    { name = "nbformat" },
+    { name = "packaging" },
+    { name = "platformdirs" },
+    { name = "psutil" },
+    { name = "pulp" },
+    { name = "pyyaml" },
+    { name = "referencing" },
+    { name = "requests" },
+    { name = "smart-open" },
+    { name = "snakemake-interface-common" },
+    { name = "snakemake-interface-executor-plugins" },
+    { name = "snakemake-interface-logger-plugins" },
+    { name = "snakemake-interface-report-plugins" },
+    { name = "snakemake-interface-scheduler-plugins" },
+    { name = "snakemake-interface-storage-plugins" },
+    { name = "sqlmodel" },
+    { name = "tabulate" },
+    { name = "tenacity" },
+    { name = "throttler" },
+    { name = "wrapt" },
+    { name = "yte" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9e/c2/45aa858e55edbb7dbc243ed60859f4f3d92d63ecdd67a80632aa3659fe6b/snakemake-9.23.1.tar.gz", hash = "sha256:ef8d698bfce66a6669cc29df7e344b0b367fd90956c725e5ae0a79a556e8e93f", size = 6802587, upload-time = "2026-06-18T09:42:57.653Z" }
 wheels = [
@@ -3577,9 +3675,9 @@ name = "snakemake-interface-common"
 version = "1.23.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "argparse-dataclass", marker = "sys_platform == 'linux'" },
-    { name = "configargparse", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "argparse-dataclass" },
+    { name = "configargparse" },
+    { name = "packaging" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/89/c3/592f832f6e5d2d31f749392e48e8401b7625dec668d3d365d8d28f2b6c30/snakemake_interface_common-1.23.0.tar.gz", hash = "sha256:6ed14531a461417659364a0dd0acc51b786af4e26fc15cc5e00ff3d9fcaffacc", size = 13960, upload-time = "2026-03-08T21:54:29.251Z" }
 wheels = [
@@ -3591,9 +3689,9 @@ name = "snakemake-interface-executor-plugins"
 version = "9.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "argparse-dataclass", marker = "sys_platform == 'linux'" },
-    { name = "snakemake-interface-common", marker = "sys_platform == 'linux'" },
-    { name = "throttler", marker = "sys_platform == 'linux'" },
+    { name = "argparse-dataclass" },
+    { name = "snakemake-interface-common" },
+    { name = "throttler" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/54/50/de06b284c45a8e94fb8e4a12d5235065e78b49b8f84329dc10fe39f4b7dd/snakemake_interface_executor_plugins-9.4.0.tar.gz", hash = "sha256:9d4138897beacbaadaedad94b63f948eaeb604b7fc78f9cf65ac57f090f2c066", size = 16549, upload-time = "2026-03-08T17:04:02.644Z" }
 wheels = [
@@ -3605,7 +3703,7 @@ name = "snakemake-interface-logger-plugins"
 version = "2.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "snakemake-interface-common", marker = "sys_platform == 'linux'" },
+    { name = "snakemake-interface-common" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a7/0c/3fa5d592663c65669a867526604aadc6fbc235fb9284e94b49c0ef59aa41/snakemake_interface_logger_plugins-2.1.0.tar.gz", hash = "sha256:c89a00d2a398490cecd91b6dc6db8049cba93712d82e1d8f3000f3040bf3791c", size = 15917, upload-time = "2026-05-20T15:12:35.259Z" }
 wheels = [
@@ -3617,7 +3715,7 @@ name = "snakemake-interface-report-plugins"
 version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "snakemake-interface-common", marker = "sys_platform == 'linux'" },
+    { name = "snakemake-interface-common" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/18/d6/6160ed98de665d6871dd356597dbf726688cc786e88668359ca37b7d9f54/snakemake_interface_report_plugins-1.3.0.tar.gz", hash = "sha256:fc9495298bec4e69721ab8afe6d6d88a86966fda2eeb003db56b9a88b86d5934", size = 4283, upload-time = "2025-10-31T10:52:36.55Z" }
 wheels = [
@@ -3629,7 +3727,7 @@ name = "snakemake-interface-scheduler-plugins"
 version = "2.0.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "snakemake-interface-common", marker = "sys_platform == 'linux'" },
+    { name = "snakemake-interface-common" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/88/d9/d480807d2cfc2d132bc760d877d45ec8fbe620a24200ec4d2697c4a26031/snakemake_interface_scheduler_plugins-2.0.2.tar.gz", hash = "sha256:2797e8fa9019d983132c2b403f14d6fcd3c5ad4c8d8a66b984b4740a71cacc46", size = 8642, upload-time = "2025-10-20T13:58:12.988Z" }
 wheels = [
@@ -3641,11 +3739,11 @@ name = "snakemake-interface-storage-plugins"
 version = "4.4.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "humanfriendly", marker = "sys_platform == 'linux'" },
-    { name = "snakemake-interface-common", marker = "sys_platform == 'linux'" },
-    { name = "tenacity", marker = "sys_platform == 'linux'" },
-    { name = "throttler", marker = "sys_platform == 'linux'" },
-    { name = "wrapt", marker = "sys_platform == 'linux'" },
+    { name = "humanfriendly" },
+    { name = "snakemake-interface-common" },
+    { name = "tenacity" },
+    { name = "throttler" },
+    { name = "wrapt" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/93/6e/f3c5b2d621fd6a6b78d8cfc01fef6b926fe2c277f5ed77c5e4deeacb94eb/snakemake_interface_storage_plugins-4.4.1.tar.gz", hash = "sha256:b2b5bf05318af36955ebf2ce76c921c0fb06904ca98fb30e1657d88b7b7b6945", size = 14924, upload-time = "2026-03-16T11:16:01.075Z" }
 wheels = [
@@ -3675,81 +3773,82 @@ name = "sp-validation"
 version = "0.6.0"
 source = { virtual = "." }
 dependencies = [
-    { name = "adjusttext", marker = "sys_platform == 'linux'" },
-    { name = "astropy", marker = "sys_platform == 'linux'" },
-    { name = "camb", marker = "sys_platform == 'linux'" },
-    { name = "clmm", marker = "sys_platform == 'linux'" },
-    { name = "colorama", marker = "sys_platform == 'linux'" },
-    { name = "cosmo-numba", marker = "sys_platform == 'linux'" },
-    { name = "cryptography", marker = "sys_platform == 'linux'" },
-    { name = "cs-util", marker = "sys_platform == 'linux'" },
-    { name = "emcee", marker = "sys_platform == 'linux'" },
-    { name = "getdist", marker = "sys_platform == 'linux'" },
-    { name = "h5py", marker = "sys_platform == 'linux'" },
-    { name = "healpy", marker = "sys_platform == 'linux'" },
-    { name = "healsparse", marker = "sys_platform == 'linux'" },
-    { name = "importlib-metadata", marker = "sys_platform == 'linux'" },
-    { name = "joblib", marker = "sys_platform == 'linux'" },
-    { name = "jupyter", marker = "sys_platform == 'linux'" },
-    { name = "jupyterlab", marker = "sys_platform == 'linux'" },
-    { name = "jupytext", marker = "sys_platform == 'linux'" },
-    { name = "lenspack", marker = "sys_platform == 'linux'" },
-    { name = "lmfit", marker = "sys_platform == 'linux'" },
-    { name = "matplotlib", marker = "sys_platform == 'linux'" },
-    { name = "numba", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "opencv-python-headless", marker = "sys_platform == 'linux'" },
-    { name = "pandas", marker = "sys_platform == 'linux'" },
-    { name = "pyarrow", marker = "sys_platform == 'linux'" },
-    { name = "pyccl", marker = "sys_platform == 'linux'" },
-    { name = "pymaster", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "regions", marker = "sys_platform == 'linux'" },
-    { name = "reproject", marker = "sys_platform == 'linux'" },
-    { name = "sacc", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
-    { name = "seaborn", marker = "sys_platform == 'linux'" },
-    { name = "shear-psf-leakage", marker = "sys_platform == 'linux'" },
-    { name = "skyproj", marker = "sys_platform == 'linux'" },
-    { name = "smokescreen", marker = "sys_platform == 'linux'" },
-    { name = "statsmodels", marker = "sys_platform == 'linux'" },
-    { name = "tqdm", marker = "sys_platform == 'linux'" },
-    { name = "treecorr", marker = "sys_platform == 'linux'" },
-    { name = "uncertainties", marker = "sys_platform == 'linux'" },
+    { name = "adjusttext" },
+    { name = "astropy" },
+    { name = "camb" },
+    { name = "clmm" },
+    { name = "colorama" },
+    { name = "cosmo-numba" },
+    { name = "cryptography" },
+    { name = "cs-util" },
+    { name = "emcee" },
+    { name = "getdist" },
+    { name = "h5py" },
+    { name = "healpy" },
+    { name = "healsparse" },
+    { name = "importlib-metadata" },
+    { name = "joblib" },
+    { name = "jupyter" },
+    { name = "jupyterlab" },
+    { name = "jupytext" },
+    { name = "lenspack" },
+    { name = "levin" },
+    { name = "lmfit" },
+    { name = "matplotlib" },
+    { name = "numba" },
+    { name = "numpy" },
+    { name = "opencv-python-headless" },
+    { name = "pandas" },
+    { name = "pyarrow" },
+    { name = "pyccl" },
+    { name = "pymaster" },
+    { name = "pyyaml" },
+    { name = "regions" },
+    { name = "reproject" },
+    { name = "sacc" },
+    { name = "scipy" },
+    { name = "seaborn" },
+    { name = "shear-psf-leakage" },
+    { name = "skyproj" },
+    { name = "smokescreen" },
+    { name = "statsmodels" },
+    { name = "tqdm" },
+    { name = "treecorr" },
+    { name = "uncertainties" },
 ]
 
 [package.optional-dependencies]
 develop = [
-    { name = "myst-parser", marker = "sys_platform == 'linux'" },
-    { name = "numpydoc", marker = "sys_platform == 'linux'" },
-    { name = "pytest", marker = "sys_platform == 'linux'" },
-    { name = "pytest-cov", marker = "sys_platform == 'linux'" },
-    { name = "ruff", marker = "sys_platform == 'linux'" },
-    { name = "sphinx", marker = "sys_platform == 'linux'" },
-    { name = "sphinxawesome-theme", marker = "sys_platform == 'linux'" },
-    { name = "sphinxcontrib-bibtex", marker = "sys_platform == 'linux'" },
+    { name = "myst-parser" },
+    { name = "numpydoc" },
+    { name = "pytest" },
+    { name = "pytest-cov" },
+    { name = "ruff" },
+    { name = "sphinx" },
+    { name = "sphinxawesome-theme" },
+    { name = "sphinxcontrib-bibtex" },
 ]
 docs = [
-    { name = "myst-parser", marker = "sys_platform == 'linux'" },
-    { name = "numpydoc", marker = "sys_platform == 'linux'" },
-    { name = "sphinx", marker = "sys_platform == 'linux'" },
-    { name = "sphinxawesome-theme", marker = "sys_platform == 'linux'" },
-    { name = "sphinxcontrib-bibtex", marker = "sys_platform == 'linux'" },
+    { name = "myst-parser" },
+    { name = "numpydoc" },
+    { name = "sphinx" },
+    { name = "sphinxawesome-theme" },
+    { name = "sphinxcontrib-bibtex" },
 ]
 glass = [
-    { name = "cosmology", marker = "sys_platform == 'linux'" },
-    { name = "fitsio", marker = "sys_platform == 'linux'" },
-    { name = "glass", marker = "sys_platform == 'linux'" },
-    { name = "glass-ext-camb", marker = "sys_platform == 'linux'" },
+    { name = "cosmology" },
+    { name = "fitsio" },
+    { name = "glass", extra = ["examples"] },
+    { name = "glass-ext-camb" },
 ]
 test = [
-    { name = "pytest", marker = "sys_platform == 'linux'" },
-    { name = "pytest-cov", marker = "sys_platform == 'linux'" },
-    { name = "ruff", marker = "sys_platform == 'linux'" },
+    { name = "pytest" },
+    { name = "pytest-cov" },
+    { name = "ruff" },
 ]
 workflow = [
-    { name = "mpi4py", marker = "sys_platform == 'linux'" },
-    { name = "snakemake", marker = "sys_platform == 'linux'" },
+    { name = "mpi4py" },
+    { name = "snakemake" },
 ]
 
 [package.metadata]
@@ -3766,7 +3865,7 @@ requires-dist = [
     { name = "emcee" },
     { name = "fitsio", marker = "extra == 'glass'" },
     { name = "getdist", git = "https://github.com/benabed/getdist.git?rev=113cd22a9a0d013b6f72fe734be81f260f3d3be5" },
-    { name = "glass", marker = "extra == 'glass'", specifier = "==2025.1" },
+    { name = "glass", extras = ["examples"], marker = "extra == 'glass'", specifier = "==2026.2" },
     { name = "glass-ext-camb", marker = "extra == 'glass'", specifier = "==2023.6" },
     { name = "h5py" },
     { name = "healpy" },
@@ -3777,6 +3876,7 @@ requires-dist = [
     { name = "jupyterlab" },
     { name = "jupytext", specifier = ">=1.15" },
     { name = "lenspack" },
+    { name = "levin", git = "https://github.com/sachaguer/OneCovariance.git?rev=main" },
     { name = "lmfit" },
     { name = "matplotlib" },
     { name = "mpi4py", marker = "extra == 'workflow'" },
@@ -3818,22 +3918,22 @@ name = "sphinx"
 version = "9.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "alabaster", marker = "sys_platform == 'linux'" },
-    { name = "babel", marker = "sys_platform == 'linux'" },
-    { name = "docutils", marker = "sys_platform == 'linux'" },
-    { name = "imagesize", marker = "sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pygments", marker = "sys_platform == 'linux'" },
-    { name = "requests", marker = "sys_platform == 'linux'" },
-    { name = "roman-numerals", marker = "sys_platform == 'linux'" },
-    { name = "snowballstemmer", marker = "sys_platform == 'linux'" },
-    { name = "sphinxcontrib-applehelp", marker = "sys_platform == 'linux'" },
-    { name = "sphinxcontrib-devhelp", marker = "sys_platform == 'linux'" },
-    { name = "sphinxcontrib-htmlhelp", marker = "sys_platform == 'linux'" },
-    { name = "sphinxcontrib-jsmath", marker = "sys_platform == 'linux'" },
-    { name = "sphinxcontrib-qthelp", marker = "sys_platform == 'linux'" },
-    { name = "sphinxcontrib-serializinghtml", marker = "sys_platform == 'linux'" },
+    { name = "alabaster" },
+    { name = "babel" },
+    { name = "docutils" },
+    { name = "imagesize" },
+    { name = "jinja2" },
+    { name = "packaging" },
+    { name = "pygments" },
+    { name = "requests" },
+    { name = "roman-numerals" },
+    { name = "snowballstemmer" },
+    { name = "sphinxcontrib-applehelp" },
+    { name = "sphinxcontrib-devhelp" },
+    { name = "sphinxcontrib-htmlhelp" },
+    { name = "sphinxcontrib-jsmath" },
+    { name = "sphinxcontrib-qthelp" },
+    { name = "sphinxcontrib-serializinghtml" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cd/bd/f08eb0f4eed5c83f1ba2a3bd18f7745a2b1525fad70660a1c00224ec468a/sphinx-9.1.0.tar.gz", hash = "sha256:7741722357dd75f8190766926071fed3bdc211c74dd2d7d4df5404da95930ddb", size = 8718324, upload-time = "2025-12-31T15:09:27.646Z" }
 wheels = [
@@ -3845,8 +3945,8 @@ name = "sphinxawesome-theme"
 version = "6.0.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "beautifulsoup4", marker = "sys_platform == 'linux'" },
-    { name = "sphinx", marker = "sys_platform == 'linux'" },
+    { name = "beautifulsoup4" },
+    { name = "sphinx" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9a/3f/ba7f8dc2837c0ac362127c6cd491578c23ac4d4e8cc6a37726531be29256/sphinxawesome_theme-6.0.5.tar.gz", hash = "sha256:ed3d82b7f0e30e3d6f38f5245d89775e9472a80a45ffd73d6a0a4b9d05ac5736", size = 343775, upload-time = "2026-06-15T15:09:36.094Z" }
 wheels = [
@@ -3867,10 +3967,10 @@ name = "sphinxcontrib-bibtex"
 version = "2.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "docutils", marker = "sys_platform == 'linux'" },
-    { name = "pybtex", marker = "sys_platform == 'linux'" },
-    { name = "pybtex-docutils", marker = "sys_platform == 'linux'" },
-    { name = "sphinx", marker = "sys_platform == 'linux'" },
+    { name = "docutils" },
+    { name = "pybtex" },
+    { name = "pybtex-docutils" },
+    { name = "sphinx" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/15/6a/8e0b2c2420286389e7fed78ff361ec30e2f1d58c8560af8d64df5e7b61e0/sphinxcontrib_bibtex-2.7.0.tar.gz", hash = "sha256:fee700f7aae29bb8f654c62913f00d34ac44fc0b8ca0fa67ac922ff4453addee", size = 120669, upload-time = "2026-05-06T09:29:24.935Z" }
 wheels = [
@@ -3927,8 +4027,8 @@ name = "sqlalchemy"
 version = "2.0.51"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "greenlet", marker = "(platform_machine == 'AMD64' and sys_platform == 'linux') or (platform_machine == 'WIN32' and sys_platform == 'linux') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'amd64' and sys_platform == 'linux') or (platform_machine == 'ppc64le' and sys_platform == 'linux') or (platform_machine == 'win32' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/02/f1/a7a892f18d4d224e6b26f706531eafccc41e37594d37d304786969ee13cb/sqlalchemy-2.0.51.tar.gz", hash = "sha256:804dccd8a4a6242c4e30ad961e540e18a588f6527202f2d6791b01845d59fdc9", size = 9912201, upload-time = "2026-06-15T15:41:20.012Z" }
 wheels = [
@@ -3956,8 +4056,8 @@ name = "sqlmodel"
 version = "0.0.37"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pydantic", marker = "sys_platform == 'linux'" },
-    { name = "sqlalchemy", marker = "sys_platform == 'linux'" },
+    { name = "pydantic" },
+    { name = "sqlalchemy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/fb/26/1d2faa0fd5a765267f49751de533adac6b9ff9366c7c6e7692df4f32230f/sqlmodel-0.0.37.tar.gz", hash = "sha256:d2c19327175794faf50b1ee31cc966764f55b1dedefc046450bc5741a3d68352", size = 85527, upload-time = "2026-02-21T16:39:47.038Z" }
 wheels = [
@@ -3969,31 +4069,25 @@ name = "stack-data"
 version = "0.6.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "asttokens", marker = "sys_platform == 'linux'" },
-    { name = "executing", marker = "sys_platform == 'linux'" },
-    { name = "pure-eval", marker = "sys_platform == 'linux'" },
+    { name = "asttokens" },
+    { name = "executing" },
+    { name = "pure-eval" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
 ]
 
-[[package]]
-name = "stats"
-version = "0.1.2a0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/87/43/f2d8d8e2660740ecca9c0fab85a07bc02da27d1fcc5071ee481082888720/stats-0.1.2a.tar.gz", hash = "sha256:854e59fa99f92ce8319c16149ef8e9939dba3e2237bbb0fb6a6094c60155bd4c", size = 127625, upload-time = "2010-12-31T09:02:15.131Z" }
-
 [[package]]
 name = "statsmodels"
 version = "0.14.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "pandas", marker = "sys_platform == 'linux'" },
-    { name = "patsy", marker = "sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+    { name = "patsy" },
+    { name = "scipy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0d/81/e8d74b34f85285f7335d30c5e3c2d7c0346997af9f3debf9a0a9a63de184/statsmodels-0.14.6.tar.gz", hash = "sha256:4d17873d3e607d398b85126cd4ed7aad89e4e9d89fc744cdab1af3189a996c2a", size = 20689085, upload-time = "2025-12-05T23:08:39.522Z" }
 wheels = [
@@ -4035,7 +4129,7 @@ name = "sympy"
 version = "1.14.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "mpmath", marker = "sys_platform == 'linux'" },
+    { name = "mpmath" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
 wheels = [
@@ -4047,11 +4141,11 @@ name = "tables"
 version = "3.11.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "blosc2", marker = "sys_platform == 'linux'" },
-    { name = "numexpr", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "py-cpuinfo", marker = "sys_platform == 'linux'" },
+    { name = "blosc2" },
+    { name = "numexpr" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "py-cpuinfo" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cc/a3/d213ebe7376d48055bd55a29cd9f99061afa0dcece608f94a5025d797b0a/tables-3.11.1.tar.gz", hash = "sha256:78abcf413091bc7c1e4e8c10fbbb438d1ac0b5a87436c5b972c3e8253871b6fb", size = 4790533, upload-time = "2026-03-01T11:43:36.036Z" }
 wheels = [
@@ -4066,12 +4160,12 @@ name = "tables-io"
 version = "1.1.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "click", marker = "sys_platform == 'linux'" },
-    { name = "deprecated", marker = "sys_platform == 'linux'" },
-    { name = "h5py", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pandas", marker = "sys_platform == 'linux'" },
-    { name = "tables", marker = "sys_platform == 'linux'" },
+    { name = "click" },
+    { name = "deprecated" },
+    { name = "h5py" },
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "tables" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/12/1b/61bed3c55ce4602be5379362ce939b71a2e707e856ee497c1d1e72f8ff3d/tables_io-1.1.2.tar.gz", hash = "sha256:ea27eac8b22ff4e3500afd92140794bd41161f768a2c84520b91b3b58e945182", size = 91394, upload-time = "2026-06-18T16:21:20.896Z" }
 wheels = [
@@ -4101,8 +4195,8 @@ name = "terminado"
 version = "0.18.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ptyprocess", marker = "os_name != 'nt' and sys_platform == 'linux'" },
-    { name = "tornado", marker = "sys_platform == 'linux'" },
+    { name = "ptyprocess", marker = "os_name != 'nt'" },
+    { name = "tornado" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" }
 wheels = [
@@ -4132,7 +4226,7 @@ name = "tifffile"
 version = "2026.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "numpy" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/b7/38/5e2ecef5af2f4fd4a89bb8d6240de9458bab4d51a4cbd97aeb3a0cd618e2/tifffile-2026.6.1.tar.gz", hash = "sha256:626c892c0e899d959b9438e7c0e1491dc154a7fead1f1f37a991724a50eceba9", size = 429694, upload-time = "2026-05-31T23:57:12.165Z" }
 wheels = [
@@ -4144,13 +4238,22 @@ name = "tinycss2"
 version = "1.5.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "webencodings", marker = "sys_platform == 'linux'" },
+    { name = "webencodings" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", hash = "sha256:d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957", size = 88195, upload-time = "2025-11-23T10:29:10.082Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", hash = "sha256:3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661", size = 28404, upload-time = "2025-11-23T10:29:08.676Z" },
 ]
 
+[[package]]
+name = "toml"
+version = "0.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" },
+]
+
 [[package]]
 name = "toolz"
 version = "1.1.0"
@@ -4195,8 +4298,8 @@ name = "transformcl"
 version = "2026.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "array-api-compat", marker = "sys_platform == 'linux'" },
-    { name = "flt", marker = "sys_platform == 'linux'" },
+    { name = "array-api-compat" },
+    { name = "flt" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9d/ce/ae8373b67259c3ea6033425161f7d195387b1e68b17d4d00eee1b68e5edd/transformcl-2026.1.tar.gz", hash = "sha256:14551c33d164f3db24b9141f1f77553182a4b9c789f883476eb33d87ea4d8f13", size = 4850, upload-time = "2026-03-02T19:18:21.221Z" }
 wheels = [
@@ -4208,11 +4311,11 @@ name = "treecorr"
 version = "5.1.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "lsstdesc-coord", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "pybind11", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
-    { name = "setuptools", marker = "sys_platform == 'linux'" },
+    { name = "lsstdesc-coord" },
+    { name = "numpy" },
+    { name = "pybind11" },
+    { name = "pyyaml" },
+    { name = "setuptools" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5d/95/ff399cb37b9e3d7c758f8cf0d5757f06a38093f223f2a65d7cc5b50313d5/treecorr-5.1.3.tar.gz", hash = "sha256:d921ccace064325a8ebb93f371c624f13fcc9559373e3b37cc216cb94ae81ed2", size = 1146147, upload-time = "2026-03-18T18:38:03.626Z" }
 wheels = [
@@ -4227,8 +4330,8 @@ name = "typeshed-client"
 version = "2.12.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-resources", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "importlib-resources" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/54/5d/97d6fa8c204b0d42be931e7a568b306cda43f93ff45f8b47537ee61390de/typeshed_client-2.12.0.tar.gz", hash = "sha256:54dcfa25fcff82cedcb1b51c03c1b3c51a614097aab8fe49e4316aff6f79d9c7", size = 529457, upload-time = "2026-06-02T04:00:51.51Z" }
 wheels = [
@@ -4249,7 +4352,7 @@ name = "typing-inspection"
 version = "0.4.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
 wheels = [
@@ -4297,9 +4400,9 @@ name = "vos"
 version = "3.6.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "aenum", marker = "sys_platform == 'linux'" },
-    { name = "cadcutils", marker = "sys_platform == 'linux'" },
-    { name = "html2text", marker = "sys_platform == 'linux'" },
+    { name = "aenum" },
+    { name = "cadcutils" },
+    { name = "html2text" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/3e/6c/445bbedf2f90e71c09ff890aa8b409af5d074b1578eef383117cbcdfd09a/vos-3.6.4.tar.gz", hash = "sha256:67e4e24689ee881124b6670d7d2fc6527cc404687fc527fffc20cf5b1bd4c0bd", size = 103445, upload-time = "2025-12-12T00:20:56.398Z" }
 wheels = [
@@ -4342,6 +4445,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" },
 ]
 
+[[package]]
+name = "wget"
+version = "3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/6a/62e288da7bcda82b935ff0c6cfe542970f04e29c756b0e147251b2fb251f/wget-3.2.zip", hash = "sha256:35e630eca2aa50ce998b9b1a127bb26b30dfee573702782aa982f875e3f16061", size = 10857, upload-time = "2015-10-22T15:26:37.51Z" }
+
 [[package]]
 name = "widgetsnbextension"
 version = "4.0.15"
@@ -4395,9 +4504,9 @@ name = "yte"
 version = "1.9.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "argparse-dataclass", marker = "sys_platform == 'linux'" },
-    { name = "dpath", marker = "sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "argparse-dataclass" },
+    { name = "dpath" },
+    { name = "pyyaml" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/44/f5/7e44620e6e077bfe624b9a17c329b8e0d0159e176e1f1a93c2790428ab2c/yte-1.9.4.tar.gz", hash = "sha256:86a47e6d722cec9419a7ac88be57d0d6c4ce28f02860393b71a66f2c674069f6", size = 8101, upload-time = "2025-11-27T12:55:00.85Z" }
 wheels = [
@@ -4409,12 +4518,12 @@ name = "zarr"
 version = "3.2.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "donfig", marker = "sys_platform == 'linux'" },
-    { name = "google-crc32c", marker = "sys_platform == 'linux'" },
-    { name = "numcodecs", marker = "sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "donfig" },
+    { name = "google-crc32c" },
+    { name = "numcodecs" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/93/8d/aeb164004f87543b06ef54f885d02c342c31ceb274e2bbec470a98927621/zarr-3.2.1.tar.gz", hash = "sha256:71565b738a0e7e8ed226f0516eba8c6bb53440ad7669a8c48ebb3534a161d035", size = 675161, upload-time = "2026-05-05T12:37:22.383Z" }
 wheels = [