pywavelet 0.2.6__tar.gz → 0.2.7__tar.gz

{pywavelet-0.2.6 → pywavelet-0.2.7}/.gitignore

@@ -119,3 +119,4 @@ venv.bak/
 
 # VSCode
 .vscode/
+/docs/runtime_data_cpu.csv

{pywavelet-0.2.6 → pywavelet-0.2.7}/CHANGELOG.rst

@@ -5,6 +5,19 @@ CHANGELOG
 =========
 
 
+.. _changelog-v0.2.7:
+
+v0.2.7 (2025-03-25)
+===================
+
+Unknown
+-------
+
+* Merge branch 'main' of github.com:pywavelet/pywavelet (`ef5aa31`_)
+
+.. _ef5aa31: https://github.com/pywavelet/pywavelet/commit/ef5aa31e72c8a838cfb008c03bd47b009df728dc
+
+
 .. _changelog-v0.2.6:
 
 v0.2.6 (2025-03-24)
@@ -13,8 +26,15 @@ v0.2.6 (2025-03-24)
 Bug Fixes
 ---------
 
+* fix: add more checkingn for cupy and jax backends (`75e54c0`_)
+
 * fix: add note in readme about JAX and cupy (`d3cd8d9`_)
 
+Chores
+------
+
+* chore(release): 0.2.6 (`d2e3cb2`_)
+
 Unknown
 -------
 
@@ -120,7 +140,9 @@ Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.gi
 
 * add additional JAX tests (`c0d8396`_)
 
+.. _75e54c0: https://github.com/pywavelet/pywavelet/commit/75e54c00dd9ddfff98a7f0612f54abf1ac17184e
 .. _d3cd8d9: https://github.com/pywavelet/pywavelet/commit/d3cd8d92b5e6cf398ff3a4948b911533abe842f1
+.. _d2e3cb2: https://github.com/pywavelet/pywavelet/commit/d2e3cb271b06d1d9bc3060e924fa5bcd57ceb269
 .. _6cdfb28: https://github.com/pywavelet/pywavelet/commit/6cdfb28b152a7f7ad499f0b6ba6ef69da9284c57
 .. _14b250b: https://github.com/pywavelet/pywavelet/commit/14b250b55dbea88c3b7c22b5faca531113d34477
 .. _3d8b4cd: https://github.com/pywavelet/pywavelet/commit/3d8b4cdc8dea6af33b08985cb97f0897984838fc

{pywavelet-0.2.6 → pywavelet-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pywavelet
-Version: 0.2.6
+Version: 0.2.7
 Summary: WDM wavelet transform your time/freq series!
 Author-email: Pywavelet Team <avi.vajpeyi@gmail.com>
 Project-URL: Homepage, https://pywavelet.github.io/pywavelet/

pywavelet-0.2.7/docs/runtime.ipynb

@@ -0,0 +1,322 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/pywavelet/pywavelet/blob/main/docs/runtime.ipynb\">\n",
+    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
+    "</a>\n",
+    "\n",
+    "\n",
+    "# Runtime Comparisons"
+   ],
+   "id": "9df79fd10b46e463"
+  },
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "import importlib\n",
+    "import numpy as np\n",
+    "import jax.numpy as jnp\n",
+    "import pandas as pd \n",
+    "import jax\n",
+    "from pywavelet.backend import cuda_available\n",
+    "from tqdm.auto import tqdm\n",
+    "from pywavelet.types import FrequencySeries\n",
+    "from pywavelet.transforms.phi_computer import phitilde_vec_norm\n",
+    "from timeit import repeat as timing_repeat\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "jax.config.update(\"jax_enable_x64\", False)\n",
+    "    \n",
+    "JAX_DEVICE = jax.default_backend()\n",
+    "JAX_PRECISION = \"x64\" if jax.config.jax_enable_x64 else \"x32\"\n",
+    "\n",
+    "\n",
+    "if cuda_available:\n",
+    "    import cupy as cp\n",
+    "\n",
+    "\n",
+    "def generate_freq_domain_signal(\n",
+    "        ND, f0=20.0, dt=0.0125, A=2\n",
+    ") -> FrequencySeries:\n",
+    "    \"\"\"\n",
+    "    Generates a frequency domain signal.\n",
+    "\n",
+    "    Parameters:\n",
+    "    ND (int): Number of data points.\n",
+    "    f0 (float): Frequency of the signal. Default is 20.0.\n",
+    "    dt (float): Time step. Default is 0.0125.\n",
+    "    A (float): Amplitude of the signal. Default is 2.\n",
+    "\n",
+    "    Returns:\n",
+    "    FrequencySeries: The generated frequency domain signal.\n",
+    "    \"\"\"\n",
+    "    ts = np.arange(0, ND) * dt\n",
+    "    y = A * np.sin(2 * np.pi * f0 * ts)\n",
+    "    yf = FrequencySeries(y, ts)\n",
+    "    return yf\n",
+    "\n",
+    "\n",
+    "def generate_func_args(ND, backend=\"numpy\"):\n",
+    "    Nf = Nt = int(np.sqrt(ND))\n",
+    "    yf = generate_freq_domain_signal(ND).data\n",
+    "    phif = phitilde_vec_norm(Nf, Nt, d=4.0)\n",
+    "    if backend == \"jax\":\n",
+    "        yf = jnp.array(yf)\n",
+    "        phif = jnp.array(phif)\n",
+    "    if backend == \"cupy\" and cuda_available:\n",
+    "        yf = cp.array(yf)\n",
+    "        phif = cp.array(phif)\n",
+    "    return yf, Nf, Nt, phif\n",
+    "\n",
+    "\n",
+    "def collect_runtime(\n",
+    "        func, func_args, n=5, nreps=5\n",
+    "):\n",
+    "    func(*func_args)  # Warm up run\n",
+    "    times = timing_repeat(\n",
+    "        lambda: func(*func_args),\n",
+    "        number=n,\n",
+    "        repeat=nreps\n",
+    "    )\n",
+    "\n",
+    "    return (np.median(times), (np.std(times)))\n",
+    "\n",
+    "\n",
+    "def collect_runtimes(func, backend, NF_values, number=5, repeat=5):\n",
+    "    results = {}\n",
+    "    bar = tqdm(NF_values, desc=\"Running\")\n",
+    "    for Nf in bar:\n",
+    "        ND = Nf * Nf\n",
+    "        bar.set_postfix(ND=f\"2**{int(np.log2(ND))}\")\n",
+    "        func_args = generate_func_args(ND, backend)\n",
+    "        try:\n",
+    "            results[ND] = collect_runtime(func, func_args, number, repeat)\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error processing ND={ND}: {e}\")\n",
+    "            results[ND] = (np.nan, np.nan)\n",
+    "    return results\n",
+    "\n",
+    "\n",
+    "def run_transforms():\n",
+    "    from pywavelet.transforms.jax.forward.from_freq import transform_wavelet_freq_helper as jax_transform\n",
+    "    from pywavelet.transforms.numpy.forward.from_freq import transform_wavelet_freq_helper as np_transform\n",
+    "\n",
+    "    min_pow2 = 2\n",
+    "    max_pow2 = 12\n",
+    "    NF = [2 ** i for i in range(min_pow2, max_pow2)]\n",
+    "\n",
+    "    runtimes = {}\n",
+    "    runtimes[\"numpy\"] = collect_runtimes(np_transform, \"numpy\", NF, number=5, repeat=5)\n",
+    "    \n",
+    "    max_pow2 = 15\n",
+    "    NF = [2 ** i for i in range(min_pow2, max_pow2)]\n",
+    "    runtimes[\"jax\"] = collect_runtimes(jax_transform, \"jax\", NF, number=5, repeat=5)\n",
+    "\n",
+    "    if cuda_available:\n",
+    "        from pywavelet.transforms.cupy.forward.from_freq import transform_wavelet_freq_helper as cp_transform\n",
+    "        runtimes['cupy'] = collect_runtimes(cp_transform, \"cupy\", NF, number=10, repeat=10)\n",
+    "    \n",
+    "    \n",
+    "    return runtimes\n",
+    "\n",
+    "\n",
+    "def plot(runtimes):\n",
+    "    fig, ax = plt.subplots(figsize=(4, 3.5))\n",
+    "    for i, backend in enumerate(runtimes.keys()):\n",
+    "        _plot_backend_runtime(ax, runtimes[backend], backend, f\"C{i}\")\n",
+    "    ax.set_yscale(\"log\")\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.set_xlabel(\"Number of Data Points\")\n",
+    "    ax.set_ylabel(\"Runtime (s)\")\n",
+    "    ax.legend(frameon=False)\n",
+    "    return fig, ax\n",
+    "\n",
+    "\n",
+    "def _plot_backend_runtime(ax, runtimes, backend, color):\n",
+    "    NDs = list(runtimes.keys())\n",
+    "    times = [runtimes[ND][0] for ND in NDs]\n",
+    "    stds = [runtimes[ND][1] for ND in NDs]\n",
+    "    # plot a band around the median runtime\n",
+    "    ax.fill_between(NDs, np.array(times) - np.array(stds), np.array(times) + np.array(stds), alpha=0.3, color=color)\n",
+    "    ax.plot(NDs, times, label=f\"{backend}\", color=color)\n",
+    "    ax.set_xlim(min(NDs), max(NDs))\n",
+    "\n",
+    "\n",
+    "runtimes = run_transforms()\n",
+    "# save runtime data as a txt file\n",
+    "runtime_data = pd.DataFrame(runtimes)\n",
+    "runtime_data.to_csv(f\"runtime_data_{JAX_DEVICE}.csv\")\n",
+    "    \n",
+    "\n",
+    "fig, ax = plot(runtimes)\n",
+    "fig.savefig(\"runtime.png\", bbox_inches=\"tight\")\n",
+    "\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-24T07:53:51.232554Z",
+     "start_time": "2025-03-24T07:53:51.116610Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "nan = np.nan\n",
+    "\n",
+    "\n",
+    "gpu_runtimes = {'numpy': {16: (np.float64(2.7647000024444424e-05),\n",
+    "   np.float64(1.6699892612917253e-05)),\n",
+    "  64: (np.float64(4.7878000032142154e-05), np.float64(7.901239258106135e-06)),\n",
+    "  256: (np.float64(0.00014417199997751595),\n",
+    "   np.float64(2.8245273864177316e-05)),\n",
+    "  1024: (np.float64(0.00025147099995592725),\n",
+    "   np.float64(8.368707136149373e-06)),\n",
+    "  4096: (np.float64(0.0008757960000593812),\n",
+    "   np.float64(0.00039357430227278433)),\n",
+    "  16384: (np.float64(0.0017043970000258923),\n",
+    "   np.float64(0.0016274004399110828)),\n",
+    "  65536: (np.float64(0.006220592999966357),\n",
+    "   np.float64(0.00021847848737320755)),\n",
+    "  262144: (np.float64(0.023843203999945217),\n",
+    "   np.float64(0.0008785219521943771)),\n",
+    "  1048576: (np.float64(0.11971158300002571), np.float64(0.02209812945217875)),\n",
+    "  4194304: (np.float64(0.7133738380000523), np.float64(0.006134709481659322))},\n",
+    " 'jax': {16: (np.float64(0.0005724070000496795),\n",
+    "   np.float64(0.0001069087688290125)),\n",
+    "  64: (np.float64(0.0007151319999820771), np.float64(0.0001322757281663352)),\n",
+    "  256: (np.float64(0.0009230550000438598), np.float64(0.00031332690291921287)),\n",
+    "  1024: (np.float64(0.001453614000070047), np.float64(0.00012679139424215402)),\n",
+    "  4096: (np.float64(0.00050203600005716), np.float64(8.404927733069893e-05)),\n",
+    "  16384: (np.float64(0.0007342449999896417), np.float64(6.60918000741e-05)),\n",
+    "  65536: (np.float64(0.0009854250000671527),\n",
+    "   np.float64(9.820818468604813e-05)),\n",
+    "  262144: (np.float64(0.0005175009999902613),\n",
+    "   np.float64(4.419451355415323e-05)),\n",
+    "  1048576: (np.float64(0.0003900709999697938),\n",
+    "   np.float64(7.364248018965731e-05)),\n",
+    "  4194304: (np.float64(0.0004053449999901204),\n",
+    "   np.float64(7.663108380403174e-05)),\n",
+    "  16777216: (np.float64(0.00039541899991490936),\n",
+    "   np.float64(6.804382786659215e-05)),\n",
+    "  67108864: (np.float64(0.00040576800006419944),\n",
+    "   np.float64(0.00010823411767385025)),\n",
+    "  268435456: (np.float64(0.00041394100003344647),\n",
+    "   np.float64(0.00010930952627993826))},\n",
+    " 'cupy': {16: (np.float64(0.019849124999950618),\n",
+    "   np.float64(0.0012326430575985117)),\n",
+    "  64: (np.float64(0.022546809499999654), np.float64(0.001692504727864258)),\n",
+    "  256: (np.float64(0.021691686499991647), np.float64(0.00294086495457803)),\n",
+    "  1024: (np.float64(0.022270052500005022), np.float64(0.003807071679929202)),\n",
+    "  4096: (np.float64(0.02085154750000129), np.float64(0.0010313077174266435)),\n",
+    "  16384: (np.float64(0.02093089249996183), np.float64(0.0010492676283390795)),\n",
+    "  65536: (np.float64(0.022014402500019514), np.float64(0.0006802123910234058)),\n",
+    "  262144: (np.float64(0.024796750999996675),\n",
+    "   np.float64(0.0057645733683490815)),\n",
+    "  1048576: (np.float64(0.02190001700000721),\n",
+    "   np.float64(0.0008732466576075845)),\n",
+    "  4194304: (np.float64(0.05879033200005779), np.float64(0.014904883472313363)),\n",
+    "  16777216: (np.float64(0.23404195400001981), np.float64(0.07533314482865239)),\n",
+    "  67108864: (nan, nan),\n",
+    "  268435456: (nan, nan)}}\n",
+    "\n",
+    "cpu_runtimes = {'numpy': {16: (np.float64(9.805700028664432e-05),\n",
+    "   np.float64(0.0002719699903221544)),\n",
+    "  64: (np.float64(8.721999984118156e-05), np.float64(3.582454577267885e-05)),\n",
+    "  256: (np.float64(0.00017828199997893535),\n",
+    "   np.float64(1.2305009703125784e-05)),\n",
+    "  1024: (np.float64(0.00036261100103729405),\n",
+    "   np.float64(2.4494629976772865e-05)),\n",
+    "  4096: (np.float64(0.0006539139994856669), np.float64(0.0008354864099797487)),\n",
+    "  16384: (np.float64(0.002017660999626969), np.float64(0.0005277675716976345)),\n",
+    "  65536: (np.float64(0.007982569000887452), np.float64(0.0007685313919699793)),\n",
+    "  262144: (np.float64(0.03098107999903732),\n",
+    "   np.float64(0.00045184700913424144)),\n",
+    "  1048576: (np.float64(0.12877668900000572), np.float64(0.002616350943173567)),\n",
+    "  4194304: (np.float64(0.719053980001263), np.float64(0.0469158455496374))},\n",
+    " 'jax': {16: (np.float64(0.00023953800155140925),\n",
+    "   np.float64(0.00015563753017088007)),\n",
+    "  64: (np.float64(0.00035316300090926234), np.float64(0.0002318705268616366)),\n",
+    "  256: (np.float64(0.00029555400033132173), np.float64(8.832475279764218e-05)),\n",
+    "  1024: (np.float64(0.0004884099998889724),\n",
+    "   np.float64(0.00024645926639514133)),\n",
+    "  4096: (np.float64(0.0004465590009203879),\n",
+    "   np.float64(0.00019698850450255553)),\n",
+    "  16384: (np.float64(0.0005183960001886589),\n",
+    "   np.float64(0.00025487691910374257)),\n",
+    "  65536: (np.float64(0.00037294600042514503),\n",
+    "   np.float64(0.0008727913545748731)),\n",
+    "  262144: (np.float64(0.0033758919998945203),\n",
+    "   np.float64(0.002688101382975047)),\n",
+    "  1048576: (np.float64(0.019741617999898153),\n",
+    "   np.float64(0.010757652737059507)),\n",
+    "  4194304: (np.float64(0.10961731399947894), np.float64(0.05839073400005447))},\n",
+    " 'tpu_jax': {16: (np.float64(0.0001429589999588643),\n",
+    "   np.float64(3.5459720815065046e-05)),\n",
+    "  64: (np.float64(0.00017167299995435314), np.float64(4.2662062404195546e-05)),\n",
+    "  256: (np.float64(0.00014238400001431728),\n",
+    "   np.float64(2.8613417994725626e-05)),\n",
+    "  1024: (np.float64(0.00016977199993561953),\n",
+    "   np.float64(0.0002816987455046532)),\n",
+    "  4096: (np.float64(0.00015566100000796723),\n",
+    "   np.float64(4.2144860721421086e-05)),\n",
+    "  16384: (np.float64(0.00015526099991802766),\n",
+    "   np.float64(3.326513666243062e-05)),\n",
+    "  65536: (np.float64(0.00011258099993938231),\n",
+    "   np.float64(5.987320498690532e-05)),\n",
+    "  262144: (np.float64(0.00011269100002664345),\n",
+    "   np.float64(3.9259844590263475e-05)),\n",
+    "  1048576: (np.float64(0.00012115300000914431),\n",
+    "   np.float64(4.568541504776411e-05)),\n",
+    "  4194304: (np.float64(0.00013279199993121438),\n",
+    "   np.float64(3.920358955286624e-05)),\n",
+    "  16777216: (np.float64(0.00012158700008058076),\n",
+    "   np.float64(2.9125096906138658e-05)),\n",
+    "  67108864: (np.float64(0.0002409089998991476), np.float64(2.604900528570504)),\n",
+    "  268435456: (nan, nan)}}\n",
+    "\n"
+   ],
+   "id": "7b1a6e9fd3a1955d",
+   "outputs": [],
+   "execution_count": 24
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "",
+   "id": "59d0660f82642a3"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{pywavelet-0.2.6 → pywavelet-0.2.7}/src/pywavelet/_version.py

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

pywavelet-0.2.7/src/pywavelet/backend.py

@@ -0,0 +1,101 @@
+import importlib
+import os
+from rich.table import Table, Text
+from rich.console import Console
+
+
+
+from .logger import logger
+
+JAX = "jax"
+CUPY = "cupy"
+NUMPY = "numpy"
+
+
+def cuda_is_available() -> bool:
+    """Check if CUDA is available."""
+    # Check if CuPy is available and CUDA is accessible
+    cupy_available = importlib.util.find_spec("cupy") is not None
+    if cupy_available:
+        import cupy
+
+        try:
+            cupy.cuda.runtime.getDeviceCount()  # Check if any CUDA device is available
+            cuda_available = True
+        except cupy.cuda.runtime.CUDARuntimeError:
+            cuda_available = False
+    else:
+        cuda_available = False
+    return cuda_available
+
+
+def jax_is_available() -> bool:
+    """Check if JAX is available."""
+    return importlib.util.find_spec(JAX) is not None
+
+
+def get_available_backends_table():
+    """Print the available backends as a rich table."""
+
+    jax_avail = jax_is_available()
+    cupy_avail = cuda_is_available()
+    table = Table("Backend", "Available", title="Available backends")
+    true_check = "[green]✓[/green]"
+    false_check = "[red]✗[/red]"
+    table.add_row(JAX, true_check if jax_avail else false_check)
+    table.add_row(CUPY, true_check if cupy_avail else false_check)
+    table.add_row(NUMPY, true_check)
+    console = Console(width=150)
+    with console.capture() as capture:
+        console.print(table)
+    return Text.from_ansi(capture.get())
+
+
+def get_backend_from_env():
+    """Select and return the appropriate backend module."""
+    backend = os.getenv("PYWAVELET_BACKEND", NUMPY).lower()
+
+    if backend == JAX and jax_is_available():
+
+        import jax.numpy as xp
+        from jax.numpy.fft import fft, ifft, irfft, rfft, rfftfreq
+        from jax.scipy.special import betainc
+
+        logger.info("Using JAX backend")
+
+    elif backend == CUPY and cuda_is_available():
+
+        import cupy as xp
+        from cupy.fft import fft, ifft, irfft, rfft, rfftfreq
+        from cupyx.scipy.special import betainc
+
+        logger.info("Using CuPy backend")
+
+    elif backend == NUMPY:
+        import numpy as xp
+        from numpy.fft import fft, ifft, irfft, rfft, rfftfreq
+        from scipy.special import betainc
+
+        logger.info("Using NumPy backend")
+
+
+    else:
+        logger.error(
+            f"Backend {backend} is not available. "
+        )
+        print(get_available_backends_table())
+        logger.warning(
+            f"Setting backend to NumPy. "
+        )
+        os.environ["PYWAVELET_BACKEND"] = NUMPY
+        return get_backend_from_env()
+
+    return xp, fft, ifft, irfft, rfft, rfftfreq, betainc, backend
+
+
+cuda_available = cuda_is_available()
+
+# Get the chosen backend
+xp, fft, ifft, irfft, rfft, rfftfreq, betainc, current_backend = (
+    get_backend_from_env()
+)

{pywavelet-0.2.6 → pywavelet-0.2.7}/src/pywavelet/transforms/__init__.py

@@ -1,5 +1,11 @@
+from ..logger import logger
+
 from ..backend import current_backend
 
+
+logger.debug(f"Using {current_backend} backend")
+
+
 if current_backend == "jax":
     from .jax import (
         from_freq_to_wavelet,

pywavelet-0.2.7/src/pywavelet/transforms/jax/__init__.py

@@ -0,0 +1,36 @@
+from ...logger import logger
+from .forward import from_freq_to_wavelet, from_time_to_wavelet
+from .inverse import from_wavelet_to_freq, from_wavelet_to_time
+
+logger.warning("JAX SUBPACKAGE NOT FULLY TESTED")
+
+
+def _log_jax_info():
+    """Log JAX backend and precision information.
+
+    backend : str
+        JAX backend. ["cpu", "gpu", "tpu"]
+    precision : str
+        JAX precision. ["32bit", "64bit"]
+    """
+    import jax
+
+    _backend = jax.default_backend()
+    _precision = "64bit" if jax.config.jax_enable_x64 else "32bit"
+
+    logger.info(f"Jax running on {_backend} [{_precision} precision].")
+    if _precision == "32bit":
+        logger.warning(
+            "Jax is not running in 64bit precision. "
+            "To change, use jax.config.update('jax_enable_x64', True)."
+        )
+
+
+_log_jax_info()
+
+__all__ = [
+    "from_wavelet_to_time",
+    "from_wavelet_to_freq",
+    "from_time_to_wavelet",
+    "from_freq_to_wavelet",
+]

{pywavelet-0.2.6 → pywavelet-0.2.7}/src/pywavelet.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pywavelet
-Version: 0.2.6
+Version: 0.2.7
 Summary: WDM wavelet transform your time/freq series!
 Author-email: Pywavelet Team <avi.vajpeyi@gmail.com>
 Project-URL: Homepage, https://pywavelet.github.io/pywavelet/

{pywavelet-0.2.6 → pywavelet-0.2.7}/src/pywavelet.egg-info/SOURCES.txt

@@ -81,6 +81,5 @@ tests/test_data/roundtrip_sine_freq.npz
 tests/test_data/roundtrip_sine_time.npz
 tests/utils/__init__.py
 tests/utils/conversions.py
-tests/utils/cupy_check.py
 tests/utils/generate_data.py
 tests/utils/plotting.py

pywavelet-0.2.7/tests/test_backends.py

@@ -0,0 +1,42 @@
+import importlib
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pytest
+from utils import cuda_available
+
+from pywavelet import set_backend
+from pywavelet.transforms import from_freq_to_wavelet
+from pywavelet.types import FrequencySeries, TimeSeries
+from pywavelet.utils import compute_snr, evolutionary_psd_from_stationary_psd
+
+
+
+@pytest.mark.parametrize("backend", ["jax", "cupy", "numpy"])
+def test_backend_loader(backend):
+
+    if backend == "cupy" and not cuda_available:
+        pytest.skip("CUDA is not available")
+    set_backend(backend)
+    from pywavelet.backend import current_backend, xp
+
+    assert current_backend == backend
+
+    set_backend("numpy")
+
+def test_backend_fails_gracefully_if_no_cupy():
+    if cuda_available:
+        pytest.skip("CUDA is available")
+
+    set_backend('cupy')
+    from pywavelet.backend import current_backend
+
+    assert current_backend == 'numpy'
+
+
+def test_backed_logger():
+    from pywavelet.backend import get_available_backends_table
+    print(get_available_backends_table())
+
+