reboost 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

reboost/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.2.6'
+__version_tuple__ = version_tuple = (0, 2, 6)

reboost/build_glm.py

@@ -153,6 +153,10 @@ def get_stp_evtids(
         )
         evtids = lh5_obj.view_as("ak")
 
+        # pick the first evtid
+        if evtids.ndim > 1:
+            evtids = ak.fill_none(ak.firsts(evtids, axis=-1), -1)
+
         # if the evtids_proc is not set then this is the first valid chunk
         if evtids_proc is None:
             evtids_proc = evtids

reboost/build_hit.py

@@ -166,6 +166,7 @@ import awkward as ak
 import dbetto
 from dbetto import AttrsDict
 from lgdo import lh5
+from lgdo.types import Struct
 
 from reboost.iterator import GLMIterator
 from reboost.profile import ProfileDict
@@ -187,6 +188,7 @@ def build_hit(
     in_field: str = "stp",
     out_field: str = "hit",
     buffer: int = int(5e6),
+    overwrite: bool = False,
 ) -> None | ak.Array:
     """Build the hit tier from the remage step files.
 
@@ -213,6 +215,8 @@ def build_hit(
         name of the output field
     buffer
         buffer size for use in the `LH5Iterator`.
+    overwrite
+        flag to overwrite the existing output.
     """
     # extract the config file
     if isinstance(config, str):
@@ -263,6 +267,7 @@ def build_hit(
                     for mapping in proc_group.get("detector_mapping")
                 ]
             )
+
             # loop over detectors
             for in_det_idx, (in_detector, out_detectors) in enumerate(detectors_mapping.items()):
                 msg = f"... processing {in_detector} (to {out_detectors})"
@@ -341,22 +346,17 @@ def build_hit(
                         # assign units in the output table
                         hit_table = utils.assign_units(hit_table, attrs)
 
-                        # get the IO mode
-
                         new_hit_file = (file_idx == 0) or (
                             files.hit[file_idx] != files.hit[file_idx - 1]
                         )
 
-                        wo_mode = (
-                            "of"
-                            if (
-                                group_idx == 0
-                                and out_det_idx == 0
-                                and in_det_idx == 0
-                                and chunk_idx == 0
-                                and new_hit_file
-                            )
-                            else "append"
+                        wo_mode = utils.get_wo_mode(
+                            group=group_idx,
+                            out_det=out_det_idx,
+                            in_det=in_det_idx,
+                            chunk=chunk_idx,
+                            new_hit_file=new_hit_file,
+                            overwrite=overwrite,
                         )
 
                         # now write
@@ -364,12 +364,20 @@ def build_hit(
                             if time_dict is not None:
                                 start_time = time.time()
 
-                            lh5.write(
-                                hit_table,
-                                f"{out_detector}/{out_field}",
-                                files.hit[file_idx],
-                                wo_mode=wo_mode,
-                            )
+                            if wo_mode != "a":
+                                lh5.write(
+                                    Struct({out_detector: hit_table}),
+                                    out_field,
+                                    files.hit[file_idx],
+                                    wo_mode=wo_mode,
+                                )
+                            else:
+                                lh5.write(
+                                    hit_table,
+                                    f"{out_field}/{out_detector}",
+                                    files.hit[file_idx],
+                                    wo_mode=wo_mode,
+                                )
                             if time_dict is not None:
                                 time_dict[proc_name].update_field("write", start_time)
 

reboost/cli.py

@@ -175,6 +175,8 @@ def cli(args=None) -> None:
         msg += f"    in_field:       {args.in_field}\n"
         msg += f"    out_field:      {args.out_field}\n"
         msg += f"    buffer:         {args.buffer}"
+        msg += f"    overwrite:      {args.overwrite}"
+
         log.info(msg)
 
         build_hit(
@@ -188,4 +190,5 @@ def cli(args=None) -> None:
             in_field=args.in_field,
             out_field=args.out_field,
             buffer=args.buffer,
+            overwrite=args.overwrite,
         )

reboost/hpge/psd.py

@@ -3,29 +3,33 @@ from __future__ import annotations
 import logging
 
 import awkward as ak
+import numba
 import numpy as np
-from lgdo import Array
+import pint
+import pyg4ometry
+from lgdo import Array, VectorOfVectors
+from numpy.typing import ArrayLike, NDArray
+
+from .. import units
+from ..units import ureg as u
+from .utils import HPGeScalarRZField
 
 log = logging.getLogger(__name__)
 
 
 def r90(edep: ak.Array, xloc: ak.Array, yloc: ak.Array, zloc: ak.Array) -> Array:
-    """Computes R90 for each hit in a ged.
+    """R90 HPGe pulse shape heuristic.
 
     Parameters
     ----------
     edep
-        awkward array of energy
+        array of energy.
     xloc
-        awkward array of x coordinate position
+        array of x coordinate position.
     yloc
-        awkward array of y coordinate position
+        array of y coordinate position.
     zloc
-        awkward array of z coordinate position
-
-    Returns
-    -------
-    r90
+        array of z coordinate position.
     """
     tot_energy = ak.sum(edep, axis=-1, keepdims=True)
 
@@ -44,7 +48,7 @@ def r90(edep: ak.Array, xloc: ak.Array, yloc: ak.Array, zloc: ak.Array) -> Array
     sorted_dist = dist[sorted_indices]
     sorted_edep = edep[sorted_indices]
 
-    def cumsum(layout, **_kwargs):
+    def _ak_cumsum(layout, **_kwargs):
         if layout.is_numpy:
             return ak.contents.NumpyArray(np.cumsum(layout.data))
 
@@ -52,7 +56,7 @@ def r90(edep: ak.Array, xloc: ak.Array, yloc: ak.Array, zloc: ak.Array) -> Array
 
     # Calculate the cumulative sum of energies for each event
     cumsum_edep = ak.transform(
-        cumsum, sorted_edep
+        _ak_cumsum, sorted_edep
     )  # Implement cumulative sum over whole jagged array
     if len(edep) == 1:
         cumsum_edep_corrected = cumsum_edep
@@ -72,3 +76,163 @@ def r90(edep: ak.Array, xloc: ak.Array, yloc: ak.Array, zloc: ak.Array) -> Array
     r90 = sorted_dist[r90_indices]
 
     return Array(ak.flatten(r90).to_numpy())
+
+
+def drift_time(
+    xloc: ArrayLike,
+    yloc: ArrayLike,
+    zloc: ArrayLike,
+    dt_map: HPGeScalarRZField,
+    coord_offset: pint.Quantity | pyg4ometry.gdml.Position = (0, 0, 0) * u.m,
+) -> VectorOfVectors:
+    """Calculates drift times for each step (cluster) in an HPGe detector.
+
+    Parameters
+    ----------
+    xloc
+        awkward array of x coordinate position.
+    yloc
+        awkward array of y coordinate position.
+    zloc
+        awkward array of z coordinate position.
+    dt_map
+        the drift time map.
+    coord_offset
+        this `(x, y, z)` coordinates will be subtracted to (xloc, yloc, zloc)`
+        before drift time computation. The length units must be the same as
+        `xloc`, `yloc` and `zloc`.
+    """
+    # sanitize coord_offset
+    coord_offset = units.pg4_to_pint(coord_offset)
+
+    # unit handling (for matching with drift time map units)
+    xu, yu = [units.units_convfact(data, dt_map.r_units) for data in (xloc, yloc)]
+    zu = units.units_convfact(zloc, dt_map.z_units)
+
+    # unwrap LGDOs
+    xloc, yloc, zloc = [units.unwrap_lgdo(data)[0] for data in (xloc, yloc, zloc)]
+
+    # awkward transform to apply the drift time map to the step coordinates
+    def _ak_dt_map(layouts, **_kwargs):
+        if layouts[0].is_numpy and layouts[1].is_numpy:
+            return ak.contents.NumpyArray(
+                dt_map.φ(np.stack([layouts[0].data, layouts[1].data], axis=1))
+            )
+
+        return None
+
+    # transform coordinates
+    xloc = xu * xloc - coord_offset[0].to(dt_map.r_units).m
+    yloc = yu * yloc - coord_offset[1].to(dt_map.r_units).m
+    zloc = zu * zloc - coord_offset[2].to(dt_map.z_units).m
+
+    # evaluate the drift time
+    dt_values = ak.transform(
+        _ak_dt_map,
+        np.sqrt(xloc**2 + yloc**2),
+        zloc,
+    )
+
+    return VectorOfVectors(
+        dt_values,
+        attrs={"units": units.unit_to_lh5_attr(dt_map.φ_units)},
+    )
+
+
+def drift_time_heuristic(
+    drift_time: ArrayLike,
+    edep: ArrayLike,
+) -> Array:
+    """HPGe drift-time-based pulse-shape heuristic.
+
+    See :func:`_drift_time_heuristic_impl` for a description of the algorithm.
+
+    Parameters
+    ----------
+    drift_time
+        drift time of charges originating from steps/clusters. Can be
+        calculated with :func:`drift_time`.
+    edep
+        energy deposited in step/cluster (same shape as `drift_time`).
+    """
+    # extract LGDO data and units
+    drift_time, t_units = units.unwrap_lgdo(drift_time)
+    edep, e_units = units.unwrap_lgdo(edep)
+
+    # we want to attach the right units to the dt heuristic, if possible
+    attrs = {}
+    if t_units is not None and e_units is not None:
+        attrs["units"] = units.unit_to_lh5_attr(t_units / e_units)
+
+    return Array(_drift_time_heuristic_impl(drift_time, edep), attrs=attrs)
+
+
+@numba.njit(cache=True)
+def _drift_time_heuristic_impl(
+    dt: ak.Array,
+    edep: ak.Array,
+) -> NDArray:
+    r"""Low-level implementation of the HPGe drift-time-based pulse-shape heuristic.
+
+    Accepts Awkward arrays and uses Numba to speed up the computation.
+
+    For each hit (collection of steps), the drift times and corresponding
+    energies are sorted in ascending order. The function finds the optimal
+    split point :math:`m` that maximizes the *identification metric*:
+
+    .. math::
+
+       I = \frac{|T_1 - T_2|}{E_\text{s}(E_1, E_2)}
+
+    where:
+
+    .. math::
+
+        T_1 = \frac{\sum_{i < m} t_i E_i}{\sum_{i < m} E_i}
+        \quad \text{and} \quad
+        T_2 = \frac{\sum_{i \geq m} t_i E_i}{\sum_{i \geq m} E_i}
+
+    are the energy-weighted mean drift times of the two groups.
+
+    .. math::
+
+        E_\text{scale}(E_1, E_2) = \frac{1}{\sqrt{E_1 E_2}}
+
+    is the scaling factor.
+
+    The function iterates over all possible values of :math:`m` and selects the
+    maximum `I` as the drift time heuristic value.
+    """
+    dt_heu = np.zeros(len(dt))
+
+    # loop over hits
+    for i in range(len(dt)):
+        t = np.asarray(dt[i])
+        e = np.asarray(edep[i])
+
+        valid_idx = np.where(e > 0)[0]
+        if len(valid_idx) < 2:
+            continue
+
+        t = t[valid_idx]
+        e = e[valid_idx]
+
+        sort_idx = np.argsort(t)
+        t = t[sort_idx]
+        e = e[sort_idx]
+
+        max_id_metric = 0
+        for j in range(1, len(t)):
+            e1 = np.sum(e[:j])
+            e2 = np.sum(e[j:])
+
+            t1 = np.sum(t[:j] * e[:j]) / e1
+            t2 = np.sum(t[j:] * e[j:]) / e2
+
+            id_metric = abs(t1 - t2) * np.sqrt(e1 * e2)
+
+            max_id_metric = max(max_id_metric, id_metric)
+
+        dt_heu[i] = max_id_metric
+
+    return dt_heu

reboost/hpge/utils.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import Callable, NamedTuple
+
+import lgdo
+import numpy as np
+import pint
+from dbetto import AttrsDict
+from lgdo import lh5
+from scipy.interpolate import RegularGridInterpolator
+
+
+class HPGeScalarRZField(NamedTuple):
+    """A scalar field defined in the cylindrical-like (r, z) HPGe plane."""
+
+    φ: Callable
+    "Scalar field, function of the coordinates (r, z)."
+    r_units: pint.Unit
+    "Physical units of the coordinate `r`."
+    z_units: pint.Unit
+    "Physical units of the coordinate `z`."
+    φ_units: pint.Unit
+    "Physical units of the field."
+
+
+def get_hpge_scalar_rz_field(
+    filename: str, obj: str, field: str, out_of_bounds_val: int | float = np.nan, **kwargs
+) -> HPGeScalarRZField:
+    """Create an interpolator for a gridded scalar HPGe field defined on `(r, z)`.
+
+    Reads from disk the following data structure: ::
+
+        FILENAME/
+        └── OBJ · struct{r,z,FIELD}
+            ├── r · array<1>{real} ── {'units': 'UNITS'}
+            ├── z · array<1>{real} ── {'units': 'UNITS'}
+            └── FIELD · array<2>{real} ── {'units': 'UNITS'}
+
+    where ``FILENAME``, ``OBJ`` and ``FIELD`` are provided as
+    arguments to this function. `obj` is a :class:`~lgdo.types.struct.Struct`,
+    `r` and `z` are one dimensional arrays specifying the radial and z
+    coordinates of the rectangular grid — not the coordinates of each single
+    grid point. In this coordinate system, the center of the p+ contact surface
+    is at `(0, 0)`, with the p+ contact facing downwards. `field` is instead a
+    two-dimensional array specifying the field value at each grid point. The
+    first and second dimensions are `r` and `z`, respectively. NaN values are
+    interpreted as points outside the detector profile in the `(r, z)` plane.
+
+    Before returning a :class:`HPGeScalarRZField`, the gridded field is fed to
+    :class:`scipy.interpolate.RegularGridInterpolator`.
+
+    Parameters
+    ----------
+    filename
+        name of the LH5 file containing the gridded scalar field.
+    obj
+        name of the HDF5 dataset where the data is saved.
+    field
+        name of the HDF5 dataset holding the field values.
+    out_of_bounds_val
+        value to use to replace NaNs in the field values.
+    """
+    data = lh5.read(obj, filename)
+
+    if not isinstance(data, lgdo.Struct):
+        msg = f"{obj} in {filename} is not an LGDO Struct"
+        raise ValueError(msg)
+
+    data = AttrsDict(
+        {
+            k: np.nan_to_num(data[k].view_as("np", with_units=True), nan=out_of_bounds_val)
+            for k in ("r", "z", field)
+        }
+    )
+
+    interpolator = RegularGridInterpolator((data.r.m, data.z.m), data[field].m, **kwargs)
+
+    return HPGeScalarRZField(interpolator, data.r.u, data.z.u, data[field].u)

reboost/iterator.py

@@ -129,7 +129,10 @@ class GLMIterator:
                 time_start = time.time()
 
             stp_rows, n_steps = self.sto.read(
-                f"{self.stp_field}/{self.lh5_group}", self.stp_file, start_row=start, n_rows=n
+                f"{self.stp_field}/{self.lh5_group}",
+                self.stp_file,
+                start_row=int(start),
+                n_rows=int(n),
             )
 
             # save time

reboost/units.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import pint
+import pyg4ometry as pg4
+from lgdo import LGDO
+
+log = logging.getLogger(__name__)
+
+ureg = pint.get_application_registry()
+"""The physical units registry."""
+
+# default pretty printing of physical units
+ureg.formatter.default_format = "~P"
+
+
+def pg4_to_pint(obj) -> pint.Quantity:
+    """Convert pyg4ometry object to pint Quantity."""
+    if isinstance(obj, pint.Quantity):
+        return obj
+    if isinstance(obj, pg4.gdml.Defines.VectorBase):
+        return [getattr(obj, field).eval() for field in ("x", "y", "z")] * ureg(obj.unit)
+    msg = f"I don't know how to convert object of type {type(obj)} to pint object"
+    raise ValueError(msg)
+
+
+def units_convfact(data: Any, target_units: pint.Units) -> float:
+    """Calculate numeric conversion factor to reach `target_units`.
+
+    Parameters
+    ----------
+    data
+        starting data structure. If an LGDO, try to determine units by peeking
+        into its attributes. Otherwise, just return 1.
+    target_units
+        units you wish to convert data to.
+    """
+    if isinstance(data, LGDO) and "units" in data.attrs:
+        return ureg(data.attrs["units"]).to(target_units).magnitude
+    return 1
+
+
+def unwrap_lgdo(data: Any, library: str = "ak") -> tuple(Any, pint.Unit | None):
+    """Return a view of the data held by the LGDO and its physical units.
+
+    Parameters
+    ----------
+    data
+        the data container. If not an LGDO, it will be returned as is with
+        ``None`` units.
+    library
+        forwarded to :func:`lgdo.view_as`.
+
+    Returns
+    -------
+    A tuple of the un-lgdo'd data and the data units.
+    """
+    ret_data = data
+    ret_units = None
+    if isinstance(data, LGDO):
+        ret_data = data.view_as(library)
+        if "units" in data.attrs:
+            ret_units = ureg(data.attrs["units"]).u
+
+    return ret_data, ret_units
+
+
+def unit_to_lh5_attr(unit: pint.Unit) -> str:
+    """Convert Pint unit to a string that can be used as attrs["units"] in an LGDO."""
+    # TODO: we should check if this can be always parsed by Unitful.jl
+    if isinstance(unit, pint.Unit):
+        return f"{unit:~C}"
+    return unit

reboost/utils.py

@@ -9,11 +9,28 @@ from contextlib import contextmanager
 from pathlib import Path
 
 from dbetto import AttrsDict
-from lgdo.types import Table
+from lgdo.types import Table, VectorOfVectors
 
 log = logging.getLogger(__name__)
 
 
+def get_wo_mode(
+    group: int, out_det: int, in_det: int, chunk: int, new_hit_file: bool, overwrite: bool = False
+):
+    """Get the mode for lh5 file writing."""
+    indices = [group, out_det, in_det, chunk]
+
+    good_idx = all(i == 0 for i in indices)
+
+    if good_idx and new_hit_file:
+        return "of" if overwrite else "w"
+
+    # if we have a detector not the first and chunk 0 append column
+    if ((in_det > 0) or (out_det > 0)) & (chunk == 0):
+        return "ac"
+    return "a"
+
+
 def get_file_dict(
     stp_files: list[str] | str,
     glm_files: list[str] | str | None,
@@ -113,7 +130,11 @@ def assign_units(tab: Table, units: Mapping) -> Table:
     """
     for field in tab:
         if field in units:
-            tab[field].attrs["units"] = units[field]
+            if not isinstance(tab[field], VectorOfVectors):
+                tab[field].attrs["units"] = units[field]
+            else:
+                tab[field].flattened_data.attrs["units"] = units[field]
+
     return tab
 
 

{reboost-0.2.4.dist-info → reboost-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reboost
-Version: 0.2.4
+Version: 0.2.6
 Summary: New LEGEND Monte-Carlo simulation post-processing
 Author-email: Manuel Huber <info@manuelhu.de>, Toby Dixon <toby.dixon.23@ucl.ac.uk>, Luigi Pertoldi <gipert@pm.me>
 Maintainer: The LEGEND Collaboration
@@ -700,7 +700,7 @@ Requires-Dist: colorlog
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: numba
-Requires-Dist: legend-pydataobj>=1.11.6
+Requires-Dist: legend-pydataobj>=1.11.10
 Requires-Dist: legend-pygeom-optics>=0.6.5
 Requires-Dist: hist
 Requires-Dist: dbetto
@@ -708,6 +708,7 @@ Requires-Dist: particle
 Requires-Dist: pandas
 Requires-Dist: matplotlib
 Requires-Dist: pygama
+Requires-Dist: pyg4ometry
 Provides-Extra: all
 Requires-Dist: reboost[docs,test]; extra == "all"
 Provides-Extra: docs
@@ -722,7 +723,7 @@ Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: legend-pygeom-hpges; extra == "test"
 Requires-Dist: legend-pygeom-tools; extra == "test"
 Requires-Dist: pyg4ometry; extra == "test"
-Requires-Dist: pylegendtestdata; extra == "test"
+Requires-Dist: pylegendtestdata>=0.6; extra == "test"
 Dynamic: license-file
 
 # reboost

{reboost-0.2.4.dist-info → reboost-0.2.6.dist-info}/RECORD

@@ -1,18 +1,20 @@
 reboost/__init__.py,sha256=RVNl3Qgx_hTUeBGXaWYmiTcmXUDhTfvlAGGC8bo_jP8,316
-reboost/_version.py,sha256=1LUN_sRKOiFInoB6AlW6TYoQMCh1Z4KutwcHNvHcfB0,511
+reboost/_version.py,sha256=nObnONsicQ3YX6SG5MVBxmIp5dmRacXDauSqZijWQbY,511
 reboost/build_evt.py,sha256=zj3wG_kaV3EoRMQ33AkCNa_2Fv8cLtRuhyRyRmSrOYQ,4797
-reboost/build_glm.py,sha256=LQkM6x6mMOE92-c78uoclOvP9zp3vdMuLQCSP2f2Zk4,9263
-reboost/build_hit.py,sha256=_JDe7j2lYmvQD7ABoSgVhIw6CiCQHqnqFGvZbcRY-EU,14290
+reboost/build_glm.py,sha256=kSY9hQjEsOE-0PiblhdBy_SvFIlgXLX6CUlgpxW-_OI,9389
+reboost/build_hit.py,sha256=OyXkYdLIpSBmq3MLNXD_kLjVqxeSQcs7RGAOZSy1Bns,14695
 reboost/build_tcm.py,sha256=-PawBHoHj0zsm4XsZu5bco9d9a09STicZchduefSNfI,2951
-reboost/cli.py,sha256=HTZ05DRnDodcf_D6BJCCavx5HqhKDadJCgf-oh8HTJk,6365
+reboost/cli.py,sha256=swPJcYzvg18rSOMN-mpe0PCMf1-a9V7osIssX7JP7k0,6459
 reboost/core.py,sha256=7Nclc6RUCOSJ1CWVAX0rFNJGM1LEgqvc4tD04CxEAtg,10766
-reboost/iterator.py,sha256=72AyoRTgMpWghZt2UOqRj0RGiNzaiBAwgNIUZdduK2s,4698
+reboost/iterator.py,sha256=0KmrekpZwOYZJaP0nmp-SNrr2WmGUKeNUVcqO-OChhY,4757
 reboost/log_utils.py,sha256=VqS_9OC5NeNU3jcowVOBB0NJ6ssYvNWnirEY-JVduEA,766
 reboost/profile.py,sha256=EOTmjmS8Rm_nYgBWNh6Rntl2XDsxdyed7yEdWtsZEeg,2598
-reboost/utils.py,sha256=wzfW0_W5IF3sw3DcrLOLDNZV2LKfUoEi6Ks8Db5gQHg,7785
+reboost/units.py,sha256=3EH8XlpbsObdu5vLgxhm1600L6UNYD5jng4SjJT_1QE,2202
+reboost/utils.py,sha256=eBw0ZzwhlniTLbjz9tnstCXSYrjSeH4FJ0fkJ9-uqps,8450
 reboost/hpge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reboost/hpge/psd.py,sha256=vFs8Y5XVW261pB6aOvWmIDzqOaBg-gEOLhL9PbjlEKI,2113
+reboost/hpge/psd.py,sha256=868OUJzO9TNja0YSrZ3NDGeEAbUtpDZnmvBDm0jCC9E,6856
 reboost/hpge/surface.py,sha256=SZyTmOCTipf27jYaJhtdInzGF1RZ2wKpbtf6HlOQYwM,3662
+reboost/hpge/utils.py,sha256=0Rx4HubCOm8JMECjWcAJXfAch9OkSlRpUkdsSlzwZ2E,2830
 reboost/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reboost/math/functions.py,sha256=OymiYTcA0NXxxm-MBDw5kqyNwHoLCmuv4J48AwnSrbU,5633
 reboost/math/stats.py,sha256=iiOEi87x93kqPWeSmlRiA5Oe-R8XR-plm6Z532PhC9M,1401
@@ -28,9 +30,9 @@ reboost/shape/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reboost/shape/cluster.py,sha256=RIvBlhHzp88aaUZGofp5SD9bimnoiqIOddhQ84jiwoM,8135
 reboost/shape/group.py,sha256=Q3DhEPxbhw3p4bwvpswSd0A-p224l5vRZnfQIEkOVJE,4475
 reboost/shape/reduction.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reboost-0.2.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-reboost-0.2.4.dist-info/METADATA,sha256=3TF-pB7slRO8Y7UuAqVHfZpUJdUKUzAW_UKshjJzYv4,44219
-reboost-0.2.4.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-reboost-0.2.4.dist-info/entry_points.txt,sha256=DxhD6BidSWNot9BrejHJjQ7RRLmrMaBIl52T75oWTwM,93
-reboost-0.2.4.dist-info/top_level.txt,sha256=q-IBsDepaY_AbzbRmQoW8EZrITXRVawVnNrB-_zyXZs,8
-reboost-0.2.4.dist-info/RECORD,,
+reboost-0.2.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+reboost-0.2.6.dist-info/METADATA,sha256=Irdm3IrpsoXDPWyqeYSa4QHI6MdACh0ZYAnGMQwofbg,44251
+reboost-0.2.6.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+reboost-0.2.6.dist-info/entry_points.txt,sha256=DxhD6BidSWNot9BrejHJjQ7RRLmrMaBIl52T75oWTwM,93
+reboost-0.2.6.dist-info/top_level.txt,sha256=q-IBsDepaY_AbzbRmQoW8EZrITXRVawVnNrB-_zyXZs,8
+reboost-0.2.6.dist-info/RECORD,,

{reboost-0.2.4.dist-info → reboost-0.2.6.dist-info}/WHEEL

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