Address Copilot review comments on UDF aggregations (Gap D2)

- _final_rows() was wrapping the UDF's return value in np.asarray()
  before passing it to _python_scalar(). Since _python_scalar() only
  unwraps np.generic (NumPy scalar types), a 0-D ndarray produced by
  that wrapping was left as-is instead of becoming a plain Python/
  NumPy scalar. Pass the UDF result through directly instead.
- _infer_udf_spec() silently inferred float64 from an empty results
  list (e.g. an empty table, or every group all-null so the UDF was
  never called), even though there's nothing to infer from. Now raises
  a clear error pointing at the explicit-dtype escape hatch, matching
  the existing inconsistent-types error.

Added regression tests for both.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: FrancescAlted

src/blosc2/groupby.py

@@ -1800,7 +1800,7 @@ def _final_rows(  # noqa: C901
                     else:
                         group_values = np.concatenate(chunks)
                         try:
-                            result = _python_scalar(np.asarray(spec.udf(group_values)))
+                            result = _python_scalar(spec.udf(group_values))
                         except Exception as exc:
                             raise RuntimeError(
                                 f"UDF aggregation {spec.output_col!r} raised for group "
@@ -1835,6 +1835,16 @@ def _infer_udf_spec(results: list, name: str) -> SchemaSpec:
         another) is caught here with a clear error, rather than surfacing as
         an opaque failure while building the result table.
         """
+        if not results:
+            # No group ever produced a value (e.g. an empty table, or every
+            # group is all-null so the UDF was never called) -- there is
+            # nothing to infer a dtype from.
+            raise ValueError(
+                f"Cannot infer a CTable dtype for UDF aggregation {name!r}: it was never "
+                f"called (empty table, or every group had no non-null values). Pass an "
+                f"explicit dtype in the named-agg tuple, e.g. "
+                f"g.agg({name}=(col, fn, blosc2.float64()))."
+            )
         try:
             arr = np.asarray(results)
         except ValueError as exc:

tests/ctable/test_groupby.py

@@ -906,6 +906,34 @@ def test_agg_udf_unsupported_result_dtype_raises_clear_error():
         g.agg(x=("sales", lambda a: "always-a-string"))
 
 
+def test_agg_udf_never_called_raises_clear_error():
+    # Every group has zero non-null "sales" values, so the UDF is never
+    # called for any of them -- there is nothing to infer a dtype from.
+    t = CTable(SalesRow, new_data=[("Paris", 1, np.nan, 0), ("Rome", 1, np.nan, 0)])
+    g = t.group_by("city")
+
+    with pytest.raises(ValueError, match="it was never called"):
+        g.agg(x=("sales", lambda a: a.max() - a.min()))
+
+
+def test_agg_udf_result_not_wrapped_in_zero_d_array(monkeypatch):
+    # Regression test: the UDF result must reach _python_scalar() directly,
+    # not pre-wrapped in np.asarray() -- a plain Python/NumPy scalar wrapped
+    # in np.asarray() becomes a 0-D ndarray, which _python_scalar() (only
+    # unwraps np.generic) then fails to turn back into a plain scalar.
+    import blosc2.groupby as gb_module
+
+    seen_types = []
+    original = gb_module._python_scalar
+    monkeypatch.setattr(gb_module, "_python_scalar", lambda v: (seen_types.append(type(v)), original(v))[1])
+
+    t = CTable(SalesRow, new_data=[("Paris", 1, 10.0, 0), ("Rome", 1, 20.0, 0)])
+    g = t.group_by("city")
+    g.agg(x=("sales", lambda a: float(a.sum())))
+
+    assert np.ndarray not in seen_types
+
+
 def test_agg_udf_error_names_the_group_key():
     t = CTable(SalesRow, new_data=DATA)
     g = t.group_by("city")