ml4gw 0.7.8__py3-none-any.whl → 0.7.10__py3-none-any.whl

ml4gw/dataloading/hdf5_dataset.py

@@ -151,6 +151,7 @@ class Hdf5TimeSeriesDataset(torch.utils.data.IterableDataset):
         unique_fnames, inv, counts = np.unique(
             fnames, return_inverse=True, return_counts=True
         )
+        inv = inv.reshape(-1)
         for i, (fname, count) in enumerate(
             zip(unique_fnames, counts, strict=True)
         ):

ml4gw/distributions.py

@@ -225,8 +225,10 @@ class UniformComovingVolume(dist.Distribution):
                 f"or 'luminosity_distance'; got {distance_type}"
             )
 
-        self.minimum = minimum
-        self.maximum = maximum
+        self.minimum = torch.as_tensor(minimum)
+        self.maximum = torch.as_tensor(maximum)
+        if self.minimum.device != self.maximum.device:
+            raise RuntimeError("Min and max values are not on same device")
         self.distance_type = distance_type
         self.grid_size = grid_size
         self.z_grid_max = z_grid_max
@@ -265,7 +267,9 @@ class UniformComovingVolume(dist.Distribution):
         distances, using the specified distance type.
         """
         self._generate_distance_grids()
-        bounds = torch.tensor([self.minimum, self.maximum])
+        bounds = torch.tensor(
+            [self.minimum, self.maximum], device=self.minimum.device
+        )
         z_min, z_max = self._linear_interp_1d(
             self.distance_grid, self.z_grid, bounds
         )
@@ -276,7 +280,9 @@ class UniformComovingVolume(dist.Distribution):
         """
         Generate distance grids based on the specified redshift range.
         """
-        self.z_grid = torch.linspace(0, self.z_grid_max, self.grid_size)
+        self.z_grid = torch.linspace(
+            0, self.z_grid_max, self.grid_size, device=self.minimum.device
+        )
         self.dz = self.z_grid[1] - self.z_grid[0]
         # C is specfied in m/s, h0 in km/s/Mpc, so divide by 1000 to convert
         comoving_dist_grid = (
@@ -285,7 +291,9 @@ class UniformComovingVolume(dist.Distribution):
             )
             / 1000
         )
-        zero_prefix = torch.zeros(1, dtype=comoving_dist_grid.dtype)
+        zero_prefix = torch.zeros(
+            1, dtype=comoving_dist_grid.dtype, device=self.minimum.device
+        )
         self.comoving_dist_grid = torch.cat([zero_prefix, comoving_dist_grid])
         self.luminosity_dist_grid = self.comoving_dist_grid * (1 + self.z_grid)
 
@@ -315,7 +323,9 @@ class UniformComovingVolume(dist.Distribution):
             p_of_distance, self.distance_grid
         )
         cdf = torch.cumulative_trapezoid(self.pdf, self.distance_grid)
-        zero_prefix = torch.zeros(1, dtype=cdf.dtype)
+        zero_prefix = torch.zeros(
+            1, dtype=cdf.dtype, device=self.minimum.device
+        )
         self.cdf = torch.cat([zero_prefix, cdf])
         self.log_pdf = torch.log(self.pdf)
 
@@ -333,7 +343,7 @@ class UniformComovingVolume(dist.Distribution):
 
     def rsample(self, sample_shape: torch.Size = None) -> Tensor:
         sample_shape = sample_shape or torch.Size()
-        u = torch.rand(sample_shape)
+        u = torch.rand(sample_shape, device=self.minimum.device)
         return self._linear_interp_1d(self.cdf, self.distance_grid, u)
 
     def log_prob(self, value: Tensor) -> Tensor:
@@ -341,7 +351,9 @@ class UniformComovingVolume(dist.Distribution):
             self.distance_grid, self.log_pdf, value
         )
         inside_range = (value >= self.minimum) & (value <= self.maximum)
-        log_prob[~inside_range] = float("-inf")
+        log_prob[~inside_range] = torch.as_tensor(
+            float("-inf"), device=self.minimum.device
+        )
         return log_prob
 
 

ml4gw/spectral.py

@@ -436,6 +436,7 @@ def normalize_by_psd(
     psd: PSDTensor,
     sample_rate: float,
     pad: int,
+    crop: bool = True,
 ):
     # compute the FFT of the section we want to whiten
     # and divide it by the ASD of the background section.
@@ -452,7 +453,8 @@ def normalize_by_psd(
     X = X.float() / sample_rate**0.5
 
     # slice off corrupted data at edges of kernel
-    X = X[:, :, pad:-pad]
+    if crop:
+        X = X[:, :, pad:-pad]
     return X
 
 
@@ -463,6 +465,7 @@ def whiten(
     sample_rate: float,
     highpass: float | None = None,
     lowpass: float | None = None,
+    crop: bool = True,
 ) -> WaveformTensor:
     """
     Whiten a batch of timeseries using the specified
@@ -506,9 +509,14 @@ def whiten(
             the data, setting the frequency response in the
             whitening filter to 0. If left as ``None``, no
             lowpass filtering will be applied.
+        crop:
+            If ``True``, crop ``fduration / 2`` seconds of data
+            from both sides of the time dimension to remove the
+            corruption from the filter. If ``False``, return the
+            full timeseries.
     Returns:
-        Batch of whitened multichannel timeseries with
-            ``fduration / 2`` seconds trimmed from each side.
+        Batch of whitened multichannel timeseries with ``fduration / 2``
+            seconds optionally trimmed from each side.
     """
 
     # figure out how much data we'll need to slice
@@ -549,4 +557,4 @@ def whiten(
         lowpass,
     )
 
-    return normalize_by_psd(X, psd, sample_rate, pad)
+    return normalize_by_psd(X, psd, sample_rate, pad, crop)

ml4gw/transforms/__init__.py

@@ -4,6 +4,7 @@ including objects to calculate spectral densities, whiten data,
 and compute Q-transforms.
 """
 
+from .decimator import Decimator
 from .iirfilter import IIRFilter
 from .pearson import ShiftedPearsonCorrelation
 from .qtransform import QScan, SingleQTransform

ml4gw/transforms/decimator.py

@@ -21,17 +21,25 @@ class Decimator(torch.nn.Module):
         schedule (torch.Tensor):
             Tensor of shape `(N, 3)` defining start time, end time,
             and target sample rate for each segment.
+        split (bool, optional):
+            - If True, the module returns a list of decimated segments
+              (one per schedule entry). Overlapping schedule segments are
+              only allowed when ``split=True``.
+            - If False (default), the segments are concatenated into a
+              single continuous output tensor.
 
     Shape:
         - Input: `(B, C, T)` where
             - B = batch size
             - C = channels
             - T = number of timesteps
-                    (must equal schedule duration × sample_rate)
+                    (must equal schedule duration x sample_rate)
         - Output:
-            - If ``split=False`` → `(B, C, T')` where `T'` is total
+            - If ``split=False`` → `(B, C, T')` where `T'` is the total
               number of decimated samples across all segments.
-            - If ``split=True`` → list of tensors, one per segment.
+            - If ``split=True`` → list of tensors, each with shape
+              :math:`(B, C, T_i)`, corresponding to the decimated samples
+              in each schedule segment.
 
     Returns:
         torch.Tensor or List[torch.Tensor]:
@@ -45,16 +53,16 @@ class Decimator(torch.nn.Module):
             >>> from ml4gw.transforms.decimator import Decimator
 
             >>> sample_rate = 2048
-            >>> X_duration = 60
+            >>> X_duration = 60  # seconds
+            >>> X = torch.randn(1, 1, sample_rate * X_duration)
 
             >>> schedule = torch.tensor(
             ...     [[0, 40, 256], [40, 58, 512], [58, 60, 2048]],
             ...     dtype=torch.int,
             ... )
-
             >>> decimator = Decimator(sample_rate=sample_rate,
-            ...    schedule=schedule)
-            >>> X = torch.randn(1, 1, sample_rate * X_duration)
+            ...     schedule=schedule)
+
             >>> X_dec = decimator(X)
             >>> X_seg = decimator(X, split=True)
 
@@ -67,16 +75,34 @@ class Decimator(torch.nn.Module):
             Segment 0 shape: torch.Size([1, 1, 10240])
             Segment 1 shape: torch.Size([1, 1, 9216])
             Segment 2 shape: torch.Size([1, 1, 4096])
+
+            >>> overlap_schedule = torch.tensor(
+            ...     [[0, 40, 256], [32, 58, 512]], [52, 60, 2048]],
+            ...     dtype=torch.int,
+            ... )
+            >>> decimator_ov = Decimator(
+            ...     sample_rate=sample_rate,
+            ...     schedule=overlap_schedule,
+            ...     split=True,
+            ... )
+            >>> X_overlap = decimator_ov(X)
+            >>> for i, seg in enumerate(X_overlap):
+            ...     print(f"Overlapping segment {i} shape:", seg.shape)
+            Overlapping segment 0 shape: torch.Size([1, 1, 10240])
+            Overlapping segment 1 shape: torch.Size([1, 1, 13312])
+            Overlapping segment 2 shape: torch.Size([1, 1, 16384])
     """
 
     def __init__(
         self,
         sample_rate: int = None,
         schedule: torch.Tensor = None,
+        split: bool = False,
     ) -> None:
         super().__init__()
         self.sample_rate = sample_rate
-        self.schedule = schedule
+        self.register_buffer("schedule", schedule)
+        self.split = split
 
         self._validate_inputs()
         idx = self.build_variable_indices()
@@ -89,7 +115,8 @@ class Decimator(torch.nn.Module):
 
     def _validate_inputs(self) -> None:
         r"""
-        Validate the schedule and sample_rate.
+        Validate the schedule and sample_rate. This method also checks
+        schedule segments do **not overlap** unless ``split=True``.
         """
         if self.schedule.ndim != 2 or self.schedule.shape[1] != 3:
             raise ValueError(
@@ -107,6 +134,15 @@ class Decimator(torch.nn.Module):
                 f"target rates {self.schedule[:, 2].tolist()}"
             )
 
+        if not self.split:
+            starts = self.schedule[:, 0]
+            ends = self.schedule[:, 1]
+            if torch.any(starts[1:] < ends[:-1]):
+                raise ValueError(
+                    "Schedule segments overlap — overlapping schedules "
+                    "are only supported when split=True."
+                )
+
     def build_variable_indices(self) -> torch.Tensor:
         r"""
         Compute the time indices to keep based on the schedule.
@@ -130,11 +166,15 @@ class Decimator(torch.nn.Module):
 
     def split_by_schedule(self, X: torch.Tensor) -> tuple[torch.Tensor, ...]:
         r"""
-        Split a decimated timeseries into segments according to the schedule.
+        Split and decimate a timeseries into segments according to the
+        schedule.
+
+        This method applies the decimation defined by each schedule row
+        and returns a list of the resulting segments.
 
         Args:
             X (torch.Tensor):
-                Decimated input of shape `(B, C, T')`.
+                Input timeseries of shape `(B, C, T)` before decimation.
 
         Returns:
             tuple of torch.Tensor:
@@ -142,33 +182,42 @@ class Decimator(torch.nn.Module):
                 where :math:`T_i` is the length implied by
                 the corresponding schedule row.
         """
-        split_sizes = (
-            ((self.schedule[:, 1] - self.schedule[:, 0]) * self.schedule[:, 2])
-            .long()
-            .tolist()
-        )
+        segments = []
+
+        for s in self.schedule:
+            start = int(s[0] * self.sample_rate)
+            stop = int(s[1] * self.sample_rate)
+            step = int(self.sample_rate // s[2])
+            idx = torch.arange(
+                start,
+                stop,
+                step,
+                dtype=torch.long,
+                device=self.schedule.device,
+            )
+            seg = X.index_select(dim=-1, index=idx)
+            segments.append(seg)
 
-        return torch.split(X, split_sizes, dim=-1)
+        return segments
 
     def forward(
         self,
         X: torch.Tensor,
-        split: bool = False,
     ) -> torch.Tensor | list[torch.Tensor]:
         r"""
-        Apply decimation to the input timeseries.
+        Apply decimation to the input timeseries according to the schedule.
 
         Args:
             X (torch.Tensor):
                 Input tensor of shape `(B, C, T)`, where `T` must equal
-                schedule duration × sample_rate.
-            split (bool, optional):
-                If True, return a list of segments instead of a single
-                concatenated tensor. Default: False.
+                schedule duration x sample_rate.
 
         Returns:
-            torch.Tensor or List[torch.Tensor]:
-                Decimated timeseries, or list of decimated segments.
+            torch.Tensor or list[torch.Tensor]:
+                - If ``split=False`` (default), returns a single decimated
+                  tensor of shape `(B, C, T')`.
+                - If ``split=True``, returns a list of decimated segments,
+                  one per schedule entry.
         """
         if X.shape[-1] != self.expected_len:
             raise ValueError(
@@ -176,8 +225,7 @@ class Decimator(torch.nn.Module):
                 f"expected schedule duration {self.expected_len}"
             )
 
-        X_dec = X.index_select(dim=-1, index=self.idx)
+        if self.split:
+            return self.split_by_schedule(X)
 
-        if split:
-            X_dec = self.split_by_schedule(X_dec)
-        return X_dec
+        return X.index_select(dim=-1, index=self.idx)

ml4gw/transforms/whitening.py

@@ -69,7 +69,10 @@ class Whiten(torch.nn.Module):
         self.register_buffer("window", window)
 
     def forward(
-        self, X: TimeSeries3d, psd: FrequencySeries1to3d
+        self,
+        X: TimeSeries3d,
+        psd: FrequencySeries1to3d,
+        crop: bool = True,
     ) -> TimeSeries3d:
         """
         Whiten a batch of multichannel timeseries by a
@@ -96,6 +99,11 @@ class Whiten(torch.nn.Module):
                 For more information about what these different
                 shapes for ``psd`` represent, consult the documentation
                 for :meth:`~ml4gw.spectral.whiten`.
+            crop:
+                If ``True``, crop ``fduration / 2`` seconds of data
+                from both sides of the time dimension to remove the
+                corruption from the filter. If ``False``, return the
+                full timeseries.
         Returns:
             Whitened timeseries, with ``fduration * sample_rate / 2``
                 samples cropped from each edge. Output shape will then
@@ -109,6 +117,7 @@ class Whiten(torch.nn.Module):
             sample_rate=self.sample_rate,
             highpass=self.highpass,
             lowpass=self.lowpass,
+            crop=crop,
         )
 
 
@@ -127,7 +136,7 @@ class FixedWhiten(FittableSpectralTransform):
             frequency bins in the fit PSD.
         sample_rate:
             Rate at which timeseries will be sampled, in Hz
-        dtype:
+        crop:
             Datatype with which background PSD will be stored
     """
 
@@ -243,11 +252,24 @@ class FixedWhiten(FittableSpectralTransform):
         fduration = torch.Tensor([fduration])
         self.build(psd=psd, fduration=fduration)
 
-    def forward(self, X: TimeSeries3d) -> TimeSeries3d:
+    def forward(self, X: TimeSeries3d, crop: bool = True) -> TimeSeries3d:
         """
         Whiten the input timeseries tensor using the
         PSD fit by the ``.fit`` method, which must be
         called **before** the first call to ``.forward``.
+
+        Args:
+            X:
+                Batch of multichannel timeseries to whiten.
+                Should have the shape ``(B, C, N)``, where
+                ``B`` is the batch size, ``C`` is the number of
+                channels, and ``N`` is the number of seconds
+                in the timeseries times ``self.sample_rate``.
+            crop:
+                If ``True``, crop ``fduration / 2`` seconds of data
+                from both sides of the time dimension to remove the
+                corruption from the filter. If ``False``, return the
+                full timeseries.
         """
         expected_dim = int(self.kernel_length * self.sample_rate)
         if X.size(-1) != expected_dim:
@@ -258,4 +280,6 @@ class FixedWhiten(FittableSpectralTransform):
             )
 
         pad = int(self.fduration.item() * self.sample_rate / 2)
-        return spectral.normalize_by_psd(X, self.psd, self.sample_rate, pad)
+        return spectral.normalize_by_psd(
+            X, self.psd, self.sample_rate, pad, crop
+        )

{ml4gw-0.7.8.dist-info → ml4gw-0.7.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ml4gw
-Version: 0.7.8
+Version: 0.7.10
 Summary: Tools for training torch models on gravitational wave data
 Author-email: Ethan Marx <emarx@mit.edu>, Will Benoit <benoi090@umn.edu>, Deep Chatterjee <deep1018@mit.edu>, Alec Gunny <alec.gunny@ligo.org>, Ravi Kumar <ravi.kumar@ligo.org>
 Maintainer-email: Ethan Marx <emarx@mit.edu>, Will Benoit <benoi090@umn.edu>, Deep Chatterjee <deep1018@mit.edu>
@@ -16,7 +16,7 @@ License-File: LICENSE
 Requires-Dist: jaxtyping<0.3,>=0.2
 Requires-Dist: torch~=2.0
 Requires-Dist: torchaudio~=2.0
-Requires-Dist: numpy<2.0.0
+Requires-Dist: numpy>=1.0.0
 Requires-Dist: scipy<1.15,>=1.9.0
 Dynamic: license-file
 
@@ -26,6 +26,7 @@ Dynamic: license-file
 ![GitHub License](https://img.shields.io/github/license/ML4GW/ml4gw)
 ![Test status](https://github.com/ML4GW/ml4gw/actions/workflows/unit-tests.yaml/badge.svg)
 ![Coverage badge](https://raw.githubusercontent.com/ML4GW/ml4gw/python-coverage-comment-action-data/badge.svg)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.08836/status.svg)](https://doi.org/10.21105/joss.08836)
 
 Torch utilities for training neural networks in gravitational wave physics applications.
 

{ml4gw-0.7.8.dist-info → ml4gw-0.7.10.dist-info}/RECORD

@@ -1,13 +1,13 @@
 ml4gw/__init__.py,sha256=81quoggCuIypZjZs3bbf1Ty70KHdva5RGEJxi0oC57E,25
 ml4gw/augmentations.py,sha256=Jck8FVtKM18evUESIRrJC-WFk8amhTdqD4kM74HjlGI,1382
 ml4gw/constants.py,sha256=RQPXwavlw_cWu3ByltvTejPsi6EWXHDJQ1HaV9iE3Lg,850
-ml4gw/distributions.py,sha256=zyE0Sk1cpBqmJ3oumWnJ9FCcIszz9yQDguAvbcrKcn4,12828
+ml4gw/distributions.py,sha256=gmTxbqi3zSM42Oizm_svPMrDK3GX8zYLhoNl3B7mUro,13288
 ml4gw/gw.py,sha256=L4WgicskE_Nn6UQMDG1C0TNquXC7D3A84yd_I54e9y0,20181
-ml4gw/spectral.py,sha256=lT08wBEfCOnmdYDf5mwUqqFF-rrf-FZFx6jmpLeh63U,19897
+ml4gw/spectral.py,sha256=rDfptr2WQ8dE11EUjXVmYb8-T9ROwizMBYtryI_03ag,20213
 ml4gw/types.py,sha256=weerxUI-PEWWvzGtzwY_A9AH_m_I1p-rGWvKbiZle-0,919
 ml4gw/dataloading/__init__.py,sha256=Qrfq3yPGMy8-1gAMyo81MuKGK5gwp7y6Gx8gd4suEjc,240
 ml4gw/dataloading/chunked_dataset.py,sha256=CZ40OTjuRx_v0nzLrApybIj40zCkdhP5xsGBnqGArB8,5255
-ml4gw/dataloading/hdf5_dataset.py,sha256=72RfdKXCJiZShbRD0nqbuQFDdnVitYtkF-G2LBjG_fc,7934
+ml4gw/dataloading/hdf5_dataset.py,sha256=Xf_AKBCmwsuPxqRTaJQqJbt4w7BEpTPeWhGKm2YKGbE,7964
 ml4gw/dataloading/in_memory_dataset.py,sha256=wbdWID76IqhD01u-XlD-QPRnWPSVmkSQTyHR2lyy_NA,9559
 ml4gw/nn/__init__.py,sha256=Vn8CqewYAK6GD-gOvsR7TJK6I568soXLpp9Ga9sYqkY,188
 ml4gw/nn/norm.py,sha256=zd8NcjrtqM4yFyHFmDkknuV623NA5Cj0o6jBdPv6xh0,3584
@@ -22,8 +22,8 @@ ml4gw/nn/resnet/resnet_2d.py,sha256=YiHxP3cNIfjOrEmKSVqZYOUxoVnIkpDdwCW9VieNM7E,
 ml4gw/nn/streaming/__init__.py,sha256=zgjGR2L8t0txXLnil9ceZT0tM8Y2FC8yPxqIKYH0o1A,80
 ml4gw/nn/streaming/online_average.py,sha256=22jQ_JbJTpusmqeGdo7Ta7lTsGoTBjYtKZnXzucW3wc,4676
 ml4gw/nn/streaming/snapshotter.py,sha256=kH73np-LUGF0ZP-tkWY19TrCJa3m1RIvvZ-SmLA7YvM,4378
-ml4gw/transforms/__init__.py,sha256=0pnZhiW1Yz9ozhMlmZrMyPjRPQVZ9hUn0nIPeIIRpAk,632
-ml4gw/transforms/decimator.py,sha256=6iuRyordzteWp9fE27zdrEfJY_sTmIe5sTSfs4xTL1U,6137
+ml4gw/transforms/__init__.py,sha256=Q5o8L7LKLc2AYItI_-fapNQVU6gJE6a5BOaAPwQbBVo,665
+ml4gw/transforms/decimator.py,sha256=_7AtlM9UqwpJbE1G9gyuV61l044gw7lrVfOfeGBLie8,8279
 ml4gw/transforms/iirfilter.py,sha256=T4qgrJeA3vPeVWyZ-bPBOxQkJL0yfaUVoU0MTtpwhvg,3152
 ml4gw/transforms/pearson.py,sha256=buPEfjaPJkMtdnBP5tvFzRzId8DbThAfJcGzaYmANqc,3202
 ml4gw/transforms/qtransform.py,sha256=a7hqZ4pq9J6pq8L3Dm4Dqyxz-QyaznoNZO4mTdb5apY,20616
@@ -34,7 +34,7 @@ ml4gw/transforms/spectrogram.py,sha256=TGG_fVng-Y569KsIQAaf5_WN-W4-6F89oQSyHFxVo
 ml4gw/transforms/spline_interpolation.py,sha256=QHBp5g_1_lOYmCFJqQyZAbPXBZaqzb5_LBWeLY6ppkI,18614
 ml4gw/transforms/transform.py,sha256=_jAxsCnLmIo97g4b2J8WKS0Omy-yyOzNt6lFHEM5ESM,2463
 ml4gw/transforms/waveforms.py,sha256=yFOzGlYjjM488oYxZLpikS9noZCnisVM0_gjgWoF-_E,3018
-ml4gw/transforms/whitening.py,sha256=65B6V_ERh_Pc9zghRPlMQSacxYg2bPunTDTswAW7GOk,10265
+ml4gw/transforms/whitening.py,sha256=s3nE5Z45jYCJIZSaAYCXn_j6Kic5AXF2WwS7USu2bvM,11226
 ml4gw/utils/interferometer.py,sha256=lRGtMRFSco1mI1Y1O2kz4dRp5hmK5cp4nG7sYbAiYG4,2179
 ml4gw/utils/slicing.py,sha256=kaO54GMUV8d7vIt3oodVZJ4jFwJMEK8aGknJ8UOJzRs,13667
 ml4gw/waveforms/__init__.py,sha256=SxTc6rSkQfoOtEgNYvA-8tMJsQQQROTRRKaFDRQOmh4,172
@@ -50,8 +50,8 @@ ml4gw/waveforms/cbc/phenom_d_data.py,sha256=WA1FBxUp9fo1IQaV_OLJ_5g5gI166mY1FtG9
 ml4gw/waveforms/cbc/phenom_p.py,sha256=m81Xt_zIffHiGlWgzf-AmI46mSn6CFZAX-6Fwwr5Tfk,27635
 ml4gw/waveforms/cbc/taylorf2.py,sha256=emWbl3vjsCzBOooHOVO7pPlPcj05r4up6InlMkO5m_E,10422
 ml4gw/waveforms/cbc/utils.py,sha256=LT1ky10_6ZrbwTcxIrWP1O75GUEuU5q2ZE2yYDhadQE,3037
-ml4gw-0.7.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ml4gw-0.7.8.dist-info/METADATA,sha256=ZURGSlU7-WODIwI7GckMtDhzWkFxxsJ31_F14Gk23UU,4282
-ml4gw-0.7.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ml4gw-0.7.8.dist-info/top_level.txt,sha256=JnWLyPXJ3_WUcjr6fRV0ZTXj8FR0x4vBzjkg-1bl2tw,6
-ml4gw-0.7.8.dist-info/RECORD,,
+ml4gw-0.7.10.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ml4gw-0.7.10.dist-info/METADATA,sha256=wIeraROEpLgAXivws9yOmH2BMOXCGPULCbZzXlCU89k,4392
+ml4gw-0.7.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ml4gw-0.7.10.dist-info/top_level.txt,sha256=JnWLyPXJ3_WUcjr6fRV0ZTXj8FR0x4vBzjkg-1bl2tw,6
+ml4gw-0.7.10.dist-info/RECORD,,