sxs 2025.0.2__py3-none-any.whl → 2025.0.3__py3-none-any.whl

sxs/waveforms/norms.py

@@ -0,0 +1,270 @@
+import numpy as np
+from scipy.integrate import trapezoid
+
+from .waveform_modes import WaveformModes
+
+
+def check_time_constraint(wa, wb, t1, t2):
+    """Check that the times t1 and t2 are contained in wa.t and wb.t.
+
+    Parameters
+    ----------
+    wa : WaveformModes
+    wb : WaveformModes
+    t1 : float
+    t2 : float
+    """
+    time_intersection = (max(wa.t[0], wb.t[0]), min(wa.t[-1], wb.t[-1]))
+    if t1 < time_intersection[0]:
+        raise ValueError(f"{t1} is not contained in intersection of waveform time arrays: {time_intersection}.")
+    if t2 > time_intersection[1]:
+        raise ValueError(f"{t2} is not contained in intersection of waveform time arrays: {time_intersection}.")
+
+
+def create_unified_waveforms(wa, wb, t1, t2, padding_time_factor=0.2):
+    """Convert WaveformModes to common time and modes
+
+    The output waveforms will be interpolated to a set of times
+    including — as nearly as possible — the times `t1` and `t2`,
+    padded by the given fraction of `(t2-t1)` on other side.
+
+    Parameters
+    ----------
+    wa : WaveformModes
+    wb : WaveformModes
+    t1 : float
+    t2 : float
+    padding_time_factor : float, optional
+        Extra time of size (t2 - t1)*padding_time_factor to include
+        int the waveforms.  Default is 0.2.
+
+    Returns
+    -------
+    wa_interp : WaveformModes
+    wb_interp : WaveformModes
+    """
+    check_time_constraint(wa, wb, t1, t2)
+
+    padding_time = (t2 - t1) * padding_time_factor
+    t1_padded = max(wa.t[0], wb.t[0], t1 - padding_time)
+    t2_padded = min(wa.t[-1], wb.t[-1], t2 + padding_time)
+
+    idx1 = np.argmin(abs(wa.t - t1_padded))
+    idx2 = np.argmin(abs(wa.t - t2_padded)) + 1
+
+    wa_interp = wa.interpolate(wa.t[idx1:idx2])
+    wb_interp = wb.interpolate(wa_interp.t)
+
+    ell_min = max(wa_interp.ell_min, wb_interp.ell_min)
+    ell_max = min(wa_interp.ell_max, wb_interp.ell_max)
+    ia1 = wa_interp.index(ell_min, -ell_min)
+    ia2 = wa_interp.index(ell_max, ell_max) + 1
+    ib1 = wb_interp.index(ell_min, -ell_min)
+    ib2 = wb_interp.index(ell_max, ell_max) + 1
+
+    return wa_interp[:,ia1:ia2], wb_interp[:,ib1:ib2]
+
+
+def L2_difference(wa, wb, t1=-np.inf, t2=np.inf, modes=None, modes_for_norm=None, normalize=True):
+    """Compute L² norm of difference between two waveforms
+    
+    The norm is integrated over the time window (`t1`, `t2`), and over
+    the sphere using the modes specified by `modes`.
+
+    Parameters
+    ----------
+    wa : WaveformModes
+    wb : WaveformModes
+        Waveforms to compare.
+    t1 : float
+        Beginning of L² norm integral.
+    t2 : float
+        End of L² norm integral.
+    modes : list, optional
+        Modes (ell, m) to include in numerator of L² norm calculation.
+        Default is all modes.
+    modes_for_norm : list, optional
+        Modes (ell, m) to include in denominator of L² norm
+        calculation.  Default is all modes.
+    normalize : bool, optional
+        Whether or not to divide by sqrt(||wa||²||wb||²) in the sqrt.
+        If False, returns the unnormalized L² norm of the residual and
+        what would have been the normalization.  Default is True.
+
+    Returns
+    -------
+    L2_norm: float
+        L² norm of the residual between the waveforms.  This is sqrt(
+        ||wa - wb||² / sqrt(||wa||² ||wb||²) )
+    """
+    t1 = max(wa.t[0], wb.t[0], t1)
+    t2 = min(wa.t[-1], wb.t[-1], t2)
+
+    already_unified = (
+        np.array_equal(wa.t, wb.t)
+        and (wa.ndim == wb.ndim == 1 or np.array_equal(wa.LM, wb.LM))
+    )
+
+    if already_unified:
+        i1, i2 = np.argmin(abs(wa.t - t1)), np.argmin(abs(wa.t - t2)) + 1
+        wa = wa.copy()[i1:i2]
+        wb = wb.copy()[i1:i2]
+    else:
+        wa, wb = create_unified_waveforms(wa, wb, t1, t2, padding_time_factor=0)
+
+    data_diff = wa.data - wb.data
+
+    data_for_norm1 = wa.data
+    data_for_norm2 = wb.data
+
+    # Eliminate unwanted modes
+    if modes is not None or modes_for_norm is not None:
+        for L in range(wa.ell_min, wa.ell_max + 1):
+            for M in range(-L, L + 1):
+                if modes is not None:
+                    if not (L, M) in modes:
+                        data_diff[:, wa.index(L, M)] *= 0
+                if modes_for_norm is not None:
+                    if not (L, M) in modes_for_norm:
+                        data_for_norm1[:, wa.index(L, M)] *= 0
+                        data_for_norm2[:, wb.index(L, M)] *= 0
+
+    if normalize:
+        L2_norm = np.sqrt(
+            trapezoid(np.linalg.norm(data_diff, axis=wa.modes_axis) ** 2, wa.t)
+            / np.sqrt(
+                trapezoid(np.linalg.norm(data_for_norm1, axis=wa.modes_axis) ** 2, wa.t)
+                * trapezoid(np.linalg.norm(data_for_norm2, axis=wa.modes_axis) ** 2, wb.t)
+            )
+        )
+
+        return L2_norm
+    else:
+        L2_norm_unnormalized = np.sqrt(trapezoid(np.linalg.norm(data_diff, axis=wa.modes_axis) ** 2, wa.t))
+        norm = np.sqrt(
+            np.sqrt(
+                trapezoid(np.linalg.norm(data_for_norm1, axis=wa.modes_axis) ** 2, wa.t)
+                * trapezoid(np.linalg.norm(data_for_norm2, axis=wb.modes_axis) ** 2, wb.t)
+            )
+        )
+
+        return L2_norm_unnormalized, norm
+
+
+def inner_product(wa, wb, ASD_values=None):
+    """Compute the inner product between two waveforms
+
+    No interpolation is performed, including for the `ASD`.  If the
+    inputs are `WaveformModes` objects, the modes are assumed to match
+    between the two waveforms.
+    
+    Note that this can be provided with time-domain or
+    frequency-domain waveforms, either over the two-sphere
+    (WaveformModes) or at a point on the two-sphere (TimeSeries).
+      
+    For frequency-domain waveforms, the .t attribute should be the
+    frequency.
+    
+    Parameters
+    ----------
+    wa : WaveformModes or TimeSeries
+    wb : WaveformModes or TimeSeries
+    ASD_values : ndarray, optioanl
+        ASD values for frequency-domain overlaps.
+        Default is flat ASD.
+
+    Returns
+    -------
+    inner_product : float
+        Inner product between the two waveforms.
+    """
+    if ASD_values is None:
+        ASD_values = 1
+
+    if not wa.ndim == wb.ndim == 1:
+        inner_product = trapezoid(
+            np.sum(wa.data * np.conjugate(wb.data), axis=1) / ASD_values**2,
+            wa.t,
+        )
+    else:
+        inner_product = trapezoid(
+            (wa * np.conjugate(wb)).ndarray / ASD_values**2,
+            wa.t,
+        )
+
+    return inner_product
+
+
+def mismatch(wa, wb, x1=-np.inf, x2=np.inf, modes=None, ASD=None):
+    """Compute the mismatch between two waveforms
+
+    The mismatch is calculated over the time or frequency window
+    (`x1`, `x2`), and — if relevant — over the sphere using the modes
+    specified by `modes`.
+
+    Note that this can be provided with time-domain or
+    frequency-domain waveforms, either over the two-sphere
+    (WaveformModes) or at a point on the two-sphere (TimeSeries).
+
+    For frequency-domain waveforms, the .t attribute should be the
+    frequency.
+
+    Parameters
+    ----------
+    wa : WaveformModes or TimeSeries
+    wb : WaveformModes or TimeSeries
+    x1 : float, optional
+        Beginning of mismatch integral.  Default uses all values.
+    x2 : float, optional
+        End of mismatch integral.  Default uses all values.
+    modes : list, optional
+        Modes (ell, m) to include in the mismatch calculation.
+        Default is all modes.
+    ASD : func, optional
+        Function mapping frequencies to the ASD of a detector.
+        Default is flat ASD.
+
+    Returns
+    -------
+    mismatch : float
+        Mismatch between the two waveforms.
+    """
+    x1 = max(wa.t[0], wb.t[0], x1)
+    x2 = min(wa.t[-1], wb.t[-1], x2)
+
+    already_unified = (
+        np.array_equal(wa.t, wb.t)
+        and (wa.ndim == wb.ndim == 1 or np.array_equal(wa.LM, wb.LM))
+    )
+
+    if already_unified:
+        i1, i2 = np.argmin(abs(wa.t - x1)), np.argmin(abs(wa.t - x2)) + 1
+        wa = wa.copy()[i1:i2]
+        wb = wb.copy()[i1:i2]
+    else:
+        wa, wb = create_unified_waveforms(wa, wb, x1, x2, padding_time_factor=0)
+
+    # Eliminate unwanted modes
+    if modes is not None:
+        if wa.ndim > 1:
+            for L in range(wa.ell_min, wa.ell_max + 1):
+                for M in range(-L, L + 1):
+                    if not (L, M) in modes:
+                        wa.data[:, wa.index(L, M)] *= 0
+                        wb.data[:, wb.index(L, M)] *= 0
+        else:
+            raise ValueError(
+                "A `modes` argument was provided, but the input `wa` "
+                "and `wb` only have one dimension."
+            )
+
+    if ASD is not None:
+        ASD_values = ASD(wa.t)
+    else:
+        ASD_values = 1
+
+    wa_wb_overlap = inner_product(wa, wb, ASD_values=ASD_values).real
+    wa_norm = inner_product(wa, wa, ASD_values=ASD_values).real
+    wb_norm = inner_product(wb, wb, ASD_values=ASD_values).real
+
+    return 1 - wa_wb_overlap / np.sqrt(wa_norm * wb_norm)

sxs/waveforms/waveform_modes.py

@@ -7,6 +7,7 @@ import warnings
 import numpy as np
 from scipy.interpolate import CubicSpline
 from scipy.optimize import minimize_scalar
+from scipy import fft
 import quaternionic
 import spherical
 from .. import TimeSeries
@@ -1275,6 +1276,89 @@ class WaveformModes(WaveformMixin, TimeSeries):
         result = result.line_subtraction(treat_as_zero=treat_as_zero)
         return result
 
+    def fourier_transform(self, theta_phi=None, total_mass=None, luminosity_distance=None):
+        """Fourier transform the modes of a waveform.
+
+        This Fourier transforms the mode time series
+        of the WaveformModes object and replaces the
+        time attribute with the frequencies.
+
+        Parameters
+        ----------
+        theta_phi : tuple, optional
+            Point on the two-sphere to evaluate the waveform at.
+            Default is None.
+        total_mass : float, optional
+            Total mass in solar masses.
+            Default is no scaling is applied.
+        luminosity_distance : float, optional
+            Luminosity distance in Mpc.
+
+        Returns
+        -------
+        h_tilde : TimeSeries
+            Unitful Fourier transform.
+        """
+        from .. import m_sun_in_meters, m_sun_in_seconds, parsec_in_meters
+
+        dt = np.diff(self.t)
+        max_dt = np.max(dt)
+        min_dt = np.min(dt)
+        if max_dt - min_dt > (self.t[-1] - self.t[0]) * 10 * np.finfo(self.t.dtype).eps:
+            raise ValueError("Time array must be uniform! Maybe run .preprocess first.")
+        
+        h_factor = 1
+        t_factor = 1
+        if total_mass is not None:
+            h_factor = total_mass * m_sun_in_meters
+            t_factor = total_mass * m_sun_in_seconds
+            
+        if luminosity_distance is not None:
+            h_factor /= (luminosity_distance * 1e6 * parsec_in_meters)
+            
+        if theta_phi is not None:
+            h_unitful = self.evaluate(*theta_phi)
+            if total_mass is not None and luminosity_distance is not None:
+                h_unitful *= h_factor
+                h_unitful.t *= t_factor
+        else:                
+            h_unitful = WaveformModes(
+                input_array=self.data * h_factor,
+                time=self.t * t_factor,
+                time_axis=self.time_axis,
+                modes_axis=self.modes_axis,
+                ell_min=self.ell_min,
+                ell_max=self.ell_max,
+                spin_weight=self.spin_weight,
+            )
+
+        N = h_unitful.t.size
+        max_dt = max(np.diff(h_unitful.t))
+
+        if theta_phi is not None:
+            h_tilde = TimeSeries(
+                fft.fftshift(
+                    max_dt * fft.fft(h_unitful.data, axis=self.time_axis), axes=self.time_axis
+                ),
+                fft.fftshift(fft.fftfreq(N, max_dt)),
+            )
+        else:
+            h_tilde = WaveformModes(
+                input_array=fft.fftshift(
+                    max_dt * fft.fft(h_unitful.data, axis=self.time_axis), axes=self.time_axis
+                ),
+                time=fft.fftshift(fft.fftfreq(N, max_dt)),
+                time_axis=self.time_axis,
+                modes_axis=self.modes_axis,
+                ell_min=self.ell_min,
+                ell_max=self.ell_max,
+                spin_weight=self.spin_weight,
+            )
+            
+        h_tilde = h_tilde[h_tilde.t.size//2:]
+
+        return h_tilde
+        
 
 class WaveformModesDict(MutableMapping, WaveformModes):
     """A dictionary-like class for storing waveform modes

sxs/waveforms/waveform_mts.py

@@ -0,0 +1,30 @@
+import spherical
+from . import WaveformModes
+
+class _ModesTimeSeries(WaveformModes):
+
+    @property
+    def s(self):
+        return self.spin_weight
+
+    @property
+    def u(self):
+        return self.time
+
+    from spherical.modes.algebra import (
+        conjugate, bar, _real_func, real, _imag_func, imag, norm,
+        add, subtract, multiply, divide
+    )
+
+    conj = conjugate
+
+    from spherical.modes.utilities import (
+        truncate_ell, _check_broadcasting
+    )
+
+    from spherical.modes.ufuncs import __array_ufunc__
+
+
+def MTS(*args, **kwargs):
+    kwargs.setdefault('multiplication_truncator', max)
+    return _ModesTimeSeries(*args, **kwargs)

{sxs-2025.0.2.dist-info → sxs-2025.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sxs
-Version: 2025.0.2
+Version: 2025.0.3
 Summary: Interface to data produced by the Simulating eXtreme Spacetimes collaboration
 Project-URL: Homepage, https://github.com/sxs-collaboration/sxs
 Project-URL: Documentation, https://sxs.readthedocs.io/
@@ -40,6 +40,7 @@ Requires-Dist: inflection>=0.5.1
 Requires-Dist: juliacall>=0.9.20
 Requires-Dist: numba>=0.55; implementation_name == 'cpython'
 Requires-Dist: numpy>=1.25
+Requires-Dist: packaging
 Requires-Dist: pandas>=1.1.2
 Requires-Dist: pytz>=2020.1
 Requires-Dist: quaternionic>=1.0.15

{sxs-2025.0.2.dist-info → sxs-2025.0.3.dist-info}/RECORD

@@ -1,6 +1,6 @@
 sxs/__init__.py,sha256=8PntABL6yx7Ad70hP7WedNAVDTZiwm_2At5xIQGo4k8,2610
-sxs/__version__.py,sha256=00CnSIbrBDJK1w5pLXr3qrweMV-XKl67exMRg7gte3Q,25
-sxs/handlers.py,sha256=Rhj6HAKPKSCJYwpWcz2eUkd6yuQZdCndQjZhq71QQ1A,18308
+sxs/__version__.py,sha256=KcF5yAdb5CxfI3m_tuljFiWg8XFkWLOA922PgZ-Lf1g,25
+sxs/handlers.py,sha256=jVV-HK-omzoBx5N2wcpLHvyoWq86hUfWCjnGbPpD91I,18343
 sxs/juliapkg.json,sha256=-baaa3Za_KBmmiGjlh2YYLWmvUvZl6GaKKXwNI4S7qU,178
 sxs/time_series.py,sha256=OKaLg8tFyrtKcef7900ri-a0C6A8wKxA68KovZXvH6I,41081
 sxs/catalog/__init__.py,sha256=9-WTMTPDmqqkFyIHOtEbPA6etXm3_RSRrLWvHtLrjLg,205
@@ -15,9 +15,10 @@ sxs/julia/__init__.py,sha256=uSLP_xfU-GZG7IO5vs0TEkCR4LH8aBYMF-852wDY3kI,3490
 sxs/metadata/__init__.py,sha256=vEb633hoKAnI9O7kBtejZXFFsWM6h_ShuTq2_Xl3hUs,72
 sxs/metadata/metadata.py,sha256=8LBDWeUAtLOP-MTqbwf_m5eb6k8UKj0L_yKthidF7lA,98
 sxs/metadata/metric.py,sha256=Tsig1Jm50OO8r89zfjCuQ4i3JAoiazSb4J9qYtPWKgM,41
-sxs/simulations/__init__.py,sha256=GrZym0PHTULDg_hyFmISNzDfqVLz_hQo-djbgecZs54,134
+sxs/simulations/__init__.py,sha256=eXkheYhRaYyKjul5J1IXpoJ7Wq4nr3Tgwr-HSS3BTek,156
+sxs/simulations/analyze.py,sha256=RaImREx3fWlXgJRCI-Wsq0-LjidL-Mb8SIN3-n-TMqM,10373
 sxs/simulations/local.py,sha256=e77SeaWMl2PWX_EndQtShOXZxcFKhQsUDQ55R2Njcuc,43
-sxs/simulations/simulation.py,sha256=OCkpzKtjkX6CgCbnY8d_CWv4oDKY7spaqvj8rEHM3TY,38223
+sxs/simulations/simulation.py,sha256=to8iAofvW_TMIfyO1tYSiCwuVUC7v-2ykGsjN0WvTGY,41104
 sxs/simulations/simulations.py,sha256=sMle89VoD1CQni1N23Vjo3h2yj9LHHAtuaB_qfD3Wgg,109
 sxs/utilities/__init__.py,sha256=WSStlqljfgQheMxHGfuofSc5LdmASGvO3FNO3f_zaT0,4806
 sxs/utilities/bitwise.py,sha256=G9ZNYgwDQRhq5wbDf-p2HcUqkEP_IRDiQoXW4KyU17k,13205
@@ -54,18 +55,20 @@ sxs/utilities/references/fairchild_report.py,sha256=MUnYQD7zJcz202Vt3-j9ueXglthG
 sxs/utilities/references/inspire.py,sha256=kDjY-UFJT-VTS3yJOT8fT6LJG-pRrX9TK8nv3RZqrbo,8431
 sxs/utilities/references/journal_abbreviations.py,sha256=SuRXcr4rv9YPbXD4mzujSvE7M6KS1lwELimuyn7mfCE,31018
 sxs/utilities/references/references.py,sha256=29rPUZKw3dztXQLRDEt1hGYjZaONFd0qX--xQxzOmUU,418
-sxs/waveforms/__init__.py,sha256=FPu_MFwfzcLsWhvoLm_AXRLz59eBODes4MY2_taTE5c,1150
-sxs/waveforms/alignment.py,sha256=Z_fCnUIza89Vwzl5qo4spwd2-ZrzYxFU8Q7b6UKFtMU,21341
-sxs/waveforms/memory.py,sha256=1BOov3QJl9wexgGt8HA8MqVZZfLKbykff5pRVzLiILo,7763
+sxs/waveforms/__init__.py,sha256=yfPzExhZZqNrPOe784f8BC8mHUiwb85urKM_4_pzUFo,1157
+sxs/waveforms/alignment.py,sha256=TYSsGq3dRQwoookyzkNkT02pGViPC0TqQ64RksX4OxU,32649
+sxs/waveforms/memory.py,sha256=zuph5JgeBog6xrCbcSYzXegPfUtoPUXnYmmY5KfYUj8,7272
 sxs/waveforms/mode_utilities.py,sha256=gxsW-hunCoIReBVv9IrkGLdshr0rmztbH-JRgD6D9z0,5253
+sxs/waveforms/norms.py,sha256=zemgJsWNhng3QAi3ixHAZ8P5SSIUcHysSQIcqRGDeyI,8944
 sxs/waveforms/transformations.py,sha256=S5C-xnCk2umZlVsYgciyp7VMGZA8NI6md7OZp72upJU,9124
 sxs/waveforms/waveform_grid.py,sha256=aBlcsudj1XozZD7n42sh6-nzysKNalAdHJkVQ7M6fE4,180
 sxs/waveforms/waveform_mixin.py,sha256=S0RNe2HkwnqdCyGEarGYmoXD_DkTWGorsiGGIBWOam8,1179
-sxs/waveforms/waveform_modes.py,sha256=NousbAeSedN1RNh21g_5LAh0K82ikIumHPELKf9X_tc,57143
+sxs/waveforms/waveform_modes.py,sha256=BpjjB42COmr9A3Li5MjhPs_jr9FOfOWRGN_tykQyEYA,60177
+sxs/waveforms/waveform_mts.py,sha256=rdEDlAK4TA4F6hFCVi0DrdYucJIGneqmWkEHaScDh0I,660
 sxs/waveforms/waveform_signal.py,sha256=Ojrt6DSDdleB0qmu6UwjjPnYdaWsrjnpBA_8dhnM_q4,182
 sxs/waveforms/format_handlers/__init__.py,sha256=0wsnuBYCYsCkN19L2ipga7BtigvPyBcqiy_4qrzmLpE,50
 sxs/waveforms/format_handlers/grathena.py,sha256=5NrHL3K0mRHApnFx5YsMUufDKUD1A_dZu8mGQqOdBeE,3622
-sxs/waveforms/format_handlers/lvc.py,sha256=8hGyjSaXRfS1RPiknbACi6mSLDU-xoD3EiDG2CqEit4,7861
+sxs/waveforms/format_handlers/lvc.py,sha256=bGAB2k1vXIloA25dUKu4ZUJde5Y4CHrjkPXtQ93aw7w,8006
 sxs/waveforms/format_handlers/nrar.py,sha256=3ycVoqQcWAAixV3mKp58_wUhYBHt6QeLv2YGSvy-EGM,21538
 sxs/waveforms/format_handlers/rotating_paired_diff_multishuffle_bzip2.py,sha256=7XgXnroQ-3dHCYnN6KrDkz8z9EVl57f8W6iOX6bUemA,27745
 sxs/waveforms/format_handlers/rotating_paired_xor_multishuffle_bzip2.py,sha256=pFEJIlb6OQQNhv6r48ALFnZMKNZjuQY55ydWBADCDgU,2348
@@ -79,7 +82,7 @@ sxs/zenodo/api/__init__.py,sha256=EM_eh4Q8R5E0vIfMhyIR1IYFfOBu6vA0UTasgX9gHys,21
 sxs/zenodo/api/deposit.py,sha256=J4RGvGjh0cEOrN4bBZWEDcPAhNscqB2fzLlvRZ5HTHM,36948
 sxs/zenodo/api/login.py,sha256=Yz0ytgi81_5BpDzhrS0WPMXlvU2qUaCK8yn8zxfEbko,18007
 sxs/zenodo/api/records.py,sha256=nKkhoHZ95CTztHF9Zzaug5p7IiUCJG4Em1i-l-WqH6U,3689
-sxs-2025.0.2.dist-info/METADATA,sha256=1LSOQXL_n4JZSL1Z_EW-ShJ5JLvurIp2WbHYBFuHHqY,9288
-sxs-2025.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sxs-2025.0.2.dist-info/licenses/LICENSE,sha256=ptVOd5m7LDM5ZF0x32cxb8c2Nd5NDmAhy6DX7xt_7VA,1080
-sxs-2025.0.2.dist-info/RECORD,,
+sxs-2025.0.3.dist-info/METADATA,sha256=07jpPE3ytnWTOb_fPvoCCy4ux8cBMzP5LeNEQhvv0n4,9313
+sxs-2025.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sxs-2025.0.3.dist-info/licenses/LICENSE,sha256=ptVOd5m7LDM5ZF0x32cxb8c2Nd5NDmAhy6DX7xt_7VA,1080
+sxs-2025.0.3.dist-info/RECORD,,