figpack 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

figpack/views/Spectrogram.py

@@ -0,0 +1,223 @@
+"""
+Spectrogram visualization component
+"""
+
+import math
+from typing import Optional
+
+import numpy as np
+import zarr
+
+from ..core.figpack_view import FigpackView
+
+
+class Spectrogram(FigpackView):
+    """
+    A spectrogram visualization component for time-frequency data
+    """
+
+    def __init__(
+        self,
+        *,
+        start_time_sec: float,
+        sampling_frequency_hz: float,
+        frequency_min_hz: float,
+        frequency_delta_hz: float,
+        data: np.ndarray,
+    ):
+        """
+        Initialize a Spectrogram view
+
+        Args:
+            start_time_sec: Starting time in seconds
+            sampling_frequency_hz: Sampling rate in Hz
+            frequency_min_hz: Minimum frequency in Hz
+            frequency_delta_hz: Frequency bin spacing in Hz
+            data: N×M numpy array where N is timepoints and M is frequency bins
+        """
+        assert data.ndim == 2, "Data must be a 2D array (timepoints × frequencies)"
+        assert sampling_frequency_hz > 0, "Sampling frequency must be positive"
+        assert frequency_delta_hz > 0, "Frequency delta must be positive"
+
+        self.start_time_sec = start_time_sec
+        self.sampling_frequency_hz = sampling_frequency_hz
+        self.frequency_min_hz = frequency_min_hz
+        self.frequency_delta_hz = frequency_delta_hz
+        self.data = data.astype(np.float32)  # Ensure float32 for efficiency
+
+        n_timepoints, n_frequencies = data.shape
+        self.n_timepoints = n_timepoints
+        self.n_frequencies = n_frequencies
+
+        # Calculate frequency bins
+        self.frequency_bins = (
+            frequency_min_hz + np.arange(n_frequencies) * frequency_delta_hz
+        )
+
+        # Calculate data range for color scaling
+        self.data_min = float(np.nanmin(data))
+        self.data_max = float(np.nanmax(data))
+
+        # Prepare downsampled arrays for efficient rendering
+        self.downsampled_data = self._compute_downsampled_data()
+
+    def _compute_downsampled_data(self) -> dict:
+        """
+        Compute downsampled arrays at power-of-4 factors using max values only.
+
+        Returns:
+            dict: {factor: (ceil(N/factor), M) float32 array}, where each bin
+                contains the maximum value across the time dimension.
+        """
+        data = self.data  # (N, M), float32
+        n_timepoints, n_frequencies = data.shape
+        downsampled = {}
+
+        if n_timepoints < 4:
+            # No level with factor >= 4 fits the stop condition (factor < N)
+            return downsampled
+
+        def _first_level_from_raw(x: np.ndarray) -> np.ndarray:
+            """Build the factor=4 level directly from the raw data."""
+            N, M = x.shape
+            n_bins = math.ceil(N / 4)
+            pad = n_bins * 4 - N
+            # Pad time axis with NaNs so max ignores the padded tail
+            x_pad = np.pad(
+                x, ((0, pad), (0, 0)), mode="constant", constant_values=np.nan
+            )
+            blk = x_pad.reshape(n_bins, 4, M)  # (B, 4, M)
+            maxs = np.nanmax(blk, axis=1)  # (B, M)
+            return maxs.astype(np.float32)
+
+        def _downsample4_bins(level_max: np.ndarray) -> np.ndarray:
+            """
+            Build the next pyramid level from the previous one by grouping every 4
+            bins. Input is (B, M) -> Output is (ceil(B/4), M).
+            """
+            B, M = level_max.shape
+            n_bins_next = math.ceil(B / 4)
+            pad = n_bins_next * 4 - B
+            lvl_pad = np.pad(
+                level_max,
+                ((0, pad), (0, 0)),
+                mode="constant",
+                constant_values=np.nan,
+            )
+            blk = lvl_pad.reshape(n_bins_next, 4, M)  # (B', 4, M)
+
+            # Next maxs from maxs
+            maxs = np.nanmax(blk, axis=1)  # (B', M)
+            return maxs.astype(np.float32)
+
+        # Level 1: factor = 4 from raw data
+        factor = 4
+        level = _first_level_from_raw(data)
+        downsampled[factor] = level
+
+        # Higher levels: factor *= 4 each time, built from previous level
+        factor *= 4  # -> 16
+        while factor < n_timepoints / 1000:
+            level = _downsample4_bins(level)
+            downsampled[factor] = level
+            factor *= 4
+
+        return downsampled
+
+    def _calculate_optimal_chunk_size(
+        self, shape: tuple, target_size_mb: float = 5.0
+    ) -> tuple:
+        """
+        Calculate optimal chunk size for Zarr storage targeting ~5MB per chunk
+
+        Args:
+            shape: Array shape (n_timepoints, n_frequencies)
+            target_size_mb: Target chunk size in MB
+
+        Returns:
+            Tuple of chunk dimensions
+        """
+        # Calculate bytes per element (float32 = 4 bytes)
+        bytes_per_element = 4
+        target_size_bytes = target_size_mb * 1024 * 1024
+
+        n_timepoints, n_frequencies = shape
+        elements_per_timepoint = n_frequencies
+
+        # Calculate chunk size in timepoints
+        max_timepoints_per_chunk = target_size_bytes // (
+            elements_per_timepoint * bytes_per_element
+        )
+
+        # Find next lower power of 2
+        chunk_timepoints = 2 ** math.floor(math.log2(max_timepoints_per_chunk))
+        chunk_timepoints = max(chunk_timepoints, 1)  # At least 1
+        chunk_timepoints = min(chunk_timepoints, n_timepoints)  # At most n_timepoints
+
+        # If n_timepoints is less than our calculated size, round down to next power of 2
+        if chunk_timepoints > n_timepoints:
+            chunk_timepoints = 2 ** math.floor(math.log2(n_timepoints))
+
+        return (chunk_timepoints, n_frequencies)
+
+    def _write_to_zarr_group(self, group: zarr.Group) -> None:
+        """
+        Write the spectrogram data to a Zarr group
+
+        Args:
+            group: Zarr group to write data into
+        """
+        group.attrs["view_type"] = "Spectrogram"
+
+        # Store metadata
+        group.attrs["start_time_sec"] = self.start_time_sec
+        group.attrs["sampling_frequency_hz"] = self.sampling_frequency_hz
+        group.attrs["frequency_min_hz"] = self.frequency_min_hz
+        group.attrs["frequency_delta_hz"] = self.frequency_delta_hz
+        group.attrs["n_timepoints"] = self.n_timepoints
+        group.attrs["n_frequencies"] = self.n_frequencies
+        group.attrs["data_min"] = self.data_min
+        group.attrs["data_max"] = self.data_max
+
+        # Store frequency bins
+        group.create_dataset(
+            "frequency_bins",
+            data=self.frequency_bins.astype(np.float32),
+            compression="blosc",
+            compression_opts={"cname": "lz4", "clevel": 5, "shuffle": 1},
+        )
+
+        # Store original data with optimal chunking
+        original_chunks = self._calculate_optimal_chunk_size(self.data.shape)
+        group.create_dataset(
+            "data",
+            data=self.data,
+            chunks=original_chunks,
+            compression="blosc",
+            compression_opts={"cname": "lz4", "clevel": 5, "shuffle": 1},
+        )
+
+        # Store downsampled data arrays
+        downsample_factors = list(self.downsampled_data.keys())
+        group.attrs["downsample_factors"] = downsample_factors
+
+        for factor, downsampled_array in self.downsampled_data.items():
+            dataset_name = f"data_ds_{factor}"
+
+            # Calculate optimal chunks for this downsampled array
+            ds_chunks = self._calculate_optimal_chunk_size(downsampled_array.shape)
+
+            group.create_dataset(
+                dataset_name,
+                data=downsampled_array,
+                chunks=ds_chunks,
+                compression="blosc",
+                compression_opts={"cname": "lz4", "clevel": 5, "shuffle": 1},
+            )
+
+        print(f"Stored Spectrogram with {len(downsample_factors)} downsampled levels:")
+        print(f"  Original: {self.data.shape} (chunks: {original_chunks})")
+        for factor in downsample_factors:
+            ds_shape = self.downsampled_data[factor].shape
+            ds_chunks = self._calculate_optimal_chunk_size(ds_shape)
+            print(f"  Factor {factor}: {ds_shape} (chunks: {ds_chunks})")

figpack/views/__init__.py

@@ -1,4 +1,5 @@
 from .Box import Box
+from .DataFrame import DataFrame
 from .Gallery import Gallery
 from .GalleryItem import GalleryItem
 from .Image import Image
@@ -7,6 +8,7 @@ from .Markdown import Markdown
 from .MatplotlibFigure import MatplotlibFigure
 from .MultiChannelTimeseries import MultiChannelTimeseries
 from .PlotlyFigure import PlotlyFigure
+from .Spectrogram import Spectrogram
 from .Splitter import Splitter
 from .TabLayout import TabLayout
 from .TabLayoutItem import TabLayoutItem

{figpack-0.2.6.dist-info → figpack-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: figpack
-Version: 0.2.6
+Version: 0.2.8
 Summary: A Python package for creating shareable, interactive visualizations in the browser
 Author-email: Jeremy Magland <jmagland@flatironinstitute.org>
 License: Apache-2.0
@@ -36,6 +36,7 @@ Requires-Dist: spikeinterface; extra == "test"
 Requires-Dist: matplotlib; extra == "test"
 Requires-Dist: plotly; extra == "test"
 Requires-Dist: Pillow; extra == "test"
+Requires-Dist: pandas; extra == "test"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"

{figpack-0.2.6.dist-info → figpack-0.2.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-figpack/__init__.py,sha256=0qLJ7E5m_1HlQz2yVbgdZj__rO56AZjWGC3NDzswq7U,181
+figpack/__init__.py,sha256=HxAr8mGrHvxeBsPiVIzWFXNs2g74PFwMyFB8yfQK1u4,181
 figpack/cli.py,sha256=xWF7J2BxUqOLvPu-Kje7Q6oGukTroXsLq8WN8vJgyw0,8321
 figpack/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 figpack/core/_bundle_utils.py,sha256=JBZh2LJyu0oYHQBBVw5fF3uUNQJY_2bxVf6V7CN10FM,1884
@@ -9,9 +9,9 @@ figpack/core/_upload_bundle.py,sha256=54hdWayJJdRZdx7N9V2aH_X33KkR6hImMjN6tkBTLi
 figpack/core/_view_figure.py,sha256=o1x1I2VKFrp2W_TStUS3fQblRW8AvGbu7Uy7MgVjofA,4186
 figpack/core/config.py,sha256=oOR7SlP192vuFhYlS-h14HnG-kd_3gaz0vshXch2RNc,173
 figpack/core/figpack_view.py,sha256=peJFkoP6HIqyNATzyucxAIq9HuCnK7SRO_-gE_rbEvg,6130
-figpack/figpack-figure-dist/index.html,sha256=yRCsTBF07s2OLoSIlkMFUSA5Vp94yR7oh_SX6uXT8d8,486
+figpack/figpack-figure-dist/index.html,sha256=koS5dlEb8lylfHmHnG5pBmXHlMIyK2ICrJ31aw5COmE,486
+figpack/figpack-figure-dist/assets/index-CjiTpC6i.js,sha256=5JLWD3VReahxiEbAB0h61FJCRe4CRZVEzBlX9qUS5m0,1618290
 figpack/figpack-figure-dist/assets/index-Cmae55E4.css,sha256=Yg0apcYehJwQvSQIUH13S7tsfqWQDevpJsAho0dDf0g,5499
-figpack/figpack-figure-dist/assets/index-HXdk2TtM.js,sha256=GhqJkoATKYiprLAbc3V5CYUt-MtKteWLx7KUh1fjA_0,1598198
 figpack/figpack-figure-dist/assets/neurosift-logo-CLsuwLMO.png,sha256=g5m-TwrGh5f6-9rXtWV-znH4B0nHgc__0GWclRDLUHs,9307
 figpack/franklab/__init__.py,sha256=HkehqGImJE_sE2vbPDo-HbgtEYaMICb9-230xTYvRTU,56
 figpack/franklab/views/TrackAnimation.py,sha256=3Jv1Ri4FIwTyqNahinqhHsBH1Bv_iZrEGx12w6diJ2M,5636
@@ -22,9 +22,9 @@ figpack/spike_sorting/views/Autocorrelograms.py,sha256=6MXOYJKUNEhJokiyOs8SGJVF9
 figpack/spike_sorting/views/AverageWaveforms.py,sha256=mvMkS3wf6MpI95tlGqKxBjxZlHqJr4aqG7SZvHigIsI,5193
 figpack/spike_sorting/views/CrossCorrelogramItem.py,sha256=uSd0i2hupteuILi_aKp7bYPYpL_PdC3CUDRMOEKUEM0,880
 figpack/spike_sorting/views/CrossCorrelograms.py,sha256=OGQq_5t_T1zq4eFCpuTAvUIhZQu7ef7LVexKNdByMvo,4415
-figpack/spike_sorting/views/RasterPlot.py,sha256=gFdfH9SEm-tf8Ptqw4M1Q7IHRytUOULpBZfM2TdMfZQ,2215
+figpack/spike_sorting/views/RasterPlot.py,sha256=m8Cg-KioAM3CdIJOecpyTqp71HwhQVDzAk3J4Xb4V-c,9940
 figpack/spike_sorting/views/RasterPlotItem.py,sha256=iW7fuDEjSfvf5YMIwrF_6cmKvD76oCigOUMHtGgBsPI,638
-figpack/spike_sorting/views/SpikeAmplitudes.py,sha256=vQYWdJM-3qu568bcfGDC9k9LW_PgvU8j4tN9QYc08Mo,2665
+figpack/spike_sorting/views/SpikeAmplitudes.py,sha256=UOGxReKs5WwH7iRdR-iVN3Pr6wF3AnIV15veoZZzOco,13433
 figpack/spike_sorting/views/SpikeAmplitudesItem.py,sha256=j5Na-diY-vRUAPu0t0VkyFCSKFnQ_f5HT077mB3Cy8c,1134
 figpack/spike_sorting/views/UnitSimilarityScore.py,sha256=cJA9MkETos9qHhV1tqgA7SfNEaPo-duXYCE76hSFGnA,948
 figpack/spike_sorting/views/UnitsTable.py,sha256=M3y1IDJzSnvOaM1-QOyJOVcUcdTkVvxYhEMGd1kmUzs,2969
@@ -32,6 +32,7 @@ figpack/spike_sorting/views/UnitsTableColumn.py,sha256=zBnuoeILTuiVLDvtcOxqa37E5
 figpack/spike_sorting/views/UnitsTableRow.py,sha256=rEb2hMTA_pl2fTW1nOvnGir0ysfNx4uww3aekZzfWjk,720
 figpack/spike_sorting/views/__init__.py,sha256=iRq7xPmyhnQ3GffnPC0GxKGEWnlqXY_8IOxsMqYZ1IM,967
 figpack/views/Box.py,sha256=TfhPFNtVEq71LCucmWk3XX2WxQLdaeRiWGm5BM0k2l4,2236
+figpack/views/DataFrame.py,sha256=VFP-EM_Wnc1G3uimVVMJe08KKWCAZe7DvmYf5e07uTk,3653
 figpack/views/Gallery.py,sha256=sHlZbaqxcktasmNsJnuxe8WmgUQ6iurG50JiChKSMbQ,3314
 figpack/views/GalleryItem.py,sha256=b_upJno5P3ANSulbG-h3t6Xj56tPGJ7iVxqyiZu3zaQ,1244
 figpack/views/Image.py,sha256=hmyAHlRwj0l6fC7aNmHYJFaj-qCqyH67soERm78V5dk,3953
@@ -40,14 +41,15 @@ figpack/views/Markdown.py,sha256=Dl1UX5s0aC-mEx5m6jIJ839YKMNeeVzIDG-EANVrbys,114
 figpack/views/MatplotlibFigure.py,sha256=YoNtZTItEjatbtNJqATm2H-Oircp5Ca6FZLjHk_B0zg,2778
 figpack/views/MultiChannelTimeseries.py,sha256=sWr2nW1eoYR7V44wF7fac7IoQ6BOnus1nc4STkgIkYw,8501
 figpack/views/PlotlyFigure.py,sha256=E33PEkWSj907Ue73bYfZQlF-JFDdWA8jNrG-buFQLgs,2174
+figpack/views/Spectrogram.py,sha256=czjA1I_T86oNsWwXX_GHFM8WZ5UkP9nT8e8hrgav4iY,8110
 figpack/views/Splitter.py,sha256=x9jLCTlIvDy5p9ymVd0X48KDccyD6bJANhXyFgKEmtE,2007
 figpack/views/TabLayout.py,sha256=5g3nmL95PfqgI0naqZXHMwLVo2ebDlGX01Hy9044bUw,1898
 figpack/views/TabLayoutItem.py,sha256=xmHA0JsW_6naJze4_mQuP_Fy0Nm17p2N7w_AsmVRp8k,880
 figpack/views/TimeseriesGraph.py,sha256=OAaCjO8fo86u_gO_frNfRGxng3tczxGDGKcJEvZo3rE,7469
-figpack/views/__init__.py,sha256=npSsSmbxN7_tZcjCK76L2l9dRVqubVXIgBnxj1uhjf4,473
-figpack-0.2.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-figpack-0.2.6.dist-info/METADATA,sha256=VoUFPcVVhIVIxWp7sExL2kXVONvLYmRHMmXNVIRPqCo,3577
-figpack-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-figpack-0.2.6.dist-info/entry_points.txt,sha256=l6d3siH2LxXa8qJGbjAqpIZtI5AkMSyDeoRDCzdrUto,45
-figpack-0.2.6.dist-info/top_level.txt,sha256=lMKGaC5xWmAYBx9Ac1iMokm42KFnJFjmkP2ldyvOo-c,8
-figpack-0.2.6.dist-info/RECORD,,
+figpack/views/__init__.py,sha256=h9B6RWTOfgizOMqtEu8xGJxtXAhK-XXroN6ebL-Vcr0,543
+figpack-0.2.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+figpack-0.2.8.dist-info/METADATA,sha256=ih-mdvrks4Dxrtx1ieS82NJCAQp9QcqliCeFqWmUhkk,3616
+figpack-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+figpack-0.2.8.dist-info/entry_points.txt,sha256=l6d3siH2LxXa8qJGbjAqpIZtI5AkMSyDeoRDCzdrUto,45
+figpack-0.2.8.dist-info/top_level.txt,sha256=lMKGaC5xWmAYBx9Ac1iMokm42KFnJFjmkP2ldyvOo-c,8
+figpack-0.2.8.dist-info/RECORD,,