lint

Author: rok

docs/source/developers/python/development.rst

@@ -42,7 +42,7 @@ Unit Testing
 ============
 
 We are using `pytest <https://docs.pytest.org/en/latest/>`_ to develop our unit
-test suite. After `building the project <build_pyarrow>`_ you can run its unit tests
+test suite. After `building the project <building.html>`_ you can run its unit tests
 like so:
 
 .. code-block::
@@ -111,7 +111,7 @@ included in the distributed wheel packages.
 Running Type Checkers
 ---------------------
 
-We support multiple type checkers. The configuration for each is in
+We support multiple type checkers. Their configurations are in
 ``pyproject.toml``.
 
 **mypy**
@@ -157,19 +157,17 @@ When adding or modifying public APIs:
    to reflect the new or changed function/class signatures.
 
 2. **Include type annotations** where possible. For Cython modules or
-   dynamically, generated APIs such as compute kernels add the corresponding
+   dynamically generated APIs such as compute kernels add the corresponding
    stub in ``pyarrow-stubs/``.
 
 3. **Run type checkers** to ensure the stubs are correct and complete.
 
-The stub files are automatically copied to the built wheel during the build
+The stub files are automatically copied into the built wheel during the build
 process and will be included when users install PyArrow, enabling type checking
-in downstream projects.
+in downstream projects and for users' IDEs.
 
-.. note::
-
-   The ``py.typed`` marker file in the ``pyarrow/`` directory indicates to type
-   checkers that PyArrow supports type checking according to :pep:`561`.
+Note: ``py.typed`` marker file in the ``pyarrow/`` directory indicates to type
+checkers that PyArrow supports type checking according to :pep:`561`.
 
 Doctest
 =======

python/pyarrow/parquet/core.py

@@ -1413,7 +1413,9 @@ def __init__(self, path_or_paths, filesystem=None, schema=None, *, filters=None,
             else:
                 single_file = path_or_paths
 
-        parquet_format = ds.ParquetFileFormat(**read_options)  # type: ignore[invalid-argument-type]
+        parquet_format = ds.ParquetFileFormat(
+            **read_options  # type: ignore[invalid-argument-type]
+        )
 
         if single_file is not None:
             fragment = parquet_format.make_fragment(single_file, filesystem)

python/pyarrow/tests/parquet/test_pandas.py

@@ -571,15 +571,18 @@ def test_write_to_dataset_pandas_preserve_extensiondtypes(tempdir):
         table, str(tempdir / "case1"), partition_cols=['part'],
     )
     result = pq.read_table(str(tempdir / "case1")).to_pandas()
-    tm.assert_frame_equal(cast(pd.DataFrame, result[["col"]]), cast(pd.DataFrame, df[["col"]]))
+    tm.assert_frame_equal(
+        cast(pd.DataFrame, result[["col"]]), cast(pd.DataFrame, df[["col"]]))
 
     pq.write_to_dataset(table, str(tempdir / "case2"))
     result = pq.read_table(str(tempdir / "case2")).to_pandas()
-    tm.assert_frame_equal(cast(pd.DataFrame, result[["col"]]), cast(pd.DataFrame, df[["col"]]))
+    tm.assert_frame_equal(
+        cast(pd.DataFrame, result[["col"]]), cast(pd.DataFrame, df[["col"]]))
 
     pq.write_table(table, str(tempdir / "data.parquet"))
     result = pq.read_table(str(tempdir / "data.parquet")).to_pandas()
-    tm.assert_frame_equal(cast(pd.DataFrame, result[["col"]]), cast(pd.DataFrame, df[["col"]]))
+    tm.assert_frame_equal(
+        cast(pd.DataFrame, result[["col"]]), cast(pd.DataFrame, df[["col"]]))
 
 
 @pytest.mark.pandas

python/pyarrow/tests/parquet/test_parquet_file.py

@@ -262,9 +262,10 @@ def get_all_batches(f):
 
         tm.assert_frame_equal(
             batches[batch_no].to_pandas().reset_index(drop=True),
-            file_.read_row_groups([i]).to_pandas().iloc[900:].reset_index(  # type: ignore[arg-type]
-                drop=True
-            )
+            file_
+            .read_row_groups([i])
+            .to_pandas().iloc[900:]
+            .reset_index(drop=True)  # type: ignore[arg-type]
         )
 
         batch_no += 1

python/pyarrow/tests/test_acero.py

@@ -269,20 +269,23 @@ def test_order_by():
     table = pa.table({'a': [1, 2, 3, 4], 'b': [1, 3, None, 2]})
     table_source = Declaration("table_source", TableSourceNodeOptions(table))
 
-    sort_keys: list[tuple[str, Literal["ascending", "descending"]]] = [("b", "ascending")]
+    sort_keys = [("b", "ascending")]
+    sort_keys = cast(list[tuple[str, Literal["ascending", "descending"]]], sort_keys)
     ord_opts = OrderByNodeOptions(sort_keys)
     decl = Declaration.from_sequence([table_source, Declaration("order_by", ord_opts)])
     result = decl.to_table()
     expected = pa.table({"a": [1, 4, 2, 3], "b": [1, 2, 3, None]})
     assert result.equals(expected)
 
-    ord_opts = OrderByNodeOptions([(field("b"), "descending")])  # type: ignore[arg-type]
+    ord_opts = OrderByNodeOptions(
+        [(field("b"), "descending")])  # type: ignore[arg-type]
     decl = Declaration.from_sequence([table_source, Declaration("order_by", ord_opts)])
     result = decl.to_table()
     expected = pa.table({"a": [2, 4, 1, 3], "b": [3, 2, 1, None]})
     assert result.equals(expected)
 
-    ord_opts = OrderByNodeOptions([(1, "descending")], null_placement="at_start")  # type: ignore[arg-type]
+    ord_opts = OrderByNodeOptions(
+        [(1, "descending")], null_placement="at_start")  # type: ignore[arg-type]
     decl = Declaration.from_sequence([table_source, Declaration("order_by", ord_opts)])
     result = decl.to_table()
     expected = pa.table({"a": [3, 2, 4, 1], "b": [None, 3, 2, 1]})

python/pyarrow/tests/test_array.py

@@ -1192,15 +1192,15 @@ def test_map_from_arrays():
     assert result.equals(expected)
 
     # pass in the type explicitly
-    result = pa.MapArray.from_arrays(offsets, keys, items, pa.map_(  # type: ignore[arg-type]
-        keys.type,
-        items.type
-    ))
+    result = pa.MapArray.from_arrays(offsets, keys, items,  # type: ignore[arg-type]
+                                     pa.map_(keys.type, items.type))
     assert result.equals(expected)
 
     # pass in invalid types
     with pytest.raises(pa.ArrowTypeError, match='Expected map type, got string'):
-        pa.MapArray.from_arrays(offsets, keys, items, pa.string())  # type: ignore[arg-type]
+        pa.MapArray.from_arrays(
+            offsets, keys, items, pa.string()  # type: ignore[arg-type]
+        )
 
     with pytest.raises(pa.ArrowTypeError, match='Mismatching map items type'):
         pa.MapArray.from_arrays(offsets, keys, items, pa.map_(  # type: ignore[arg-type]

python/pyarrow/tests/test_fs.py

@@ -1440,20 +1440,23 @@ def test_s3_proxy_options(monkeypatch, pickle_module):
         S3FileSystem(proxy_options=('http', 'localhost', 9090))
     # Missing scheme
     with pytest.raises(KeyError):
-        S3FileSystem(proxy_options={'host': 'localhost', 'port': 9090})  # type: ignore[missing-typed-dict-key]
+        S3FileSystem(proxy_options={  # type: ignore[missing-typed-dict-key]
+            'host': 'localhost', 'port': 9090})
     # Missing host
     with pytest.raises(KeyError):
-        S3FileSystem(proxy_options={'scheme': 'https', 'port': 9090})  # type: ignore[missing-typed-dict-key]
+        S3FileSystem(proxy_options={  # type: ignore[missing-typed-dict-key]
+            'scheme': 'https', 'port': 9090})
     # Missing port
     with pytest.raises(KeyError):
-        S3FileSystem(proxy_options={'scheme': 'http', 'host': 'localhost'})  # type: ignore[missing-typed-dict-key]
+        S3FileSystem(proxy_options={  # type: ignore[missing-typed-dict-key]
+            'scheme': 'http', 'host': 'localhost'})
     # Invalid proxy URI (invalid scheme httpsB)
     with pytest.raises(pa.ArrowInvalid):
         S3FileSystem(proxy_options='httpsB://localhost:9000')
     # Invalid proxy_options dict (invalid scheme httpA)
     with pytest.raises(pa.ArrowInvalid):
-        S3FileSystem(proxy_options={'scheme': 'httpA', 'host': 'localhost',  # type: ignore[typeddict-item]
-                                    'port': 8999})
+        S3FileSystem(proxy_options={  # type: ignore[typeddict-item]
+            'scheme': 'httpA', 'host': 'localhost', 'port': 8999})
 
 
 @pytest.mark.s3

python/pyarrow/tests/test_ipc.py

@@ -393,7 +393,8 @@ def test_stream_write_table_batches(stream_fixture):
         'one': np.random.randn(20),
     })
 
-    b1 = pa.RecordBatch.from_pandas(df[:10], preserve_index=False)  # type: ignore[arg-type]
+    b1 = pa.RecordBatch.from_pandas(
+        df[:10], preserve_index=False)  # type: ignore[arg-type]
     b2 = pa.RecordBatch.from_pandas(df, preserve_index=False)
 
     table = pa.Table.from_batches([b1, b2, b1])
@@ -976,7 +977,8 @@ def test_batches_with_custom_metadata_roundtrip(ipc_type):
 
     with file_factory(sink, batch.schema) as writer:
         for i in range(batch_count):
-            writer.write_batch(batch, custom_metadata={"batch_id": str(i)})  # type: ignore[arg-type]
+            writer.write_batch(batch, custom_metadata={  # type: ignore[arg-type]
+                "batch_id": str(i)})
         # write a batch without custom metadata
         writer.write_batch(batch)