style: pre-commit fixes

Author: pre-commit-ci[bot]

include/pybind11/detail/class.h

@@ -602,7 +602,8 @@ extern "C" inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int fla
         return -1;
     }
 
-    // Fill in all the information, and then downgrade as requested by the caller, or raise an error if that's not possible.
+    // Fill in all the information, and then downgrade as requested by the caller, or raise an
+    // error if that's not possible.
     view->obj = obj;
     view->internal = info;
     view->buf = info->ptr;
@@ -624,14 +625,16 @@ extern "C" inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int fla
         if (!PyBuffer_IsContiguous(view, 'C')) {
             std::memset(view, 0, sizeof(Py_buffer));
             delete info;
-            set_error(PyExc_BufferError, "C-contiguous buffer requested for discontiguous storage");
+            set_error(PyExc_BufferError,
+                      "C-contiguous buffer requested for discontiguous storage");
             return -1;
         }
     } else if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) {
         if (!PyBuffer_IsContiguous(view, 'F')) {
             std::memset(view, 0, sizeof(Py_buffer));
             delete info;
-            set_error(PyExc_BufferError, "Fortran-contiguous buffer requested for discontiguous storage");
+            set_error(PyExc_BufferError,
+                      "Fortran-contiguous buffer requested for discontiguous storage");
             return -1;
         }
     } else if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS) {
@@ -642,13 +645,14 @@ extern "C" inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int fla
             return -1;
         }
 
-    // If no strides are requested, the buffer must be C-contiguous.
-    // https://docs.python.org/3/c-api/buffer.html#contiguity-requests
+        // If no strides are requested, the buffer must be C-contiguous.
+        // https://docs.python.org/3/c-api/buffer.html#contiguity-requests
     } else if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES) {
         if (!PyBuffer_IsContiguous(view, 'C')) {
             std::memset(view, 0, sizeof(Py_buffer));
             delete info;
-            set_error(PyExc_BufferError, "C-contiguous buffer requested for discontiguous storage");
+            set_error(PyExc_BufferError,
+                      "C-contiguous buffer requested for discontiguous storage");
             return -1;
         }
 

tests/test_buffers.cpp

@@ -171,16 +171,13 @@ TEST_SUBMODULE(buffers, m) {
     class FortranMatrix : public Matrix {
     public:
         FortranMatrix(py::ssize_t rows, py::ssize_t cols) : Matrix(cols, rows) {
-            print_created(this, std::to_string(rows) + "x" + std::to_string(cols) + " Fortran matrix");
+            print_created(this,
+                          std::to_string(rows) + "x" + std::to_string(cols) + " Fortran matrix");
         }
 
-        float operator()(py::ssize_t i, py::ssize_t j) const {
-            return Matrix::operator()(j, i);
-        }
+        float operator()(py::ssize_t i, py::ssize_t j) const { return Matrix::operator()(j, i); }
 
-        float &operator()(py::ssize_t i, py::ssize_t j) {
-            return Matrix::operator()(j, i);
-        }
+        float &operator()(py::ssize_t i, py::ssize_t j) { return Matrix::operator()(j, i); }
 
         using Matrix::data;
 
@@ -210,30 +207,33 @@ TEST_SUBMODULE(buffers, m) {
              })
         /// Provide buffer access
         .def_buffer([](FortranMatrix &m) -> py::buffer_info {
-            return py::buffer_info(
-                m.data(),                          /* Pointer to buffer */
-                {m.rows(), m.cols()},              /* Buffer dimensions */
-                /* Strides (in bytes) for each index */
-                {sizeof(float), sizeof(float) * size_t(m.rows())});
+            return py::buffer_info(m.data(),             /* Pointer to buffer */
+                                   {m.rows(), m.cols()}, /* Buffer dimensions */
+                                   /* Strides (in bytes) for each index */
+                                   {sizeof(float), sizeof(float) * size_t(m.rows())});
         });
 
     // A matrix that uses a discontiguous underlying memory block.
     class DiscontiguousMatrix : public Matrix {
     public:
-        DiscontiguousMatrix(py::ssize_t rows, py::ssize_t cols,
-                            py::ssize_t row_factor, py::ssize_t col_factor)
-        : Matrix(rows * row_factor, cols * col_factor),
-          m_row_factor(row_factor), m_col_factor(col_factor)
-        {
+        DiscontiguousMatrix(py::ssize_t rows,
+                            py::ssize_t cols,
+                            py::ssize_t row_factor,
+                            py::ssize_t col_factor)
+            : Matrix(rows * row_factor, cols * col_factor), m_row_factor(row_factor),
+              m_col_factor(col_factor) {
             print_created(this,
-                          std::to_string(rows) + "(*" + std::to_string(row_factor) + ")x" +
-                          std::to_string(cols) + "(*" + std::to_string(col_factor) + ") matrix");
+                          std::to_string(rows) + "(*" + std::to_string(row_factor) + ")x"
+                              + std::to_string(cols) + "(*" + std::to_string(col_factor)
+                              + ") matrix");
         }
 
         ~DiscontiguousMatrix() {
             print_destroyed(this,
-                            std::to_string(rows() / m_row_factor) + "(*" + std::to_string(m_row_factor) + ")x" +
-                            std::to_string(cols() / m_col_factor) + "(*" + std::to_string(m_col_factor) + ") matrix");
+                            std::to_string(rows() / m_row_factor) + "(*"
+                                + std::to_string(m_row_factor) + ")x"
+                                + std::to_string(cols() / m_col_factor) + "(*"
+                                + std::to_string(m_col_factor) + ") matrix");
         }
 
         float operator()(py::ssize_t i, py::ssize_t j) const {
@@ -278,12 +278,12 @@ TEST_SUBMODULE(buffers, m) {
              })
         /// Provide buffer access
         .def_buffer([](DiscontiguousMatrix &m) -> py::buffer_info {
-            return py::buffer_info(
-                m.data(),                          /* Pointer to buffer */
-                {m.rows(), m.cols()},              /* Buffer dimensions */
-                /* Strides (in bytes) for each index */
-                {size_t(m.col_factor()) * sizeof(float) * size_t(m.cols()) * size_t(m.row_factor()),
-                 size_t(m.col_factor()) * sizeof(float)});
+            return py::buffer_info(m.data(),             /* Pointer to buffer */
+                                   {m.rows(), m.cols()}, /* Buffer dimensions */
+                                   /* Strides (in bytes) for each index */
+                                   {size_t(m.col_factor()) * sizeof(float) * size_t(m.cols())
+                                        * size_t(m.row_factor()),
+                                    size_t(m.col_factor()) * sizeof(float)});
         });
 
     class BrokenMatrix : public Matrix {

tests/test_buffers.py

@@ -310,7 +310,9 @@ def test_to_pybuffer():
 def test_to_pybuffer_contiguity():
     def check_strides(mat):
         # The full block is memset to 0, so fill it with non-zero in real spots.
-        expected = np.arange(1, mat.rows() * mat.cols() + 1).reshape((mat.rows(), mat.cols()))
+        expected = np.arange(1, mat.rows() * mat.cols() + 1).reshape(
+            (mat.rows(), mat.cols())
+        )
         for i in range(mat.rows()):
             for j in range(mat.cols()):
                 mat[i, j] = expected[i, j]