chore: more Ruff

awkward-cpp/src/awkward_cpp/__init__.py

@@ -1,2 +1,2 @@
-import awkward_cpp.cpu_kernels  # noqa: F401
+import awkward_cpp.cpu_kernels
 import awkward_cpp.libawkward  # noqa: F401

dev/generate-kernel-signatures.py

@@ -93,7 +93,8 @@
     "awkward_reduce_max",
     "awkward_reduce_min",
     "awkward_reduce_sum",
-    "awkward_reduce_sum_int32_bool_64" "awkward_reduce_sum_int64_bool_64",
+    "awkward_reduce_sum_int32_bool_64",
+    "awkward_reduce_sum_int64_bool_64",
     "awkward_reduce_sum_bool",
     "awkward_reduce_prod_bool",
     "awkward_reduce_countnonzero",

pyproject.toml

@@ -257,7 +257,7 @@ ignore_errors = true
 ignore_missing_imports = true
 
 [tool.ruff]
-exclude = [
+extend-exclude = [
     "studies",
     "pybind11",
     "rapidjson",
@@ -269,17 +269,23 @@ ignore = [
     "UP030",  # {0} -> {}
 ]
 select = [
-    "B0",                # flake8-bugbear
-    "C", "E", "F", "W",  # flake8
-    "I",                 # isort
-    "T20",               # flake8-print
-    "UP",                # pyupgrade
-    "TID251"             # flake8-tidy-imports
+    "C", "E", "F", "W",            # flake8
+    "B0", "B904",                  # flake8-bugbear
+    "T20",                         # flake8-print
+    "TID251",                      # flake8-tidy-imports
+    "ISC",                         # flake8-implicit-str-concat
+    "I",                           # isort
+    "UP",                          # pyupgrade
+    "PGH002", "PGH003", "PGH004",  # pygrep-hooks
+    "C4",                          # flake8-comprehensions
+    "YTT",                         # flake8-2020
+    "RUF0", "RUF1"                 # Ruff-specific
 ]
 target-version = "py37"
 typing-modules = ["awkward.typing"]
 src = ["src"]
 unfixable = ["T20"]
+external = ["AK101"]
 
 mccabe.max-complexity = 100
 
@@ -293,8 +299,6 @@ mccabe.max-complexity = 100
     "E402",
     "F401",
     "F403",
-    "F401",
-    "F403",
     "I001",
 ]
 "src/awkward/_connect/*" = [

src/awkward/_connect/numba/layout.py

@@ -64,7 +64,7 @@ def getitem_range(self, viewtype):
     def getitem_field(self, viewtype, key):
         if self.has_field(key):
             return ak._connect.numba.arrayview.wrap(
-                self, viewtype, viewtype.fields + (key,)
+                self, viewtype, (*viewtype.fields, key)
             )
         else:
             raise TypeError(f"array does not have a field with key {repr(key)}")

src/awkward/_connect/rdataframe/from_rdataframe.py

@@ -2,6 +2,7 @@
 
 import ctypes
 import os
+import textwrap
 
 import cppyy
 import ROOT
@@ -55,11 +56,7 @@
 compiler = ROOT.gInterpreter.Declare
 
 
-done = compiler(
-    """
-#include "rdataframe/jagged_builders.h"
-"""
-)
+done = compiler('\n#include "rdataframe/jagged_builders.h"\n')
 assert done is True
 
 
@@ -68,55 +65,52 @@ def cpp_builder_type(depth, data_type):
         if depth == 1:
             return f"awkward::LayoutBuilder::Numpy<{data_type}>>"
         else:
-            return (
-                "awkward::LayoutBuilder::ListOffset<int64_t, "
-                + cpp_builder_type(depth - 1, data_type)
-                + ">"
-            )
+            return f"awkward::LayoutBuilder::ListOffset<int64_t, {cpp_builder_type(depth - 1, data_type)}>"
 
     def cpp_fill_offsets_and_flatten(depth):
         if depth == 1:
-            return (
-                "\nfor (auto const& it : vec1) {\n" + "  builder1.append(it);\n" + "}\n"
+            return textwrap.dedent(
+                """
+                for (auto const& it : vec1) {
+                    builder1.append(it);
+                }
+                """
             )
         else:
-            return (
-                f"for (auto const& vec{depth - 1} : vec{depth}) "
-                + "{\n"
-                + f"  auto& builder{depth - 1} = builder{depth}.begin_list();\n"
-                + "  "
-                + cpp_fill_offsets_and_flatten(depth - 1)
-                + "\n"
-                + f"  builder{depth}.end_list();\n"
-                + "}\n"
+            return textwrap.dedent(
+                f"""
+                for (auto const& vec{depth - 1} : vec{depth}) {{
+                    auto& builder{depth - 1} = builder{depth}.begin_list();
+                    {cpp_fill_offsets_and_flatten(depth - 1)}
+                    builder{depth}.end_list();
+                }}
+                """
             )
 
     def cpp_fill_function(depth):
         if depth == 1:
-            return (
-                "template<class BUILDER, typename PRIMITIVE>\n"
-                + "void\n"
-                + "fill_from(BUILDER& builder, ROOT::RDF::RResultPtr<std::vector<PRIMITIVE>>& result) {"
-                + "  for (auto const& it : result) {\n"
-                + "    builder.append(it);\n"
-                + "  }\n"
-                + "}\n"
+            return textwrap.dedent(
+                """
+                template<class BUILDER, typename PRIMITIVE>
+                void fill_from(BUILDER& builder, ROOT::RDF::RResultPtr<std::vector<PRIMITIVE>>& result) {
+                    for (auto const& it : result) {
+                        builder.append(it);
+                    }
+                }
+                """
             )
         else:
-            return (
-                "template<class BUILDER, typename PRIMITIVE>\n"
-                + "void\n"
-                + f"fill_offsets_and_flatten{depth}(BUILDER& builder{depth}, ROOT::RDF::RResultPtr<std::vector<PRIMITIVE>>& result) "
-                + "{\n"
-                + f"  for (auto const& vec{depth - 1} : result) "
-                + "{\n"
-                + f"  auto& builder{depth - 1} = builder{depth}.begin_list();\n"
-                + "  "
-                + cpp_fill_offsets_and_flatten(depth - 1)
-                + "\n"
-                + f"  builder{depth}.end_list();\n"
-                + "}\n"
-                + "}\n"
+            return textwrap.dedent(
+                f"""
+                template<class BUILDER, typename PRIMITIVE>
+                void fill_offsets_and_flatten{depth}(BUILDER& builder{depth}, ROOT::RDF::RResultPtr<std::vector<PRIMITIVE>>& result) {{
+                    for (auto const& vec{depth - 1} : result) {{
+                      auto& builder{depth - 1} = builder{depth}.begin_list();
+                      {cpp_fill_offsets_and_flatten(depth - 1)}
+                      builder{depth}.end_list();
+                    }}
+                }}
+                """
             )
 
     def form_dtype(form):
@@ -132,7 +126,7 @@ def form_dtype(form):
     contents = {}
     awkward_type_cols = {}
 
-    columns = columns + ("rdfentry_",)
+    columns = (*columns, "rdfentry_")
     maybe_indexed = False
 
     # Important note: This loop is separate from the next one

src/awkward/_kernels.py

@@ -82,16 +82,16 @@ def _cast(cls, x, t):
             return x
 
     def __call__(self, *args) -> None:
-        assert len(args) == len(self._impl.argtypes)  # type: ignore
+        assert len(args) == len(self._impl.argtypes)
 
         return self._impl(
-            *(self._cast(x, t) for x, t in zip(args, self._impl.argtypes))  # type: ignore
+            *(self._cast(x, t) for x, t in zip(args, self._impl.argtypes))
         )
 
 
 class JaxKernel(NumpyKernel):
     def __call__(self, *args) -> None:
-        assert len(args) == len(self._impl.argtypes)  # type: ignore
+        assert len(args) == len(self._impl.argtypes)
 
         if not any(Jax.is_tracer(arg) for arg in args):
             return super().__call__(*args)
@@ -133,7 +133,7 @@ def __call__(self, *args) -> None:
                 [],
             )
 
-        assert len(args) == len(self._impl.dir)  # type: ignore
+        assert len(args) == len(self._impl.dir)
         # The first arg is the invocation index which raises itself by 8 in the kernel if there was no error before.
         # The second arg is the error_code.
         args = (

src/awkward/_nplikes/numpylike.py

@@ -46,7 +46,7 @@ def T(self) -> Self:
         ...
 
     @abstractmethod
-    def __getitem__(  # noqa: F811
+    def __getitem__(
         self,
         key: SupportsIndex
         | slice
@@ -69,7 +69,7 @@ def __setitem__(
         ...
 
     @overload
-    def __setitem__(  # noqa: F811
+    def __setitem__(
         self,
         key: slice
         | Ellipsis
@@ -80,7 +80,7 @@ def __setitem__(  # noqa: F811
         ...
 
     @abstractmethod
-    def __setitem__(self, key, value):  # noqa: F811
+    def __setitem__(self, key, value):
         ...
 
     @abstractmethod

src/awkward/_nplikes/typetracer.py

@@ -312,7 +312,7 @@ def strides(self):
         self.touch_shape()
         out = (self._dtype.itemsize,)
         for x in self._shape[:0:-1]:
-            out = (x * out[0],) + out
+            out = (x * out[0], *out)
         return out
 
     @property
@@ -384,7 +384,7 @@ def __getitem__(
         | Ellipsis
         | tuple[SupportsIndex | slice | Ellipsis | ArrayLike, ...]
         | ArrayLike,
-    ) -> Self:  # noqa: F811
+    ) -> Self:
         if not isinstance(key, tuple):
             key = (key,)
 
@@ -514,7 +514,7 @@ def __setitem__(
         | tuple[SupportsIndex | slice | Ellipsis | ArrayLike, ...]
         | ArrayLike,
         value: int | float | bool | complex | ArrayLike,
-    ):  # noqa: F811        existing_value = self.__getitem__(key)
+    ):
         existing_value = self.__getitem__(key)
         if isinstance(value, TypeTracerArray) and value.ndim > existing_value.ndim:
             raise wrap_error(ValueError("cannot assign shape larger than destination"))
@@ -1071,7 +1071,7 @@ def concat(self, arrays, *, axis: int | None = 0) -> TypeTracerArray:
             )
 
         return TypeTracerArray._new(
-            numpy.concatenate(emptyarrays).dtype, (unknown_length,) + inner_shape
+            numpy.concatenate(emptyarrays).dtype, (unknown_length, *inner_shape)
         )
 
     def repeat(

src/awkward/behaviors/categorical.py

@@ -19,7 +19,7 @@ class _HashableDict:
     def __init__(self, obj):
         self.keys = tuple(sorted(obj))
         self.values = tuple(_as_hashable(obj[k]) for k in self.keys)
-        self.hash = hash((_HashableDict,) + self.keys, self.values)
+        self.hash = hash((_HashableDict, *self.keys), self.values)
 
     def __hash__(self):
         return self.hash
@@ -35,7 +35,7 @@ def __eq__(self, other):
 class _HashableList:
     def __init__(self, obj):
         self.values = tuple(obj)
-        self.hash = hash((_HashableList,) + self.values)
+        self.hash = hash((_HashableList, *self.values))
 
     def __hash__(self):
         return self.hash

src/awkward/behaviors/mixins.py

@@ -51,7 +51,7 @@ def register(cls):
                     if rhs is None:
                         registry.setdefault((ufunc, behavior_name), method)
                         continue
-                    for rhs_name in list(rhs) + [behavior_name]:
+                    for rhs_name in [*list(rhs), behavior_name]:
                         registry.setdefault((ufunc, behavior_name, rhs_name), method)
                         if transpose is not None and rhs_name != behavior_name:
                             registry.setdefault(

src/awkward/contents/content.py

@@ -376,7 +376,7 @@ def _getitem_next_ellipsis(self, tail, advanced: Index | None):
             )
 
         else:
-            return self._getitem_next(slice(None), (Ellipsis,) + tail, advanced)
+            return self._getitem_next(slice(None), (Ellipsis, *tail), advanced)
 
     def _getitem_next_regular_missing(
         self,

src/awkward/contents/numpyarray.py

@@ -340,24 +340,24 @@ def _getitem_next(
             return self
 
         elif isinstance(head, int):
-            where = (slice(None), head) + tail
+            where = (slice(None), head, *tail)
 
             try:
                 out = self._data[where]
             except IndexError as err:
-                raise ak._errors.index_error(self, (head,) + tail, str(err)) from err
+                raise ak._errors.index_error(self, (head, *tail), str(err)) from err
 
             if hasattr(out, "shape") and len(out.shape) != 0:
                 return NumpyArray(out, parameters=None, backend=self._backend)
             else:
                 return out
 
         elif isinstance(head, slice) or head is np.newaxis or head is Ellipsis:
-            where = (slice(None), head) + tail
+            where = (slice(None), head, *tail)
             try:
                 out = self._data[where]
             except IndexError as err:
-                raise ak._errors.index_error(self, (head,) + tail, str(err)) from err
+                raise ak._errors.index_error(self, (head, *tail), str(err)) from err
 
             return NumpyArray(out, parameters=self._parameters, backend=self._backend)
 
@@ -369,26 +369,27 @@ def _getitem_next(
 
         elif isinstance(head, ak.index.Index64):
             if advanced is None:
-                where = (slice(None), head.data) + tail
+                where = (slice(None), head.data, *tail)
             else:
                 where = (
                     self._backend.index_nplike.asarray(advanced.data),
                     head.data,
-                ) + tail
+                    *tail,
+                )
 
             try:
                 out = self._data[where]
             except IndexError as err:
-                raise ak._errors.index_error(self, (head,) + tail, str(err)) from err
+                raise ak._errors.index_error(self, (head, *tail), str(err)) from err
 
             return NumpyArray(out, parameters=self._parameters, backend=self._backend)
 
         elif isinstance(head, ak.contents.ListOffsetArray):
-            where = (slice(None), head) + tail
+            where = (slice(None), head, *tail)
             try:
                 out = self._data[where]
             except IndexError as err:
-                raise ak._errors.index_error(self, (head,) + tail, str(err)) from err
+                raise ak._errors.index_error(self, (head, *tail), str(err)) from err
 
             return NumpyArray(out, parameters=self._parameters, backend=self._backend)
 
@@ -745,7 +746,7 @@ def _unique(self, negaxis, starts, parents, outlength):
                     "awkward_unique",
                     out.dtype.type,
                     nextlength.dtype.type,
-                ](  # noqa: E231
+                ](
                     out,
                     out.shape[0],
                     nextlength.data,