From 4ec11ac5c9e067409e92b0fd33de87e61b4644bd Mon Sep 17 00:00:00 2001 From: Ruifeng Zheng Date: Thu, 25 Dec 2025 20:26:11 +0800 Subject: [PATCH 1/5] fix --- python/pyarrow/_compute_docstrings.py | 57 +++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/python/pyarrow/_compute_docstrings.py b/python/pyarrow/_compute_docstrings.py index 150dbdb1175..2bf6f43f838 100644 --- a/python/pyarrow/_compute_docstrings.py +++ b/python/pyarrow/_compute_docstrings.py @@ -54,3 +54,60 @@ >>> modes[1] """ + +function_doc_additions["min"] = """ + Examples + -------- + >>> import pyarrow as pa + >>> import pyarrow.compute as pc + >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) + >>> pc.min(arr1) + + >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) + >>> pc.min(arr2) + + >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) + >>> pc.min(arr3) + + >>> arr4 = pa.array(["z", None, "y", "x"]) + >>> pc.min(arr4) + + """ + +function_doc_additions["max"] = """ + Examples + -------- + >>> import pyarrow as pa + >>> import pyarrow.compute as pc + >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) + >>> pc.max(arr1) + + >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) + >>> pc.max(arr2) + + >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) + >>> pc.max(arr3) + + >>> arr4 = pa.array(["z", None, "y", "x"]) + >>> pc.max(arr4) + + """ + +function_doc_additions["min_max"] = """ + Examples + -------- + >>> import pyarrow as pa + >>> import pyarrow.compute as pc + >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) + >>> pc.min_max(arr1) + + >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) + >>> pc.min_max(arr2) + + >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) + >>> pc.min_max(arr3) + + >>> arr4 = pa.array(["z", None, "y", "x"]) + >>> pc.min_max(arr4) + + """ From 4a1cfcefe376a4979ef124b2d31ae6b0c8e8e68e Mon Sep 17 00:00:00 2001 From: Ruifeng Zheng Date: Tue, 6 Jan 2026 21:39:53 +0800 Subject: [PATCH 2/5] fix --- python/pyarrow/_compute_docstrings.py | 45 +++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/python/pyarrow/_compute_docstrings.py b/python/pyarrow/_compute_docstrings.py index 2bf6f43f838..d6d7f368d31 100644 --- a/python/pyarrow/_compute_docstrings.py +++ b/python/pyarrow/_compute_docstrings.py @@ -63,12 +63,27 @@ >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) >>> pc.min(arr1) + + Using `skip_nulls` to handle null values. + >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.min(arr2) + >>> pc.min(arr2, skip_nulls=False) + + + Using `ScalarAggregateOptions` to control minimum number of non-null values. + >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) >>> pc.min(arr3) + >>> pc.min(arr3, options=pc.ScalarAggregateOptions(min_count=3)) + + >>> pc.min(arr3, options=pc.ScalarAggregateOptions(min_count=4)) + + + This function also works with string values. + >>> arr4 = pa.array(["z", None, "y", "x"]) >>> pc.min(arr4) @@ -82,12 +97,27 @@ >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) >>> pc.max(arr1) + + Using `skip_nulls` to handle null values. + >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.max(arr2) + >>> pc.max(arr2, skip_nulls=False) + + + Using `ScalarAggregateOptions` to control minimum number of non-null values. + >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) >>> pc.max(arr3) + >>> pc.max(arr3, options=pc.ScalarAggregateOptions(min_count=3)) + + >>> pc.max(arr3, options=pc.ScalarAggregateOptions(min_count=4)) + + + This function also works with string values. + >>> arr4 = pa.array(["z", None, "y", "x"]) >>> pc.max(arr4) @@ -100,13 +130,28 @@ >>> import pyarrow.compute as pc >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) >>> pc.min_max(arr1) + + Using `skip_nulls` to handle null values. + >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.min_max(arr2) + >>> pc.min_max(arr2, skip_nulls=False) + + + Using `ScalarAggregateOptions` to control minimum number of non-null values. + >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) >>> pc.min_max(arr3) + >>> pc.min_max(arr3, options=pc.ScalarAggregateOptions(min_count=3)) + + >>> pc.min_max(arr3, options=pc.ScalarAggregateOptions(min_count=4)) + + + This function also works with string values. + >>> arr4 = pa.array(["z", None, "y", "x"]) >>> pc.min_max(arr4) From f7a68c3846a2b7ffd945a1361e4111aa4c0e2111 Mon Sep 17 00:00:00 2001 From: Ruifeng Zheng Date: Tue, 6 Jan 2026 22:05:22 +0800 Subject: [PATCH 3/5] fix test --- python/pyarrow/tests/test_compute.py | 32 ++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py index c6b17e4791d..0893b28b2db 100644 --- a/python/pyarrow/tests/test_compute.py +++ b/python/pyarrow/tests/test_compute.py @@ -883,6 +883,38 @@ def test_generated_docstrings(): Alternative way of passing options. memory_pool : pyarrow.MemoryPool, optional If not passed, will allocate memory from the default memory pool. + + Examples + -------- + >>> import pyarrow as pa + >>> import pyarrow.compute as pc + >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) + >>> pc.min_max(arr1) + + Using `skip_nulls` to handle null values. + + + >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) + >>> pc.min_max(arr2) + + >>> pc.min_max(arr2, skip_nulls=False) + + + Using `ScalarAggregateOptions` to control minimum number of non-null values. + + >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) + >>> pc.min_max(arr3) + + >>> pc.min_max(arr3, options=pc.ScalarAggregateOptions(min_count=3)) + + >>> pc.min_max(arr3, options=pc.ScalarAggregateOptions(min_count=4)) + + + This function also works with string values. + + >>> arr4 = pa.array(["z", None, "y", "x"]) + >>> pc.min_max(arr4) + """) # Without options assert pc.add.__doc__ == textwrap.dedent("""\ From 317373cf712ed55bf8fe1c19e96fea2e7c8872dd Mon Sep 17 00:00:00 2001 From: Ruifeng Zheng Date: Wed, 7 Jan 2026 08:04:45 +0800 Subject: [PATCH 4/5] fix --- python/pyarrow/_compute_docstrings.py | 2 +- python/pyarrow/tests/test_compute.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/python/pyarrow/_compute_docstrings.py b/python/pyarrow/_compute_docstrings.py index d6d7f368d31..29e83f09a03 100644 --- a/python/pyarrow/_compute_docstrings.py +++ b/python/pyarrow/_compute_docstrings.py @@ -130,10 +130,10 @@ >>> import pyarrow.compute as pc >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) >>> pc.min_max(arr1) + Using `skip_nulls` to handle null values. - >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.min_max(arr2) diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py index 0893b28b2db..419fd806c23 100644 --- a/python/pyarrow/tests/test_compute.py +++ b/python/pyarrow/tests/test_compute.py @@ -890,10 +890,10 @@ def test_generated_docstrings(): >>> import pyarrow.compute as pc >>> arr1 = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) >>> pc.min_max(arr1) + Using `skip_nulls` to handle null values. - >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.min_max(arr2) From aa4985282502a92763570d10cae9acd74154f394 Mon Sep 17 00:00:00 2001 From: Ruifeng Zheng Date: Wed, 7 Jan 2026 21:18:01 +0800 Subject: [PATCH 5/5] Apply suggestions from code review Co-authored-by: Alenka Frim --- python/pyarrow/_compute_docstrings.py | 12 ++++++------ python/pyarrow/tests/test_compute.py | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/python/pyarrow/_compute_docstrings.py b/python/pyarrow/_compute_docstrings.py index 29e83f09a03..4b690dd1c57 100644 --- a/python/pyarrow/_compute_docstrings.py +++ b/python/pyarrow/_compute_docstrings.py @@ -64,7 +64,7 @@ >>> pc.min(arr1) - Using `skip_nulls` to handle null values. + Using ``skip_nulls`` to handle null values. >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.min(arr2) @@ -72,7 +72,7 @@ >>> pc.min(arr2, skip_nulls=False) - Using `ScalarAggregateOptions` to control minimum number of non-null values. + Using ``ScalarAggregateOptions`` to control minimum number of non-null values. >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) >>> pc.min(arr3) @@ -98,7 +98,7 @@ >>> pc.max(arr1) - Using `skip_nulls` to handle null values. + Using ``skip_nulls`` to handle null values. >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.max(arr2) @@ -106,7 +106,7 @@ >>> pc.max(arr2, skip_nulls=False) - Using `ScalarAggregateOptions` to control minimum number of non-null values. + Using ``ScalarAggregateOptions`` to control minimum number of non-null values. >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) >>> pc.max(arr3) @@ -132,7 +132,7 @@ >>> pc.min_max(arr1) - Using `skip_nulls` to handle null values. + Using ``skip_nulls`` to handle null values. >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.min_max(arr2) @@ -140,7 +140,7 @@ >>> pc.min_max(arr2, skip_nulls=False) - Using `ScalarAggregateOptions` to control minimum number of non-null values. + Using ``ScalarAggregateOptions`` to control minimum number of non-null values. >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) >>> pc.min_max(arr3) diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py index 419fd806c23..d8a1c4d093e 100644 --- a/python/pyarrow/tests/test_compute.py +++ b/python/pyarrow/tests/test_compute.py @@ -892,7 +892,7 @@ def test_generated_docstrings(): >>> pc.min_max(arr1) - Using `skip_nulls` to handle null values. + Using ``skip_nulls`` to handle null values. >>> arr2 = pa.array([1.0, None, 2.0, 3.0]) >>> pc.min_max(arr2) @@ -900,7 +900,7 @@ def test_generated_docstrings(): >>> pc.min_max(arr2, skip_nulls=False) - Using `ScalarAggregateOptions` to control minimum number of non-null values. + Using ``ScalarAggregateOptions`` to control minimum number of non-null values. >>> arr3 = pa.array([1.0, None, float("nan"), 3.0]) >>> pc.min_max(arr3)