eryn 1.2.0__py3-none-any.whl

eryn/utils/utility.py

@@ -0,0 +1,329 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from scipy.special import logsumexp
+import warnings
+
+
+def groups_from_inds(inds):
+    """Convert inds to group information
+
+    Args:
+        inds (dict): Keys are ``branch_names`` and values are inds
+            np.ndarrays[ntemps, nwalkers, nleaves_max] that specify
+            which leaves are used in this step.
+
+    Returns:
+        dict: Dictionary with group information.
+            Keys are ``branch_names`` and values are
+            np.ndarray[total number of used leaves]. The array is flat.
+
+    """
+    # prepare output
+    groups = {}
+    for name, inds_temp in inds.items():
+
+        # shape information
+        ntemps, nwalkers, nleaves_max = inds_temp.shape
+        num_groups = ntemps * nwalkers
+
+        # place which group each active leaf belongs to along flattened array
+        group_id = np.repeat(
+            np.arange(num_groups).reshape(ntemps, nwalkers)[:, :, None],
+            nleaves_max,
+            axis=-1,
+        )
+
+        # fill new information
+        groups[name] = group_id[inds_temp]
+
+    return groups
+
+
+def get_acf(x, axis=0, fast=False):
+    """
+    Estimate the autocorrelation function of a time series using the FFT.
+    :param x:
+        The time series. If multidimensional, set the time axis using the
+        ``axis`` keyword argument and the function will be computed for every
+        other axis.
+    :param axis: (optional)
+        The time axis of ``x``. Assumed to be the first axis if not specified.
+    :param fast: (optional)
+        If ``True``, only use the largest ``2^n`` entries for efficiency.
+        (default: False)
+    """
+
+    x = np.atleast_1d(x)
+    m = [
+        slice(None),
+    ] * len(x.shape)
+
+    # For computational efficiency, crop the chain to the largest power of
+    # two if requested.
+    if fast:
+        n = int(2 ** np.floor(np.log2(x.shape[axis])))
+        m[axis] = slice(0, n)
+        x = x
+    else:
+        n = x.shape[axis]
+
+    # Compute the FFT and then (from that) the auto-correlation function.
+    f = np.fft.fft(x - np.mean(x, axis=axis), n=2 * n, axis=axis)
+    m[axis] = slice(0, n)
+    acf = np.fft.ifft(f * np.conjugate(f), axis=axis)[tuple(m)].real
+    m[axis] = 0
+    return acf / acf[tuple(m)]
+
+
+def get_integrated_act(x, axis=0, window=50, fast=False, average=True):
+    """
+    Estimate the integrated autocorrelation time of a time series.
+    See `Sokal's notes on
+    MCMC and sample estimators for autocorrelation times.
+    :param x:
+        The time series. If multidimensional, set the time axis using the
+        ``axis`` keyword argument and the function will be computed for every
+        other axis.
+    :param axis: (optional)
+        The time axis of ``x``. Assumed to be the first axis if not specified.
+    :param window: (optional)
+        The size of the window to use. (default: 50)
+    :param fast: (optional)
+        If ``True``, only use the largest ``2^n`` entries for efficiency.
+        (default: False)
+    """
+
+    if axis != 0:
+        # TODO: need to check this
+        raise NotImplementedError
+
+    # Compute the autocorrelation function.
+    if isinstance(x, dict):
+        is_dict = True
+        ndim_total = 0
+        values_out = []
+        ind_breaks = []
+        for name, values in x.items():
+            nsteps, ntemps, nwalkers, nleaves_max, ndim = values.shape
+            ndim_total += ndim
+            ind_breaks.append(ndim_total)
+            values_out.append(values.reshape(nsteps, ntemps, nwalkers, -1))
+
+        x_in = np.concatenate(values_out, axis=-1)
+
+    elif isinstance(x, np.ndarray):
+        is_dict = False
+        x_in = x
+    else:
+        raise ValueError("x must be dictionary of np.ndarrays or an np.ndarray.")
+
+    f = get_acf(x_in, axis=axis, fast=fast)
+
+    # Special case 1D for simplicity.
+    if len(f.shape) == 1:
+        return 1 + 2 * np.sum(f[1:window])
+
+    # N-dimensional case.
+    m = [
+        slice(None),
+    ] * len(f.shape)
+    m[axis] = slice(1, window)
+    tau = 1 + 2 * np.sum(f[tuple(m)], axis=axis)
+
+    if average:
+        tau = np.average(tau, axis=1)
+
+    if is_dict:
+        splits = np.split(tau, ind_breaks, axis=-1)
+        out = {name: split for name, split in zip(x.keys(), splits)}
+
+    else:
+        out = tau
+
+    return out
+
+
+def thermodynamic_integration_log_evidence(betas, logls):
+    """
+    Thermodynamic integration estimate of the evidence.
+
+    This function origindated in ``ptemcee``.
+
+    Args:
+        betas (np.ndarray[ntemps]): The inverse temperatures to use for the quadrature.
+        logls (np.ndarray[ntemps]): The mean log-Likelihoods corresponding to ``betas`` to use for
+            computing the thermodynamic evidence.
+    Returns:
+        tuple:   ``(logZ, dlogZ)``:
+                Returns an estimate of the
+                log-evidence and the error associated with the finite
+                number of temperatures at which the posterior has been
+                sampled.
+
+    The evidence is the integral of the un-normalized posterior
+    over all of parameter space:
+    .. math::
+        Z \\equiv \\int d\\theta \\, l(\\theta) p(\\theta)
+    Thermodymanic integration is a technique for estimating the
+    evidence integral using information from the chains at various
+    temperatures.  Let
+    .. math::
+        Z(\\beta) = \\int d\\theta \\, l^\\beta(\\theta) p(\\theta)
+    Then
+    .. math::
+        \\frac{d \\log Z}{d \\beta}
+        = \\frac{1}{Z(\\beta)} \\int d\\theta l^\\beta p \\log l
+        = \\left \\langle \\log l \\right \\rangle_\\beta
+    so
+    .. math::
+        \\log Z(1) - \\log Z(0)
+        = \\int_0^1 d\\beta \\left \\langle \\log l \\right\\rangle_\\beta
+    By computing the average of the log-likelihood at the
+    difference temperatures, the sampler can approximate the above
+    integral.
+
+    """
+
+    # make sure they are the same length
+    if len(betas) != len(logls):
+        raise ValueError("Need the same number of log(L) values as temperatures.")
+
+    # make sure they are in order
+    order = np.argsort(betas)[::-1]
+    betas = betas[order]
+    logls = logls[order]
+
+    betas0 = np.copy(betas)
+    if betas[-1] != 0.0:
+        betas = np.concatenate((betas0, [0.0]))
+        betas2 = np.concatenate((betas0[::2], [0.0]))
+
+        # Duplicate mean log-likelihood of hottest chain as a best guess for beta = 0.
+        logls2 = np.concatenate((logls[::2], [logls[-1]]))
+        logls = np.concatenate((logls, [logls[-1]]))
+    else:
+        betas2 = np.concatenate((betas0[:-1:2], [0.0]))
+        logls2 = np.concatenate((logls[:-1:2], [logls[-1]]))
+
+    # integrate by trapz
+    logZ = -np.trapz(logls, betas)
+    logZ2 = -np.trapz(logls2, betas2)
+    return logZ, np.abs(logZ - logZ2)
+
+
+def stepping_stone_log_evidence(betas, logls, block_len=50, repeats=100):
+    """
+    Stepping stone approximation for the evidence calculation.
+
+    Based on
+    a. https://arxiv.org/abs/1810.04488 and
+    b. https://pubmed.ncbi.nlm.nih.gov/21187451/.
+
+    Args:
+        betas (np.ndarray[ntemps]): The inverse temperatures to use for the quadrature.
+        logls (np.ndarray[ntemps]): The mean log-Likelihoods corresponding to ``betas`` to use for
+            computing the thermodynamic evidence.
+        block_len (int): The length of each chain block to compute the evidence from. Useful for computing the error-bars.
+        repeats (int): The number of repeats to compute the evidence (using the block above).
+
+    Returns
+        tuple:   ``(logZ, dlogZ)``:
+            Returns an estimate of the
+            log-evidence and the error associated with the finite
+            number of temperatures at which the posterior has been
+            sampled.
+    """
+
+    def calculate_stepping_stone(betas, logls):
+        n = logls.shape[0]
+        delta_betas = betas[1:] - betas[:-1]
+        n_T = betas.shape[0]
+        log_ratio = logsumexp(delta_betas * logls[:, :-1], axis=0) - np.log(n)
+        return np.sum(log_ratio), log_ratio
+
+    # make sure they are the same length
+    if len(betas) != logls.shape[1]:
+        raise ValueError(
+            "Need the log(L).shape[1] to be the same as the number of temperatures."
+        )
+
+    # make sure they are in order
+    order = np.argsort(betas)
+    betas = betas[order]
+    logls = logls[:, order, :]
+    logls = logls.reshape(-1, betas.shape[0])  # Get all samples per temperature
+    steps = logls.shape[0]  # Get number of samples
+
+    logZ, _ = calculate_stepping_stone(betas, logls)
+
+    # Estimate the evidence uncertainty (Maturana-Russel et. al. (2019))
+    logZ_i = np.zeros(repeats)
+    try:
+        for i in range(repeats):
+            idxs = [
+                np.random.randint(i, i + block_len) for i in range(steps - block_len)
+            ]
+            logZ_i[i] = calculate_stepping_stone(betas, logls[idxs, :])[0]
+        dlogZ = np.std(logZ_i)
+    except ValueError:
+        warnings.warn(
+            "Warning: Failed to compute evidence uncertainty via Stepping Stone algorithm"
+        )
+        dlogZ = np.nan
+
+    return logZ, dlogZ
+
+
+def psrf(C, ndims, per_walker=False):
+    """
+    The Gelman - Rubin convergence diagnostic.
+    A general approach to monitoring convergence of MCMC output of multiple walkers.
+    The function makes a comparison of within-chain and between-chain variances.
+    A large deviation between these two variances indicates non-convergence, and
+    the output [Rhat] deviates from unity.
+
+    By default, it combines the MCMC chains for all walkers, and then computes the
+    Rhat for the first and last 1/3 parts of the traces. This can be tuned with the
+    ``per_walker`` flag.
+
+    Based on
+    a. Brooks, SP. and Gelman, A. (1998) General methods for monitoring convergence
+       of iterative simulations. Journal of Computational and Graphical Statistics, 7, 434-455
+    b. Gelman, A and Rubin, DB (1992) Inference from iterative simulation using multiple sequences,
+       Statistical Science, 7, 457-511.
+
+    Args:
+        C (np.ndarray[nwalkers, ndim]): The parameter traces. The MCMC chains.
+        ndims (int): The dimensions
+        per_walker (bool, optional): Do the test on the combined chains, or using
+        each if the walkers separatelly.
+
+    Returns
+        tuple:   ``(Rhat, neff)``:
+            Returns an estimate of the Gelman-Rubin convergence diagnostic ``Rhat``,
+            and the effective number od samples ``neff``.
+
+    Code taken from https://joergdietrich.github.io/emcee-convergence.html
+    """
+    if not per_walker:
+        # Split the complete chains into three parts and perform the
+        # diagnostic on the forst and last 1/3 of the chains.
+        C = C.reshape(-1, ndims)
+        n = int(np.floor(C[:, 0].shape[0] / 3))
+        c1 = C[0:n, :]
+        c2 = C[-n:, :]
+        C = np.zeros((2, c1.shape[0], c1.shape[1]))
+        C = np.array([c1, c2])
+
+    ssq = np.var(C, axis=1, ddof=1)
+    W = np.mean(ssq, axis=0)
+    θb = np.mean(C, axis=1)
+    θbb = np.mean(θb, axis=0)
+    m = C.shape[0]
+    nn = C.shape[1]
+    B = nn / (m - 1) * np.sum((θbb - θb) ** 2, axis=0)
+
+    var_θ = (nn - 1) / nn * W + 1 / nn * B
+    R̂ = np.sqrt(var_θ / W)
+    return R̂

eryn-1.2.0.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.3
+Name: eryn
+Version: 1.2.0
+Summary: Eryn: an omni-MCMC sampling package.
+Author: Michael Katz
+Author-email: Michael Katz <mikekatz04@gmail.com>
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: exceptiongroup ; python_full_version < '3.11'
+Requires-Dist: h5py
+Requires-Dist: jsonschema
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: nvidia-ml-py
+Requires-Dist: platformdirs
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
+Requires-Dist: requests
+Requires-Dist: rich
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Requires-Dist: wrapt
+Requires-Dist: ipykernel ; extra == 'doc'
+Requires-Dist: ipython ; extra == 'doc'
+Requires-Dist: ipywidgets ; extra == 'doc'
+Requires-Dist: myst-parser ; extra == 'doc'
+Requires-Dist: nbsphinx ; extra == 'doc'
+Requires-Dist: pypandoc ; extra == 'doc'
+Requires-Dist: sphinx ; extra == 'doc'
+Requires-Dist: sphinx-rtd-theme ; extra == 'doc'
+Requires-Dist: sphinx-tippy ; extra == 'doc'
+Requires-Dist: corner ; extra == 'doc'
+Requires-Dist: matplotlib ; extra == 'testing'
+Requires-Dist: corner ; extra == 'testing'
+Requires-Dist: chainconsumer ; extra == 'testing'
+Requires-Python: >=3.9
+Provides-Extra: doc
+Provides-Extra: testing
+Description-Content-Type: text/markdown
+
+# Eryn: a multi-purpose MCMC sampler
+
+Eryn is an advanced MCMC sampler. It has the capability to run with parallel tempering, multiple model types, and unknown counts within each model type using Reversible Jump MCMC techniques. Eryn is heavily based on [emcee](https://emcee.readthedocs.io/en/stable/). The `emcee` base structure with the Ensemble Sampler, State objects, proposal setup, and storage backends is carried over into Eryn with small changes to account for the increased complexity. In a simple sense, Eryn is an advanced (and slightly more complicated) version of `emcee`. 
+
+If you use Eryn in your publication, please cite the paper [arXiv:2303.02164](https://arxiv.org/abs/2303.02164), its [zenodo](https://zenodo.org/record/7705496#.ZAhzukJKjlw), and [emcee](https://emcee.readthedocs.io/en/stable/). The documentation for Eryn can be found here: [mikekatz04.github.io/Eryn](https://mikekatz04.github.io/Eryn). You will find the code on Github: [github.com/mikekatz04/Eryn](https://github.com/mikekatz04/Eryn). 
+
+## Getting Started
+
+Below is a quick set of instructions to get you started with `eryn`.
+
+```
+pip install eryn
+```
+To import eryn:
+
+```
+from eryn.ensemble import EnsembleSampler
+```
+
+See [examples notebook](https://github.com/mikekatz04/Eryn/blob/main/examples/Eryn_tutorial.ipynb) for more info. You can also navigate the [Documentation](https://mikekatz04.github.io/Eryn/html/index.html) pages.
+
+
+### Prerequisites
+
+Eryn has only a few python-based dependencies: `tqdm`, `corner` for plotting, `numpy`, `matplotlib`. 
+
+### Installing
+
+If you are not planning to develop the code, you can just install the latest version with the pip installation technique given above. Otherwise, you can just clone the repo and run `pip install .` inside of the Eryn directory. To run tests on Eryn during development, you can run the following in the main Eryn directory:
+```
+python -m unittest discover
+```
+
+
+## Running the Tests
+
+In the main directory of the package run in the terminal:
+```
+python -m unittest discover
+```
+
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING) for details on our code of conduct, and the process for submitting pull requests to us.
+
+## Versioning
+
+We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/mikekatz04/Eryn/tags).
+
+## Citation
+
+When using this package, please cite at minimum the following sources:
+
+```
+@article{Karnesis:2023ras,
+    author = "Karnesis, Nikolaos and Katz, Michael L. and Korsakova, Natalia and Gair, Jonathan R. and Stergioulas, Nikolaos",
+    title = "{Eryn : A multi-purpose sampler for Bayesian inference}",
+    eprint = "2303.02164",
+    archivePrefix = "arXiv",
+    primaryClass = "astro-ph.IM",
+    month = "3",
+    year = "2023"
+}
+
+@software{michael_katz_2023_7705496,
+  author       = {Michael Katz and
+                  Nikolaos Karnesis and
+                  Natalia Korsakova},
+  title        = {mikekatz04/Eryn: first full release},
+  month        = mar,
+  year         = 2023,
+  publisher    = {Zenodo},
+  version      = {v1.0.0},
+  doi          = {10.5281/zenodo.7705496},
+  url          = {https://doi.org/10.5281/zenodo.7705496}
+}
+
+@ARTICLE{2013PASP..125..306F,
+       author = {{Foreman-Mackey}, Daniel and {Hogg}, David W. and {Lang}, Dustin and {Goodman}, Jonathan},
+        title = "{emcee: The MCMC Hammer}",
+      journal = {\pasp},
+     keywords = {Astrophysics - Instrumentation and Methods for Astrophysics, Physics - Computational Physics, Statistics - Computation},
+         year = 2013,
+        month = mar,
+       volume = {125},
+       number = {925},
+        pages = {306},
+          doi = {10.1086/670067},
+archivePrefix = {arXiv},
+       eprint = {1202.3665},
+ primaryClass = {astro-ph.IM},
+       adsurl = {https://ui.adsabs.harvard.edu/abs/2013PASP..125..306F},
+      adsnote = {Provided by the SAO/NASA Astrophysics Data System}
+}
+
+```
+
+Depending on which proposals are used, you may be required to cite more sources. Please make sure you do this properly. 
+
+## Authors
+
+* **Michael Katz**
+* Nikos Karnesis
+* Natalia Korsakova
+* Jonathan Gair
+
+### Contibutors
+
+* Maybe you!
+
+## License
+
+This project is licensed under the GNU License - see the [LICENSE.md](LICENSE) file for details.
+
+## Acknowledgments
+
+* We wish to thank S. Babak, M. Le Jeune, S. Marsat, T. Littenberg, and N. Cornish for their useful comments and very fruitful discussions. 
+* N Stergioulas and N Karnesis acknowledge  support from the Gr-PRODEX 2019 funding program (PEA 4000132310).

eryn-1.2.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+eryn/CMakeLists.txt,sha256=rs-_qMYpJryM_FyvERto4RgQQ_NV4lkYvFzCNU7vvFc,1736
+eryn/__init__.py,sha256=eMxCEUQyqtaUM8zTr6kDCxeuFWpxZsfY41TefWUNHXI,821
+eryn/backends/__init__.py,sha256=yRQszA4WSofDDsSpTsA1V9eNw-pLVO_qalP5wpKjyZQ,380
+eryn/backends/backend.py,sha256=Gcl6qk8UI1QKK74C8Kr9QYASWzuKLJhxPOj9OyiDSFI,46906
+eryn/backends/hdfbackend.py,sha256=njW1KA2Anw9zxpLTYLkpNErNRBgNMA4VKidZXidkh-A,29414
+eryn/ensemble.py,sha256=EPmlGl1-FoXqZ0Xi9iYdhn6INHiaViVFHh_QM_TlYfM,71743
+eryn/git_version.py.in,sha256=dZ5WklaoF4dDsCVqhgw5jwr3kJCc8zjRX_LR90byZOw,139
+eryn/model.py,sha256=5TeWTI6V-Xcuy5C2LI6AmtZZU-EkRSSuA7VojXNALk8,284
+eryn/moves/__init__.py,sha256=9pWsSZSKLt05Ihd46vPASHwotTOHOPk_zEsCm8jWiw8,1081
+eryn/moves/combine.py,sha256=YfIiRqObi11qBbTgqRQ3nMBr6a-ugGGBd1VgPSEosx4,4545
+eryn/moves/delayedrejection.py,sha256=deaPPwNG2nKz-FAvi5NVTsrcoKONhy-LD15FLN0iLpY,7645
+eryn/moves/distgen.py,sha256=jNTxL23KSradICJydeTsUcnE7BqMDTPmzuGh4ydQGkQ,3935
+eryn/moves/distgenrj.py,sha256=szTgY1VYriJ1YYDJEOYT_kkjewk42BoXgQeZc41CO_c,9133
+eryn/moves/gaussian.py,sha256=5No4tN3PFzkx5JugLwX8LboSXBt2DOHU8xegtj5zOGo,6853
+eryn/moves/group.py,sha256=sm1iUvHJwuk_dvtmBTbmhZBbB_Esxl_4f2h0Ofx5p7s,10100
+eryn/moves/groupstretch.py,sha256=tMXeCauYy_AyAhWM5kpgOcoQRdKLJYx2h85Tdfq6WLk,3920
+eryn/moves/mh.py,sha256=63xvBRk6iNLn6EZmGb1W_buLmNw3WS7ch4kSK7yGfeE,6517
+eryn/moves/move.py,sha256=8djVzFeLcpwh7hhu1sNTTFBiVDHrUPWc0TsN_FCPmRs,28952
+eryn/moves/mtdistgen.py,sha256=ZCPY5lUgoyVcmPLl6jl5boBjakp4DzWfObQyo_MmOVA,5347
+eryn/moves/mtdistgenrj.py,sha256=MP1KL796WcFWazys20ZXlTSzSISh61VU1jOArJz-b6U,8102
+eryn/moves/multipletry.py,sha256=KSR6H7YPy5v-qxALt4X3jlGbs9UTLfTSLkTpK2Qcpgk,30156
+eryn/moves/red_blue.py,sha256=UM9PSJi4H1f8oN-1ZCIevvnpt91Xgnlm-KY7LRFAOOU,13267
+eryn/moves/rj.py,sha256=6krjJ5EsvgLZMTMgE9rStjjKtBIW6nw87ywRYbYtROU,15915
+eryn/moves/stretch.py,sha256=auKjeN5elf9fqLR1-oDeR0pF1vdaRnKJEQcpI0mLgVU,8242
+eryn/moves/tempering.py,sha256=e2doT8jVWSuaPpVUKIkWQjRe20T0i98w70wi-dz7buo,23977
+eryn/pbar.py,sha256=uDDn8dMVHLD6EqZyk6vGhkOQwxgFm21Us9dz-nZE4oI,1330
+eryn/prior.py,sha256=x4E5NS4v7Odag7a30OXQ-kJuoU3a6M6JnJuKlWGO6F4,14393
+eryn/state.py,sha256=x4HZNrGhxnR6Ia2JrVskJGDS1Uk3AgQHgxJ4384Hpzs,31456
+eryn/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eryn/tests/test_eryn.py,sha256=JTac0NdiBfTa2-l8z0Q6S5oxr-C-UzH0uNTOE61jVFY,39792
+eryn/utils/__init__.py,sha256=HzlQs1wg3J1xdrZjIMO34QHd0ZT58SQFCKEdclj7vpM,250
+eryn/utils/periodic.py,sha256=Q07HKMNeUN8V_rauUjT7fKRwlYOd2AFsa9DekuRYUbk,4135
+eryn/utils/stopping.py,sha256=fX1np10U3B-fpI3dGqEPZfqeYt8dc0x3PQGwrvYbbFU,5095
+eryn/utils/transform.py,sha256=wzOYow7xHjqVOi8ZQDXBeoFj9y53cCtIeLggrQuo_sc,8895
+eryn/utils/updates.py,sha256=U3T9UxPLabJzJuuB9s2OuX3vMD_2P7486SkgaFEkbLw,2137
+eryn/utils/utility.py,sha256=Mxmx-XoLe5tEdzc2QuprpOd3u4Z2aYmR4aDVWRi6Jsk,11151
+eryn-1.2.0.dist-info/WHEEL,sha256=pFCy50wRV2h7SjJ35YOsQUupaV45rMdgpNIvnXbG5bE,79
+eryn-1.2.0.dist-info/METADATA,sha256=8KRio9HsI9zew0k5-keZndsrWuihfm0_az-IgmI6_is,6256
+eryn-1.2.0.dist-info/RECORD,,

eryn-1.2.0.dist-info/WHEEL

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