Add files using upload-large-folder tool

.gitattributes

@@ -2153,3 +2153,20 @@ infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/groupby.cpython-310-x86_6
 infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/hashing.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 infer_4_30_0/lib/python3.10/site-packages/altair/vegalite/v5/schema/__pycache__/core.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/index.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/missing.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/sparse.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/lib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/testing.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/internals.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseek/lib/python3.10/site-packages/nvidia/curand/lib/libcurand.so.10 filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/interval.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/tzconversion.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/hashtable.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/reshape.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/ops.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/fields.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/period.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/timestamps.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/dtypes.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/nattype.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

deepseek/lib/python3.10/site-packages/nvidia/curand/lib/libcurand.so.10

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dab8074b610b82a863a42eceda788e9b08364b545bab948509306b48c46018cf
+size 96525744

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/hashtable.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4cc2ad0a28ef26e4e23045485710310dcf84e73fee57d8c23fb5f7d47e2855a
+size 2162216

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/internals.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6703cc1493b6d1ddd5d017acd97b822a3050a7b5939242111b8db20e3fc61cff
+size 415592

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/interval.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55d89065c918f5d8eae09cc25b7b21479c288e1b5c7b1b4d0ef83bf08af8d521
+size 1528808

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/lib.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:524c92ee2ccb5583f8ca8adac91ae0afa3f43db0ea0456ab0aece9ccacb87273
+size 933480

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/missing.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe110ce6b3b10095c1c4c2f7745c02223aec6fcd4aa6cbc6782f83df72e77620
+size 211400

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/ops.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c89028f0caa0df725cb3e89514edf7e8a4f4abdaace336d8bdf4040db291928
+size 270472

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/reshape.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:379e0968c40307a1dd2ee93593b0ef888b1fcdffc9e7b4def9b6d41bcff80ce1
+size 309608

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/sparse.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9d4b81d1da2d284b1f61370c3e87b54de10f249a3debb14f7ad7bbf2c100523
+size 988968

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/testing.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5f7c4ecc85c1d9b0452ec4b031757c5e9aa0a893d46f47caead6a32115ffb73
+size 127456

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslib.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f28ec212e94a75d6066e383be4243e1317de1339e61ad445b8a79f0aed216136
+size 340264

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/dtypes.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7bfd05b7ddda111668cc65264b433f64bca56626e8f077954f53cbbe4423319
+size 202624

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/fields.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec8574945550f774a538695ccb3dac25ade35c419ec191d195dbe4919b73e2df
+size 345064

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/nattype.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6669ad3ce3c3efbda83d69097e963e85f8617d91a388da39b12bea940048b58
+size 237184

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/period.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b08d39a4fb6d3dd4d20d5043a2029f6b4f1c380ef9c8b8a60322c919af50c687
+size 532232

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/timestamps.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe91ba0e49ec3818ec96f0dd02eef9cb95774573e2ff136b47dba565e35c0105
+size 660840

infer_4_30_0/lib/python3.10/site-packages/pandas/_libs/tslibs/tzconversion.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b587802ccc8a49d5c0bb70c1fc96c45915d6a2705787de833db44fb9860db90
+size 340840

infer_4_30_0/lib/python3.10/site-packages/pandas/tests/construction/test_extract_array.py

@@ -0,0 +1,18 @@
+from pandas import Index
+import pandas._testing as tm
+from pandas.core.construction import extract_array
+
+
+def test_extract_array_rangeindex():
+    ri = Index(range(5))
+
+    expected = ri._values
+    res = extract_array(ri, extract_numpy=True, extract_range=True)
+    tm.assert_numpy_array_equal(res, expected)
+    res = extract_array(ri, extract_numpy=False, extract_range=True)
+    tm.assert_numpy_array_equal(res, expected)
+
+    res = extract_array(ri, extract_numpy=True, extract_range=False)
+    tm.assert_index_equal(res, ri)
+    res = extract_array(ri, extract_numpy=False, extract_range=False)
+    tm.assert_index_equal(res, ri)

infer_4_30_0/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_can_hold_element.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+from pandas.core.dtypes.cast import can_hold_element
+
+
+def test_can_hold_element_range(any_int_numpy_dtype):
+    # GH#44261
+    dtype = np.dtype(any_int_numpy_dtype)
+    arr = np.array([], dtype=dtype)
+
+    rng = range(2, 127)
+    assert can_hold_element(arr, rng)
+
+    # negatives -> can't be held by uint dtypes
+    rng = range(-2, 127)
+    if dtype.kind == "i":
+        assert can_hold_element(arr, rng)
+    else:
+        assert not can_hold_element(arr, rng)
+
+    rng = range(2, 255)
+    if dtype == "int8":
+        assert not can_hold_element(arr, rng)
+    else:
+        assert can_hold_element(arr, rng)
+
+    rng = range(-255, 65537)
+    if dtype.kind == "u":
+        assert not can_hold_element(arr, rng)
+    elif dtype.itemsize < 4:
+        assert not can_hold_element(arr, rng)
+    else:
+        assert can_hold_element(arr, rng)
+
+    # empty
+    rng = range(-(10**10), -(10**10))
+    assert len(rng) == 0
+    # assert can_hold_element(arr, rng)
+
+    rng = range(10**10, 10**10)
+    assert len(rng) == 0
+    assert can_hold_element(arr, rng)
+
+
+def test_can_hold_element_int_values_float_ndarray():
+    arr = np.array([], dtype=np.int64)
+
+    element = np.array([1.0, 2.0])
+    assert can_hold_element(arr, element)
+
+    assert not can_hold_element(arr, element + 0.5)
+
+    # integer but not losslessly castable to int64
+    element = np.array([3, 2**65], dtype=np.float64)
+    assert not can_hold_element(arr, element)
+
+
+def test_can_hold_element_int8_int():
+    arr = np.array([], dtype=np.int8)
+
+    element = 2
+    assert can_hold_element(arr, element)
+    assert can_hold_element(arr, np.int8(element))
+    assert can_hold_element(arr, np.uint8(element))
+    assert can_hold_element(arr, np.int16(element))
+    assert can_hold_element(arr, np.uint16(element))
+    assert can_hold_element(arr, np.int32(element))
+    assert can_hold_element(arr, np.uint32(element))
+    assert can_hold_element(arr, np.int64(element))
+    assert can_hold_element(arr, np.uint64(element))
+
+    element = 2**9
+    assert not can_hold_element(arr, element)
+    assert not can_hold_element(arr, np.int16(element))
+    assert not can_hold_element(arr, np.uint16(element))
+    assert not can_hold_element(arr, np.int32(element))
+    assert not can_hold_element(arr, np.uint32(element))
+    assert not can_hold_element(arr, np.int64(element))
+    assert not can_hold_element(arr, np.uint64(element))

infer_4_30_0/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_construct_from_scalar.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import construct_1d_arraylike_from_scalar
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+from pandas import (
+    Categorical,
+    Timedelta,
+)
+import pandas._testing as tm
+
+
+def test_cast_1d_array_like_from_scalar_categorical():
+    # see gh-19565
+    #
+    # Categorical result from scalar did not maintain
+    # categories and ordering of the passed dtype.
+    cats = ["a", "b", "c"]
+    cat_type = CategoricalDtype(categories=cats, ordered=False)
+    expected = Categorical(["a", "a"], categories=cats)
+
+    result = construct_1d_arraylike_from_scalar("a", len(expected), cat_type)
+    tm.assert_categorical_equal(result, expected)
+
+
+def test_cast_1d_array_like_from_timestamp(fixed_now_ts):
+    # check we dont lose nanoseconds
+    ts = fixed_now_ts + Timedelta(1)
+    res = construct_1d_arraylike_from_scalar(ts, 2, np.dtype("M8[ns]"))
+    assert res[0] == ts
+
+
+def test_cast_1d_array_like_from_timedelta():
+    # check we dont lose nanoseconds
+    td = Timedelta(1)
+    res = construct_1d_arraylike_from_scalar(td, 2, np.dtype("m8[ns]"))
+    assert res[0] == td
+
+
+def test_cast_1d_array_like_mismatched_datetimelike():
+    td = np.timedelta64("NaT", "ns")
+    dt = np.datetime64("NaT", "ns")
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(td, 2, dt.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(np.timedelta64(4, "ns"), 2, dt.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(dt, 2, td.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(np.datetime64(4, "ns"), 2, td.dtype)

infer_4_30_0/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_construct_ndarray.py

@@ -0,0 +1,36 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.construction import sanitize_array
+
+
+@pytest.mark.parametrize(
+    "values, dtype, expected",
+    [
+        ([1, 2, 3], None, np.array([1, 2, 3], dtype=np.int64)),
+        (np.array([1, 2, 3]), None, np.array([1, 2, 3])),
+        (["1", "2", None], None, np.array(["1", "2", None])),
+        (["1", "2", None], np.dtype("str"), np.array(["1", "2", None])),
+        ([1, 2, None], np.dtype("str"), np.array(["1", "2", None])),
+    ],
+)
+def test_construct_1d_ndarray_preserving_na(
+    values, dtype, expected, using_infer_string
+):
+    result = sanitize_array(values, index=None, dtype=dtype)
+    if using_infer_string and expected.dtype == object and dtype is None:
+        tm.assert_extension_array_equal(result, pd.array(expected))
+    else:
+        tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["m8[ns]", "M8[ns]"])
+def test_construct_1d_ndarray_preserving_na_datetimelike(dtype):
+    arr = np.arange(5, dtype=np.int64).view(dtype)
+    expected = np.array(list(arr), dtype=object)
+    assert all(isinstance(x, type(arr[0])) for x in expected)
+
+    result = sanitize_array(arr, index=None, dtype=np.dtype(object))
+    tm.assert_numpy_array_equal(result, expected)

infer_4_30_0/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_construct_object_arr.py

@@ -0,0 +1,20 @@
+import pytest
+
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+
+
+@pytest.mark.parametrize("datum1", [1, 2.0, "3", (4, 5), [6, 7], None])
+@pytest.mark.parametrize("datum2", [8, 9.0, "10", (11, 12), [13, 14], None])
+def test_cast_1d_array(datum1, datum2):
+    data = [datum1, datum2]
+    result = construct_1d_object_array_from_listlike(data)
+
+    # Direct comparison fails: https://github.com/numpy/numpy/issues/10218
+    assert result.dtype == "object"
+    assert list(result) == data
+
+
+@pytest.mark.parametrize("val", [1, 2.0, None])
+def test_cast_1d_array_invalid_scalar(val):
+    with pytest.raises(TypeError, match="has no len()"):
+        construct_1d_object_array_from_listlike(val)

infer_4_30_0/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_dict_compat.py

@@ -0,0 +1,14 @@
+import numpy as np
+
+from pandas.core.dtypes.cast import dict_compat
+
+from pandas import Timestamp
+
+
+def test_dict_compat():
+    data_datetime64 = {np.datetime64("1990-03-15"): 1, np.datetime64("2015-03-15"): 2}
+    data_unchanged = {1: 2, 3: 4, 5: 6}
+    expected = {Timestamp("1990-3-15"): 1, Timestamp("2015-03-15"): 2}
+    assert dict_compat(data_datetime64) == expected
+    assert dict_compat(expected) == expected
+    assert dict_compat(data_unchanged) == data_unchanged

infer_4_30_0/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_downcast.py

@@ -0,0 +1,97 @@
+import decimal
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import maybe_downcast_to_dtype
+
+from pandas import (
+    Series,
+    Timedelta,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "arr,dtype,expected",
+    [
+        (
+            np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995]),
+            "infer",
+            np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995]),
+        ),
+        (
+            np.array([8.0, 8.0, 8.0, 8.0, 8.9999999999995]),
+            "infer",
+            np.array([8, 8, 8, 8, 9], dtype=np.int64),
+        ),
+        (
+            np.array([8.0, 8.0, 8.0, 8.0, 9.0000000000005]),
+            "infer",
+            np.array([8, 8, 8, 8, 9], dtype=np.int64),
+        ),
+        (
+            # This is a judgement call, but we do _not_ downcast Decimal
+            #  objects
+            np.array([decimal.Decimal(0.0)]),
+            "int64",
+            np.array([decimal.Decimal(0.0)]),
+        ),
+        (
+            # GH#45837
+            np.array([Timedelta(days=1), Timedelta(days=2)], dtype=object),
+            "infer",
+            np.array([1, 2], dtype="m8[D]").astype("m8[ns]"),
+        ),
+        # TODO: similar for dt64, dt64tz, Period, Interval?
+    ],
+)
+def test_downcast(arr, expected, dtype):
+    result = maybe_downcast_to_dtype(arr, dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_downcast_booleans():
+    # see gh-16875: coercing of booleans.
+    ser = Series([True, True, False])
+    result = maybe_downcast_to_dtype(ser, np.dtype(np.float64))
+
+    expected = ser.values
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_downcast_conversion_no_nan(any_real_numpy_dtype):
+    dtype = any_real_numpy_dtype
+    expected = np.array([1, 2])
+    arr = np.array([1.0, 2.0], dtype=dtype)
+
+    result = maybe_downcast_to_dtype(arr, "infer")
+    tm.assert_almost_equal(result, expected, check_dtype=False)
+
+
+def test_downcast_conversion_nan(float_numpy_dtype):
+    dtype = float_numpy_dtype
+    data = [1.0, 2.0, np.nan]
+
+    expected = np.array(data, dtype=dtype)
+    arr = np.array(data, dtype=dtype)
+
+    result = maybe_downcast_to_dtype(arr, "infer")
+    tm.assert_almost_equal(result, expected)
+
+
+def test_downcast_conversion_empty(any_real_numpy_dtype):
+    dtype = any_real_numpy_dtype
+    arr = np.array([], dtype=dtype)
+    result = maybe_downcast_to_dtype(arr, np.dtype("int64"))
+    tm.assert_numpy_array_equal(result, np.array([], dtype=np.int64))
+
+
+@pytest.mark.parametrize("klass", [np.datetime64, np.timedelta64])
+def test_datetime_likes_nan(klass):
+    dtype = klass.__name__ + "[ns]"
+    arr = np.array([1, 2, np.nan])
+
+    exp = np.array([1, 2, klass("NaT")], dtype)
+    res = maybe_downcast_to_dtype(arr, dtype)
+    tm.assert_numpy_array_equal(res, exp)

infer_4_30_0/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_find_common_type.py

@@ -0,0 +1,175 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import find_common_type
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    IntervalDtype,
+    PeriodDtype,
+)
+
+from pandas import (
+    Categorical,
+    Index,
+)
+
+
+@pytest.mark.parametrize(
+    "source_dtypes,expected_common_dtype",
+    [
+        ((np.int64,), np.int64),
+        ((np.uint64,), np.uint64),
+        ((np.float32,), np.float32),
+        ((object,), object),
+        # Into ints.
+        ((np.int16, np.int64), np.int64),
+        ((np.int32, np.uint32), np.int64),
+        ((np.uint16, np.uint64), np.uint64),
+        # Into floats.
+        ((np.float16, np.float32), np.float32),
+        ((np.float16, np.int16), np.float32),
+        ((np.float32, np.int16), np.float32),
+        ((np.uint64, np.int64), np.float64),
+        ((np.int16, np.float64), np.float64),
+        ((np.float16, np.int64), np.float64),
+        # Into others.
+        ((np.complex128, np.int32), np.complex128),
+        ((object, np.float32), object),
+        ((object, np.int16), object),
+        # Bool with int.
+        ((np.dtype("bool"), np.int64), object),
+        ((np.dtype("bool"), np.int32), object),
+        ((np.dtype("bool"), np.int16), object),
+        ((np.dtype("bool"), np.int8), object),
+        ((np.dtype("bool"), np.uint64), object),
+        ((np.dtype("bool"), np.uint32), object),
+        ((np.dtype("bool"), np.uint16), object),
+        ((np.dtype("bool"), np.uint8), object),
+        # Bool with float.
+        ((np.dtype("bool"), np.float64), object),
+        ((np.dtype("bool"), np.float32), object),
+        (
+            (np.dtype("datetime64[ns]"), np.dtype("datetime64[ns]")),
+            np.dtype("datetime64[ns]"),
+        ),
+        (
+            (np.dtype("timedelta64[ns]"), np.dtype("timedelta64[ns]")),
+            np.dtype("timedelta64[ns]"),
+        ),
+        (
+            (np.dtype("datetime64[ns]"), np.dtype("datetime64[ms]")),
+            np.dtype("datetime64[ns]"),
+        ),
+        (
+            (np.dtype("timedelta64[ms]"), np.dtype("timedelta64[ns]")),
+            np.dtype("timedelta64[ns]"),
+        ),
+        ((np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]")), object),
+        ((np.dtype("datetime64[ns]"), np.int64), object),
+    ],
+)
+def test_numpy_dtypes(source_dtypes, expected_common_dtype):
+    source_dtypes = [pandas_dtype(x) for x in source_dtypes]
+    assert find_common_type(source_dtypes) == expected_common_dtype
+
+
+def test_raises_empty_input():
+    with pytest.raises(ValueError, match="no types given"):
+        find_common_type([])
+
+
+@pytest.mark.parametrize(
+    "dtypes,exp_type",
+    [
+        ([CategoricalDtype()], "category"),
+        ([object, CategoricalDtype()], object),
+        ([CategoricalDtype(), CategoricalDtype()], "category"),
+    ],
+)
+def test_categorical_dtype(dtypes, exp_type):
+    assert find_common_type(dtypes) == exp_type
+
+
+def test_datetimetz_dtype_match():
+    dtype = DatetimeTZDtype(unit="ns", tz="US/Eastern")
+    assert find_common_type([dtype, dtype]) == "datetime64[ns, US/Eastern]"
+
+
+@pytest.mark.parametrize(
+    "dtype2",
+    [
+        DatetimeTZDtype(unit="ns", tz="Asia/Tokyo"),
+        np.dtype("datetime64[ns]"),
+        object,
+        np.int64,
+    ],
+)
+def test_datetimetz_dtype_mismatch(dtype2):
+    dtype = DatetimeTZDtype(unit="ns", tz="US/Eastern")
+    assert find_common_type([dtype, dtype2]) == object
+    assert find_common_type([dtype2, dtype]) == object
+
+
+def test_period_dtype_match():
+    dtype = PeriodDtype(freq="D")
+    assert find_common_type([dtype, dtype]) == "period[D]"
+
+
+@pytest.mark.parametrize(
+    "dtype2",
+    [
+        DatetimeTZDtype(unit="ns", tz="Asia/Tokyo"),
+        PeriodDtype(freq="2D"),
+        PeriodDtype(freq="h"),
+        np.dtype("datetime64[ns]"),
+        object,
+        np.int64,
+    ],
+)
+def test_period_dtype_mismatch(dtype2):
+    dtype = PeriodDtype(freq="D")
+    assert find_common_type([dtype, dtype2]) == object
+    assert find_common_type([dtype2, dtype]) == object
+
+
+interval_dtypes = [
+    IntervalDtype(np.int64, "right"),
+    IntervalDtype(np.float64, "right"),
+    IntervalDtype(np.uint64, "right"),
+    IntervalDtype(DatetimeTZDtype(unit="ns", tz="US/Eastern"), "right"),
+    IntervalDtype("M8[ns]", "right"),
+    IntervalDtype("m8[ns]", "right"),
+]
+
+
+@pytest.mark.parametrize("left", interval_dtypes)
+@pytest.mark.parametrize("right", interval_dtypes)
+def test_interval_dtype(left, right):
+    result = find_common_type([left, right])
+
+    if left is right:
+        assert result is left
+
+    elif left.subtype.kind in ["i", "u", "f"]:
+        # i.e. numeric
+        if right.subtype.kind in ["i", "u", "f"]:
+            # both numeric -> common numeric subtype
+            expected = IntervalDtype(np.float64, "right")
+            assert result == expected
+        else:
+            assert result == object
+
+    else:
+        assert result == object
+
+
+@pytest.mark.parametrize("dtype", interval_dtypes)
+def test_interval_dtype_with_categorical(dtype):
+    obj = Index([], dtype=dtype)
+
+    cat = Categorical([], categories=obj)
+
+    result = find_common_type([dtype, cat.dtype])
+    assert result == dtype