style: pre-commit fixes

Author: pre-commit-ci[bot]

src/awkward/contents/listoffsetarray.py

@@ -222,8 +222,7 @@ def _to_buffers(
         container[key] = ak._util.native_to_byteorder(
             self._offsets.raw(backend.nplike), byteorder
         )
-        self._content._to_buffers(
-            form.content, getkey, container, backend, byteorder)
+        self._content._to_buffers(form.content, getkey, container, backend, byteorder)
 
     def _to_typetracer(self, forget_length: bool) -> Self:
         offsets = self._offsets.to_nplike(TypeTracer.instance())
@@ -256,10 +255,8 @@ def _repr(self, indent, pre, post):
         out.append(">")
         out.extend(self._repr_extra(indent + "    "))
         out.append("\n")
-        out.append(self._offsets._repr(
-            indent + "    ", "<offsets>", "</offsets>\n"))
-        out.append(self._content._repr(
-            indent + "    ", "<content>", "</content>\n"))
+        out.append(self._offsets._repr(indent + "    ", "<offsets>", "</offsets>\n"))
+        out.append(self._content._repr(indent + "    ", "<content>", "</content>\n"))
         out.append(indent + "</ListOffsetArray>")
         out.append(post)
         return "".join(out)
@@ -272,7 +269,7 @@ def to_ListOffsetArray64(self, start_at_zero: bool = False) -> ListOffsetArray:
                 nplike=self._backend.nplike,
             )
             return ListOffsetArray(
-                offsets, self._content[self._offsets[0]:], parameters=self._parameters
+                offsets, self._content[self._offsets[0] :], parameters=self._parameters
             )
         else:
             return ListOffsetArray(
@@ -283,8 +280,7 @@ def to_RegularArray(self):
         start, stop = (
             self._offsets[0],
             self._offsets[
-                self._backend.nplike.shape_item_as_index(
-                    self._offsets.length - 1)
+                self._backend.nplike.shape_item_as_index(self._offsets.length - 1)
             ],
         )
         content = self._content._getitem_range(start, stop)
@@ -329,8 +325,7 @@ def _is_getitem_at_virtual(self) -> bool:
     def _getitem_at(self, where: IndexType):
         # Wrap `where` by length
         if not is_unknown_scalar(where) and where < 0:
-            length_index = self._backend.nplike.shape_item_as_index(
-                self.length)
+            length_index = self._backend.nplike.shape_item_as_index(self.length)
             where += length_index
         # Validate `where`
         if not (
@@ -352,7 +347,7 @@ def _getitem_range(self, start: IndexType, stop: IndexType) -> Content:
         if self._backend.nplike.known_data and (start == 0 and stop == self.length):
             return self
 
-        offsets = self._offsets[start: stop + 1]
+        offsets = self._offsets[start : stop + 1]
         if offsets.length is not unknown_length and offsets.length == 0:
             offsets = Index(
                 self._backend.nplike.zeros(1, dtype=self._offsets.dtype),
@@ -524,8 +519,7 @@ def _getitem_next(
             )
 
             if self._starts.dtype == "int64":
-                nextoffsets = Index64.empty(
-                    lenstarts + 1, nplike=self._backend.nplike)
+                nextoffsets = Index64.empty(lenstarts + 1, nplike=self._backend.nplike)
             elif self._starts.dtype == "int32":
                 nextoffsets = ak.index.Index32.empty(
                     lenstarts + 1, nplike=self._backend.nplike
@@ -615,8 +609,7 @@ def _getitem_next(
 
                 return ak.contents.ListOffsetArray(
                     nextoffsets,
-                    nextcontent._getitem_next(
-                        nexthead, nexttail, nextadvanced),
+                    nextcontent._getitem_next(nexthead, nexttail, nextadvanced),
                     parameters=self._parameters,
                 )
 
@@ -673,12 +666,10 @@ def _getitem_next(
                 )
                 nextcontent = self._content._carry(nextcarry, True)
 
-                out = nextcontent._getitem_next(
-                    nexthead, nexttail, nextadvanced)
+                out = nextcontent._getitem_next(nexthead, nexttail, nextadvanced)
                 if advanced is None:
                     return ak._slicing.getitem_next_array_wrap(
-                        out, head.metadata.get(
-                            "shape", (head.length,), self.length)
+                        out, head.metadata.get("shape", (head.length,), self.length)
                     )
                 else:
                     return out
@@ -774,8 +765,7 @@ def _offsets_and_flattened(self, axis: int, depth: int) -> tuple[Index, Content]
                 tooffsets = Index64([inneroffsets[0]])
                 return (
                     offsets,
-                    ListOffsetArray(tooffsets, flattened,
-                                    parameters=self._parameters),
+                    ListOffsetArray(tooffsets, flattened, parameters=self._parameters),
                 )
 
             else:
@@ -804,8 +794,7 @@ def _offsets_and_flattened(self, axis: int, depth: int) -> tuple[Index, Content]
                 )
                 return (
                     offsets,
-                    ListOffsetArray(tooffsets, flattened,
-                                    parameters=self._parameters),
+                    ListOffsetArray(tooffsets, flattened, parameters=self._parameters),
                 )
 
     def _mergeable_next(
@@ -850,8 +839,7 @@ def _mergemany(self, others: Sequence[Content]) -> Content:
         out = listarray._mergemany(others)
 
         if all(
-            isinstance(
-                x, ListOffsetArray) and x._offsets.dtype == self._offsets.dtype
+            isinstance(x, ListOffsetArray) and x._offsets.dtype == self._offsets.dtype
             for x in others
         ):
             return out.to_ListOffsetArray64(False)
@@ -923,8 +911,7 @@ def _is_unique(self, negaxis, starts, parents, outlength):
             # FIXME: check validity error
 
             if isinstance(self._content, ak.contents.NumpyArray):
-                out, outoffsets = self._content._as_unique_strings(
-                    self._offsets)
+                out, outoffsets = self._content._as_unique_strings(self._offsets)
                 out2 = ak.contents.ListOffsetArray(
                     outoffsets, out, parameters=self._parameters
                 )
@@ -971,14 +958,12 @@ def _unique(self, negaxis, starts, parents, outlength):
             or self.parameter("__array__") == "bytestring"
         ):
             if branch or (negaxis != depth):
-                raise AxisError(
-                    "array with strings can only be sorted with axis=-1")
+                raise AxisError("array with strings can only be sorted with axis=-1")
 
             # FIXME: check validity error
 
             if isinstance(self._content, ak.contents.NumpyArray):
-                out, nextoffsets = self._content._as_unique_strings(
-                    self._offsets)
+                out, nextoffsets = self._content._as_unique_strings(self._offsets)
                 return ak.contents.ListOffsetArray(
                     nextoffsets, out, parameters=self._parameters
                 )
@@ -988,8 +973,7 @@ def _unique(self, negaxis, starts, parents, outlength):
                 self.parameter("__array__") == "string"
                 or self.parameter("__array__") == "bytestring"
             ):
-                raise AxisError(
-                    "array with strings can only be sorted with axis=-1")
+                raise AxisError("array with strings can only be sorted with axis=-1")
 
             if self._backend.nplike.known_data and parents.nplike.known_data:
                 assert self._offsets.length - 1 == parents.length
@@ -1056,7 +1040,7 @@ def _unique(self, negaxis, starts, parents, outlength):
                 )
             )
 
-            trimmed = self._content[self._offsets[0]: self._offsets[-1]]
+            trimmed = self._content[self._offsets[0] : self._offsets[-1]]
             outcontent = trimmed._unique(
                 negaxis,
                 self._offsets[:-1],
@@ -1089,8 +1073,7 @@ def _argsort_next(
             or self.parameter("__array__") == "bytestring"
         ):
             if branch or (negaxis != depth):
-                raise AxisError(
-                    "array with strings can only be sorted with axis=-1")
+                raise AxisError("array with strings can only be sorted with axis=-1")
 
             # FIXME: check validity error
 
@@ -1136,8 +1119,7 @@ def _argsort_next(
                 self.parameter("__array__") == "string"
                 or self.parameter("__array__") == "bytestring"
             ):
-                raise AxisError(
-                    "array with strings can only be sorted with axis=-1")
+                raise AxisError("array with strings can only be sorted with axis=-1")
 
             if self._backend.nplike.known_data and parents.nplike.known_data:
                 assert self._offsets.length - 1 == parents.length
@@ -1243,7 +1225,7 @@ def _argsort_next(
                 )
             )
 
-            trimmed = self._content[self._offsets[0]: self._offsets[-1]]
+            trimmed = self._content[self._offsets[0] : self._offsets[-1]]
             outcontent = trimmed._argsort_next(
                 negaxis,
                 self._offsets[:-1],
@@ -1268,8 +1250,7 @@ def _sort_next(self, negaxis, starts, parents, outlength, ascending, stable):
             or self.parameter("__array__") == "bytestring"
         ):
             if branch or (negaxis != depth):
-                raise AxisError(
-                    "array with strings can only be sorted with axis=-1")
+                raise AxisError("array with strings can only be sorted with axis=-1")
 
             # FIXME: check validity error
 
@@ -1311,8 +1292,7 @@ def _sort_next(self, negaxis, starts, parents, outlength, ascending, stable):
                 self.parameter("__array__") == "string"
                 or self.parameter("__array__") == "bytestring"
             ):
-                raise AxisError(
-                    "array with strings can only be sorted with axis=-1")
+                raise AxisError("array with strings can only be sorted with axis=-1")
 
             if self._backend.nplike.known_data and parents.nplike.known_data:
                 assert self._offsets.length - 1 == parents.length
@@ -1356,8 +1336,7 @@ def _sort_next(self, negaxis, starts, parents, outlength, ascending, stable):
                 parameters=self._parameters,
             )
         else:
-            nextlen = nplike.index_as_shape_item(
-                self._offsets[-1] - self._offsets[0])
+            nextlen = nplike.index_as_shape_item(self._offsets[-1] - self._offsets[0])
             nextparents = Index64.empty(nextlen, nplike)
             lenstarts = self._offsets.length - 1
 
@@ -1374,7 +1353,7 @@ def _sort_next(self, negaxis, starts, parents, outlength, ascending, stable):
                 )
             )
 
-            trimmed = self._content[self._offsets[0]: self._offsets[-1]]
+            trimmed = self._content[self._offsets[0] : self._offsets[-1]]
             outcontent = trimmed._sort_next(
                 negaxis,
                 self._offsets[:-1],
@@ -1625,14 +1604,12 @@ def _reduce_next(
             )
 
             if keepdims:
-                out = ak.contents.RegularArray(
-                    out, 1, self.length, parameters=None)
+                out = ak.contents.RegularArray(out, 1, self.length, parameters=None)
 
             return out
 
         else:
-            nextlen = nplike.index_as_shape_item(
-                self._offsets[-1] - self._offsets[0])
+            nextlen = nplike.index_as_shape_item(self._offsets[-1] - self._offsets[0])
             nextparents = Index64.empty(nextlen, nplike)
 
             # n.b. awkward_ListOffsetArray_reduce_local_nextparents_64 always returns parents that are
@@ -1650,7 +1627,7 @@ def _reduce_next(
                 )
             )
 
-            trimmed = self._content[self.offsets[0]: self.offsets[-1]]
+            trimmed = self._content[self.offsets[0] : self.offsets[-1]]
             nextstarts = self.offsets[:-1]
 
             outcontent = trimmed._reduce_next(
@@ -1698,8 +1675,7 @@ def _reduce_next(
 
     def _rearrange_prepare_next(self, outlength, parents):
         nplike = self._backend.nplike
-        nextlen = nplike.index_as_shape_item(
-            self._offsets[-1] - self._offsets[0])
+        nextlen = nplike.index_as_shape_item(self._offsets[-1] - self._offsets[0])
         lenstarts = self._offsets.length - 1
         _maxcount = Index64.empty(1, nplike)
         offsetscopy = Index64.empty(self.offsets.length, nplike)
@@ -1939,7 +1915,7 @@ def _to_arrow(
         else:
             downsize = options["list_to32"]
         (npoffsets,) = maybe_materialize(self._offsets.raw(numpy))
-        akcontent = self._content[npoffsets[0]: npoffsets[length]]
+        akcontent = self._content[npoffsets[0] : npoffsets[length]]
         if len(npoffsets) > length + 1:
             npoffsets = npoffsets[: length + 1]
         if npoffsets[0] != 0:
@@ -2001,8 +1977,7 @@ def _to_arrow(
                 [
                     ak._connect.pyarrow.to_validbits(validbytes),
                     pyarrow.py_buffer(npoffsets),
-                    pyarrow.py_buffer(
-                        *maybe_materialize(akcontent._raw(numpy))),
+                    pyarrow.py_buffer(*maybe_materialize(akcontent._raw(numpy))),
                 ],
             )
 
@@ -2064,7 +2039,6 @@ def _to_cudf(self, cudf: Any, mask: Content | None, length: int):
             m = None
         if self.parameters.get("__array__") == "string":
             from cudf.core.column.string import StringColumn
-            from cudf.utils.dtypes import CUDF_STRING_DTYPE
 
             data = cudf.core.buffer.as_buffer(cupy.asarray(self._content.data))
             StrCol = StringColumn
@@ -2104,8 +2078,7 @@ def _to_backend_array(self, allow_missing, backend):
                 self._offsets.length,
                 _max_code_points,
             )
-            max_code_points = backend.nplike.index_as_shape_item(
-                _max_code_points[0])
+            max_code_points = backend.nplike.index_as_shape_item(_max_code_points[0])
             # Ensure that we have at-least length-1 bytestrings
             if max_code_points is not unknown_length:
                 max_code_points = max(1, max_code_points)
@@ -2141,8 +2114,7 @@ def _to_backend_array(self, allow_missing, backend):
             if max_count is not unknown_length:
                 max_count = max(1, max_count)
 
-            buffer = backend.nplike.empty(
-                max_count * self.length, dtype=np.uint8)
+            buffer = backend.nplike.empty(max_count * self.length, dtype=np.uint8)
 
             self.backend[
                 "awkward_NumpyArray_pad_zero_to_length",
@@ -2169,7 +2141,7 @@ def _remove_structure(
         ):
             return [self]
         else:
-            content = self._content[self._offsets[0]: self._offsets[-1]]
+            content = self._content[self._offsets[0] : self._offsets[-1]]
             contents = content._remove_structure(backend, options)
             if options["keepdims"]:
                 if options["list_to_regular"]:
@@ -2189,8 +2161,7 @@ def _remove_structure(
                                 backend.nplike.asarray(
                                     [
                                         0,
-                                        backend.nplike.shape_item_as_index(
-                                            c.length),
+                                        backend.nplike.shape_item_as_index(c.length),
                                     ]
                                 )
                             ),
@@ -2248,7 +2219,7 @@ def _recursively_apply(
             offsets = ak.index.Index(
                 self._offsets.data - offsetsmin, nplike=self._backend.nplike
             )
-            content = self._content[offsetsmin: self._offsets[-1]]
+            content = self._content[offsetsmin : self._offsets[-1]]
         else:
             self._touch_data(recursive=False)
             offsets, content = self._offsets, self._content
@@ -2333,20 +2304,19 @@ def _to_list(self, behavior, json_conversions):
             out = [None] * starts.length
             if convert_bytes is None:
                 for i in range(starts.length):
-                    out[i] = ak._util.tobytes(
-                        data[starts_data[i]: stops_data[i]])
+                    out[i] = ak._util.tobytes(data[starts_data[i] : stops_data[i]])
             else:
                 for i in range(starts.length):
                     out[i] = convert_bytes(
-                        ak._util.tobytes(data[starts_data[i]: stops_data[i]])
+                        ak._util.tobytes(data[starts_data[i] : stops_data[i]])
                     )
             return out
 
         elif self.parameter("__array__") == "string":
             data = nextcontent.data
             out = [None] * starts.length
             for i in range(starts.length):
-                out[i] = ak._util.tobytes(data[starts_data[i]: stops_data[i]]).decode(
+                out[i] = ak._util.tobytes(data[starts_data[i] : stops_data[i]]).decode(
                     errors="surrogateescape"
                 )
             return out
@@ -2360,7 +2330,7 @@ def _to_list(self, behavior, json_conversions):
             out = [None] * starts.length
 
             for i in range(starts.length):
-                out[i] = content[starts_data[i]: stops_data[i]]
+                out[i] = content[starts_data[i] : stops_data[i]]
             return out
 
     def _to_backend(self, backend: Backend) -> Self:
@@ -2402,11 +2372,9 @@ def _awkward_strings_to_nonfinite(self, nonfinit_dict):
                     union_tags = ak.index.Index8.zeros(
                         content.length, nplike=self._backend.nplike
                     )
-                    content.backend.nplike.isnan(
-                        content._data, union_tags._data)
+                    content.backend.nplike.isnan(content._data, union_tags._data)
                     union_index = Index64(
-                        self._backend.nplike.arange(
-                            content.length, dtype=np.int64),
+                        self._backend.nplike.arange(content.length, dtype=np.int64),
                         nplike=self._backend.nplike,
                     )