uproot 5.7.3__tar.gz → 5.7.4__tar.gz

{uproot-5.7.3 → uproot-5.7.4}/.github/workflows/build-test.yml

@@ -16,7 +16,7 @@ jobs:
       fail-fast: false
       matrix:
         platform: [windows-latest, macos-latest, ubuntu-latest]
-        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
+        python-version: ['3.10', '3.14', 3.14 python-freethreading]
 
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 30
@@ -39,10 +39,14 @@ jobs:
             conda-forge/label/python_rc::_python_rc
             python=${{ matrix.python-version }}
 
-      - uses: astral-sh/setup-uv@v7
+      - name: Set PYTHON_GIL=0 for free-threaded builds
+        if: contains(matrix.python-version, 'python-freethreading')
+        run: echo "PYTHON_GIL=0" >> $GITHUB_ENV
+
+      - uses: astral-sh/setup-uv@v8.1.0
 
       - name: Check active Python version
-        run: python -c "import sys; assert '.'.join(str(s) for s in sys.version_info[:2]) == '${{ matrix.python-version }}', f'{version} incorrect!'"
+        run: python -c "import sys; assert '.'.join(str(s) for s in sys.version_info[:2]) == '${{ matrix.python-version }}'.split()[0], f'{version} incorrect!'"
 
       - name: Install ROOT
         if: matrix.python-version == 3.10  &&  runner.os == 'Linux'
@@ -94,7 +98,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
           allow-prereleases: true
 
-      - uses: astral-sh/setup-uv@v7
+      - uses: astral-sh/setup-uv@v8.1.0
 
       - name: Pip install the package
         run: uv pip install --system -e. --group=dev
@@ -120,7 +124,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - uses: astral-sh/setup-uv@v7
+      - uses: astral-sh/setup-uv@v8.1.0
 
       - name: Pip install the package
         run: |
@@ -148,7 +152,7 @@ jobs:
         with:
           python-version: '3.13'
 
-      - uses: astral-sh/setup-uv@v7
+      - uses: astral-sh/setup-uv@v8.1.0
 
       - name: Install pyodide-build
         run: python3 -m pip install pyodide-build==$PYODIDE_BUILD_VERSION
@@ -162,7 +166,7 @@ jobs:
           echo "emsdk-version=$EMSCRIPTEN_VERSION" >> $GITHUB_OUTPUT
 
       - name: Install EMSDK
-        uses: mymindstorm/setup-emsdk@v14
+        uses: mymindstorm/setup-emsdk@v16
         with:
           version: ${{ steps.compute-emsdk-version.outputs.emsdk-version }}
 
@@ -229,7 +233,6 @@ jobs:
           init-shell: bash
           create-args: >-
             -c rapidsai
-            -c nvidia
             python=3.13
             cuda-version=${{ matrix.cuda-version }}
             cuda-toolkit
@@ -263,9 +266,10 @@ jobs:
 
       - name: Upload test results to Codecov
         if: ${{ !cancelled() && matrix.cuda-version == 13 }}
-        uses: codecov/test-results-action@v1
+        uses: codecov/codecov-action@v6
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
+          report_type: test_results
 
   pass:
     if: always()

{uproot-5.7.3 → uproot-5.7.4}/.github/workflows/upload-nightly-wheels.yml

@@ -33,7 +33,7 @@ jobs:
         run: ls -lha dist/*.whl
 
       - name: Upload wheel to Anaconda Cloud as nightly
-        uses: scientific-python/upload-nightly-action@5748273c71e2d8d3a61f3a11a16421c8954f9ecf # 0.6.3
+        uses: scientific-python/upload-nightly-action@e76cfec8a4611fd02808a801b0ff5a7d7c1b2d99 # 0.6.4
         with:
           artifacts_path: dist
           anaconda_nightly_upload_token: ${{ secrets.ANACONDA_ORG_UPLOAD_TOKEN }}

{uproot-5.7.3 → uproot-5.7.4}/.pre-commit-config.yaml

@@ -19,12 +19,12 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 26.1.0
+    rev: 26.3.1
     hooks:
       - id: black
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.4
+    rev: v0.15.9
     hooks:
       - id: ruff-check
         args: [--fix, --show-fixes]

{uproot-5.7.3 → uproot-5.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uproot
-Version: 5.7.3
+Version: 5.7.4
 Summary: ROOT I/O in pure Python and NumPy.
 Project-URL: Download, https://github.com/scikit-hep/uproot5/releases
 Project-URL: Homepage, https://github.com/scikit-hep/uproot5

{uproot-5.7.3 → uproot-5.7.4}/docs-sphinx/basic.rst

@@ -924,6 +924,8 @@ Reading RNTuples
 
 TTree has been the default format to store large datasets in ROOT files for decades. However, it has slowly become outdated and is not optimized for modern systems. This is where the RNTuple format comes in. It is a modern serialization format that is designed with modern systems in mind and is planned to replace TTree in the coming years. `Version 1.0.0.0 <https://cds.cern.ch/record/2923186>`__ is out and will be supported "forever".
 
+Starting in Uproot v5.7.0, RNTuple is the default format for writing. When you use the dict-like syntax to write data to a file, Uproot will create an RNTuple instead of a TTree.
+
 RNTuples are deliberately simpler than TTrees by design. For the first time, there’s an official specification, making it much easier for third-party I/O tools like Uproot to support it. Uproot already supports reading the full RNTuple specification, meaning that you can read any RNTuple you find in the wild. It also already supports writing a large part of the specification, and intends to support as much as it makes sense for data analysis.
 
 To ease the transition into RNTuples, we are designing the interface to closely match the existing TTree interface. Many of the functionality explained in the previous subsections works in the same way. However, there the terminology is slightly different (e.g. "branch" becomes "field") and arguments may vary slightly, accordingly.
@@ -1145,8 +1147,10 @@ Writing TTrees to a file
 TTrees are a special type of object, just as TDirectories are special: data can be cumulatively added to them.
 
 :doc:`uproot.writing.writable.WritableTree` objects can be created using the :ref:`uproot.writing.writable.WritableDirectory.mktree` method that Uproot provides for TDirectories.
-Previously, they could be created by assigning TTree-like data to a name in a directory (e.g., ``file["tree"] = {"branch": np.arange(1000)}``). However, this syntax was deprecated,
-as Uproot will switch to writing RNTuples with syntax, since the HEP community is moving towards RNTuples.
+
+.. note::
+
+    Starting in v5.7.0, Uproot uses RNTuples as the default format for writing data when using the dict-like assignment syntax (e.g., ``file["my_data"] = {"my_array": np.arange(1000)}``). If you specifically want to write a TTree, you should use the :ref:`uproot.writing.writable.WritableDirectory.mktree` method.
 
 .. code-block:: python
 
@@ -1327,14 +1331,21 @@ Writing RNTuples
 
 Just like with reading, writing RNTuples is similar to writing TTree objects. Since RNTuples are much simpler, we aim to be able to write almost any RNTuple that you might want.
 
-Here is an example of writing an RNTuple. Since TTree is still the default format for the near future, writing an RNTuple is a bit more verbose.
+RNTuples are the default format for writing data starting in Uproot v5.7.0. You can write an RNTuple by using a dict-like syntax:
 
 .. code-block:: python
 
     >>> file = uproot.recreate("example.root")
     >>> data = {"my_int": [1,2], "my_vector": [[1,2], [3,4,5]]}
-    >>> rntuple = file.mkrntuple("my_rntuple", data)
-    >>> rntuple.extend(data) # Can be extended, just like TTrees
+    >>> file["my_rntuple"] = data
+    >>> file["my_rntuple"].extend(data) # Can be extended, just like TTrees
+
+You can also use the :ref:`uproot.writing.writable.WritableDirectory.mkrntuple` method for more explicit RNTuple creation, and to have the ability to initialize an empty RNTuple from a type specification dictionary or an Awkward form.
+
+.. code-block:: python
+
+    >>> file.mkrntuple("ntuple", {"x": "f4", "y": "var * int64"})
+    <WritableNTuple '/ntuple' at 0x000131ff30e0>
 
 Using your own interpretation
 --------------------------------

{uproot-5.7.3 → uproot-5.7.4}/src/uproot/behaviors/TProfile.py

@@ -103,11 +103,11 @@ def _values_errors_1d(error_mode, fBinEntries, root_cont, fSumw2, fNcells, fBinS
 
     root_neff = _effective_counts_1d(fBinEntries, fBinSumw2, fNcells)
 
-    root_eprim2 = numpy.zeros(len(root_cont), dtype=numpy.float64)
-    root_eprim2[nonzero] = abs(
+    root_eprisum_sq_dev = numpy.zeros(len(root_cont), dtype=numpy.float64)
+    root_eprisum_sq_dev[nonzero] = abs(
         root_err2[nonzero] / root_sum[nonzero] - root_contsum[nonzero] ** 2
     )
-    root_eprim = numpy.sqrt(root_eprim2)
+    root_eprim = numpy.sqrt(root_eprisum_sq_dev)
 
     if error_mode == _kERRORSPREADI:
         numer = numpy.ones(len(root_cont), dtype=numpy.float64)
@@ -237,7 +237,7 @@ class TProfile(Profile):
     @property
     def weighted(self):
         fBinSumw2 = self.member("fBinSumw2", none_if_missing=True)
-        return fBinSumw2 is None or len(fBinSumw2) != len(self.member("fNcells"))
+        return fBinSumw2 is not None and len(fBinSumw2) == self.member("fNcells")
 
     def counts(self, flow=True):
         out = _effective_counts_1d(
@@ -298,40 +298,76 @@ class TProfile(Profile):
         boost_histogram = uproot.extras.boost_histogram()
 
         effective_counts = self.counts(flow=True)
-        _, errors = self._values_errors(True, self.member("fErrorMode"))
-        values = self._bases[0]._bases[-1]
-        variances = numpy.square(errors)
-        sum_of_bin_weights = numpy.asarray(self.member("fBinEntries"))
+        sum_of_bin_weights = numpy.asarray(
+            self.member("fBinEntries"), dtype=numpy.float64
+        )
+        raw_values = numpy.asarray(self._bases[0]._bases[-1], dtype=numpy.float64)
+        fSumw2_member = self.member("fSumw2", none_if_missing=True)
+        fNcells = self.member("fNcells")
+
+        # Compute mean = sum(y) / count (ROOT TProfile stores sum(y) in the TArray)
+        nonzero = sum_of_bin_weights != 0
+        mean_values = numpy.zeros(len(raw_values), dtype=numpy.float64)
+        mean_values[nonzero] = raw_values[nonzero] / sum_of_bin_weights[nonzero]
+
+        # Compute sum_sq_dev = sum(y^2) - count * mean^2 directly from fSumw2.
+        # fErrorMode is intentionally ignored here: it controls how ROOT displays
+        # bin errors but does not change the underlying data. boost-hostogram's
+        # storage has a fixed meaning for _sum_of_weighted_deltas_squared,
+        # so we can't change it based on fErrorMode.
+        if fSumw2_member is not None:
+            fSumw2 = numpy.asarray(fSumw2_member, dtype=numpy.float64)
+        else:
+            fSumw2 = numpy.array([], dtype=numpy.float64)
+        if len(fSumw2) == fNcells:
+            sum_sq_dev = numpy.maximum(
+                fSumw2 - sum_of_bin_weights * mean_values**2, 0.0
+            )
+        else:
+            sum_sq_dev = numpy.zeros(len(raw_values), dtype=numpy.float64)
 
-        storage = boost_histogram.storage.WeightedMean()
+        if self.weighted:
+            storage = boost_histogram.storage.WeightedMean()
+        else:
+            storage = boost_histogram.storage.Mean()
 
         xaxis = uproot.behaviors.TH1._boost_axis(self.member("fXaxis"), axis_metadata)
         out = boost_histogram.Histogram(xaxis, storage=storage)
         for k, v in metadata.items():
             setattr(out, k, self.member(v))
 
-        if isinstance(xaxis, boost_histogram.axis.StrCategory):
+        if self.member("fXaxis").member("fLabels") is not None:
+            # ROOT's categorical axes (with fLabels) always have an underflow bin (bin 0).
+            # boost-histogram's Category axes do not have underflow.
+            # We slice off the first ROOT bin (underflow) to align with boost-histogram.
             effective_counts = effective_counts[1:]
-            values = values[1:]
-            variances = variances[1:]
+            mean_values = mean_values[1:]
+            sum_sq_dev = sum_sq_dev[1:]
             sum_of_bin_weights = sum_of_bin_weights[1:]
 
-        out.metadata = {"fSumw2": self.member("fSumw2")}
+        # TODO: This should only be needed for weighted storage, but there seems to be some bug in Uproot's serialization of fBinSumw2
+        # that causes weighted TProfiles to appear unweighted when read back in.
+        out.metadata = {
+            "fEntries": self.member("fEntries"),
+        }
         view = out.view(flow=True)
 
         # https://github.com/root-project/root/blob/ffc7c588ac91aca30e75d356ea971129ee6a836a/hist/hist/src/TProfileHelper.h#L668-L671
-        with numpy.errstate(divide="ignore", invalid="ignore"):
-            sum_of_bin_weights_squared = (sum_of_bin_weights**2) / effective_counts
-
-        # TODO: Drop this when boost-histogram has a way to set using the constructor.
-        # New version should look something like this:
-        # view[...] = np.stack(sum_of_bin_weights, sum_of_bin_weights_squared, values, variances)
-        # Current / classic version:
-        view["sum_of_weights"] = sum_of_bin_weights
-        view["sum_of_weights_squared"] = sum_of_bin_weights_squared
-        view["value"] = values
-        view["_sum_of_weighted_deltas_squared"] = variances * (
-            sum_of_bin_weights - sum_of_bin_weights_squared / sum_of_bin_weights
-        )
+        if self.weighted:
+            with numpy.errstate(divide="ignore", invalid="ignore"):
+                sum_of_bin_weights_squared = (sum_of_bin_weights**2) / effective_counts
+
+            # TODO: Drop this when boost-histogram has a way to set using the constructor.
+            # New version should look something like this:
+            # view[...] = np.stack(sum_of_bin_weights, sum_of_bin_weights_squared, mean_values, sum_sq_dev)
+            # Current / classic version:
+            view["sum_of_weights"] = sum_of_bin_weights
+            view["sum_of_weights_squared"] = sum_of_bin_weights_squared
+            view["value"] = mean_values
+            view["_sum_of_weighted_deltas_squared"] = sum_sq_dev
+        else:
+            view["count"] = sum_of_bin_weights
+            view["value"] = mean_values
+            view["_sum_of_deltas_squared"] = sum_sq_dev
 
         return out

{uproot-5.7.3 → uproot-5.7.4}/src/uproot/reading.py

@@ -646,11 +646,15 @@ in file {file_path}""")
         :ref:`uproot.reading.ReadOnlyFile.object_cache` would still be
         accessible.
         """
-        self._source.close()
+        if hasattr(self, "_source") and hasattr(self._source, "close"):
+            self._source.close()
         if hasattr(self._decompression_executor, "shutdown"):
-            getattr(self._decompression_executor, "shutdown", None)()
+            self._decompression_executor.shutdown()
         if hasattr(self._interpretation_executor, "shutdown"):
-            getattr(self._interpretation_executor, "shutdown", None)()
+            self._interpretation_executor.shutdown()
+
+    def __del__(self):
+        self.close()
 
     @property
     def closed(self):
@@ -674,11 +678,12 @@ in file {file_path}""")
         return self
 
     def __exit__(self, exception_type, exception_value, traceback):
-        self._source.__exit__(exception_type, exception_value, traceback)
+        if hasattr(self, "_source") and hasattr(self._source, "__exit__"):
+            self._source.__exit__(exception_type, exception_value, traceback)
         if hasattr(self._decompression_executor, "shutdown"):
-            getattr(self._decompression_executor, "shutdown", None)()
+            self._decompression_executor.shutdown()
         if hasattr(self._interpretation_executor, "shutdown"):
-            getattr(self._interpretation_executor, "shutdown", None)()
+            self._interpretation_executor.shutdown()
 
     @property
     def source(self):

{uproot-5.7.3 → uproot-5.7.4}/src/uproot/source/fsspec.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import concurrent.futures
+import contextlib
 import queue
 import re
 
@@ -55,20 +56,20 @@ class FSSpecSource(uproot.source.chunk.Source):
 
         file_path = _maybe_wrap_remote_url(file_path)
 
-        fsspec_options = {
+        self._fsspec_options = {
             k: v for k, v in options.items() if k not in uproot.reading.open.defaults
         }
-        self._fs, self._file_path = fsspec.core.url_to_fs(file_path, **fsspec_options)
-
-        # What should we do when there is a chain of filesystems?
-        self._async_impl = self._fs.async_impl
-
+        self._file_path_orig = file_path
         self._open()
 
-        self.__enter__()
-
     def _open(self):
         self._executor = FSSpecLoopExecutor()
+        self._open_file = fsspec.open(self._file_path_orig, **self._fsspec_options)
+        self._fs = self._open_file.fs
+        self._file_path = self._open_file.path
+        self._fo = self._open_file.__enter__()
+        self._async_impl = self._fs.async_impl
+        self._closed = False
 
     def __repr__(self):
         path = repr(self._file_path)
@@ -79,6 +80,9 @@ class FSSpecSource(uproot.source.chunk.Source):
     def __getstate__(self):
         state = dict(self.__dict__)
         state.pop("_executor")
+        state.pop("_open_file")
+        state.pop("_fo")
+        state.pop("_fs")
         return state
 
     def __setstate__(self, state):
@@ -90,6 +94,19 @@ class FSSpecSource(uproot.source.chunk.Source):
 
     def __exit__(self, exception_type, exception_value, traceback):
         self._executor.shutdown()
+        if not self._closed:
+            self._open_file.__exit__(exception_type, exception_value, traceback)
+
+            # Workaround for leaking fsspec filesystems (like ZipFileSystem/TarFileSystem)
+            # that don't correctly close their underlying file objects.
+            if hasattr(self._fs, "close"):
+                with contextlib.suppress(Exception):
+                    self._fs.close()
+            if hasattr(self._fs, "of") and hasattr(self._fs.of, "__exit__"):
+                with contextlib.suppress(Exception):
+                    self._fs.of.__exit__(None, None, None)
+
+            self._closed = True
 
     def chunk(self, start: int, stop: int) -> uproot.source.chunk.Chunk:
         """
@@ -199,8 +216,7 @@ class FSSpecSource(uproot.source.chunk.Source):
         True if the associated file/connection/thread pool is closed; False
         otherwise.
         """
-        # FSSpecSource uses entirely stateless interfaces
-        return False
+        return self._closed
 
 
 class FSSpecLoopExecutor(uproot.source.futures.Executor):

{uproot-5.7.3 → uproot-5.7.4}/src/uproot/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '5.7.3'
-__version_tuple__ = version_tuple = (5, 7, 3)
+__version__ = version = '5.7.4'
+__version_tuple__ = version_tuple = (5, 7, 4)
 
 __commit_id__ = commit_id = None

{uproot-5.7.3 → uproot-5.7.4}/src/uproot/writing/_cascade.py

@@ -451,6 +451,28 @@ _free_format_small = struct.Struct(">HII")
 _free_format_big = struct.Struct(">HQQ")
 
 
+def _slices_bytes(slices):
+    total = 0
+    for _, stop in slices:
+        if stop - 1 >= uproot.const.kStartBigFile:
+            total += _free_format_big.size
+        else:
+            total += _free_format_small.size
+    return total
+
+
+def _free_segments_num_bytes(slices, file_end, data_location=0):
+    total = _slices_bytes(slices)
+
+    if file_end is None:
+        file_end = (data_location or 0) + total + _free_format_small.size
+
+    if file_end >= uproot.const.kStartBigFile:
+        return total + _free_format_big.size
+    else:
+        return total + _free_format_small.size
+
+
 class FreeSegmentsData(CascadeLeaf):
     """
     A :doc:`uproot.writing._cascade.CascadeLeaf` for the FreeSegments record
@@ -502,24 +524,12 @@ class FreeSegmentsData(CascadeLeaf):
 
     @property
     def num_bytes(self):
-        total = 0
-        for _, stop in self._slices:
-            if stop - 1 >= uproot.const.kStartBigFile:
-                total += _free_format_big.size
-            else:
-                total += _free_format_small.size
-
-        if self._end is None:
-            if total + _free_format_small.size >= uproot.const.kStartBigFile:
-                total += _free_format_big.size
-            else:
-                total += _free_format_small.size
-        elif self._end >= uproot.const.kStartBigFile:
-            total += _free_format_big.size
-        else:
-            total += _free_format_small.size
+        return _free_segments_num_bytes(self._slices, self._end, self._location)
 
-        return total
+    def required_end(self, data_location):
+        return data_location + _free_segments_num_bytes(
+            self._slices, None, data_location
+        )
 
     def serialize(self):
         pairs = []
@@ -660,8 +670,8 @@ class FreeSegments(CascadeNode):
             out = self._key.location
             if not dry_run:
                 self._key.location = self._key.location + num_bytes
-                self._data.end = (
-                    self._key.location + self._key.allocation + self._data.allocation
+                self._data.end = self._data.required_end(
+                    self._key.location + self._key.num_bytes
                 )
             return out
 
@@ -707,25 +717,18 @@ class FreeSegments(CascadeNode):
 
     @staticmethod
     def _slices_bytes(slices):
-        total = 0
-        for _, stop in slices:
-            if stop - 1 >= uproot.const.kStartBigFile:
-                total += _free_format_big.size
-            else:
-                total += _free_format_small.size
-        return total
+        return _slices_bytes(slices)
 
     def release(self, start, stop):
         new_slices = self._another_slice(self._data.slices, start, stop)
 
         if self.at_end:
             self._data.slices = new_slices
-            self._data.allocation = None
+            self._data.end = self._data.required_end(
+                self._key.location + self._key.num_bytes
+            )
             self._key.uncompressed_bytes = self._data.allocation
             self._key.compressed_bytes = self._key.uncompressed_bytes
-            self._data.end = (
-                self._key.location + self._key.allocation + self._key.uncompressed_bytes
-            )
 
         elif self._slices_bytes(new_slices) <= self._slices_bytes(self._data.slices):
             # Wherever the FreeSegments record is, it's not getting bigger.
@@ -744,12 +747,12 @@ class FreeSegments(CascadeNode):
                 self._key.location,
                 self._key.location + self._key.allocation + self._data.allocation,
             )
-            self._data.allocation = None
+            self._key.location = self._data.end
+            self._data.end = self._data.required_end(
+                self._key.location + self._key.num_bytes
+            )
             self._key.uncompressed_bytes = self._data.allocation
             self._key.compressed_bytes = self._key.uncompressed_bytes
-            self._key.location = self._data.end
-            self._data.location = self._key.location + self._key.allocation
-            self._data.end = self._data.location + self._key.uncompressed_bytes
 
     def write(self, sink):
         self._key.uncompressed_bytes = self._data.allocation

{uproot-5.7.3 → uproot-5.7.4}/src/uproot/writing/_dask_write.py

@@ -176,19 +176,22 @@ def ak_to_root(
         **(storage_options or {}),
     )
 
-    branch_types = {name: array[name].type for name in array.fields}
-
-    out_file.mktree(
-        tree_name,
-        branch_types,
-        title=title,
-        counter_name=counter_name,
-        field_name=field_name,
-        initial_basket_capacity=initial_basket_capacity,
-        resize_factor=resize_factor,
-    )
+    try:
+        branch_types = {name: array[name].type for name in array.fields}
+
+        out_file.mktree(
+            tree_name,
+            branch_types,
+            title=title,
+            counter_name=counter_name,
+            field_name=field_name,
+            initial_basket_capacity=initial_basket_capacity,
+            resize_factor=resize_factor,
+        )
 
-    out_file[tree_name].extend({name: array[name] for name in array.fields})
+        out_file[tree_name].extend({name: array[name] for name in array.fields})
+    finally:
+        out_file.close()
 
 
 def none_to_none(*_):