)

import numpy as np
import pytest

import pandas as pd
from pandas import (
    DataFrame,
    Series,

            

Reported by Pylint.

              
@all_ts
@pytest.mark.parametrize("arg", ["mean", {"value": "mean"}, ["mean"]])
def test_resample_loffset_arg_type(frame, create_index, arg):
    # GH 13218, 15002
    df = frame
    expected_means = [df.values[i : i + 2].mean() for i in range(0, len(df.values), 2)]
    expected_index = create_index(df.index[0], periods=len(df.index) / 2, freq="2D")


            

Reported by Pylint.

                  with tm.assert_produces_warning(FutureWarning):
        expected = s.to_timestamp().resample(end_freq, base=base).mean()
    if end_freq == "M":
        # TODO: is non-tick the relevant characteristic? (GH 33815)
        expected.index = expected.index._with_freq(None)
    tm.assert_series_equal(result, expected)


def test_resample_base_with_timedeltaindex():

            

Reported by Pylint.

                      expected = s.to_timestamp().resample(end_freq, base=base).mean()
    if end_freq == "M":
        # TODO: is non-tick the relevant characteristic? (GH 33815)
        expected.index = expected.index._with_freq(None)
    tm.assert_series_equal(result, expected)


def test_resample_base_with_timedeltaindex():
    # GH 10530

            

Reported by Pylint.

                  )
    expected = Series([1.0, 1.0, 1.0, 1.0], index=idx)

    expected.index._data.freq = "3s"
    tm.assert_series_equal(result, expected)

            

Reported by Pylint.

              from datetime import (
    datetime,
    timedelta,
)

import numpy as np
import pytest

import pandas as pd

            

Reported by Pylint.

              

@pytest.fixture
def create_index(_index_factory):
    def _create_index(*args, **kwargs):
        """return the _index_factory created using the args, kwargs"""
        return _index_factory(*args, **kwargs)

    return _create_index

            

Reported by Pylint.

              

# new test to check that all FutureWarning are triggered
def test_deprecating_on_loffset_and_base():
    # GH 31809

    idx = date_range("2001-01-01", periods=4, freq="T")
    df = DataFrame(data=4 * [range(2)], index=idx, columns=["a", "b"])


            

Reported by Pylint.

                  # GH 31809

    idx = date_range("2001-01-01", periods=4, freq="T")
    df = DataFrame(data=4 * [range(2)], index=idx, columns=["a", "b"])

    with tm.assert_produces_warning(FutureWarning):
        pd.Grouper(freq="10s", base=0)
    with tm.assert_produces_warning(FutureWarning):
        pd.Grouper(freq="10s", loffset="0s")

            

Reported by Pylint.

              
@all_ts
@pytest.mark.parametrize("arg", ["mean", {"value": "mean"}, ["mean"]])
def test_resample_loffset_arg_type(frame, create_index, arg):
    # GH 13218, 15002
    df = frame
    expected_means = [df.values[i : i + 2].mean() for i in range(0, len(df.values), 2)]
    expected_index = create_index(df.index[0], periods=len(df.index) / 2, freq="2D")


            

Reported by Pylint.

              import numpy as np
import pytest

import pandas as pd
import pandas._testing as tm


def test_astype():
    # with missing values

            

Reported by Pylint.

                  # copy=True -> ensure both data and mask are actual copies
    result = arr.astype("Float64", copy=True)
    assert result is not arr
    assert not np.shares_memory(result._data, arr._data)
    assert not np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    tm.assert_extension_array_equal(arr, orig)
    result[0] = pd.NA
    tm.assert_extension_array_equal(arr, orig)

            

Reported by Pylint.

                  # copy=True -> ensure both data and mask are actual copies
    result = arr.astype("Float64", copy=True)
    assert result is not arr
    assert not np.shares_memory(result._data, arr._data)
    assert not np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    tm.assert_extension_array_equal(arr, orig)
    result[0] = pd.NA
    tm.assert_extension_array_equal(arr, orig)

            

Reported by Pylint.

                  result = arr.astype("Float64", copy=True)
    assert result is not arr
    assert not np.shares_memory(result._data, arr._data)
    assert not np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    tm.assert_extension_array_equal(arr, orig)
    result[0] = pd.NA
    tm.assert_extension_array_equal(arr, orig)


            

Reported by Pylint.

                  result = arr.astype("Float64", copy=True)
    assert result is not arr
    assert not np.shares_memory(result._data, arr._data)
    assert not np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    tm.assert_extension_array_equal(arr, orig)
    result[0] = pd.NA
    tm.assert_extension_array_equal(arr, orig)


            

Reported by Pylint.

                  # copy=False
    result = arr.astype("Float64", copy=False)
    assert result is arr
    assert np.shares_memory(result._data, arr._data)
    assert np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    assert arr[0] == 10
    result[0] = pd.NA
    assert arr[0] is pd.NA

            

Reported by Pylint.

                  # copy=False
    result = arr.astype("Float64", copy=False)
    assert result is arr
    assert np.shares_memory(result._data, arr._data)
    assert np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    assert arr[0] == 10
    result[0] = pd.NA
    assert arr[0] is pd.NA

            

Reported by Pylint.

                  result = arr.astype("Float64", copy=False)
    assert result is arr
    assert np.shares_memory(result._data, arr._data)
    assert np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    assert arr[0] == 10
    result[0] = pd.NA
    assert arr[0] is pd.NA


            

Reported by Pylint.

                  result = arr.astype("Float64", copy=False)
    assert result is arr
    assert np.shares_memory(result._data, arr._data)
    assert np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    assert arr[0] == 10
    result[0] = pd.NA
    assert arr[0] is pd.NA


            

Reported by Pylint.

                  orig = pd.array([0.1, 0.2, None], dtype="Float64")

    result = arr.astype("Float32", copy=False)
    assert not np.shares_memory(result._data, arr._data)
    assert not np.shares_memory(result._mask, arr._mask)
    result[0] = 10
    tm.assert_extension_array_equal(arr, orig)
    result[0] = pd.NA
    tm.assert_extension_array_equal(arr, orig)

            

Reported by Pylint.

              import pytest

import pandas as pd


class TestFlags:
    def test_equality(self):
        a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

            

Reported by Pylint.

                      assert flags["allows_duplicate_labels"] is False

        with pytest.raises(KeyError, match="a"):
            flags["a"]

        with pytest.raises(ValueError, match="a"):
            flags["a"] = 10

            

Reported by Pylint.

              import pytest

import pandas as pd


class TestFlags:
    def test_equality(self):
        a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

            

Reported by Pylint.

              import pandas as pd


class TestFlags:
    def test_equality(self):
        a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

        assert a == a

            

Reported by Pylint.

              

class TestFlags:
    def test_equality(self):
        a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

        assert a == a
        assert b == b

            

Reported by Pylint.

              

class TestFlags:
    def test_equality(self):
        a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

        assert a == a
        assert b == b

            

Reported by Pylint.

              
class TestFlags:
    def test_equality(self):
        a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

        assert a == a
        assert b == b
        assert a != b

            

Reported by Pylint.

              class TestFlags:
    def test_equality(self):
        a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

        assert a == a
        assert b == b
        assert a != b
        assert a != 2

            

Reported by Pylint.

                      a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

        assert a == a
        assert b == b
        assert a != b
        assert a != 2

    def test_set(self):

            

Reported by Bandit.

                      a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags

        assert a == a
        assert b == b
        assert a != b
        assert a != 2

    def test_set(self):

            

Reported by Pylint.

              import numpy as np
import pytest

import pandas as pd
import pandas._testing as tm


@pytest.mark.parametrize(
    "ufunc", [np.add, np.logical_or, np.logical_and, np.logical_xor]

            

Reported by Pylint.

                  # two BooleanArrays
    a = pd.array([True, False, None], dtype="boolean")
    result = ufunc(a, a)
    expected = pd.array(ufunc(a._data, a._data), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_extension_array_equal(result, expected)

    s = pd.Series(a)
    result = ufunc(s, a)

            

Reported by Pylint.

                  # two BooleanArrays
    a = pd.array([True, False, None], dtype="boolean")
    result = ufunc(a, a)
    expected = pd.array(ufunc(a._data, a._data), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_extension_array_equal(result, expected)

    s = pd.Series(a)
    result = ufunc(s, a)

            

Reported by Pylint.

                  a = pd.array([True, False, None], dtype="boolean")
    result = ufunc(a, a)
    expected = pd.array(ufunc(a._data, a._data), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_extension_array_equal(result, expected)

    s = pd.Series(a)
    result = ufunc(s, a)
    expected = pd.Series(ufunc(a._data, a._data), dtype="boolean")

            

Reported by Pylint.

              
    s = pd.Series(a)
    result = ufunc(s, a)
    expected = pd.Series(ufunc(a._data, a._data), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_series_equal(result, expected)

    # Boolean with numpy array
    arr = np.array([True, True, False])

            

Reported by Pylint.

              
    s = pd.Series(a)
    result = ufunc(s, a)
    expected = pd.Series(ufunc(a._data, a._data), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_series_equal(result, expected)

    # Boolean with numpy array
    arr = np.array([True, True, False])

            

Reported by Pylint.

                  s = pd.Series(a)
    result = ufunc(s, a)
    expected = pd.Series(ufunc(a._data, a._data), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_series_equal(result, expected)

    # Boolean with numpy array
    arr = np.array([True, True, False])
    result = ufunc(a, arr)

            

Reported by Pylint.

                  # Boolean with numpy array
    arr = np.array([True, True, False])
    result = ufunc(a, arr)
    expected = pd.array(ufunc(a._data, arr), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_extension_array_equal(result, expected)

    result = ufunc(arr, a)
    expected = pd.array(ufunc(arr, a._data), dtype="boolean")

            

Reported by Pylint.

                  arr = np.array([True, True, False])
    result = ufunc(a, arr)
    expected = pd.array(ufunc(a._data, arr), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_extension_array_equal(result, expected)

    result = ufunc(arr, a)
    expected = pd.array(ufunc(arr, a._data), dtype="boolean")
    expected[a._mask] = np.nan

            

Reported by Pylint.

                  tm.assert_extension_array_equal(result, expected)

    result = ufunc(arr, a)
    expected = pd.array(ufunc(arr, a._data), dtype="boolean")
    expected[a._mask] = np.nan
    tm.assert_extension_array_equal(result, expected)

    # BooleanArray with scalar
    result = ufunc(a, True)

            

Reported by Pylint.

              import numpy as np
import pytest

import pandas as pd
from pandas import (
    DataFrame,
    Series,
    date_range,
)

            

Reported by Pylint.

              import numpy as np
import pytest

import pandas as pd
from pandas import (
    DataFrame,
    Series,
    date_range,
)

            

Reported by Pylint.

              import pandas._testing as tm


class TestDataFrameUpdate:
    def test_update_nan(self):
        # #15593 #15617
        # test 1
        df1 = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
        df2 = DataFrame({"A": [None, 2, 3]})

            

Reported by Pylint.

              

class TestDataFrameUpdate:
    def test_update_nan(self):
        # #15593 #15617
        # test 1
        df1 = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
        df2 = DataFrame({"A": [None, 2, 3]})
        expected = df1.copy()

            

Reported by Pylint.

              

class TestDataFrameUpdate:
    def test_update_nan(self):
        # #15593 #15617
        # test 1
        df1 = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
        df2 = DataFrame({"A": [None, 2, 3]})
        expected = df1.copy()

            

Reported by Pylint.

              
        tm.assert_frame_equal(df1, expected)

    def test_update(self):
        df = DataFrame(
            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
        )

        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])

            

Reported by Pylint.

              
        tm.assert_frame_equal(df1, expected)

    def test_update(self):
        df = DataFrame(
            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
        )

        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])

            

Reported by Pylint.

                      tm.assert_frame_equal(df1, expected)

    def test_update(self):
        df = DataFrame(
            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
        )

        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])


            

Reported by Pylint.

                      )
        tm.assert_frame_equal(df, expected)

    def test_update_dtypes(self):

        # gh 3016
        df = DataFrame(
            [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
            columns=["A", "B", "bool1", "bool2"],

            

Reported by Pylint.

                      )
        tm.assert_frame_equal(df, expected)

    def test_update_dtypes(self):

        # gh 3016
        df = DataFrame(
            [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
            columns=["A", "B", "bool1", "bool2"],

            

Reported by Pylint.

              import numpy as np
import pytest

from pandas._libs.missing import is_matching_na

import pandas as pd
from pandas import Index
import pandas._testing as tm


            

Reported by Pylint.

              import numpy as np
import pytest

from pandas._libs.missing import is_matching_na

import pandas as pd
from pandas import Index
import pandas._testing as tm


            

Reported by Pylint.

              import numpy as np
import pytest

from pandas._libs.missing import is_matching_na

import pandas as pd
from pandas import Index
import pandas._testing as tm


            

Reported by Pylint.

              import numpy as np
import pytest

from pandas._libs.missing import is_matching_na

import pandas as pd
from pandas import Index
import pandas._testing as tm


            

Reported by Pylint.

              import pandas._testing as tm


class TestGetLoc:
    def test_get_loc_raises_object_nearest(self):
        index = Index(["a", "c"])
        with pytest.raises(TypeError, match="unsupported operand type"):
            with tm.assert_produces_warning(FutureWarning, match="deprecated"):
                index.get_loc("a", method="nearest")

            

Reported by Pylint.

              

class TestGetLoc:
    def test_get_loc_raises_object_nearest(self):
        index = Index(["a", "c"])
        with pytest.raises(TypeError, match="unsupported operand type"):
            with tm.assert_produces_warning(FutureWarning, match="deprecated"):
                index.get_loc("a", method="nearest")


            

Reported by Pylint.

              

class TestGetLoc:
    def test_get_loc_raises_object_nearest(self):
        index = Index(["a", "c"])
        with pytest.raises(TypeError, match="unsupported operand type"):
            with tm.assert_produces_warning(FutureWarning, match="deprecated"):
                index.get_loc("a", method="nearest")


            

Reported by Pylint.

                          with tm.assert_produces_warning(FutureWarning, match="deprecated"):
                index.get_loc("a", method="nearest")

    def test_get_loc_raises_object_tolerance(self):
        index = Index(["a", "c"])
        with pytest.raises(TypeError, match="unsupported operand type"):
            with tm.assert_produces_warning(FutureWarning, match="deprecated"):
                index.get_loc("a", method="pad", tolerance="invalid")


            

Reported by Pylint.

                          with tm.assert_produces_warning(FutureWarning, match="deprecated"):
                index.get_loc("a", method="nearest")

    def test_get_loc_raises_object_tolerance(self):
        index = Index(["a", "c"])
        with pytest.raises(TypeError, match="unsupported operand type"):
            with tm.assert_produces_warning(FutureWarning, match="deprecated"):
                index.get_loc("a", method="pad", tolerance="invalid")


            

Reported by Pylint.

                              index.get_loc("a", method="pad", tolerance="invalid")


class TestGetIndexer:
    @pytest.mark.parametrize(
        "method,expected",
        [
            ("pad", np.array([-1, 0, 1, 1], dtype=np.intp)),
            ("backfill", np.array([0, 0, 1, -1], dtype=np.intp)),

            

Reported by Pylint.

              import numpy as np
import pytest

import pandas as pd
from pandas import (
    Index,
    MultiIndex,
    date_range,
    period_range,

            

Reported by Pylint.

              
    # GH8083 test the base class for shift
    msg = "This method is only implemented for DatetimeIndex, PeriodIndex and "
    "TimedeltaIndex; Got type MultiIndex"
    with pytest.raises(NotImplementedError, match=msg):
        idx.shift(1)
    with pytest.raises(NotImplementedError, match=msg):
        idx.shift(1, 2)


            

Reported by Pylint.

                      index.truncate(3, 1)


# TODO: reshape


def test_reorder_levels(idx):
    # this blows up
    with pytest.raises(IndexError, match="^Too many levels"):

            

Reported by Pylint.

                  # - now raises (previously was set op difference)
    msg = "cannot perform __sub__ with this index type: MultiIndex"
    with pytest.raises(TypeError, match=msg):
        first - idx[-3:]
    with pytest.raises(TypeError, match=msg):
        idx[-3:] - first
    with pytest.raises(TypeError, match=msg):
        idx[-3:] - first.tolist()
    msg = "cannot perform __rsub__ with this index type: MultiIndex"

            

Reported by Pylint.

                  with pytest.raises(TypeError, match=msg):
        first - idx[-3:]
    with pytest.raises(TypeError, match=msg):
        idx[-3:] - first
    with pytest.raises(TypeError, match=msg):
        idx[-3:] - first.tolist()
    msg = "cannot perform __rsub__ with this index type: MultiIndex"
    with pytest.raises(TypeError, match=msg):
        first.tolist() - idx[-3:]

            

Reported by Pylint.

                  with pytest.raises(TypeError, match=msg):
        idx[-3:] - first
    with pytest.raises(TypeError, match=msg):
        idx[-3:] - first.tolist()
    msg = "cannot perform __rsub__ with this index type: MultiIndex"
    with pytest.raises(TypeError, match=msg):
        first.tolist() - idx[-3:]



            

Reported by Pylint.

                      idx[-3:] - first.tolist()
    msg = "cannot perform __rsub__ with this index type: MultiIndex"
    with pytest.raises(TypeError, match=msg):
        first.tolist() - idx[-3:]


def test_map(idx):
    # callable
    index = idx

            

Reported by Pylint.

                  "mapper",
    [
        lambda values, idx: {i: e for e, i in zip(values, idx)},
        lambda values, idx: pd.Series(values, idx),
    ],
)
def test_map_dictlike(idx, mapper):

    if isinstance(idx, (pd.CategoricalIndex, pd.IntervalIndex)):

            

Reported by Pylint.

              import numpy as np
import pytest

import pandas as pd
from pandas import (
    Index,
    MultiIndex,
    date_range,
    period_range,

            

Reported by Pylint.

              import pandas._testing as tm


def test_shift(idx):

    # GH8083 test the base class for shift
    msg = "This method is only implemented for DatetimeIndex, PeriodIndex and "
    "TimedeltaIndex; Got type MultiIndex"
    with pytest.raises(NotImplementedError, match=msg):

            

Reported by Pylint.

              
        tm.assert_almost_equal(offset_monthly["A"], rule_monthly["A"])

        filled = rule_monthly.asfreq("B", method="pad")  # noqa
        # TODO: actually check that this worked.

        # don't forget!
        filled_dep = rule_monthly.asfreq("B", method="pad")  # noqa


            

Reported by Pylint.

                      tm.assert_almost_equal(offset_monthly["A"], rule_monthly["A"])

        filled = rule_monthly.asfreq("B", method="pad")  # noqa
        # TODO: actually check that this worked.

        # don't forget!
        filled_dep = rule_monthly.asfreq("B", method="pad")  # noqa

        # test does not blow up on length-0 DataFrame

            

Reported by Pylint.

                      # TODO: actually check that this worked.

        # don't forget!
        filled_dep = rule_monthly.asfreq("B", method="pad")  # noqa

        # test does not blow up on length-0 DataFrame
        zero_length = datetime_frame.reindex([])
        result = zero_length.asfreq("BM")
        assert result is not zero_length

            

Reported by Pylint.

                      result = frame_or_series(range(4), index=index)

        expected = result.reindex(sorted(index))
        expected.index = expected.index._with_freq("infer")

        result = result.asfreq("D")
        tm.assert_equal(result, expected)

            

Reported by Pylint.

              from datetime import datetime

import numpy as np

from pandas import (
    DataFrame,
    DatetimeIndex,
    Series,
    date_range,

            

Reported by Pylint.

              from pandas.tseries import offsets


class TestAsFreq:
    def test_asfreq_resample_set_correct_freq(self):
        # GH#5613
        # we test if .asfreq() and .resample() set the correct value for .freq
        df = DataFrame(
            {"date": ["2012-01-01", "2012-01-02", "2012-01-03"], "col": [1, 2, 3]}

            

Reported by Pylint.

              

class TestAsFreq:
    def test_asfreq_resample_set_correct_freq(self):
        # GH#5613
        # we test if .asfreq() and .resample() set the correct value for .freq
        df = DataFrame(
            {"date": ["2012-01-01", "2012-01-02", "2012-01-03"], "col": [1, 2, 3]}
        )

            

Reported by Pylint.

              

class TestAsFreq:
    def test_asfreq_resample_set_correct_freq(self):
        # GH#5613
        # we test if .asfreq() and .resample() set the correct value for .freq
        df = DataFrame(
            {"date": ["2012-01-01", "2012-01-02", "2012-01-03"], "col": [1, 2, 3]}
        )

            

Reported by Pylint.

                  def test_asfreq_resample_set_correct_freq(self):
        # GH#5613
        # we test if .asfreq() and .resample() set the correct value for .freq
        df = DataFrame(
            {"date": ["2012-01-01", "2012-01-02", "2012-01-03"], "col": [1, 2, 3]}
        )
        df = df.set_index(to_datetime(df.date))

        # testing the settings before calling .asfreq() and .resample()

            

Reported by Pylint.

                      df = DataFrame(
            {"date": ["2012-01-01", "2012-01-02", "2012-01-03"], "col": [1, 2, 3]}
        )
        df = df.set_index(to_datetime(df.date))

        # testing the settings before calling .asfreq() and .resample()
        assert df.index.freq is None
        assert df.index.inferred_freq == "D"


            

Reported by Pylint.

              import numpy as np
import pytest

from pandas import (
    Index,
    date_range,
)
import pandas._testing as tm
from pandas.core.reshape.util import cartesian_product

            

Reported by Pylint.

                      # regression test for GitHub issue #6439
        # make sure that the ordering on datetimeindex is consistent
        x = date_range("2000-01-01", periods=2)
        result1, result2 = (Index(y).day for y in cartesian_product([x, x]))
        expected1 = Index([1, 1, 2, 2])
        expected2 = Index([1, 2, 1, 2])
        tm.assert_index_equal(result1, expected1)
        tm.assert_index_equal(result2, expected2)


            

Reported by Pylint.

                  def test_tzaware_retained(self):
        x = date_range("2000-01-01", periods=2, tz="US/Pacific")
        y = np.array([3, 4])
        result1, result2 = cartesian_product([x, y])

        expected = x.repeat(2)
        tm.assert_index_equal(result1, expected)

    def test_tzaware_retained_categorical(self):

            

Reported by Pylint.

                  def test_tzaware_retained_categorical(self):
        x = date_range("2000-01-01", periods=2, tz="US/Pacific").astype("category")
        y = np.array([3, 4])
        result1, result2 = cartesian_product([x, y])

        expected = x.repeat(2)
        tm.assert_index_equal(result1, expected)

    def test_empty(self):

            

Reported by Pylint.

              import numpy as np
import pytest

from pandas import (
    Index,
    date_range,
)
import pandas._testing as tm
from pandas.core.reshape.util import cartesian_product

            

Reported by Pylint.

              from pandas.core.reshape.util import cartesian_product


class TestCartesianProduct:
    def test_simple(self):
        x, y = list("ABC"), [1, 22]
        result1, result2 = cartesian_product([x, y])
        expected1 = np.array(["A", "A", "B", "B", "C", "C"])
        expected2 = np.array([1, 22, 1, 22, 1, 22])

            

Reported by Pylint.

              

class TestCartesianProduct:
    def test_simple(self):
        x, y = list("ABC"), [1, 22]
        result1, result2 = cartesian_product([x, y])
        expected1 = np.array(["A", "A", "B", "B", "C", "C"])
        expected2 = np.array([1, 22, 1, 22, 1, 22])
        tm.assert_numpy_array_equal(result1, expected1)

            

Reported by Pylint.

              

class TestCartesianProduct:
    def test_simple(self):
        x, y = list("ABC"), [1, 22]
        result1, result2 = cartesian_product([x, y])
        expected1 = np.array(["A", "A", "B", "B", "C", "C"])
        expected2 = np.array([1, 22, 1, 22, 1, 22])
        tm.assert_numpy_array_equal(result1, expected1)

            

Reported by Pylint.

              
class TestCartesianProduct:
    def test_simple(self):
        x, y = list("ABC"), [1, 22]
        result1, result2 = cartesian_product([x, y])
        expected1 = np.array(["A", "A", "B", "B", "C", "C"])
        expected2 = np.array([1, 22, 1, 22, 1, 22])
        tm.assert_numpy_array_equal(result1, expected1)
        tm.assert_numpy_array_equal(result2, expected2)

            

Reported by Pylint.

              
class TestCartesianProduct:
    def test_simple(self):
        x, y = list("ABC"), [1, 22]
        result1, result2 = cartesian_product([x, y])
        expected1 = np.array(["A", "A", "B", "B", "C", "C"])
        expected2 = np.array([1, 22, 1, 22, 1, 22])
        tm.assert_numpy_array_equal(result1, expected1)
        tm.assert_numpy_array_equal(result2, expected2)

            

Reported by Pylint.

              import numpy as np
import pytest

import pandas.util._test_decorators as td

import pandas as pd
from pandas.core.internals import ObjectBlock
from pandas.tests.extension.base.base import BaseExtensionTests


            

Reported by Pylint.

                      ser = pd.Series(all_data, name="A")
        result = ser.astype(object)
        assert result.dtype == np.dtype(object)
        if hasattr(result._mgr, "blocks"):
            assert isinstance(result._mgr.blocks[0], ObjectBlock)
        assert isinstance(result._mgr.array, np.ndarray)
        assert result._mgr.array.dtype == np.dtype(object)

    def test_astype_object_frame(self, all_data):

            

Reported by Pylint.

                      result = ser.astype(object)
        assert result.dtype == np.dtype(object)
        if hasattr(result._mgr, "blocks"):
            assert isinstance(result._mgr.blocks[0], ObjectBlock)
        assert isinstance(result._mgr.array, np.ndarray)
        assert result._mgr.array.dtype == np.dtype(object)

    def test_astype_object_frame(self, all_data):
        df = pd.DataFrame({"A": all_data})

            

Reported by Pylint.

                      assert result.dtype == np.dtype(object)
        if hasattr(result._mgr, "blocks"):
            assert isinstance(result._mgr.blocks[0], ObjectBlock)
        assert isinstance(result._mgr.array, np.ndarray)
        assert result._mgr.array.dtype == np.dtype(object)

    def test_astype_object_frame(self, all_data):
        df = pd.DataFrame({"A": all_data})


            

Reported by Pylint.

                      if hasattr(result._mgr, "blocks"):
            assert isinstance(result._mgr.blocks[0], ObjectBlock)
        assert isinstance(result._mgr.array, np.ndarray)
        assert result._mgr.array.dtype == np.dtype(object)

    def test_astype_object_frame(self, all_data):
        df = pd.DataFrame({"A": all_data})

        result = df.astype(object)

            

Reported by Pylint.

                      df = pd.DataFrame({"A": all_data})

        result = df.astype(object)
        if hasattr(result._mgr, "blocks"):
            blk = result._data.blocks[0]
            assert isinstance(blk, ObjectBlock), type(blk)
        assert isinstance(result._mgr.arrays[0], np.ndarray)
        assert result._mgr.arrays[0].dtype == np.dtype(object)


            

Reported by Pylint.

              
        result = df.astype(object)
        if hasattr(result._mgr, "blocks"):
            blk = result._data.blocks[0]
            assert isinstance(blk, ObjectBlock), type(blk)
        assert isinstance(result._mgr.arrays[0], np.ndarray)
        assert result._mgr.arrays[0].dtype == np.dtype(object)

        # FIXME: these currently fail; dont leave commented-out

            

Reported by Pylint.

                      if hasattr(result._mgr, "blocks"):
            blk = result._data.blocks[0]
            assert isinstance(blk, ObjectBlock), type(blk)
        assert isinstance(result._mgr.arrays[0], np.ndarray)
        assert result._mgr.arrays[0].dtype == np.dtype(object)

        # FIXME: these currently fail; dont leave commented-out
        # check that we can compare the dtypes
        # cmp = result.dtypes.equals(df.dtypes)

            

Reported by Pylint.

                          blk = result._data.blocks[0]
            assert isinstance(blk, ObjectBlock), type(blk)
        assert isinstance(result._mgr.arrays[0], np.ndarray)
        assert result._mgr.arrays[0].dtype == np.dtype(object)

        # FIXME: these currently fail; dont leave commented-out
        # check that we can compare the dtypes
        # cmp = result.dtypes.equals(df.dtypes)
        # assert not cmp.any()

            

Reported by Pylint.

                      assert isinstance(result._mgr.arrays[0], np.ndarray)
        assert result._mgr.arrays[0].dtype == np.dtype(object)

        # FIXME: these currently fail; dont leave commented-out
        # check that we can compare the dtypes
        # cmp = result.dtypes.equals(df.dtypes)
        # assert not cmp.any()

    def test_tolist(self, data):

            

Reported by Pylint.