import re

import numpy as np
import pytest

import pandas as pd
from pandas import (
    Series,
    _testing as tm,

            

Reported by Pylint.

              from datetime import datetime
import re

import numpy as np
import pytest

import pandas as pd
from pandas import (
    Series,

            

Reported by Pylint.

              # --------------------------------------------------------------------------------------


def test_contains(any_string_dtype):
    values = np.array(
        ["foo", np.nan, "fooommm__foo", "mmm_", "foommm[_]+bar"], dtype=np.object_
    )
    values = Series(values, dtype=any_string_dtype)
    pat = "mmm[_]+"

            

Reported by Pylint.

                  tm.assert_series_equal(result, expected)


def test_contains_object_mixed():
    mixed = Series(
        np.array(
            ["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0],
            dtype=object,
        )

            

Reported by Pylint.

                  tm.assert_series_equal(result, expected)


def test_contains_na_kwarg_for_object_category():
    # gh 22158

    # na for category
    values = Series(["a", "b", "c", "a", np.nan], dtype="category")
    result = values.str.contains("a", na=True)

            

Reported by Pylint.

                      (3, True),
        (np.nan, pd.NA),
    ],
)
@pytest.mark.parametrize("regex", [True, False])
def test_contains_na_kwarg_for_nullable_string_dtype(
    nullable_string_dtype, na, expected, regex
):
    # https://github.com/pandas-dev/pandas/pull/41025#issuecomment-824062416

            

Reported by Pylint.

                      (3, True),
        (np.nan, pd.NA),
    ],
)
@pytest.mark.parametrize("regex", [True, False])
def test_contains_na_kwarg_for_nullable_string_dtype(
    nullable_string_dtype, na, expected, regex
):
    # https://github.com/pandas-dev/pandas/pull/41025#issuecomment-824062416

            

Reported by Pylint.

                  tm.assert_series_equal(result, expected)


def test_contains_moar(any_string_dtype):
    # PR #1179
    s = Series(
        ["A", "B", "C", "Aaba", "Baca", "", np.nan, "CABA", "dog", "cat"],
        dtype=any_string_dtype,
    )

            

Reported by Pylint.

              
def test_contains_moar(any_string_dtype):
    # PR #1179
    s = Series(
        ["A", "B", "C", "Aaba", "Baca", "", np.nan, "CABA", "dog", "cat"],
        dtype=any_string_dtype,
    )

    result = s.str.contains("a")

            

Reported by Pylint.

                  tm.assert_series_equal(result, expected)


def test_contains_nan(any_string_dtype):
    # PR #14171
    s = Series([np.nan, np.nan, np.nan], dtype=any_string_dtype)

    result = s.str.contains("foo", na=False)
    expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean"

            

Reported by Pylint.

              import inspect

import numpy as np
import pytest

import pandas.util._test_decorators as td

import pandas as pd
from pandas import (

            

Reported by Pylint.

              
    @td.skip_if_no_scipy
    def test_skew(self):
        from scipy.stats import skew

        string_series = tm.makeStringSeries().rename("series")

        alt = lambda x: skew(x, bias=False)
        self._check_stat_op("skew", alt, string_series)

            

Reported by Pylint.

              
    @td.skip_if_no_scipy
    def test_kurt(self):
        from scipy.stats import kurtosis

        string_series = tm.makeStringSeries().rename("series")

        alt = lambda x: kurtosis(x, bias=False)
        self._check_stat_op("kurt", alt, string_series)

            

Reported by Pylint.

                      dti = pd.date_range("2001-01-01", periods=11, tz=tz)
        # shuffle so that we are not just working with monotone-increasing
        dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])
        dtarr = dti._data

        obj = box(dtarr)
        assert obj.mean() == pd.Timestamp("2001-01-06", tz=tz)
        assert obj.mean(skipna=False) == pd.Timestamp("2001-01-06", tz=tz)


            

Reported by Pylint.

                      dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])

        # use hourly frequency to avoid rounding errors in expected results
        #  TODO: flesh this out with different frequencies
        parr = dti._data.to_period("H")
        obj = box(parr)
        with pytest.raises(TypeError, match="ambiguous"):
            obj.mean()
        with pytest.raises(TypeError, match="ambiguous"):

            

Reported by Pylint.

              
        # use hourly frequency to avoid rounding errors in expected results
        #  TODO: flesh this out with different frequencies
        parr = dti._data.to_period("H")
        obj = box(parr)
        with pytest.raises(TypeError, match="ambiguous"):
            obj.mean()
        with pytest.raises(TypeError, match="ambiguous"):
            obj.mean(skipna=True)

            

Reported by Pylint.

                  def test_td64_mean(self, box):
        tdi = pd.TimedeltaIndex([0, 3, -2, -7, 1, 2, -1, 3, 5, -2, 4], unit="D")

        tdarr = tdi._data
        obj = box(tdarr)

        result = obj.mean()
        expected = np.array(tdarr).mean()
        assert result == expected

            

Reported by Pylint.

              )


class TestDatetimeLikeStatReductions:
    @pytest.mark.parametrize("box", [Series, pd.Index, DatetimeArray])
    def test_dt64_mean(self, tz_naive_fixture, box):
        tz = tz_naive_fixture

        dti = pd.date_range("2001-01-01", periods=11, tz=tz)

            

Reported by Pylint.

              
class TestDatetimeLikeStatReductions:
    @pytest.mark.parametrize("box", [Series, pd.Index, DatetimeArray])
    def test_dt64_mean(self, tz_naive_fixture, box):
        tz = tz_naive_fixture

        dti = pd.date_range("2001-01-01", periods=11, tz=tz)
        # shuffle so that we are not just working with monotone-increasing
        dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])

            

Reported by Pylint.

              
class TestDatetimeLikeStatReductions:
    @pytest.mark.parametrize("box", [Series, pd.Index, DatetimeArray])
    def test_dt64_mean(self, tz_naive_fixture, box):
        tz = tz_naive_fixture

        dti = pd.date_range("2001-01-01", periods=11, tz=tz)
        # shuffle so that we are not just working with monotone-increasing
        dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])

            

Reported by Pylint.

                          )

    cf.register_option(
        # TODO(2.0): change `validator=is_nonnegative_int` see GH#31569
        "max_colwidth",
        50,
        max_colwidth_doc,
        validator=is_instance_factory([type(None), int]),
        cb=_deprecate_negative_int_max_colwidth,

            

Reported by Pylint.

              
# compute

use_bottleneck_doc = """
: bool
    Use the bottleneck library to accelerate if it is installed,
    the default is True
    Valid values: False,True
"""

            

Reported by Pylint.

              """


def use_bottleneck_cb(key):
    from pandas.core import nanops

    nanops.set_use_bottleneck(cf.get_option(key))



            

Reported by Pylint.

              

def use_bottleneck_cb(key):
    from pandas.core import nanops

    nanops.set_use_bottleneck(cf.get_option(key))


use_numexpr_doc = """

            

Reported by Pylint.

                  nanops.set_use_bottleneck(cf.get_option(key))


use_numexpr_doc = """
: bool
    Use the numexpr library to accelerate computation if it is installed,
    the default is True
    Valid values: False,True
"""

            

Reported by Pylint.

              """


def use_numexpr_cb(key):
    from pandas.core.computation import expressions

    expressions.set_use_numexpr(cf.get_option(key))



            

Reported by Pylint.

              

def use_numexpr_cb(key):
    from pandas.core.computation import expressions

    expressions.set_use_numexpr(cf.get_option(key))


use_numba_doc = """

            

Reported by Pylint.

                  expressions.set_use_numexpr(cf.get_option(key))


use_numba_doc = """
: bool
    Use the numba engine option for select operations if it is installed,
    the default is False
    Valid values: False,True
"""

            

Reported by Pylint.

              """


def use_numba_cb(key):
    from pandas.core.util import numba_

    numba_.set_use_numba(cf.get_option(key))



            

Reported by Pylint.

              

def use_numba_cb(key):
    from pandas.core.util import numba_

    numba_.set_use_numba(cf.get_option(key))


with cf.config_prefix("compute"):

            

Reported by Pylint.

              
import numpy as np

from pandas._libs import tslib
from pandas._libs.tslibs import (
    OutOfBoundsDatetime,
    Timedelta,
    Timestamp,
    conversion,

            

Reported by Pylint.

              import numpy as np

from pandas._libs import tslib
from pandas._libs.tslibs import (
    OutOfBoundsDatetime,
    Timedelta,
    Timestamp,
    conversion,
    iNaT,

            

Reported by Pylint.

              import numpy as np

from pandas._libs import tslib
from pandas._libs.tslibs import (
    OutOfBoundsDatetime,
    Timedelta,
    Timestamp,
    conversion,
    iNaT,

            

Reported by Pylint.

                  nat_strings,
    parsing,
)
from pandas._libs.tslibs.parsing import (  # noqa
    DateParseError,
    format_is_iso,
    guess_datetime_format,
)
from pandas._libs.tslibs.strptime import array_strptime

            

Reported by Pylint.

                  nat_strings,
    parsing,
)
from pandas._libs.tslibs.parsing import (  # noqa
    DateParseError,
    format_is_iso,
    guess_datetime_format,
)
from pandas._libs.tslibs.strptime import array_strptime

            

Reported by Pylint.

                  format_is_iso,
    guess_datetime_format,
)
from pandas._libs.tslibs.strptime import array_strptime
from pandas._typing import (
    AnyArrayLike,
    ArrayLike,
    Timezone,
)

            

Reported by Pylint.

                  format_is_iso,
    guess_datetime_format,
)
from pandas._libs.tslibs.strptime import array_strptime
from pandas._typing import (
    AnyArrayLike,
    ArrayLike,
    Timezone,
)

            

Reported by Pylint.

              from pandas.core.indexes.datetimes import DatetimeIndex

if TYPE_CHECKING:
    from pandas._libs.tslibs.nattype import NaTType

    from pandas import Series

# ---------------------------------------------------------------------
# types used in annotations

            

Reported by Pylint.

              from pandas.core.indexes.datetimes import DatetimeIndex

if TYPE_CHECKING:
    from pandas._libs.tslibs.nattype import NaTType

    from pandas import Series

# ---------------------------------------------------------------------
# types used in annotations

            

Reported by Pylint.

                  nat_strings,
    parsing,
)
from pandas._libs.tslibs.parsing import (  # noqa
    DateParseError,
    format_is_iso,
    guess_datetime_format,
)
from pandas._libs.tslibs.strptime import array_strptime

            

Reported by Pylint.

              import pytest

from pandas import (
    PeriodIndex,
    period_range,
)
import pandas._testing as tm



            

Reported by Pylint.

              import pytest

from pandas import (
    PeriodIndex,
    period_range,
)
import pandas._testing as tm



            

Reported by Pylint.

              import pandas._testing as tm


class TestPeriodIndex:
    def test_asfreq(self):
        pi1 = period_range(freq="A", start="1/1/2001", end="1/1/2001")
        pi2 = period_range(freq="Q", start="1/1/2001", end="1/1/2001")
        pi3 = period_range(freq="M", start="1/1/2001", end="1/1/2001")
        pi4 = period_range(freq="D", start="1/1/2001", end="1/1/2001")

            

Reported by Pylint.

              

class TestPeriodIndex:
    def test_asfreq(self):
        pi1 = period_range(freq="A", start="1/1/2001", end="1/1/2001")
        pi2 = period_range(freq="Q", start="1/1/2001", end="1/1/2001")
        pi3 = period_range(freq="M", start="1/1/2001", end="1/1/2001")
        pi4 = period_range(freq="D", start="1/1/2001", end="1/1/2001")
        pi5 = period_range(freq="H", start="1/1/2001", end="1/1/2001 00:00")

            

Reported by Pylint.

              

class TestPeriodIndex:
    def test_asfreq(self):
        pi1 = period_range(freq="A", start="1/1/2001", end="1/1/2001")
        pi2 = period_range(freq="Q", start="1/1/2001", end="1/1/2001")
        pi3 = period_range(freq="M", start="1/1/2001", end="1/1/2001")
        pi4 = period_range(freq="D", start="1/1/2001", end="1/1/2001")
        pi5 = period_range(freq="H", start="1/1/2001", end="1/1/2001 00:00")

            

Reported by Pylint.

              

class TestPeriodIndex:
    def test_asfreq(self):
        pi1 = period_range(freq="A", start="1/1/2001", end="1/1/2001")
        pi2 = period_range(freq="Q", start="1/1/2001", end="1/1/2001")
        pi3 = period_range(freq="M", start="1/1/2001", end="1/1/2001")
        pi4 = period_range(freq="D", start="1/1/2001", end="1/1/2001")
        pi5 = period_range(freq="H", start="1/1/2001", end="1/1/2001 00:00")

            

Reported by Pylint.

                      pi6 = period_range(freq="Min", start="1/1/2001", end="1/1/2001 00:00")
        pi7 = period_range(freq="S", start="1/1/2001", end="1/1/2001 00:00:00")

        assert pi1.asfreq("Q", "S") == pi2
        assert pi1.asfreq("Q", "s") == pi2
        assert pi1.asfreq("M", "start") == pi3
        assert pi1.asfreq("D", "StarT") == pi4
        assert pi1.asfreq("H", "beGIN") == pi5
        assert pi1.asfreq("Min", "S") == pi6

            

Reported by Bandit.

                      pi7 = period_range(freq="S", start="1/1/2001", end="1/1/2001 00:00:00")

        assert pi1.asfreq("Q", "S") == pi2
        assert pi1.asfreq("Q", "s") == pi2
        assert pi1.asfreq("M", "start") == pi3
        assert pi1.asfreq("D", "StarT") == pi4
        assert pi1.asfreq("H", "beGIN") == pi5
        assert pi1.asfreq("Min", "S") == pi6
        assert pi1.asfreq("S", "S") == pi7

            

Reported by Bandit.

              
        assert pi1.asfreq("Q", "S") == pi2
        assert pi1.asfreq("Q", "s") == pi2
        assert pi1.asfreq("M", "start") == pi3
        assert pi1.asfreq("D", "StarT") == pi4
        assert pi1.asfreq("H", "beGIN") == pi5
        assert pi1.asfreq("Min", "S") == pi6
        assert pi1.asfreq("S", "S") == pi7


            

Reported by Bandit.

                      assert pi1.asfreq("Q", "S") == pi2
        assert pi1.asfreq("Q", "s") == pi2
        assert pi1.asfreq("M", "start") == pi3
        assert pi1.asfreq("D", "StarT") == pi4
        assert pi1.asfreq("H", "beGIN") == pi5
        assert pi1.asfreq("Min", "S") == pi6
        assert pi1.asfreq("S", "S") == pi7

        assert pi2.asfreq("A", "S") == pi1

            

Reported by Bandit.

              
    def test_can_hold_na_valid(self, data):
        # GH-20761
        assert data._can_hold_na is True

    def test_contains(self, data, data_missing):
        # GH-37867
        # Tests for membership checks. Membership checks for nan-likes is tricky and
        # the settled on rule is: `nan_like in arr` is True if nan_like is

            

Reported by Pylint.

              
    def test_is_numeric_honored(self, data):
        result = pd.Series(data)
        if hasattr(result._mgr, "blocks"):
            assert result._mgr.blocks[0].is_numeric is data.dtype._is_numeric

    def test_isna_extension_array(self, data_missing):
        # If your `isna` returns an ExtensionArray, you must also implement
        # _reduce. At the *very* least, you must implement any and all

            

Reported by Pylint.

                  def test_is_numeric_honored(self, data):
        result = pd.Series(data)
        if hasattr(result._mgr, "blocks"):
            assert result._mgr.blocks[0].is_numeric is data.dtype._is_numeric

    def test_isna_extension_array(self, data_missing):
        # If your `isna` returns an ExtensionArray, you must also implement
        # _reduce. At the *very* least, you must implement any and all
        na = data_missing.isna()

            

Reported by Pylint.

                  def test_is_numeric_honored(self, data):
        result = pd.Series(data)
        if hasattr(result._mgr, "blocks"):
            assert result._mgr.blocks[0].is_numeric is data.dtype._is_numeric

    def test_isna_extension_array(self, data_missing):
        # If your `isna` returns an ExtensionArray, you must also implement
        # _reduce. At the *very* least, you must implement any and all
        na = data_missing.isna()

            

Reported by Pylint.

                      # _reduce. At the *very* least, you must implement any and all
        na = data_missing.isna()
        if is_extension_array_dtype(na):
            assert na._reduce("any")
            assert na.any()

            assert not na._reduce("all")
            assert not na.all()


            

Reported by Pylint.

                          assert na._reduce("any")
            assert na.any()

            assert not na._reduce("all")
            assert not na.all()

            assert na.dtype._is_boolean

    def test_copy(self, data):

            

Reported by Pylint.

                          assert not na._reduce("all")
            assert not na.all()

            assert na.dtype._is_boolean

    def test_copy(self, data):
        # GH#27083 removing deep keyword from EA.copy
        assert data[0] != data[1]
        result = data.copy()

            

Reported by Pylint.

              import numpy as np

from pandas.core.dtypes.common import is_extension_array_dtype
from pandas.core.dtypes.dtypes import ExtensionDtype

import pandas as pd
import pandas._testing as tm
from pandas.tests.extension.base.base import BaseExtensionTests


            

Reported by Pylint.

                  # Interface
    # ------------------------------------------------------------------------

    def test_len(self, data):
        assert len(data) == 100

    def test_size(self, data):
        assert data.size == 100


            

Reported by Pylint.

                  # Interface
    # ------------------------------------------------------------------------

    def test_len(self, data):
        assert len(data) == 100

    def test_size(self, data):
        assert data.size == 100


            

Reported by Pylint.

              import numpy as np
import pytest

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

            

Reported by Pylint.

              def check(result, expected=None):
    if expected is not None:
        tm.assert_frame_equal(result, expected)
    result.dtypes
    str(result)


class TestDataFrameNonuniqueIndexes:
    def test_setattr_columns_vs_construct_with_columns(self):

            

Reported by Pylint.

                      check(df, expected)

        # consolidate
        df = df._consolidate()
        expected = DataFrame(
            [[1, 1, "bah", 3], [1, 2, "bah", 3], [2, 3, "bah", 3]],
            columns=["foo", "foo", "string", "foo2"],
        )
        check(df, expected)

            

Reported by Pylint.

                          this_df = df.copy()
            expected_ser = Series(index.values, index=this_df.index)
            expected_df = DataFrame(
                {"A": expected_ser, "B": this_df["B"], "A": expected_ser},
                columns=["A", "B", "A"],
            )
            this_df["A"] = index
            check(this_df, expected_df)


            

Reported by Pylint.

                      # not-comparing like-labelled
        msg = "Can only compare identically-labeled DataFrame objects"
        with pytest.raises(ValueError, match=msg):
            df1 == df2

        df1r = df1.reindex_like(df2)
        result = df1r == df2
        expected = DataFrame(
            [[False, True], [True, False], [False, False], [True, False]],

            

Reported by Pylint.

                      df = pd.concat([df_float, df_int, df_bool, df_object, df_dt], axis=1)

        if not using_array_manager:
            assert len(df._mgr.blknos) == len(df.columns)
            assert len(df._mgr.blklocs) == len(df.columns)

        # testing iloc
        for i in range(len(df.columns)):
            df.iloc[:, i]

            

Reported by Pylint.

              
        if not using_array_manager:
            assert len(df._mgr.blknos) == len(df.columns)
            assert len(df._mgr.blklocs) == len(df.columns)

        # testing iloc
        for i in range(len(df.columns)):
            df.iloc[:, i]


            

Reported by Pylint.

              
        # testing iloc
        for i in range(len(df.columns)):
            df.iloc[:, i]

    def test_dup_columns_across_dtype(self):
        # dup columns across dtype GH 2079/2194
        vals = [[1, -1, 2.0], [2, -2, 3.0]]
        rs = DataFrame(vals, columns=["A", "A", "B"])

            

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


def check(result, expected=None):
    if expected is not None:
        tm.assert_frame_equal(result, expected)
    result.dtypes
    str(result)


            

Reported by Pylint.

              
import numpy as np

import pandas._libs.lib as lib
import pandas._libs.missing as libmissing
import pandas._libs.ops as libops
from pandas._typing import (
    Dtype,
    Scalar,

            

Reported by Pylint.

              
import numpy as np

import pandas._libs.lib as lib
import pandas._libs.missing as libmissing
import pandas._libs.ops as libops
from pandas._typing import (
    Dtype,
    Scalar,

            

Reported by Pylint.

              import numpy as np

import pandas._libs.lib as lib
import pandas._libs.missing as libmissing
import pandas._libs.ops as libops
from pandas._typing import (
    Dtype,
    Scalar,
)

            

Reported by Pylint.

              import numpy as np

import pandas._libs.lib as lib
import pandas._libs.missing as libmissing
import pandas._libs.ops as libops
from pandas._typing import (
    Dtype,
    Scalar,
)

            

Reported by Pylint.

              
import pandas._libs.lib as lib
import pandas._libs.missing as libmissing
import pandas._libs.ops as libops
from pandas._typing import (
    Dtype,
    Scalar,
)


            

Reported by Pylint.

              
import pandas._libs.lib as lib
import pandas._libs.missing as libmissing
import pandas._libs.ops as libops
from pandas._typing import (
    Dtype,
    Scalar,
)


            

Reported by Pylint.

                          )

            if len(e.args) >= 1 and re.search(p_err, e.args[0]):
                # FIXME: this should be totally avoidable
                raise e

            def g(x):
                # This type of fallback behavior can be removed once
                # we remove object-dtype .str accessor.

            

Reported by Pylint.

              
        for i, t in enumerate(tags2):
            pat = sep + t + sep
            dummies[:, i] = lib.map_infer(arr.to_numpy(), lambda x: pat in x)
        return dummies, tags2

    def _str_upper(self):
        return self._str_map(lambda x: x.upper())


            

Reported by Pylint.

              from __future__ import annotations

from collections.abc import Callable  # noqa: PDF001
import re
import textwrap
import unicodedata

import numpy as np


            

Reported by Pylint.

              from pandas.core.strings.base import BaseStringArrayMethods


class ObjectStringArrayMixin(BaseStringArrayMethods):
    """
    String Methods operating on object-dtype ndarrays.
    """

    _str_na_value = np.nan

            

Reported by Pylint.

              import numpy as np
import pytest

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

            

Reported by Pylint.

                      result = concat(
            [Series(dtype="float64").astype("Sparse"), Series(dtype="float64")]
        )
        # TODO: release-note: concat sparse dtype
        expected = pd.SparseDtype(np.float64)
        assert result.dtype == expected

        result = concat(
            [Series(dtype="float64").astype("Sparse"), Series(dtype="object")]

            

Reported by Pylint.

                      result = concat(
            [Series(dtype="float64").astype("Sparse"), Series(dtype="object")]
        )
        # TODO: release-note: concat sparse dtype
        expected = pd.SparseDtype("object")
        assert result.dtype == expected

    def test_concat_empty_df_object_dtype(self):
        # GH 9149

            

Reported by Pylint.

              import numpy as np
import pytest

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

            

Reported by Pylint.

              import pandas._testing as tm


class TestEmptyConcat:
    def test_handle_empty_objects(self, sort):
        df = DataFrame(np.random.randn(10, 4), columns=list("abcd"))

        baz = df[:5].copy()
        baz["foo"] = "bar"

            

Reported by Pylint.

              

class TestEmptyConcat:
    def test_handle_empty_objects(self, sort):
        df = DataFrame(np.random.randn(10, 4), columns=list("abcd"))

        baz = df[:5].copy()
        baz["foo"] = "bar"
        empty = df[5:5]

            

Reported by Pylint.

              

class TestEmptyConcat:
    def test_handle_empty_objects(self, sort):
        df = DataFrame(np.random.randn(10, 4), columns=list("abcd"))

        baz = df[:5].copy()
        baz["foo"] = "bar"
        empty = df[5:5]

            

Reported by Pylint.

              
class TestEmptyConcat:
    def test_handle_empty_objects(self, sort):
        df = DataFrame(np.random.randn(10, 4), columns=list("abcd"))

        baz = df[:5].copy()
        baz["foo"] = "bar"
        empty = df[5:5]


            

Reported by Pylint.

                  def test_handle_empty_objects(self, sort):
        df = DataFrame(np.random.randn(10, 4), columns=list("abcd"))

        baz = df[:5].copy()
        baz["foo"] = "bar"
        empty = df[5:5]

        frames = [baz, empty, empty, df[5:]]
        concatted = concat(frames, axis=0, sort=sort)

            

Reported by Pylint.

              
        # empty as first element with time series
        # GH3259
        df = DataFrame(
            {"A": range(10000)}, index=date_range("20130101", periods=10000, freq="s")
        )
        empty = DataFrame()
        result = concat([df, empty], axis=1)
        tm.assert_frame_equal(result, df)

            

Reported by Pylint.

              
    def test_iteritems(self):
        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
        for k, v in df.items():
            assert isinstance(v, DataFrame._constructor_sliced)

    def test_items(self):
        # GH#17213, GH#13918
        cols = ["a", "b", "c"]

            

Reported by Pylint.

                  def test_iteritems(self):
        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
        for k, v in df.items():
            assert isinstance(v, DataFrame._constructor_sliced)

    def test_items(self):
        # GH#17213, GH#13918
        cols = ["a", "b", "c"]
        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=cols)

            

Reported by Pylint.

              
    def test_itertuples(self, float_frame):
        for i, tup in enumerate(float_frame.itertuples()):
            ser = DataFrame._constructor_sliced(tup[1:])
            ser.name = tup[0]
            expected = float_frame.iloc[i, :].reset_index(drop=True)
            tm.assert_series_equal(ser, expected)

        df = DataFrame(

            

Reported by Pylint.

                      for t in df.itertuples(index=False):
            str(t)

        for row, s in df.iterrows():
            str(s)

        for c, col in df.items():
            str(s)

            

Reported by Pylint.

                      for row, s in df.iterrows():
            str(s)

        for c, col in df.items():
            str(s)

            

Reported by Pylint.

                      for row, s in df.iterrows():
            str(s)

        for c, col in df.items():
            str(s)

            

Reported by Pylint.

                          str(s)

        for c, col in df.items():
            str(s)

            

Reported by Pylint.

              import datetime

import numpy as np

from pandas.compat import (
    IS64,
    is_platform_windows,
)


            

Reported by Pylint.

              import pandas._testing as tm


class TestIteration:
    def test_keys(self, float_frame):
        assert float_frame.keys() is float_frame.columns

    def test_iteritems(self):
        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])

            

Reported by Pylint.

              

class TestIteration:
    def test_keys(self, float_frame):
        assert float_frame.keys() is float_frame.columns

    def test_iteritems(self):
        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
        for k, v in df.items():

            

Reported by Pylint.