blosc2 4.4.2__tar.gz → 4.4.3__tar.gz

blosc2-4.4.3/ANNOUNCE.rst

@@ -0,0 +1,105 @@
+Announcing Python-Blosc2 4.4.3
+==============================
+
+We are happy to announce this maintenance release that makes CTable
+cold-start, printing, querying and groupby noticeably faster, trims the
+memory footprint of ``import blosc2``, adds raw-storage access for columns,
+and exposes the new JPEG 2000 codec plugins.
+
+The main highlights are:
+
+- **Faster CTable cold-start**: views created by ``select()`` now open
+  columns lazily — only the columns actually read are loaded from storage —
+  and queries only open the SUMMARY indexes referenced by the predicate,
+  instead of every indexed column on a wide persistent table.
+
+- **Faster printing and groupby**: table rendering now performs a single
+  combined sparse read per column (instead of ~6), and groupby takes the
+  dense fast path for float key columns whose values are integral and fit a
+  compact non-negative range.
+
+- **Lighter imports**: the on-disk chunk prefetcher no longer uses asyncio,
+  so ``import blosc2`` skips ~30 asyncio modules and saves ~3 MB of memory.
+  A latent prefetcher deadlock on early iterator close was fixed as well.
+
+- **New ``Column.raw`` accessor**: the underlying storage container
+  (``NDArray``, ``ListArray``, …) as a blosc2-native compressed object —
+  unlike ``col[...]`` reads, which always materialize NumPy arrays.  Useful
+  as a lazy-expression operand and for storage introspection.
+
+- **J2K and HTJ2K codecs**: ``blosc2.Codec.J2K`` and ``blosc2.Codec.HTJ2K``
+  expose the IDs for the new JPEG 2000 plugins (``pip install blosc2-j2k``
+  / ``pip install blosc2-htj2k``).  Also, C-Blosc2 has been updated to 3.1.3.
+
+- **Fixes**: ``--float-trunc-prec`` in the ``parquet_to_blosc2`` CLI now
+  propagates to nested columns; unsupported computed-column expressions are
+  rejected early with an actionable error; and opening a ``.b2z``/``.b2d``
+  store in read mode no longer creates a temporary directory.
+
+A quick example of the new ``Column.raw`` accessor::
+
+    import blosc2
+    import dataclasses
+
+    @dataclasses.dataclass
+    class Row:
+        price: float = blosc2.field(blosc2.float64())
+        qty:   int   = blosc2.field(blosc2.int64())
+
+    t = blosc2.CTable(Row, new_data=[(1.5, 10), (2.0, 5), (3.0, 3)])
+
+    # The raw storage container, as a blosc2-native compressed object.
+    # It is over-allocated to chunk capacity, so slice to the live row count.
+    raw = t["price"].raw      # a blosc2.NDArray
+    print(raw[:len(t)])         # [1.5 2.  3. ]
+
+    # Usable directly as a lazy-expression operand, without decompressing
+    expr = raw * 2.0
+    print(expr[:len(t)])        # [3. 4. 6.]
+
+Install it with::
+
+    pip install blosc2 --upgrade   # if you prefer wheels
+    conda install -c conda-forge python-blosc2 mkl  # if you prefer conda and MKL
+
+For more info, see the release notes at:
+
+https://github.com/Blosc/python-blosc2/releases
+
+What is Python-Blosc2?
+----------------------
+
+Python-Blosc2 is a high-performance compressor, compute engine, and format
+for binary data containers that are portable and open-source. It comes with
+a lazy expression engine allowing for complex calculations on compressed data,
+whether stored in memory, on disk, or over the network (e.g., via
+`Caterva2 <https://github.com/ironArray/Caterva2>`_).  It is especially
+optimized for storing and retrieving data from N-dimensional arrays (`NDArray`),
+columnar tables (`CTable`), and a query/indexing layer.  The main use case is
+fast, compressed, out-of-core numerical data — especially when data is too
+large to fit comfortably in RAM.
+
+More info: https://www.blosc.org/python-blosc2/getting_started/overview.html
+
+
+Sources repository
+------------------
+
+The sources and documentation are managed through GitHub services at:
+
+https://github.com/Blosc/python-blosc2
+
+Python-Blosc2 is distributed using the BSD license, see
+https://github.com/Blosc/python-blosc2/blob/main/LICENSE.txt
+for details.
+
+Mastodon feed
+-------------
+
+Follow https://fosstodon.org/@Blosc2 to get informed about the latest
+developments.
+
+Enjoy!
+
+- Blosc Development Team
+  Compress Better, Compute Bigger

{blosc2-4.4.2 → blosc2-4.4.3}/CMakeLists.txt

@@ -15,7 +15,7 @@ endif()
 project(python-blosc2)
 
 set(BLOSC2_MIN_VERSION 3.0.0)
-set(BLOSC2_BUNDLED_VERSION v3.1.2)
+set(BLOSC2_BUNDLED_VERSION v3.1.3)
 
 if(WIN32 AND NOT CMAKE_C_COMPILER_ID STREQUAL "Clang")
     message(FATAL_ERROR "Windows builds require clang-cl. Set CC/CXX to clang-cl or configure CMake with -T ClangCL.")

{blosc2-4.4.2 → blosc2-4.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blosc2
-Version: 4.4.2
+Version: 4.4.3
 Summary: A fast & compressed ndarray library with a flexible compute engine.
 Author-Email: Blosc Development Team <blosc@blosc.org>
 Maintainer-Email: Blosc Development Team <blosc@blosc.org>

{blosc2-4.4.2 → blosc2-4.4.3}/RELEASE_NOTES.md

@@ -1,5 +1,76 @@
 # Release notes
 
+## Changes from 4.4.2 to 4.4.3
+
+This is a maintenance release focused on faster CTable cold-start, printing
+and groupby performance, a lighter `import blosc2`, new raw-storage access
+for columns, and support for the new J2K/HTJ2K codec plugins.
+
+### CTable performance
+
+- **Lazy column opening in views**: `select()` (and other view-producing
+  operations) no longer open every projected column up front.  A column is
+  only opened from storage when the view actually reads it, so selecting and
+  then touching a subset of columns — or aggregating a single one — skips
+  the cold-start cost of the rest.
+- **Lazy index opening in queries**: query planning no longer opens every
+  SUMMARY-indexed column on a wide persistent table; only indexes for
+  columns actually referenced by the predicate are loaded.
+- **Faster table printing**: `repr()`/`to_string()` now memoise per-column
+  sparse gathers for the duration of a render and combine the head and tail
+  rows into a single sparse read per column.  Each column is read from
+  storage once instead of ~6 times (precision detection, width sizing and
+  row rendering all hit the cache).
+- **Groupby with integral float keys**: float key columns whose values are
+  integral and fit a compact non-negative range (e.g. float32 id/second
+  columns) now take the dense single-key fast path instead of the markedly
+  slower generic float-hash path.  Fractional or non-finite keys fall back
+  automatically.
+- **No tempdir in read mode**: opening a `.b2z`/`.b2d` store in `'r'` mode
+  no longer creates a temporary working directory, since nothing is ever
+  written.
+
+### Lighter imports and prefetcher rework
+
+- **asyncio dependency dropped**: the on-disk chunk prefetcher used by the
+  UDF and numexpr fallback engines now uses plain `concurrent.futures`
+  instead of an asyncio event loop.  `import blosc2` no longer pulls in
+  ~30 asyncio modules, saving ~3 MB of memory footprint at import time.
+- **Prefetcher deadlock fixed**: an exception during evaluation could leave
+  the generator finalizer blocked forever in `thread.join()` while the
+  reader thread was stuck on a full prefetch queue.  A stop event now makes
+  the producer bail out when its consumer goes away.
+
+### New features
+
+- **`Column.raw` accessor**: returns the underlying storage container of a
+  column (`NDArray`, `ListArray`, `DictionaryColumn`, …) directly.  Unlike
+  `Column.__getitem__`, which always materializes NumPy arrays, this is the
+  column as a blosc2-native compressed object — usable as a lazy-expression
+  operand without decompressing, and exposing storage details like `schunk`,
+  `chunks` or `cparams`.  Note that this is a *physical* view: fixed-width
+  containers are over-allocated to chunk capacity, so slice to `len(table)`
+  to get just the live rows, and no validity-mask or null-sentinel
+  processing is applied.  Raises `AttributeError` for computed columns,
+  which have no backing storage.
+- **J2K and HTJ2K codec IDs**: `blosc2.Codec.J2K` and `blosc2.Codec.HTJ2K`
+  expose the IDs for the new JPEG 2000 codec plugins (installable with
+  `pip install blosc2-j2k` and `pip install blosc2-htj2k`).
+
+### Fixes
+
+- **`--float-trunc-prec` and nested columns**: the precision-truncation
+  filter of the `parquet_to_blosc2` CLI now propagates to float fields
+  inside nested (struct/list) columns too.
+- **Guard for unsupported computed-column expressions**: expressions that
+  would serialize to an empty or non-round-trippable string are now rejected
+  with an early, actionable `ValueError` at `add_computed_column()` time,
+  instead of silently breaking on reload.
+
+### Build
+
+- **C-Blosc2 updated to 3.1.3.**
+
 ## Changes from 4.4.1 to 4.4.2
 
 This is a feature and maintenance release that promotes DSL kernels to

{blosc2-4.4.2 → blosc2-4.4.3}/doc/python-blosc2.rst

@@ -6,7 +6,7 @@
 
     <p style="text-align: center; color: black; background-color: rgba(230, 169, 9, 0.65);">
         <a href="https://github.com/Blosc/python-blosc2/blob/main/RELEASE_NOTES.md"
-           style="font-size: 1.5em;">Version 4.4.1 released on 2026-06-03!</a>
+           style="font-size: 1.5em;">Version 4.4.2 released on 2026-06-04!</a>
         <span style="display: inline-block; width: 20px;"></span>
         <span style="font-family: monospace;">pip install blosc2 -U</span>
     </p>

{blosc2-4.4.2 → blosc2-4.4.3}/doc/reference/ctable.rst

@@ -565,11 +565,13 @@ Data access
 .. autosummary::
 
     Column.view
+    Column.raw
     Column.take
     Column.iter_chunks
     Column.assign
 
 .. autoproperty:: Column.view
+.. autoproperty:: Column.raw
 .. automethod:: Column.take
 .. automethod:: Column.iter_chunks
 .. automethod:: Column.assign

{blosc2-4.4.2 → blosc2-4.4.3}/pyproject.toml

@@ -40,7 +40,7 @@ dependencies = [
     "requests",
     "threadpoolctl; platform_machine != 'wasm32'",
 ]
-version = "4.4.2"
+version = "4.4.3"
 [project.entry-points."array_api"]
 blosc2 = "blosc2"
 

{blosc2-4.4.2 → blosc2-4.4.3}/src/blosc2/__init__.py

@@ -125,6 +125,10 @@ class Codec(Enum):
     GROK = 37
     #: Needs to be installed with ``pip install blosc2-openzl``
     OPENZL = 38
+    #: Needs to be installed with ``pip install blosc2-j2k``
+    J2K = 39
+    #: Needs to be installed with ``pip install blosc2-htj2k``
+    HTJ2K = 40
 
 
 class Filter(Enum):

{blosc2-4.4.2 → blosc2-4.4.3}/src/blosc2/cli/parquet_to_blosc2.py

@@ -1101,6 +1101,8 @@ def import_unnamed_root_separate_cols(  # noqa: C901
     """
 
     inner_schema = blosc2.CTable._inner_schema_for_unnamed_root(pa, parquet_schema)
+    flat_inner_schema = blosc2.CTable._flatten_arrow_struct_schema(pa, inner_schema)
+    float_trunc_column_cparams = build_float_trunc_column_cparams(pa, flat_inner_schema, args)
     total_parquet_rows = pf.metadata.num_rows if pf.metadata is not None else None
 
     # ------------------------------------------------------------------
@@ -1187,6 +1189,13 @@ def import_unnamed_root_separate_cols(  # noqa: C901
         print(f"Chunks:                {args.chunks:,}")
     if args.blocks is not None:
         print(f"Blocks:                {args.blocks:,}")
+    trunc_global = getattr(args, "float_trunc_prec_global", None)
+    trunc_columns = getattr(args, "float_trunc_prec_columns", {})
+    if trunc_global is not None:
+        print(f"Float trunc precision: {trunc_global} bits (all float columns)")
+    if trunc_columns:
+        formatted = ", ".join(f"{name}={bits}" for name, bits in sorted(trunc_columns.items()))
+        print(f"Float trunc columns:   {formatted}")
     print()
 
     cparams = blosc2.CParams(codec=blosc2.Codec[args.codec], clevel=args.clevel, use_dict=args.use_dict)
@@ -1204,6 +1213,7 @@ def import_unnamed_root_separate_cols(  # noqa: C901
         blosc2_batch_size=args.blosc2_batch_size,
         blosc2_items_per_block=args.blosc2_items_per_block,
         list_serializer=args.list_serializer,
+        column_cparams=float_trunc_column_cparams or None,
         create_summary_index=args.create_summary_index,
         chunks=args.chunks,
         blocks=args.blocks,

{blosc2-4.4.2 → blosc2-4.4.3}/src/blosc2/ctable.py

@@ -818,6 +818,34 @@ class Column:
         col = self._table._schema.columns_by_name.get(self._col_name)
         return col is not None and isinstance(col.spec, NDArraySpec)
 
+    @property
+    def raw(self):
+        """The underlying storage container for this column, without null-value processing.
+
+        Returns the raw :class:`blosc2.NDArray`, :class:`~blosc2.ListArray`,
+        :class:`~blosc2.DictionaryColumn`, or scalar varlen array directly.
+        Unlike :meth:`__getitem__`, which always materializes NumPy arrays,
+        this is the column as a blosc2-native compressed object: usable as a
+        lazy-expression operand without decompressing, and exposing storage
+        details such as ``schunk``, ``chunks``, ``cparams`` or
+        ``iterchunks_info()``.
+
+        This is a physical view of the column: fixed-width containers are
+        over-allocated to chunk capacity for appends, so their first axis is
+        longer than ``len(column)`` and positions of rows deleted from the
+        table still hold their old values.  No validity-mask or null-sentinel
+        processing is applied; use the :class:`Column` interface for logical
+        reads.
+
+        Raises :exc:`AttributeError` for computed (virtual) columns, which have
+        no backing storage.
+        """
+        if self.is_computed:
+            raise AttributeError(
+                f"Column {self._col_name!r} is a computed column and has no underlying array"
+            )
+        return self._raw_col
+
     @property
     def _valid_rows(self):
         if self._mask is None:
@@ -2711,18 +2739,34 @@ class _LazyColumnDict(dict):
     the column payloads.
     """
 
-    def __init__(self, table: CTable, storage: TableStorage, col_names: list[str]):
+    def __init__(
+        self,
+        table: CTable,
+        storage: TableStorage,
+        col_names: list[str],
+        *,
+        source_cols: dict | None = None,
+    ):
         super().__init__()
         self._table = table
         self._storage = storage
         self._col_names = list(col_names)
         self._available = set(col_names)
+        # When set, columns are projected lazily from another table's ``_cols``
+        # mapping (e.g. a ``select()`` view) instead of opened from storage.
+        # The source mapping itself opens on demand, so the same NDArray object
+        # is shared (no copy) — identical to eager projection, just deferred.
+        self._source_cols = source_cols
 
     def _load(self, name: str):
         if name not in self._available:
             raise KeyError(name)
         if not dict.__contains__(self, name):
-            dict.__setitem__(self, name, self._table._open_column_from_storage(self._storage, name))
+            if self._source_cols is not None:
+                value = self._source_cols[name]
+            else:
+                value = self._table._open_column_from_storage(self._storage, name)
+            dict.__setitem__(self, name, value)
         return dict.__getitem__(self, name)
 
     def _load_all(self) -> None:
@@ -3901,6 +3945,28 @@ class CTable(_CTableIndexingMixin, Generic[RowT]):
             + self._format_display_row(values, widths, col_names, float_precisions)
         )
 
+    def _prewarm_display_cache(self, display_cols: list[str], head_pos, tail_pos) -> None:
+        """Pre-populate the render cache with one combined head+tail gather/col.
+
+        Each storage column is then sparse-read a single time (for head ∪ tail)
+        instead of once per slice; the values are split back so the
+        ``(col, id(head_pos))`` and ``(col, id(tail_pos))`` lookups made by
+        precision detection, width sizing and row rendering all hit the cache.
+        Only pays off when both slices are non-empty.
+        """
+        cache = getattr(self, "_display_fetch_cache", None)
+        if cache is None or len(head_pos) == 0 or len(tail_pos) == 0:
+            return
+        real_cols = [n for n in display_cols if n != "..." and (n in self._cols or n in self._computed_cols)]
+        if not real_cols:
+            return
+        nh = len(head_pos)
+        combined = np.concatenate([head_pos, tail_pos])
+        for name in real_cols:
+            vals = self._fetch_col_at_positions_uncached(name, combined)
+            cache[(name, id(head_pos))] = vals[:nh]
+            cache[(name, id(tail_pos))] = vals[nh:]
+
     def _rows_to_dicts(self, positions, col_names: list[str] | None = None) -> list[dict]:
         if len(positions) == 0:
             return []
@@ -4116,10 +4182,26 @@ class CTable(_CTableIndexingMixin, Generic[RowT]):
         nrows = self._n_rows
         ncols = len(self.col_names)
         head_pos, tail_pos, hidden = self._display_positions()
+        # Memoise per-column sparse gathers for the duration of this render so
+        # the repeated (column, head_pos/tail_pos) lookups across precision,
+        # width and row formatting only touch storage once.  head_pos/tail_pos
+        # stay referenced below, so keying the cache on their id() is safe.
+        self._display_fetch_cache = {}
+        try:
+            return self._to_string_body(display_index, index_name, nrows, ncols, head_pos, tail_pos, hidden)
+        finally:
+            self._display_fetch_cache = None
+
+    def _to_string_body(self, display_index, index_name, nrows, ncols, head_pos, tail_pos, hidden) -> str:
         index_width = self._display_index_width(nrows, hidden, index_name) if display_index else 0
         display_cols, hidden_cols = self._display_columns(
             display_index=display_index, index_width=index_width
         )
+        # Warm the fetch cache with a single combined head+tail gather per column.
+        # head_pos/tail_pos land in different blocks, but folding them into one
+        # sparse read still halves the per-call gather overhead vs reading head
+        # and tail separately (and every downstream consumer hits the cache).
+        self._prewarm_display_cache(display_cols, head_pos, tail_pos)
         fancy = _CTABLE_PRINT_OPTIONS["fancy"]
         float_precisions = {} if fancy else self._compact_float_precisions(display_cols, head_pos, tail_pos)
         widths = (
@@ -5148,8 +5230,12 @@ class CTable(_CTableIndexingMixin, Generic[RowT]):
         obj._summary_indexes_built = True  # views never build indexes
         obj.base = self
 
-        # Stored columns — same NDArray objects, no copy
-        obj._cols = {name: self._cols[name] for name in cols if name in self._cols}
+        # Stored columns — same NDArray objects, no copy.  Project lazily so a
+        # column is only opened when the view actually reads it: selecting then
+        # touching a subset (or aggregating one column) no longer opens every
+        # projected column up front.
+        stored_names = [name for name in cols if name in self._cols]
+        obj._cols = _LazyColumnDict(obj, self._storage, stored_names, source_cols=self._cols)
         obj.col_names = list(cols)
         obj._materialized_cols = {
             name: dict(self._materialized_cols[name]) for name in cols if name in self._materialized_cols
@@ -7844,7 +7930,25 @@ class CTable(_CTableIndexingMixin, Generic[RowT]):
         return re.sub(r"\bo(\d+)\b", _sub, cc["expression"])
 
     def _fetch_col_at_positions(self, name: str, positions: np.ndarray):
-        """Fetch values at *positions* (physical indices) — used for display."""
+        """Fetch values at *positions* (physical indices) — used for display.
+
+        During a single ``to_string()`` call the same ``(column, positions)``
+        pair is requested repeatedly — by float-precision detection, column
+        width sizing and the final row rendering — all sharing the same
+        ``head_pos``/``tail_pos`` arrays.  When ``to_string`` installs a
+        ``_display_fetch_cache`` we memoise the sparse gather (keyed by the
+        positions array identity) so each column is read from storage once
+        instead of ~6 times.
+        """
+        cache = getattr(self, "_display_fetch_cache", None)
+        if cache is None:
+            return self._fetch_col_at_positions_uncached(name, positions)
+        key = (name, id(positions))
+        if key not in cache:
+            cache[key] = self._fetch_col_at_positions_uncached(name, positions)
+        return cache[key]
+
+    def _fetch_col_at_positions_uncached(self, name: str, positions: np.ndarray):
         cc = self._computed_cols.get(name)
         if cc is not None:
             if len(positions) == 0:
@@ -8548,6 +8652,25 @@ class CTable(_CTableIndexingMixin, Generic[RowT]):
                 "jit_backend": obj.kwargs.get("jit_backend"),
             }
         lazy, col_deps = self._normalize_expression_transformer(obj)
+        # Guard: verify the expression string round-trips before storing.
+        # An empty string means the LazyExpr was not fully constructed, and a
+        # malformed string would silently break on reload.  Catching both here
+        # gives an early, actionable error instead of a confusing failure later.
+        expression = lazy.expression
+        if not expression:
+            raise ValueError(
+                "The computed-column expression serializes to an empty string "
+                "and cannot be persisted. Make sure the lambda returns a "
+                "blosc2 expression built from table columns (e.g. cols['x'] * 2)."
+            )
+        try:
+            _ops = {f"o{i}": self._cols[dep] for i, dep in enumerate(col_deps)}
+            blosc2.lazyexpr(expression, _ops)
+        except Exception as exc:
+            raise ValueError(
+                f"The computed-column expression {expression!r} cannot be safely "
+                f"persisted and reloaded: {exc}"
+            ) from exc
         return {"kind": "expression", "lazy": lazy, "col_deps": col_deps}
 
     def _dsl_result_dtype(self, kernel, col_deps, dtype):

{blosc2-4.4.2 → blosc2-4.4.3}/src/blosc2/ctable_indexing.py

@@ -950,9 +950,21 @@ class _CTableIndexingMixin:
         indexed = []
         seen = set()
         indexed_arrays = {}
+        # Any column referenced by *operands* was already opened to build the
+        # predicate expression, so it is present in the column cache.  A still
+        # un-materialized indexed column therefore cannot be an operand: skip it
+        # instead of opening it.  Without this, a predicate on a few columns
+        # would eagerly open *every* indexed column (e.g. all 11 SUMMARY indexes
+        # on a wide persistent table) — a pure cold-start cost.  Falling back to
+        # the old behaviour for non-dict mappings keeps correctness; at worst a
+        # genuinely-unloaded operand would miss the index and full-scan.
+        cache_is_dict = isinstance(root_cols, dict)
         for col_name, descriptor in catalog.items():
-            if col_name in root_cols:
-                indexed_arrays[col_name] = (root_cols[col_name], descriptor)
+            if col_name not in root_cols:
+                continue
+            if cache_is_dict and not dict.__contains__(root_cols, col_name):
+                continue
+            indexed_arrays[col_name] = (root_cols[col_name], descriptor)
 
         for operand in operands.values():
             if not isinstance(operand, blosc2.NDArray):

{blosc2-4.4.2 → blosc2-4.4.3}/src/blosc2/dict_store.py

@@ -164,11 +164,17 @@ class DictStore:
             # Default extensionless new stores to directory-backed layout.
             self.is_zip_store = False
         if self.is_zip_store:
-            if tmpdir is None:
+            if self.mode == "r":
+                # Read mode only needs working_dir as a path namespace for relative↔absolute
+                # key arithmetic.  No files are ever written, so no real directory is needed.
+                self._temp_dir_obj = None
+                self.working_dir = os.path.splitext(os.path.abspath(self.localpath))[0]
+            elif tmpdir is None:
                 b2z_parent = os.path.dirname(os.path.abspath(self.localpath))
                 self._temp_dir_obj = tempfile.TemporaryDirectory(dir=b2z_parent)
                 self.working_dir = self._temp_dir_obj.name
             else:
+                self._temp_dir_obj = None
                 self.working_dir = tmpdir
                 os.makedirs(tmpdir, exist_ok=True)
             self.b2z_path = self.localpath

{blosc2-4.4.2 → blosc2-4.4.3}/src/blosc2/groupby.py

@@ -264,10 +264,13 @@ class CTableGroupBy:
             fast = self._try_execute_cython_float_integral_key_f64_sum(specs)
             if fast is not None:
                 return fast
-            fast = self._try_execute_cython_float_hash(specs)
+            # Dense single-key path also covers integral-valued float keys with a
+            # compact non-negative range (e.g. float32 second/id columns), so try
+            # it before the generic float hash path, which is markedly slower.
+            fast = self._try_execute_dense_single_int_key(specs)
             if fast is not None:
                 return fast
-            fast = self._try_execute_dense_single_int_key(specs)
+            fast = self._try_execute_cython_float_hash(specs)
             if fast is not None:
                 return fast
 
@@ -1033,8 +1036,12 @@ class CTableGroupBy:
         key_info = self.table._schema.columns_by_name[key_name]
         key_is_dict = self.table._is_dictionary_column(key_info)
         key_dtype = np.dtype(np.int32) if key_is_dict else getattr(key_info.spec, "dtype", None)
-        if key_dtype is None or key_dtype.kind not in "biu":
+        if key_dtype is None or key_dtype.kind not in "biuf":
             return None
+        # Float keys are accepted only when their values are integral and fit a
+        # compact non-negative range; per-chunk casting verifies integrality and
+        # bails (falling back to the hash path) on the first fractional value.
+        key_is_integral_float = (not key_is_dict) and key_dtype.kind == "f"
         if any(spec.op in {"min", "max"} and spec.input_col is not None for spec in specs):
             for spec in specs:
                 if spec.op in {"min", "max"} and spec.input_col is not None:
@@ -1107,6 +1114,16 @@ class CTableGroupBy:
             keys = np.asarray(raw_keys[live_mask])
             if keys.dtype.kind == "b":
                 keys = keys.astype(np.int8, copy=False)
+            elif key_is_integral_float:
+                # Non-finite keys (NaN/inf, e.g. a retained NaN group when
+                # dropna=False) and fractional keys both make the dense integer
+                # mapping invalid; defer to the generic/hash fallback.
+                if not np.all(np.isfinite(keys)):
+                    return None
+                keys_int = keys.astype(np.int64)
+                if not np.array_equal(keys_int, keys):
+                    return None
+                keys = keys_int
             if len(keys) == 0:
                 continue
             min_key = int(np.min(keys))
@@ -1159,7 +1176,12 @@ class CTableGroupBy:
         group_codes = np.nonzero(present)[0]
         rows = []
         for code in group_codes:
-            key_value = self.table._cols[key_name].decode(int(code)) if key_is_dict else _python_scalar(code)
+            if key_is_dict:
+                key_value = self.table._cols[key_name].decode(int(code))
+            elif key_is_integral_float:
+                key_value = float(code)
+            else:
+                key_value = _python_scalar(code)
             row = {key_name: key_value}
             for spec in specs:
                 state = states[spec.output_col]