import re

import numpy as np
import pytest

from pandas import (
    DataFrame,
    MultiIndex,
)

            

Reported by Pylint.

              import re

import numpy as np
import pytest

from pandas import (
    DataFrame,
    MultiIndex,
)

            

Reported by Pylint.

              )


class TestDataFrameDelItem:
    def test_delitem(self, float_frame):
        del float_frame["A"]
        assert "A" not in float_frame

    def test_delitem_multiindex(self):

            

Reported by Pylint.

              

class TestDataFrameDelItem:
    def test_delitem(self, float_frame):
        del float_frame["A"]
        assert "A" not in float_frame

    def test_delitem_multiindex(self):
        midx = MultiIndex.from_product([["A", "B"], [1, 2]])

            

Reported by Pylint.

              

class TestDataFrameDelItem:
    def test_delitem(self, float_frame):
        del float_frame["A"]
        assert "A" not in float_frame

    def test_delitem_multiindex(self):
        midx = MultiIndex.from_product([["A", "B"], [1, 2]])

            

Reported by Pylint.

              class TestDataFrameDelItem:
    def test_delitem(self, float_frame):
        del float_frame["A"]
        assert "A" not in float_frame

    def test_delitem_multiindex(self):
        midx = MultiIndex.from_product([["A", "B"], [1, 2]])
        df = DataFrame(np.random.randn(4, 4), columns=midx)
        assert len(df.columns) == 4

            

Reported by Bandit.

                      del float_frame["A"]
        assert "A" not in float_frame

    def test_delitem_multiindex(self):
        midx = MultiIndex.from_product([["A", "B"], [1, 2]])
        df = DataFrame(np.random.randn(4, 4), columns=midx)
        assert len(df.columns) == 4
        assert ("A",) in df.columns
        assert "A" in df.columns

            

Reported by Pylint.

                      del float_frame["A"]
        assert "A" not in float_frame

    def test_delitem_multiindex(self):
        midx = MultiIndex.from_product([["A", "B"], [1, 2]])
        df = DataFrame(np.random.randn(4, 4), columns=midx)
        assert len(df.columns) == 4
        assert ("A",) in df.columns
        assert "A" in df.columns

            

Reported by Pylint.

              
    def test_delitem_multiindex(self):
        midx = MultiIndex.from_product([["A", "B"], [1, 2]])
        df = DataFrame(np.random.randn(4, 4), columns=midx)
        assert len(df.columns) == 4
        assert ("A",) in df.columns
        assert "A" in df.columns

        result = df["A"]

            

Reported by Pylint.

                  def test_delitem_multiindex(self):
        midx = MultiIndex.from_product([["A", "B"], [1, 2]])
        df = DataFrame(np.random.randn(4, 4), columns=midx)
        assert len(df.columns) == 4
        assert ("A",) in df.columns
        assert "A" in df.columns

        result = df["A"]
        assert isinstance(result, DataFrame)

            

Reported by Bandit.

              from io import BytesIO

import numpy as np
from odf.opendocument import OpenDocumentSpreadsheet
from odf.table import (
    Table,
    TableCell,
    TableRow,
)

            

Reported by Pylint.

              
import numpy as np
from odf.opendocument import OpenDocumentSpreadsheet
from odf.table import (
    Table,
    TableCell,
    TableRow,
)
from odf.text import P

            

Reported by Pylint.

                  TableCell,
    TableRow,
)
from odf.text import P

from pandas import (
    DataFrame,
    ExcelWriter,
    date_range,

            

Reported by Pylint.

              )
from odf.text import P

from pandas import (
    DataFrame,
    ExcelWriter,
    date_range,
    read_excel,
)

            

Reported by Pylint.

                  read_excel,
)

from ..pandas_vb_common import tm


def _generate_dataframe():
    N = 2000
    C = 5

            

Reported by Pylint.

                      read_excel(fname, engine=engine)


from ..pandas_vb_common import setup  # noqa: F401 isort:skip

            

Reported by Pylint.

                  params = ["openpyxl", "xlsxwriter", "xlwt"]
    param_names = ["engine"]

    def setup(self, engine):
        self.df = _generate_dataframe()

    def time_write_excel(self, engine):
        bio = BytesIO()
        bio.seek(0)

            

Reported by Pylint.

                  param_names = ["engine"]

    def setup(self, engine):
        self.df = _generate_dataframe()

    def time_write_excel(self, engine):
        bio = BytesIO()
        bio.seek(0)
        writer = ExcelWriter(bio, engine=engine)

            

Reported by Pylint.

                      doc.save(self.fname_odf)

    def setup_cache(self):
        self.df = _generate_dataframe()

        self.df.to_excel(self.fname_excel, sheet_name="Sheet1")
        self.df.to_excel(self.fname_excel_xls, sheet_name="Sheet1")
        self._create_odf()


            

Reported by Pylint.

                      read_excel(fname, engine=engine)


from ..pandas_vb_common import setup  # noqa: F401 isort:skip

            

Reported by Pylint.

              import re

import pytest

from pandas.core.indexes.frozen import FrozenList


class TestFrozenList:


            

Reported by Pylint.

                  unicode_container = FrozenList(["\u05d0", "\u05d1", "c"])

    def setup_method(self, _):
        self.lst = [1, 2, 3, 4, 5]
        self.container = FrozenList(self.lst)

    def check_mutable_error(self, *args, **kwargs):
        # Pass whatever function you normally would to pytest.raises
        # (after the Exception kind).

            

Reported by Pylint.

              
    def setup_method(self, _):
        self.lst = [1, 2, 3, 4, 5]
        self.container = FrozenList(self.lst)

    def check_mutable_error(self, *args, **kwargs):
        # Pass whatever function you normally would to pytest.raises
        # (after the Exception kind).
        mutable_regex = re.compile("does not support mutable operations")

            

Reported by Pylint.

              import re

import pytest

from pandas.core.indexes.frozen import FrozenList


class TestFrozenList:


            

Reported by Pylint.

              from pandas.core.indexes.frozen import FrozenList


class TestFrozenList:

    unicode_container = FrozenList(["\u05d0", "\u05d1", "c"])

    def setup_method(self, _):
        self.lst = [1, 2, 3, 4, 5]

            

Reported by Pylint.

              
    unicode_container = FrozenList(["\u05d0", "\u05d1", "c"])

    def setup_method(self, _):
        self.lst = [1, 2, 3, 4, 5]
        self.container = FrozenList(self.lst)

    def check_mutable_error(self, *args, **kwargs):
        # Pass whatever function you normally would to pytest.raises

            

Reported by Pylint.

                      self.lst = [1, 2, 3, 4, 5]
        self.container = FrozenList(self.lst)

    def check_mutable_error(self, *args, **kwargs):
        # Pass whatever function you normally would to pytest.raises
        # (after the Exception kind).
        mutable_regex = re.compile("does not support mutable operations")
        msg = "'(_s)?re.(SRE_)?Pattern' object is not callable"
        with pytest.raises(TypeError, match=msg):

            

Reported by Pylint.

                      self.lst = [1, 2, 3, 4, 5]
        self.container = FrozenList(self.lst)

    def check_mutable_error(self, *args, **kwargs):
        # Pass whatever function you normally would to pytest.raises
        # (after the Exception kind).
        mutable_regex = re.compile("does not support mutable operations")
        msg = "'(_s)?re.(SRE_)?Pattern' object is not callable"
        with pytest.raises(TypeError, match=msg):

            

Reported by Pylint.

                      with pytest.raises(TypeError, match=msg):
            mutable_regex(*args, **kwargs)

    def test_no_mutable_funcs(self):
        def setitem():
            self.container[0] = 5

        self.check_mutable_error(setitem)


            

Reported by Pylint.

                      for meth in mutable_methods:
            self.check_mutable_error(getattr(self.container, meth))

    def test_slicing_maintains_type(self):
        result = self.container[1:2]
        expected = self.lst[1:2]
        self.check_result(result, expected)

    def check_result(self, result, expected):

            

Reported by Pylint.

              )

import numpy as np
import pytest

from pandas import (
    Index,
    Int64Index,
    RangeIndex,

            

Reported by Pylint.

                      tm.assert_index_equal(res1, expected_notsorted, exact=True)

        res2 = idx2.union(idx1, sort=None)
        res3 = idx1._int64index.union(idx2, sort=None)
        tm.assert_index_equal(res2, expected_sorted, exact=True)
        tm.assert_index_equal(res3, expected_sorted)

    def test_difference(self):
        # GH#12034 Cases where we operate against another RangeIndex and may

            

Reported by Pylint.

                      obj = RangeIndex.from_range(range(1, 10), name="foo")

        result = obj.difference(obj[::2])
        expected = obj[1::2]._int64index
        tm.assert_index_equal(result, expected, exact=True)

        result = obj.difference(obj[1::2])
        expected = obj[::2]._int64index
        tm.assert_index_equal(result, expected, exact=True)

            

Reported by Pylint.

                      tm.assert_index_equal(result, expected, exact=True)

        result = obj.difference(obj[1::2])
        expected = obj[::2]._int64index
        tm.assert_index_equal(result, expected, exact=True)

    def test_symmetric_difference(self):
        # GH#12034 Cases where we operate against another RangeIndex and may
        #  get back another RangeIndex

            

Reported by Pylint.

              from datetime import (
    datetime,
    timedelta,
)

import numpy as np
import pytest

from pandas import (

            

Reported by Pylint.

              import pandas._testing as tm


class TestRangeIndexSetOps:
    @pytest.mark.parametrize("klass", [RangeIndex, Int64Index, UInt64Index])
    def test_intersection_mismatched_dtype(self, klass):
        # check that we cast to float, not object
        index = RangeIndex(start=0, stop=20, step=2, name="foo")
        index = klass(index)

            

Reported by Pylint.

              
class TestRangeIndexSetOps:
    @pytest.mark.parametrize("klass", [RangeIndex, Int64Index, UInt64Index])
    def test_intersection_mismatched_dtype(self, klass):
        # check that we cast to float, not object
        index = RangeIndex(start=0, stop=20, step=2, name="foo")
        index = klass(index)

        flt = index.astype(np.float64)

            

Reported by Pylint.

              
class TestRangeIndexSetOps:
    @pytest.mark.parametrize("klass", [RangeIndex, Int64Index, UInt64Index])
    def test_intersection_mismatched_dtype(self, klass):
        # check that we cast to float, not object
        index = RangeIndex(start=0, stop=20, step=2, name="foo")
        index = klass(index)

        flt = index.astype(np.float64)

            

Reported by Pylint.

                      result = flt[:0].intersection(index)
        tm.assert_index_equal(result, flt[:0], exact=True)

    def test_intersection_empty(self, sort, names):
        # name retention on empty intersections
        index = RangeIndex(start=0, stop=20, step=2, name=names[0])

        # empty other
        result = index.intersection(index[:0].rename(names[1]), sort=sort)

            

Reported by Pylint.

                      result = flt[:0].intersection(index)
        tm.assert_index_equal(result, flt[:0], exact=True)

    def test_intersection_empty(self, sort, names):
        # name retention on empty intersections
        index = RangeIndex(start=0, stop=20, step=2, name=names[0])

        # empty other
        result = index.intersection(index[:0].rename(names[1]), sort=sort)

            

Reported by Pylint.

              import pytest

from pandas import (
    DataFrame,
    HDFStore,
    _testing as tm,
)
from pandas.tests.io.pytables.common import (
    ensure_clean_path,

            

Reported by Pylint.

              
        assert store.keys() == ["/df"]

        store._handle.create_soft_link(store._handle.root, "symlink", "df")

        # Should ignore the softlink
        assert store.keys() == ["/df"]

            

Reported by Pylint.

              
        assert store.keys() == ["/df"]

        store._handle.create_soft_link(store._handle.root, "symlink", "df")

        # Should ignore the softlink
        assert store.keys() == ["/df"]

            

Reported by Pylint.

              import pytest

from pandas import (
    DataFrame,
    HDFStore,
    _testing as tm,
)
from pandas.tests.io.pytables.common import (
    ensure_clean_path,

            

Reported by Pylint.

              pytestmark = pytest.mark.single


def test_keys(setup_path):

    with ensure_clean_store(setup_path) as store:
        store["a"] = tm.makeTimeSeries()
        store["b"] = tm.makeStringSeries()
        store["c"] = tm.makeDataFrame()

            

Reported by Pylint.

                      store["b"] = tm.makeStringSeries()
        store["c"] = tm.makeDataFrame()

        assert len(store) == 3
        expected = {"/a", "/b", "/c"}
        assert set(store.keys()) == expected
        assert set(store) == expected



            

Reported by Bandit.

              
        assert len(store) == 3
        expected = {"/a", "/b", "/c"}
        assert set(store.keys()) == expected
        assert set(store) == expected


def test_non_pandas_keys(setup_path):
    class Table1(tables.IsDescription):

            

Reported by Bandit.

                      assert len(store) == 3
        expected = {"/a", "/b", "/c"}
        assert set(store.keys()) == expected
        assert set(store) == expected


def test_non_pandas_keys(setup_path):
    class Table1(tables.IsDescription):
        value1 = tables.Float32Col()

            

Reported by Bandit.

                      assert set(store) == expected


def test_non_pandas_keys(setup_path):
    class Table1(tables.IsDescription):
        value1 = tables.Float32Col()

    class Table2(tables.IsDescription):
        value2 = tables.Float32Col()

            

Reported by Pylint.

              

def test_non_pandas_keys(setup_path):
    class Table1(tables.IsDescription):
        value1 = tables.Float32Col()

    class Table2(tables.IsDescription):
        value2 = tables.Float32Col()


            

Reported by Pylint.

              from datetime import timedelta

import numpy as np
import pytest

import pandas as pd
from pandas import (
    Float64Index,
    Index,

            

Reported by Pylint.

                      expected = pd.CategoricalIndex([Timedelta("1H"), Timedelta("2H")])
        tm.assert_index_equal(result, expected)

        result = obj._data.astype("category")
        expected = expected.values
        tm.assert_categorical_equal(result, expected)

    def test_astype_array_fallback(self):
        obj = timedelta_range("1H", periods=2)

            

Reported by Pylint.

                      expected = Index(np.array([True, True]))
        tm.assert_index_equal(result, expected)

        result = obj._data.astype(bool)
        expected = np.array([True, True])
        tm.assert_numpy_array_equal(result, expected)

            

Reported by Pylint.

              from datetime import timedelta

import numpy as np
import pytest

import pandas as pd
from pandas import (
    Float64Index,
    Index,

            

Reported by Pylint.

              import pandas._testing as tm


class TestTimedeltaIndex:
    def test_astype_object(self):
        idx = timedelta_range(start="1 days", periods=4, freq="D", name="idx")
        expected_list = [
            Timedelta("1 days"),
            Timedelta("2 days"),

            

Reported by Pylint.

              

class TestTimedeltaIndex:
    def test_astype_object(self):
        idx = timedelta_range(start="1 days", periods=4, freq="D", name="idx")
        expected_list = [
            Timedelta("1 days"),
            Timedelta("2 days"),
            Timedelta("3 days"),

            

Reported by Pylint.

              

class TestTimedeltaIndex:
    def test_astype_object(self):
        idx = timedelta_range(start="1 days", periods=4, freq="D", name="idx")
        expected_list = [
            Timedelta("1 days"),
            Timedelta("2 days"),
            Timedelta("3 days"),

            

Reported by Pylint.

                      result = idx.astype(object)
        expected = Index(expected_list, dtype=object, name="idx")
        tm.assert_index_equal(result, expected)
        assert idx.tolist() == expected_list

    def test_astype_object_with_nat(self):
        idx = TimedeltaIndex(
            [timedelta(days=1), timedelta(days=2), NaT, timedelta(days=4)], name="idx"
        )

            

Reported by Bandit.

                      tm.assert_index_equal(result, expected)
        assert idx.tolist() == expected_list

    def test_astype_object_with_nat(self):
        idx = TimedeltaIndex(
            [timedelta(days=1), timedelta(days=2), NaT, timedelta(days=4)], name="idx"
        )
        expected_list = [
            Timedelta("1 days"),

            

Reported by Pylint.

                      tm.assert_index_equal(result, expected)
        assert idx.tolist() == expected_list

    def test_astype_object_with_nat(self):
        idx = TimedeltaIndex(
            [timedelta(days=1), timedelta(days=2), NaT, timedelta(days=4)], name="idx"
        )
        expected_list = [
            Timedelta("1 days"),

            

Reported by Pylint.

              from io import StringIO

import numpy as np
import pytest

from pandas import (
    DataFrame,
    Index,
)

            

Reported by Pylint.

              )
import pandas._testing as tm

_msg_validate_usecols_arg = (
    "'usecols' must either be list-like "
    "of all strings, all unicode, all "
    "integers or a callable."
)
_msg_validate_usecols_names = (

            

Reported by Pylint.

                  "of all strings, all unicode, all "
    "integers or a callable."
)
_msg_validate_usecols_names = (
    "Usecols do not match columns, columns expected but not found: {0}"
)


def test_raise_on_mixed_dtype_usecols(all_parsers):

            

Reported by Pylint.

              )


def test_raise_on_mixed_dtype_usecols(all_parsers):
    # See gh-12678
    data = """a,b,c
        1000,2000,3000
        4000,5000,6000
        """

            

Reported by Pylint.

              

@pytest.mark.parametrize("usecols", [(1, 2), ("b", "c")])
def test_usecols(all_parsers, usecols):
    data = """\
a,b,c
1,2,3
4,5,6
7,8,9

            

Reported by Pylint.

                  tm.assert_frame_equal(result, expected)


def test_usecols_with_names(all_parsers):
    data = """\
a,b,c
1,2,3
4,5,6
7,8,9

            

Reported by Pylint.

              
@pytest.mark.parametrize(
    "names,usecols", [(["b", "c"], [1, 2]), (["a", "b", "c"], ["b", "c"])]
)
def test_usecols_relative_to_names(all_parsers, names, usecols):
    data = """\
1,2,3
4,5,6
7,8,9

            

Reported by Pylint.

                  tm.assert_frame_equal(result, expected)


def test_usecols_relative_to_names2(all_parsers):
    # see gh-5766
    data = """\
1,2,3
4,5,6
7,8,9

            

Reported by Pylint.

                  tm.assert_frame_equal(result, expected)


def test_usecols_name_length_conflict(all_parsers):
    data = """\
1,2,3
4,5,6
7,8,9
10,11,12"""

            

Reported by Pylint.

                      parser.read_csv(StringIO(data), names=["a", "b"], header=None, usecols=[1])


def test_usecols_single_string(all_parsers):
    # see gh-20558
    parser = all_parsers
    data = """foo, bar, baz
1000, 2000, 3000
4000, 5000, 6000"""

            

Reported by Pylint.

              import pytest

from pandas import (
    DataFrame,
    Index,
    MultiIndex,
    Series,
    _testing as tm,
    get_option,

            

Reported by Pylint.

                  mi = MultiIndex.from_arrays([["a", "b", "c"]])
    msg = "Can only use .str accessor with Index, not MultiIndex"
    with pytest.raises(AttributeError, match=msg):
        mi.str
    assert not hasattr(mi, "str")


@pytest.mark.parametrize("dtype", [object, "category"])
def test_api_per_dtype(index_or_series, dtype, any_skipna_inferred_dtype):

            

Reported by Pylint.

                      # GH 9184, GH 23011, GH 23163
        msg = "Can only use .str accessor with string values.*"
        with pytest.raises(AttributeError, match=msg):
            t.str
        assert not hasattr(t, "str")


@pytest.mark.parametrize("dtype", [object, "category"])
def test_api_per_method(

            

Reported by Pylint.

                  inferred_dtype, values = any_allowed_skipna_inferred_dtype
    method_name, args, kwargs = any_string_method

    # TODO: get rid of these xfails
    reason = None
    if box is Index and values.size == 0:
        if method_name in ["partition", "rpartition"] and kwargs.get("expand", True):
            raises = TypeError
            reason = "Method cannot deal with empty Index"

            

Reported by Pylint.

              import pytest

from pandas import (
    DataFrame,
    Index,
    MultiIndex,
    Series,
    _testing as tm,
    get_option,

            

Reported by Pylint.

                  _testing as tm,
    get_option,
)
from pandas.core import strings as strings


def test_api(any_string_dtype):

    # GH 6106, GH 9322

            

Reported by Pylint.

              from pandas.core import strings as strings


def test_api(any_string_dtype):

    # GH 6106, GH 9322
    assert Series.str is strings.StringMethods
    assert isinstance(Series([""], dtype=any_string_dtype).str, strings.StringMethods)


            

Reported by Pylint.

              def test_api(any_string_dtype):

    # GH 6106, GH 9322
    assert Series.str is strings.StringMethods
    assert isinstance(Series([""], dtype=any_string_dtype).str, strings.StringMethods)


def test_api_mi_raises():
    # GH 23679

            

Reported by Bandit.

              
    # GH 6106, GH 9322
    assert Series.str is strings.StringMethods
    assert isinstance(Series([""], dtype=any_string_dtype).str, strings.StringMethods)


def test_api_mi_raises():
    # GH 23679
    mi = MultiIndex.from_arrays([["a", "b", "c"]])

            

Reported by Bandit.

                  assert isinstance(Series([""], dtype=any_string_dtype).str, strings.StringMethods)


def test_api_mi_raises():
    # GH 23679
    mi = MultiIndex.from_arrays([["a", "b", "c"]])
    msg = "Can only use .str accessor with Index, not MultiIndex"
    with pytest.raises(AttributeError, match=msg):
        mi.str

            

Reported by Pylint.

              class TestIteration:
    def test_keys(self, datetime_series):
        assert datetime_series.keys() is datetime_series.index

    def test_iter_datetimes(self, datetime_series):
        for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):

            

Reported by Pylint.

              class TestIteration:
    def test_keys(self, datetime_series):
        assert datetime_series.keys() is datetime_series.index

    def test_iter_datetimes(self, datetime_series):
        for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):

            

Reported by Pylint.

              class TestIteration:
    def test_keys(self, datetime_series):
        assert datetime_series.keys() is datetime_series.index

    def test_iter_datetimes(self, datetime_series):
        for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):

            

Reported by Pylint.

              class TestIteration:
    def test_keys(self, datetime_series):
        assert datetime_series.keys() is datetime_series.index

    def test_iter_datetimes(self, datetime_series):
        for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):

            

Reported by Pylint.

              class TestIteration:
    def test_keys(self, datetime_series):
        assert datetime_series.keys() is datetime_series.index

    def test_iter_datetimes(self, datetime_series):
        for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):

            

Reported by Bandit.

                  def test_keys(self, datetime_series):
        assert datetime_series.keys() is datetime_series.index

    def test_iter_datetimes(self, datetime_series):
        for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):
        for i, val in enumerate(string_series):

            

Reported by Pylint.

                  def test_keys(self, datetime_series):
        assert datetime_series.keys() is datetime_series.index

    def test_iter_datetimes(self, datetime_series):
        for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):
        for i, val in enumerate(string_series):

            

Reported by Pylint.

              
    def test_iter_datetimes(self, datetime_series):
        for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):
        for i, val in enumerate(string_series):
            assert val == string_series[i]


            

Reported by Bandit.

                      for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):
        for i, val in enumerate(string_series):
            assert val == string_series[i]

    def test_iteritems_datetimes(self, datetime_series):
        for idx, val in datetime_series.iteritems():

            

Reported by Pylint.

                      for i, val in enumerate(datetime_series):
            assert val == datetime_series[i]

    def test_iter_strings(self, string_series):
        for i, val in enumerate(string_series):
            assert val == string_series[i]

    def test_iteritems_datetimes(self, datetime_series):
        for idx, val in datetime_series.iteritems():

            

Reported by Pylint.

              from datetime import datetime

import numpy as np
import pytest

from pandas import (
    DatetimeIndex,
    NaT,
    PeriodIndex,

            

Reported by Pylint.

                      stamps = pindex.to_timestamp("D", "end")
        expected = DatetimeIndex([x.to_timestamp("D", "end") for x in pindex])
        tm.assert_index_equal(stamps, expected)
        assert stamps.freq == expected.freq

    def test_to_timestamp_pi_mult(self):
        idx = PeriodIndex(["2011-01", "NaT", "2011-02"], freq="2M", name="idx")

        result = idx.to_timestamp()

            

Reported by Pylint.

              from datetime import datetime

import numpy as np
import pytest

from pandas import (
    DatetimeIndex,
    NaT,
    PeriodIndex,

            

Reported by Pylint.

              import pandas._testing as tm


class TestToTimestamp:
    def test_to_timestamp_freq(self):
        idx = period_range("2017", periods=12, freq="A-DEC")
        result = idx.to_timestamp()
        expected = date_range("2017", periods=12, freq="AS-JAN")
        tm.assert_index_equal(result, expected)

            

Reported by Pylint.

              

class TestToTimestamp:
    def test_to_timestamp_freq(self):
        idx = period_range("2017", periods=12, freq="A-DEC")
        result = idx.to_timestamp()
        expected = date_range("2017", periods=12, freq="AS-JAN")
        tm.assert_index_equal(result, expected)


            

Reported by Pylint.

              

class TestToTimestamp:
    def test_to_timestamp_freq(self):
        idx = period_range("2017", periods=12, freq="A-DEC")
        result = idx.to_timestamp()
        expected = date_range("2017", periods=12, freq="AS-JAN")
        tm.assert_index_equal(result, expected)


            

Reported by Pylint.

                      expected = date_range("2017", periods=12, freq="AS-JAN")
        tm.assert_index_equal(result, expected)

    def test_to_timestamp_pi_nat(self):
        # GH#7228
        index = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")

        result = index.to_timestamp("D")
        expected = DatetimeIndex(

            

Reported by Pylint.

                      expected = date_range("2017", periods=12, freq="AS-JAN")
        tm.assert_index_equal(result, expected)

    def test_to_timestamp_pi_nat(self):
        # GH#7228
        index = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="M", name="idx")

        result = index.to_timestamp("D")
        expected = DatetimeIndex(

            

Reported by Pylint.

                          [NaT, datetime(2011, 1, 1), datetime(2011, 2, 1)], name="idx"
        )
        tm.assert_index_equal(result, expected)
        assert result.name == "idx"

        result2 = result.to_period(freq="M")
        tm.assert_index_equal(result2, index)
        assert result2.name == "idx"


            

Reported by Bandit.

              
        result2 = result.to_period(freq="M")
        tm.assert_index_equal(result2, index)
        assert result2.name == "idx"

        result3 = result.to_period(freq="3M")
        exp = PeriodIndex(["NaT", "2011-01", "2011-02"], freq="3M", name="idx")
        tm.assert_index_equal(result3, exp)
        assert result3.freqstr == "3M"

            

Reported by Bandit.