wavedl 1.5.3__py3-none-any.whl → 1.5.5__py3-none-any.whl

wavedl/__init__.py

@@ -18,7 +18,7 @@ For inference:
     # or: python -m wavedl.test --checkpoint best_checkpoint --data_path test.npz
 """
 
-__version__ = "1.5.3"
+__version__ = "1.5.5"
 __author__ = "Ductho Le"
 __email__ = "ductho.le@outlook.com"
 

wavedl/hpo.py

@@ -175,13 +175,14 @@ def create_objective(args):
                 env["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
 
             # Run training
+            # Note: We inherit the user's cwd instead of setting cwd=Path(__file__).parent
+            # because site-packages may be read-only and train.py creates cache directories
             try:
                 result = subprocess.run(
                     cmd,
                     capture_output=True,
                     text=True,
                     timeout=args.timeout,
-                    cwd=Path(__file__).parent,
                     env=env,
                 )
 

wavedl/models/swin.py

@@ -191,22 +191,33 @@ class SwinTransformerBase(BaseModel):
         Returns:
             List of parameter group dictionaries
         """
-        # Separate parameters: head (full LR) vs backbone (decayed LR)
+        # Separate parameters into 4 groups for proper LR decay:
+        # 1. Head params with decay (full LR)
+        # 2. Backbone params with decay (0.1× LR)
+        # 3. Head bias/norm without decay (full LR)
+        # 4. Backbone bias/norm without decay (0.1× LR)
         head_params = []
         backbone_params = []
-        no_decay_params = []
+        head_no_decay = []
+        backbone_no_decay = []
 
         for name, param in self.backbone.named_parameters():
             if not param.requires_grad:
                 continue
 
-            # No weight decay for bias and normalization
-            if "bias" in name or "norm" in name:
-                no_decay_params.append(param)
-            elif "head" in name:
-                head_params.append(param)
+            is_head = "head" in name
+            is_no_decay = "bias" in name or "norm" in name
+
+            if is_head:
+                if is_no_decay:
+                    head_no_decay.append(param)
+                else:
+                    head_params.append(param)
             else:
-                backbone_params.append(param)
+                if is_no_decay:
+                    backbone_no_decay.append(param)
+                else:
+                    backbone_params.append(param)
 
         groups = []
 
@@ -229,15 +240,25 @@ class SwinTransformerBase(BaseModel):
                 }
             )
 
-        if no_decay_params:
+        if head_no_decay:
             groups.append(
                 {
-                    "params": no_decay_params,
+                    "params": head_no_decay,
                     "lr": base_lr,
                     "weight_decay": 0.0,
                 }
             )
 
+        if backbone_no_decay:
+            # Backbone bias/norm also gets 0.1× LR to match intended decay
+            groups.append(
+                {
+                    "params": backbone_no_decay,
+                    "lr": base_lr * 0.1,
+                    "weight_decay": 0.0,
+                }
+            )
+
         return groups if groups else [{"params": self.parameters(), "lr": base_lr}]
 
 

wavedl/train.py

@@ -122,6 +122,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import torch
+import torch.distributed as dist
 from accelerate import Accelerator
 from accelerate.utils import set_seed
 from sklearn.metrics import r2_score
@@ -470,15 +471,19 @@ def main():
             try:
                 # Handle both module names (my_model) and file paths (./my_model.py)
                 if module_name.endswith(".py"):
-                    # Import from file path
+                    # Import from file path with unique module name
                     import importlib.util
 
+                    # Derive unique module name from filename to avoid collisions
+                    base_name = os.path.splitext(os.path.basename(module_name))[0]
+                    unique_name = f"wavedl_custom_{base_name}"
+
                     spec = importlib.util.spec_from_file_location(
-                        "custom_module", module_name
+                        unique_name, module_name
                     )
                     if spec and spec.loader:
                         module = importlib.util.module_from_spec(spec)
-                        sys.modules["custom_module"] = module
+                        sys.modules[unique_name] = module
                         spec.loader.exec_module(module)
                         print(f"✓ Imported custom module from: {module_name}")
                 else:
@@ -1250,9 +1255,32 @@ def main():
                     )
 
             # Learning rate scheduling (epoch-based schedulers only)
+            # NOTE: For ReduceLROnPlateau with DDP, we must step only on main process
+            # to avoid patience counter being incremented by all GPU processes.
+            # Then we sync the new LR to all processes to keep them consistent.
             if not scheduler_step_per_batch:
                 if args.scheduler == "plateau":
-                    scheduler.step(avg_val_loss)
+                    # Step only on main process to avoid multi-GPU patience bug
+                    if accelerator.is_main_process:
+                        scheduler.step(avg_val_loss)
+
+                    # Sync LR across all processes after main process updates it
+                    accelerator.wait_for_everyone()
+
+                    # Broadcast new LR from rank 0 to all processes
+                    if dist.is_initialized():
+                        if accelerator.is_main_process:
+                            new_lr = optimizer.param_groups[0]["lr"]
+                        else:
+                            new_lr = 0.0
+                        new_lr_tensor = torch.tensor(
+                            new_lr, device=accelerator.device, dtype=torch.float32
+                        )
+                        dist.broadcast(new_lr_tensor, src=0)
+                        # Update LR on non-main processes
+                        if not accelerator.is_main_process:
+                            for param_group in optimizer.param_groups:
+                                param_group["lr"] = new_lr_tensor.item()
                 else:
                     scheduler.step()
 

wavedl/utils/data.py

@@ -207,6 +207,10 @@ class NPZSource(DataSource):
 
         The error for object arrays happens at ACCESS time, not load time.
         So we need to probe the keys to detect if pickle is required.
+
+        WARNING: When mmap_mode is not None, the returned NpzFile must be kept
+        open for arrays to remain valid. Caller is responsible for closing.
+        For non-mmap loading, use _load_and_copy() instead to avoid leaks.
         """
         data = np.load(path, allow_pickle=False, mmap_mode=mmap_mode)
         try:
@@ -222,6 +226,26 @@ class NPZSource(DataSource):
                 return np.load(path, allow_pickle=True, mmap_mode=mmap_mode)
             raise
 
+    @staticmethod
+    def _load_and_copy(path: str, keys: list[str]) -> dict[str, np.ndarray]:
+        """Load NPZ and copy arrays, ensuring file is properly closed.
+
+        This prevents file descriptor leaks by copying arrays before closing.
+        Use this for eager loading; use _safe_load for memory-mapped access.
+        """
+        data = NPZSource._safe_load(path, keys, mmap_mode=None)
+        try:
+            result = {}
+            for key in keys:
+                if key in data:
+                    arr = data[key]
+                    # Copy ensures we don't hold reference to mmap
+                    result[key] = arr.copy() if hasattr(arr, "copy") else arr
+            return result
+        finally:
+            if hasattr(data, "close"):
+                data.close()
+
     def load(self, path: str) -> tuple[np.ndarray, np.ndarray]:
         """Load NPZ file (pickle enabled only for sparse matrices)."""
         # First pass to find keys without loading data
@@ -238,7 +262,7 @@ class NPZSource(DataSource):
                 f"Found: {keys}"
             )
 
-        data = self._safe_load(path, [input_key, output_key])
+        data = self._load_and_copy(path, [input_key, output_key])
         inp = data[input_key]
         outp = data[output_key]
 
@@ -290,7 +314,7 @@ class NPZSource(DataSource):
                 f"Supported keys: {OUTPUT_KEYS}. Found: {keys}"
             )
 
-        data = self._safe_load(path, [output_key])
+        data = self._load_and_copy(path, [output_key])
         return data[output_key]
 
 
@@ -527,9 +551,17 @@ class MATSource(DataSource):
                 inp = self._load_dataset(f, input_key)
                 outp = self._load_dataset(f, output_key)
 
-                # Handle 1D outputs that become (1, N) after transpose
-                if outp.ndim == 2 and outp.shape[0] == 1:
-                    outp = outp.T
+                # Handle transposed outputs from MATLAB.
+                # Case 1: (1, N) - N samples with 1 target → transpose to (N, 1)
+                # Case 2: (T, 1) - 1 sample with T targets → transpose to (1, T)
+                num_samples = inp.shape[0]  # inp is already transposed
+                if outp.ndim == 2:
+                    if outp.shape[0] == 1 and outp.shape[1] == num_samples:
+                        # 1D vector: (1, N) → (N, 1)
+                        outp = outp.T
+                    elif outp.shape[1] == 1 and outp.shape[0] != num_samples:
+                        # Single sample with multiple targets: (T, 1) → (1, T)
+                        outp = outp.T
 
         except OSError as e:
             raise ValueError(
@@ -614,7 +646,10 @@ class MATSource(DataSource):
                 # Load with sparse matrix support
                 outp = self._load_dataset(f, output_key)
 
-                # Handle 1D outputs
+                # Handle 1D outputs that become (1, N) after transpose.
+                # Note: This method has no input to compare against, so we can't
+                # distinguish single-sample outputs. This is acceptable for training
+                # data where single-sample is unlikely. For inference, use load_test_data.
                 if outp.ndim == 2 and outp.shape[0] == 1:
                     outp = outp.T
 
@@ -775,7 +810,7 @@ def load_test_data(
                 raise KeyError(
                     f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
                 )
-            data = NPZSource._safe_load(
+            data = NPZSource._load_and_copy(
                 path, [inp_key] + ([out_key] if out_key else [])
             )
             inp = data[inp_key]
@@ -793,6 +828,14 @@ def load_test_data(
                     raise KeyError(
                         f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
                     )
+                # OOM guard: warn if dataset is very large
+                n_samples = f[inp_key].shape[0]
+                if n_samples > 100000:
+                    raise ValueError(
+                        f"Dataset has {n_samples:,} samples. load_test_data() loads "
+                        f"everything into RAM which may cause OOM. For large inference "
+                        f"sets, use a DataLoader with HDF5Source.load_mmap() instead."
+                    )
                 inp = f[inp_key][:]
                 outp = f[out_key][:] if out_key else None
         elif format == "mat":
@@ -805,11 +848,28 @@ def load_test_data(
                     raise KeyError(
                         f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
                     )
+                # OOM guard: warn if dataset is very large (MAT is transposed)
+                n_samples = f[inp_key].shape[-1]
+                if n_samples > 100000:
+                    raise ValueError(
+                        f"Dataset has {n_samples:,} samples. load_test_data() loads "
+                        f"everything into RAM which may cause OOM. For large inference "
+                        f"sets, use a DataLoader with MATSource.load_mmap() instead."
+                    )
                 inp = mat_source._load_dataset(f, inp_key)
                 if out_key:
                     outp = mat_source._load_dataset(f, out_key)
-                    if outp.ndim == 2 and outp.shape[0] == 1:
-                        outp = outp.T
+                    # Handle transposed outputs from MATLAB
+                    # Case 1: (1, N) - N samples with 1 target → transpose to (N, 1)
+                    # Case 2: (T, 1) - 1 sample with T targets → transpose to (1, T)
+                    num_samples = inp.shape[0]
+                    if outp.ndim == 2:
+                        if outp.shape[0] == 1 and outp.shape[1] == num_samples:
+                            # 1D vector: (1, N) → (N, 1)
+                            outp = outp.T
+                        elif outp.shape[1] == 1 and outp.shape[0] != num_samples:
+                            # Single sample with multiple targets: (T, 1) → (1, T)
+                            outp = outp.T
                 else:
                     outp = None
         else:
@@ -828,7 +888,7 @@ def load_test_data(
                 )
             out_key = DataSource._find_key(keys, custom_output_keys)
             keys_to_probe = [inp_key] + ([out_key] if out_key else [])
-            data = NPZSource._safe_load(path, keys_to_probe)
+            data = NPZSource._load_and_copy(path, keys_to_probe)
             inp = data[inp_key]
             if inp.dtype == object:
                 inp = np.array(
@@ -878,9 +938,17 @@ def load_test_data(
                 out_key = DataSource._find_key(keys, custom_output_keys)
                 if out_key:
                     outp = mat_source._load_dataset(f, out_key)
-                    # Handle 1D outputs that become (1, N) after transpose
-                    if outp.ndim == 2 and outp.shape[0] == 1:
-                        outp = outp.T
+                    # Handle transposed outputs from MATLAB
+                    # Case 1: (1, N) - N samples with 1 target → transpose to (N, 1)
+                    # Case 2: (T, 1) - 1 sample with T targets → transpose to (1, T)
+                    num_samples = inp.shape[0]
+                    if outp.ndim == 2:
+                        if outp.shape[0] == 1 and outp.shape[1] == num_samples:
+                            # 1D vector: (1, N) → (N, 1)
+                            outp = outp.T
+                        elif outp.shape[1] == 1 and outp.shape[0] != num_samples:
+                            # Single sample with multiple targets: (T, 1) → (1, T)
+                            outp = outp.T
                 else:
                     outp = None
         else:
@@ -1126,6 +1194,29 @@ def prepare_data(
 
     if not cache_exists:
         if accelerator.is_main_process:
+            # Delete stale cache files to force regeneration
+            # This prevents silent reuse of old data when metadata invalidates cache
+            for stale_file in [CACHE_FILE, SCALER_FILE]:
+                if os.path.exists(stale_file):
+                    try:
+                        os.remove(stale_file)
+                        logger.debug(f"   Removed stale cache: {stale_file}")
+                    except OSError as e:
+                        logger.warning(
+                            f"   Failed to remove stale cache {stale_file}: {e}"
+                        )
+
+            # Fail explicitly if stale cache files couldn't be removed
+            # This prevents silent reuse of outdated data
+            remaining_stale = [
+                f for f in [CACHE_FILE, SCALER_FILE] if os.path.exists(f)
+            ]
+            if remaining_stale:
+                raise RuntimeError(
+                    f"Cannot regenerate cache: stale files could not be removed. "
+                    f"Please manually delete: {remaining_stale}"
+                )
+
             # RANK 0: Create cache (can take a long time for large datasets)
             # Other ranks will wait at the barrier below
 

wavedl/utils/metrics.py

@@ -815,7 +815,28 @@ def plot_qq(
 
         # Standardize errors for QQ plot
         err = errors[:, i]
-        standardized = (err - np.mean(err)) / np.std(err)
+        std_err = np.std(err)
+
+        # Guard against zero variance (constant errors)
+        if std_err < 1e-10:
+            title = (
+                param_names[i] if param_names and i < len(param_names) else f"Param {i}"
+            )
+            ax.text(
+                0.5,
+                0.5,
+                "Zero variance\n(constant errors)",
+                ha="center",
+                va="center",
+                fontsize=10,
+                transform=ax.transAxes,
+            )
+            ax.set_title(f"{title}\n(zero variance)")
+            ax.set_xlabel("Theoretical Quantiles")
+            ax.set_ylabel("Sample Quantiles")
+            continue
+
+        standardized = (err - np.mean(err)) / std_err
 
         # Calculate theoretical quantiles and sample quantiles
         (osm, osr), (slope, intercept, r) = stats.probplot(standardized, dist="norm")

{wavedl-1.5.3.dist-info → wavedl-1.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: wavedl
-Version: 1.5.3
+Version: 1.5.5
 Summary: A Scalable Deep Learning Framework for Wave-Based Inverse Problems
 Author: Ductho Le
 License: MIT
@@ -37,11 +37,12 @@ Requires-Dist: wandb>=0.15.0
 Requires-Dist: optuna>=3.0.0
 Requires-Dist: onnx>=1.14.0
 Requires-Dist: onnxruntime>=1.15.0
-Requires-Dist: pytest>=7.0.0
-Requires-Dist: pytest-xdist>=3.5.0
-Requires-Dist: ruff>=0.8.0
-Requires-Dist: pre-commit>=3.5.0
 Requires-Dist: triton>=2.0.0; sys_platform == "linux"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
+Requires-Dist: ruff>=0.8.0; extra == "dev"
+Requires-Dist: pre-commit>=3.5.0; extra == "dev"
 
 <div align="center">
 
@@ -204,7 +205,7 @@ Deploy models anywhere:
 pip install wavedl
 ```
 
-This installs everything you need: training, inference, HPO, ONNX export, and dev tools.
+This installs everything you need: training, inference, HPO, ONNX export.
 
 #### From Source (for development)
 
@@ -336,7 +337,7 @@ class MyModel(BaseModel):
 **Step 2: Train**
 
 ```bash
-wavedl-hpc --import my_model --model my_model --data_path train.npz
+wavedl-hpc --import my_model.py --model my_model --data_path train.npz
 ```
 
 WaveDL handles everything else: training loop, logging, checkpoints, multi-GPU, early stopping, etc.
@@ -387,7 +388,7 @@ WaveDL/
 ├── configs/                      # YAML config templates
 ├── examples/                     # Ready-to-run examples
 ├── notebooks/                    # Jupyter notebooks
-├── unit_tests/                   # Pytest test suite (725 tests)
+├── unit_tests/                   # Pytest test suite (731 tests)
 │
 ├── pyproject.toml                # Package config, dependencies
 ├── CHANGELOG.md                  # Version history
@@ -512,7 +513,7 @@ print('\\n✓ All pretrained weights cached!')
 | Argument | Default | Description |
 |----------|---------|-------------|
 | `--model` | `cnn` | Model architecture |
-| `--import` | - | Python modules to import (for custom models) |
+| `--import` | - | Python file(s) to import for custom models (supports multiple) |
 | `--batch_size` | `128` | Per-GPU batch size |
 | `--lr` | `1e-3` | Learning rate |
 | `--epochs` | `1000` | Maximum epochs |
@@ -1223,6 +1224,6 @@ This research was enabled in part by support provided by [Compute Ontario](https
 [![Google Scholar](https://img.shields.io/badge/Google_Scholar-4285F4?style=plastic&logo=google-scholar&logoColor=white)](https://scholar.google.ca/citations?user=OlwMr9AAAAAJ)
 [![ResearchGate](https://img.shields.io/badge/ResearchGate-00CCBB?style=plastic&logo=researchgate&logoColor=white)](https://www.researchgate.net/profile/Ductho-Le)
 
-<sub>Released under the MIT License</sub>
+<sub>May your signals be strong and your attenuation low 👋</sub>
 
 </div>

{wavedl-1.5.3.dist-info → wavedl-1.5.5.dist-info}/RECORD

@@ -1,8 +1,8 @@
-wavedl/__init__.py,sha256=1h6l9c3ms45mYhJZskUm28my7Lrq9tXMUs4BtMTiK_s,1177
+wavedl/__init__.py,sha256=RTePiYlzCrUofbGSYWAAqoKeeyYjqEPzuXyze6ai324,1177
 wavedl/hpc.py,sha256=6rV38nozzMt0-jKZbVJNwvQZXK0wUsIZmr9lgWN_XUw,9212
-wavedl/hpo.py,sha256=DGCGyt2yhr3WAifAuljhE26gg07CHdaQW4wpDaTKbyo,14968
+wavedl/hpo.py,sha256=CZF0MZwTGMOrPGDveUXZFbGHwLHj1FcJTCBKVVEtLWg,15105
 wavedl/test.py,sha256=WIHG3HWT-uF399FQApPpxjggBVFn59cC54HAL4990QU,38550
-wavedl/train.py,sha256=Aao8ofyYALqPrMTQarRn4rPWzDLZD-PeuKNVJ76IrVQ,54344
+wavedl/train.py,sha256=7AVaCORFUv2_IgdYSPKdHLxbi11GzMOyu4RcNc4Uf_I,55963
 wavedl/models/__init__.py,sha256=lfSohEnAUztO14nuwayMJhPjpgySzRN3jGiyAUuBmAU,3206
 wavedl/models/_template.py,sha256=J_D8taSPmV8lBaucN_vU-WiG98iFr7CJrZVNNX_Tdts,4600
 wavedl/models/base.py,sha256=T9iDF9IQM2MYucG_ggQd31rieUkB2fob-nkHyNIl2ak,7337
@@ -16,7 +16,7 @@ wavedl/models/registry.py,sha256=InYAXX2xbRvsFDFnYUPCptJh0F9lHlFPN77A9kqHRT0,298
 wavedl/models/regnet.py,sha256=Yf9gAoDLv0j4uEuoKC822gizHNh59LCbvFCMP11Q1C0,13116
 wavedl/models/resnet.py,sha256=laePTbIgINijh-Xkcp4iui8-1F17NJAjyAuA4T11eG4,18027
 wavedl/models/resnet3d.py,sha256=C7CL4XeSnRlIBuwf5Ei-z183uzIBObrXfkM9Iwuc5e0,8746
-wavedl/models/swin.py,sha256=p-okfq3Qm4_neJTxCcMzoHoVzC0BHW3BMnbpr_Ri2U0,13224
+wavedl/models/swin.py,sha256=cbV_iqIS4no-EAUR8j_93gqd59AkAkfM5DYo6VryLEg,13937
 wavedl/models/tcn.py,sha256=RtY13QpFHqz72b4ultv2lStCIDxfvjySVe5JaTx_GaM,12601
 wavedl/models/unet.py,sha256=LqIXhasdBygwP7SZNNmiW1bHMPaJTVBpaeHtPgEHkdU,7790
 wavedl/models/vit.py,sha256=68o9nNjkftvHFArAPupU2ew5e5yCsI2AYaT9TQinVMk,12075
@@ -24,15 +24,15 @@ wavedl/utils/__init__.py,sha256=s5R9bRmJ8GNcJrD3OSAOXzwZJIXZbdYrAkZnus11sVQ,3300
 wavedl/utils/config.py,sha256=AsGwb3XtxmbTLb59BLl5AA4wzMNgVTpl7urOJ6IGqfM,10901
 wavedl/utils/constraints.py,sha256=Pof5hzeTSGsPY_E6Sc8iMQDaXc_zfEasQI2tCszk_gw,17614
 wavedl/utils/cross_validation.py,sha256=gwXSFTx5oxWndPjWLJAJzB6nnq2f1t9f86SbjbF-jNI,18475
-wavedl/utils/data.py,sha256=H5crttnSfJZBMWQOvM7Cq7nkefnhVlgO0O6J71zJdgI,52651
+wavedl/utils/data.py,sha256=cmJ6tUw4Tcxj-l3Xsphs1Dnlx1MzxOPvk8etD5KXFNs,57686
 wavedl/utils/distributed.py,sha256=7wQ3mRjkp_xjPSxDWMnBf5dSkAGUaTzntxbz0BhC5v0,4145
 wavedl/utils/losses.py,sha256=5762M-TBC_hz6uyj1NPbU1vZeFOJQq7fR3-j7OygJRo,7254
-wavedl/utils/metrics.py,sha256=EJmJvF7gACQsUoKYldlladN_SbnRiuE-Smj0eSnbraQ,39394
+wavedl/utils/metrics.py,sha256=El2NYsulH5jxBhC1gCAMcS8C-yxEjuSC930LhsKYQrY,40059
 wavedl/utils/optimizers.py,sha256=PyIkJ_hRhFi_Fio81Gy5YQNhcME0JUUEl8OTSyu-0RA,6323
 wavedl/utils/schedulers.py,sha256=e6Sf0yj8VOqkdwkUHLMyUfGfHKTX4NMr-zfgxWqCTYI,7659
-wavedl-1.5.3.dist-info/LICENSE,sha256=cEUCvcvH-9BT9Y-CNGY__PwWONCKu9zsoIqWA-NeHJ4,1066
-wavedl-1.5.3.dist-info/METADATA,sha256=bPNcR8sYE9U7a001lvMFn9oHfmcmkpHUDdGRowLjJEs,45488
-wavedl-1.5.3.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-wavedl-1.5.3.dist-info/entry_points.txt,sha256=f1RNDkXFZwBzrBzTMFocJ6xhfTvTmaEDTi5YyDEUaF8,140
-wavedl-1.5.3.dist-info/top_level.txt,sha256=ccneUt3D5Qzbh3bsBSSrq9bqrhGiogcWKY24ZC4Q6Xw,7
-wavedl-1.5.3.dist-info/RECORD,,
+wavedl-1.5.5.dist-info/LICENSE,sha256=cEUCvcvH-9BT9Y-CNGY__PwWONCKu9zsoIqWA-NeHJ4,1066
+wavedl-1.5.5.dist-info/METADATA,sha256=0e7E8zLd-GlcR5Hbgp5VDYGGr36_9NzKBTShsG4xuQs,45604
+wavedl-1.5.5.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+wavedl-1.5.5.dist-info/entry_points.txt,sha256=f1RNDkXFZwBzrBzTMFocJ6xhfTvTmaEDTi5YyDEUaF8,140
+wavedl-1.5.5.dist-info/top_level.txt,sha256=ccneUt3D5Qzbh3bsBSSrq9bqrhGiogcWKY24ZC4Q6Xw,7
+wavedl-1.5.5.dist-info/RECORD,,