)

import numpy as np
import pytest

from pandas._libs.tslibs.timezones import maybe_get_tz
import pandas.util._test_decorators as td

import pandas as pd

            

Reported by Pylint.

              import numpy as np
import pytest

from pandas._libs.tslibs.timezones import maybe_get_tz
import pandas.util._test_decorators as td

import pandas as pd
from pandas import (
    DataFrame,

            

Reported by Pylint.

              import numpy as np
import pytest

from pandas._libs.tslibs.timezones import maybe_get_tz
import pandas.util._test_decorators as td

import pandas as pd
from pandas import (
    DataFrame,

            

Reported by Pylint.

                  # GH#4098 example

    dti = date_range("2000-1-1", periods=3, freq="H", tz=gettz("US/Eastern"))
    dti = dti._with_freq(None)  # freq doesn't round-trip

    df = DataFrame({"A": Series(range(3), index=dti)})

    with ensure_clean_store(setup_path) as store:


            

Reported by Pylint.

                  # GH#4098 example

    dti = date_range("2000-1-1", periods=3, freq="H", tz=gettz("US/Eastern"))
    dti = dti._with_freq(None)  # freq doesn't round-trip

    df = DataFrame({"A": Series(range(3), index=dti)})

    with ensure_clean_store(setup_path) as store:


            

Reported by Pylint.

                  with ensure_clean_store(setup_path) as store:
        store.append("frame", frame)
        result = store.select_column("frame", "index")
        assert rng.tz == DatetimeIndex(result.values).tz

    # check utc
    rng = date_range("1/1/2000", "1/30/2000", tz="UTC")
    frame = DataFrame(np.random.randn(len(rng), 4), index=rng)


            

Reported by Pylint.

                  with ensure_clean_store(setup_path) as store:
        store.append("frame", frame)
        result = store.select_column("frame", "index")
        assert rng.tz == DatetimeIndex(result.values).tz

    # check utc
    rng = date_range("1/1/2000", "1/30/2000", tz="UTC")
    frame = DataFrame(np.random.randn(len(rng), 4), index=rng)


            

Reported by Pylint.

                  with ensure_clean_store(setup_path) as store:
        store.append("frame", frame)
        result = store.select_column("frame", "index")
        assert rng.tz == result.dt.tz

    # double check non-utc
    rng = date_range("1/1/2000", "1/30/2000", tz="US/Eastern")
    frame = DataFrame(np.random.randn(len(rng), 4), index=rng)


            

Reported by Pylint.

                  with ensure_clean_store(setup_path) as store:
        store.append("frame", frame)
        result = store.select_column("frame", "index")
        assert rng.tz == result.dt.tz

    # double check non-utc
    rng = date_range("1/1/2000", "1/30/2000", tz="US/Eastern")
    frame = DataFrame(np.random.randn(len(rng), 4), index=rng)


            

Reported by Pylint.

                  with ensure_clean_store(setup_path) as store:
        store.append("frame", frame)
        result = store.select_column("frame", "index")
        assert rng.tz == result.dt.tz


def test_timezones_fixed_format_frame_non_empty(setup_path):
    with ensure_clean_store(setup_path) as store:


            

Reported by Pylint.

              import re

import numpy as np
import pytest

from pandas.core.dtypes.common import is_float_dtype

import pandas._testing as tm


            

Reported by Pylint.

              def test_map_identity_mapping(index):
    # GH#12766
    result = index.map(lambda x: x)
    if index._is_backward_compat_public_numeric_index:
        if is_float_dtype(index.dtype):
            expected = index.astype(np.float64)
        elif index.dtype == np.uint64:
            expected = index.astype(np.uint64)
        else:

            

Reported by Pylint.

                          "and integer or boolean arrays are valid indices"
        )
        with pytest.raises(IndexError, match=msg):
            index[item]


class TestRendering:
    def test_str(self, index):
        # test the string repr

            

Reported by Pylint.

              import pandas._testing as tm


def test_boolean_context_compat(index):
    # GH#7897
    with pytest.raises(ValueError, match="The truth value of a"):
        if index:
            pass


            

Reported by Pylint.

                      bool(index)


def test_sort(index):
    msg = "cannot sort an Index object in-place, use sort_values instead"
    with pytest.raises(TypeError, match=msg):
        index.sort()



            

Reported by Pylint.

                      index.sort()


def test_hash_error(index):
    with pytest.raises(TypeError, match=f"unhashable type: '{type(index).__name__}'"):
        hash(index)


def test_copy_dtype_deprecated(index):

            

Reported by Pylint.

                      hash(index)


def test_copy_dtype_deprecated(index):
    # GH#35853
    with tm.assert_produces_warning(FutureWarning):
        index.copy(dtype=object)



            

Reported by Pylint.

                      index.copy(dtype=object)


def test_mutability(index):
    if not len(index):
        return
    msg = "Index does not support mutable operations"
    with pytest.raises(TypeError, match=msg):
        index[0] = index[0]

            

Reported by Pylint.

              

def test_mutability(index):
    if not len(index):
        return
    msg = "Index does not support mutable operations"
    with pytest.raises(TypeError, match=msg):
        index[0] = index[0]


            

Reported by Pylint.

                      index[0] = index[0]


def test_map_identity_mapping(index):
    # GH#12766
    result = index.map(lambda x: x)
    if index._is_backward_compat_public_numeric_index:
        if is_float_dtype(index.dtype):
            expected = index.astype(np.float64)

            

Reported by Pylint.

              from __future__ import annotations

import importlib
import types
from typing import (
    TYPE_CHECKING,
    Sequence,
)


            

Reported by Pylint.

              from __future__ import annotations

import importlib
import types
from typing import (
    TYPE_CHECKING,
    Sequence,
)


            

Reported by Pylint.

                  from pandas import DataFrame


def hist_series(
    self,
    by=None,
    ax=None,
    grid: bool = True,
    xlabelsize: int | None = None,

            

Reported by Pylint.

                  from pandas import DataFrame


def hist_series(
    self,
    by=None,
    ax=None,
    grid: bool = True,
    xlabelsize: int | None = None,

            

Reported by Pylint.

                  from pandas import DataFrame


def hist_series(
    self,
    by=None,
    ax=None,
    grid: bool = True,
    xlabelsize: int | None = None,

            

Reported by Pylint.

                  )


def hist_frame(
    data: DataFrame,
    column: IndexLabel = None,
    by=None,
    grid: bool = True,
    xlabelsize: int | None = None,

            

Reported by Pylint.

                  )


def hist_frame(
    data: DataFrame,
    column: IndexLabel = None,
    by=None,
    grid: bool = True,
    xlabelsize: int | None = None,

            

Reported by Pylint.

                  )


def hist_frame(
    data: DataFrame,
    column: IndexLabel = None,
    by=None,
    grid: bool = True,
    xlabelsize: int | None = None,

            

Reported by Pylint.

                  )


def hist_frame(
    data: DataFrame,
    column: IndexLabel = None,
    by=None,
    grid: bool = True,
    xlabelsize: int | None = None,

            

Reported by Pylint.

                  )


_boxplot_doc = """
Make a box plot from DataFrame columns.

Make a box-and-whisker plot from DataFrame columns, optionally grouped
by some other columns. A box plot is a method for graphically depicting
groups of numerical data through their quartiles.

            

Reported by Pylint.

              import numpy as np
import pytest

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


def test_get():

            

Reported by Pylint.

                  [np.random.randn(10), tm.makeDateIndex(10, name="a").tz_localize(tz="US/Eastern")],
)
def test_get2(arr):
    # TODO: better name, possibly split
    # GH#21260
    ser = Series(arr, index=[2 * i for i in range(len(arr))])
    assert ser.get(4) == ser.iloc[2]

    result = ser.get([4, 6])

            

Reported by Pylint.

              import numpy as np
import pytest

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


def test_get():

            

Reported by Pylint.

              import pandas._testing as tm


def test_get():
    # GH 6383
    s = Series(
        np.array(
            [
                43,

            

Reported by Pylint.

              
def test_get():
    # GH 6383
    s = Series(
        np.array(
            [
                43,
                48,
                60,

            

Reported by Pylint.

              
    result = s.get(25, 0)
    expected = 0
    assert result == expected

    s = Series(
        np.array(
            [
                43,

            

Reported by Bandit.

                  expected = 0
    assert result == expected

    s = Series(
        np.array(
            [
                43,
                48,
                60,

            

Reported by Pylint.

              
    result = s.get(25, 0)
    expected = 43
    assert result == expected

    # GH 7407
    # with a boolean accessor
    df = pd.DataFrame({"i": [0] * 3, "b": [False] * 3})
    vc = df.i.value_counts()

            

Reported by Bandit.

              
    # GH 7407
    # with a boolean accessor
    df = pd.DataFrame({"i": [0] * 3, "b": [False] * 3})
    vc = df.i.value_counts()
    result = vc.get(99, default="Missing")
    assert result == "Missing"

    vc = df.b.value_counts()

            

Reported by Pylint.

                  # GH 7407
    # with a boolean accessor
    df = pd.DataFrame({"i": [0] * 3, "b": [False] * 3})
    vc = df.i.value_counts()
    result = vc.get(99, default="Missing")
    assert result == "Missing"

    vc = df.b.value_counts()
    result = vc.get(False, default="Missing")

            

Reported by Pylint.

              import numpy as np
import pytest

import pandas.util._test_decorators as td

from pandas import (
    Categorical,
    DataFrame,
    MultiIndex,

            

Reported by Pylint.

                      if len(index) == 0:
            pytest.skip("Test doesn't make sense for empty index")

        from xarray import Dataset

        df.index = index[:3]
        df.index.name = "foo"
        df.columns.name = "bar"
        result = df.to_xarray()

            

Reported by Pylint.

                      tm.assert_frame_equal(result.to_dataframe(), expected)

    def test_to_xarray_empty(self, df):
        from xarray import Dataset

        df.index.name = "foo"
        result = df[0:0].to_xarray()
        assert result.dims["foo"] == 0
        assert isinstance(result, Dataset)

            

Reported by Pylint.

                      assert isinstance(result, Dataset)

    def test_to_xarray_with_multiindex(self, df):
        from xarray import Dataset

        # MultiIndex
        df.index = MultiIndex.from_product([["a"], range(3)], names=["one", "two"])
        result = df.to_xarray()
        assert result.dims["one"] == 1

            

Reported by Pylint.

                      if isinstance(index, MultiIndex):
            pytest.skip("MultiIndex is tested separately")

        from xarray import DataArray

        ser = Series(range(len(index)), index=index, dtype="int64")
        ser.index.name = "foo"
        result = ser.to_xarray()
        repr(result)

            

Reported by Pylint.

                      tm.assert_series_equal(result.to_series(), ser)

    def test_to_xarray_empty(self):
        from xarray import DataArray

        ser = Series([], dtype=object)
        ser.index.name = "foo"
        result = ser.to_xarray()
        assert len(result) == 0

            

Reported by Pylint.

                      assert isinstance(result, DataArray)

    def test_to_xarray_with_multiindex(self):
        from xarray import DataArray

        mi = MultiIndex.from_product([["a", "b"], range(3)], names=["one", "two"])
        ser = Series(range(6), dtype="int64", index=mi)
        result = ser.to_xarray()
        assert len(result) == 2

            

Reported by Pylint.

              import numpy as np
import pytest

import pandas.util._test_decorators as td

from pandas import (
    Categorical,
    DataFrame,
    MultiIndex,

            

Reported by Pylint.

              

@td.skip_if_no("xarray")
class TestDataFrameToXArray:
    @pytest.fixture
    def df(self):
        return DataFrame(
            {
                "a": list("abc"),

            

Reported by Pylint.

              @td.skip_if_no("xarray")
class TestDataFrameToXArray:
    @pytest.fixture
    def df(self):
        return DataFrame(
            {
                "a": list("abc"),
                "b": list(range(1, 4)),
                "c": np.arange(3, 6).astype("u1"),

            

Reported by Pylint.

              import string

import numpy as np
import pytest

import pandas.util._test_decorators as td

import pandas as pd
import pandas._testing as tm

            

Reported by Pylint.

                  @pytest.mark.parametrize("dtype", ["float64", "int64"])
    @td.skip_if_no_scipy
    def test_from_spmatrix(self, format, labels, dtype):
        import scipy.sparse

        sp_dtype = SparseDtype(dtype, np.array(0, dtype=dtype).item())

        mat = scipy.sparse.eye(10, format=format, dtype=dtype)
        result = pd.DataFrame.sparse.from_spmatrix(mat, index=labels, columns=labels)

            

Reported by Pylint.

                  @pytest.mark.parametrize("format", ["csc", "csr", "coo"])
    @td.skip_if_no_scipy
    def test_from_spmatrix_including_explicit_zero(self, format):
        import scipy.sparse

        mat = scipy.sparse.random(10, 2, density=0.5, format=format)
        mat.data[0] = 0
        result = pd.DataFrame.sparse.from_spmatrix(mat)
        dtype = SparseDtype("float64", 0.0)

            

Reported by Pylint.

                  )
    @td.skip_if_no_scipy
    def test_from_spmatrix_columns(self, columns):
        import scipy.sparse

        dtype = SparseDtype("float64", 0.0)

        mat = scipy.sparse.random(10, 2, density=0.5)
        result = pd.DataFrame.sparse.from_spmatrix(mat, columns=columns)

            

Reported by Pylint.

                  @pytest.mark.parametrize("colnames", [("A", "B"), (1, 2), (1, pd.NA), (0.1, 0.2)])
    @td.skip_if_no_scipy
    def test_to_coo(self, colnames):
        import scipy.sparse

        df = pd.DataFrame(
            {colnames[0]: [0, 1, 0], colnames[1]: [1, 0, 0]}, dtype="Sparse[int64, 0]"
        )
        result = df.sparse.to_coo()

            

Reported by Pylint.

                  @pytest.mark.parametrize("dense_index", [True, False])
    @td.skip_if_no_scipy
    def test_series_from_coo(self, dtype, dense_index):
        import scipy.sparse

        A = scipy.sparse.eye(3, format="coo", dtype=dtype)
        result = pd.Series.sparse.from_coo(A, dense_index=dense_index)
        index = pd.MultiIndex.from_tuples([(0, 0), (1, 1), (2, 2)])
        expected = pd.Series(SparseArray(np.array([1, 1, 1], dtype=dtype)), index=index)

            

Reported by Pylint.

                  @td.skip_if_no_scipy
    def test_series_from_coo_incorrect_format_raises(self):
        # gh-26554
        import scipy.sparse

        m = scipy.sparse.csr_matrix(np.array([[0, 1], [0, 0]]))
        with pytest.raises(
            TypeError, match="Expected coo_matrix. Got csr_matrix instead."
        ):

            

Reported by Pylint.

              

class TestSeriesAccessor:
    # TODO: collect other Series accessor tests
    def test_to_dense(self):
        s = pd.Series([0, 1, 0, 10], dtype="Sparse[int64]")
        result = s.sparse.to_dense()
        expected = pd.Series([0, 1, 0, 10])
        tm.assert_series_equal(result, expected)

            

Reported by Pylint.

                  def test_accessor_raises(self):
        df = pd.DataFrame({"A": [0, 1]})
        with pytest.raises(AttributeError, match="sparse"):
            df.sparse

    @pytest.mark.parametrize("format", ["csc", "csr", "coo"])
    @pytest.mark.parametrize("labels", [None, list(string.ascii_letters[:10])])
    @pytest.mark.parametrize("dtype", ["float64", "int64"])
    @td.skip_if_no_scipy

            

Reported by Pylint.

                  @pytest.mark.parametrize("labels", [None, list(string.ascii_letters[:10])])
    @pytest.mark.parametrize("dtype", ["float64", "int64"])
    @td.skip_if_no_scipy
    def test_from_spmatrix(self, format, labels, dtype):
        import scipy.sparse

        sp_dtype = SparseDtype(dtype, np.array(0, dtype=dtype).item())

        mat = scipy.sparse.eye(10, format=format, dtype=dtype)

            

Reported by Pylint.

              )

import numpy as np
import pytest

from pandas import (
    CategoricalDtype,
    CategoricalIndex,
    DataFrame,

            

Reported by Pylint.

              
        msg = "Invalid call for scalar access"
        with pytest.raises(ValueError, match=msg):
            df.at[[1, 2]]
        with pytest.raises(ValueError, match=msg):
            df.at[1, ["A"]]
        with pytest.raises(ValueError, match=msg):
            df.at[:, "A"]


            

Reported by Pylint.

                      with pytest.raises(ValueError, match=msg):
            df.at[[1, 2]]
        with pytest.raises(ValueError, match=msg):
            df.at[1, ["A"]]
        with pytest.raises(ValueError, match=msg):
            df.at[:, "A"]

        with pytest.raises(ValueError, match=msg):
            df.at[[1, 2]] = 1

            

Reported by Pylint.

                      with pytest.raises(ValueError, match=msg):
            df.at[1, ["A"]]
        with pytest.raises(ValueError, match=msg):
            df.at[:, "A"]

        with pytest.raises(ValueError, match=msg):
            df.at[[1, 2]] = 1
        with pytest.raises(ValueError, match=msg):
            df.at[1, ["A"]] = 1

            

Reported by Pylint.

              

class TestAtErrors:
    # TODO: De-duplicate/parametrize
    #  test_at_series_raises_key_error2, test_at_frame_raises_key_error2

    def test_at_series_raises_key_error(self, indexer_al):
        # GH#31724 .at should match .loc


            

Reported by Pylint.

                      assert result == 3

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

    def test_at_frame_raises_key_error(self, indexer_al):
        # GH#31724 .at should match .loc

        df = DataFrame({0: [1, 2, 3]}, index=[3, 2, 1])

            

Reported by Pylint.

                      assert result == 3

        with pytest.raises(KeyError, match="a"):
            indexer_al(df)["a", 0]

        with pytest.raises(KeyError, match="a"):
            indexer_al(df)[1, "a"]

    def test_at_series_raises_key_error2(self, indexer_al):

            

Reported by Pylint.

                          indexer_al(df)["a", 0]

        with pytest.raises(KeyError, match="a"):
            indexer_al(df)[1, "a"]

    def test_at_series_raises_key_error2(self, indexer_al):
        # at should not fallback
        # GH#7814
        # GH#31724 .at should match .loc

            

Reported by Pylint.

                      assert result == 1

        with pytest.raises(KeyError, match="^0$"):
            indexer_al(ser)[0]

    def test_at_frame_raises_key_error2(self, indexer_al):
        # GH#31724 .at should match .loc
        df = DataFrame({"A": [1, 2, 3]}, index=list("abc"))
        result = indexer_al(df)["a", "A"]

            

Reported by Pylint.

                      assert result == 1

        with pytest.raises(KeyError, match="^0$"):
            indexer_al(df)["a", 0]

    def test_at_getitem_mixed_index_no_fallback(self):
        # GH#19860
        ser = Series([1, 2, 3, 4, 5], index=["a", "b", "c", 1, 2])
        with pytest.raises(KeyError, match="^0$"):

            

Reported by Pylint.

              
import numpy as np

import pandas._libs.lib as lib
from pandas._typing import FilePathOrBuffer
from pandas.errors import (
    EmptyDataError,
    ParserError,
)

            

Reported by Pylint.

              
import numpy as np

import pandas._libs.lib as lib
from pandas._typing import FilePathOrBuffer
from pandas.errors import (
    EmptyDataError,
    ParserError,
)

            

Reported by Pylint.

                  def get_chunk(self, size=None):
        if size is None:
            # error: "PythonParser" has no attribute "chunksize"
            size = self.chunksize  # type: ignore[attr-defined]
        return self.read(rows=size)

    def _convert_data(self, data):
        # apply converters
        def _clean_mapping(mapping):

            

Reported by Pylint.

                                          line = ret[0]
                            break
                except IndexError:
                    raise StopIteration
        else:
            while self.skipfunc(self.pos):
                self.pos += 1
                # assert for mypy, data is Iterator[str] or None, would error in next
                assert self.data is not None

            

Reported by Pylint.

              
        else:
            # Case 2
            (index_name, columns_, self.index_col) = self._clean_index_names(
                columns, self.index_col, self.unnamed_cols
            )

        return index_name, orig_names, columns


            

Reported by Pylint.

              from __future__ import annotations

from collections import (
    abc,
    defaultdict,
)
from copy import copy
import csv
from io import StringIO

            

Reported by Pylint.

              from __future__ import annotations

from collections import (
    abc,
    defaultdict,
)
from copy import copy
import csv
from io import StringIO

            

Reported by Pylint.

              _BOM = "\ufeff"


class PythonParser(ParserBase):
    def __init__(self, f: FilePathOrBuffer | list, **kwds):
        """
        Workhorse function for processing nested list into DataFrame
        """
        ParserBase.__init__(self, kwds)

            

Reported by Pylint.

              _BOM = "\ufeff"


class PythonParser(ParserBase):
    def __init__(self, f: FilePathOrBuffer | list, **kwds):
        """
        Workhorse function for processing nested list into DataFrame
        """
        ParserBase.__init__(self, kwds)

            

Reported by Pylint.

              

class PythonParser(ParserBase):
    def __init__(self, f: FilePathOrBuffer | list, **kwds):
        """
        Workhorse function for processing nested list into DataFrame
        """
        ParserBase.__init__(self, kwds)


            

Reported by Pylint.

              from datetime import datetime

import numpy as np
import pytest
import pytz

from pandas import (
    NA,
    DatetimeIndex,

            

Reported by Pylint.

              
import numpy as np
import pytest
import pytz

from pandas import (
    NA,
    DatetimeIndex,
    Index,

            

Reported by Pylint.

                      item = Timestamp("2017-04-05").tz_localize(tz)

        result = dti.insert(0, item)
        assert result.freq == dti.freq

        # But not when we insert an item that doesn't conform to freq
        dti = DatetimeIndex([], tz=tz, freq="W-THU")
        result = dti.insert(0, item)
        assert result.freq is None

            

Reported by Pylint.

                          result = idx.insert(n, d)
            tm.assert_index_equal(result, expected)
            assert result.name == expected.name
            assert result.freq == expected.freq

        # reset freq to None
        result = idx.insert(3, datetime(2000, 1, 2))
        expected = DatetimeIndex(
            ["2000-01-31", "2000-02-29", "2000-03-31", "2000-01-02"],

            

Reported by Pylint.

                              assert result.tz == expected.tz
                assert result.freq is None

    # TODO: also changes DataFrame.__setitem__ with expansion
    def test_insert_mismatched_tzawareness(self):
        # see GH#7299
        idx = date_range("1/1/2000", periods=3, freq="D", tz="Asia/Tokyo", name="idx")

        # mismatched tz-awareness

            

Reported by Pylint.

                      )
        tm.assert_index_equal(result, expected)

    # TODO: also changes DataFrame.__setitem__ with expansion
    def test_insert_mismatched_tz(self):
        # see GH#7299
        idx = date_range("1/1/2000", periods=3, freq="D", tz="Asia/Tokyo", name="idx")

        # mismatched tz -> cast to object (could reasonably cast to same tz or UTC)

            

Reported by Pylint.

                      result = dti.insert(1, item)

        if isinstance(item, np.ndarray):
            # FIXME: without doing .item() here this segfaults
            assert item.item() == 0
            expected = Index([dti[0], 0] + list(dti[1:]), dtype=object, name=9)
        else:
            expected = Index([dti[0], item] + list(dti[1:]), dtype=object, name=9)


            

Reported by Pylint.

              from datetime import datetime

import numpy as np
import pytest
import pytz

from pandas import (
    NA,
    DatetimeIndex,

            

Reported by Pylint.

              import pandas._testing as tm


class TestInsert:
    @pytest.mark.parametrize("null", [None, np.nan, np.datetime64("NaT"), NaT, NA])
    @pytest.mark.parametrize("tz", [None, "UTC", "US/Eastern"])
    def test_insert_nat(self, tz, null):
        # GH#16537, GH#18295 (test missing)


            

Reported by Pylint.

              class TestInsert:
    @pytest.mark.parametrize("null", [None, np.nan, np.datetime64("NaT"), NaT, NA])
    @pytest.mark.parametrize("tz", [None, "UTC", "US/Eastern"])
    def test_insert_nat(self, tz, null):
        # GH#16537, GH#18295 (test missing)

        idx = DatetimeIndex(["2017-01-01"], tz=tz)
        expected = DatetimeIndex(["NaT", "2017-01-01"], tz=tz)
        if tz is not None and isinstance(null, np.datetime64):

            

Reported by Pylint.

              
import numpy as np

from pandas._libs import (
    lib,
    tslibs,
)
from pandas._libs.arrays import NDArrayBacked
from pandas._libs.tslibs import (

            

Reported by Pylint.

                  lib,
    tslibs,
)
from pandas._libs.arrays import NDArrayBacked
from pandas._libs.tslibs import (
    BaseOffset,
    NaT,
    NaTType,
    Period,

            

Reported by Pylint.

                  lib,
    tslibs,
)
from pandas._libs.arrays import NDArrayBacked
from pandas._libs.tslibs import (
    BaseOffset,
    NaT,
    NaTType,
    Period,

            

Reported by Pylint.

                  iNaT,
    to_offset,
)
from pandas._libs.tslibs.conversion import (
    ensure_timedelta64ns,
    precision_from_unit,
)
from pandas._libs.tslibs.fields import get_timedelta_field
from pandas._libs.tslibs.timedeltas import (

            

Reported by Pylint.

                  iNaT,
    to_offset,
)
from pandas._libs.tslibs.conversion import (
    ensure_timedelta64ns,
    precision_from_unit,
)
from pandas._libs.tslibs.fields import get_timedelta_field
from pandas._libs.tslibs.timedeltas import (

            

Reported by Pylint.

                  ensure_timedelta64ns,
    precision_from_unit,
)
from pandas._libs.tslibs.fields import get_timedelta_field
from pandas._libs.tslibs.timedeltas import (
    array_to_timedelta64,
    ints_to_pytimedelta,
    parse_timedelta_unit,
)

            

Reported by Pylint.

                  ensure_timedelta64ns,
    precision_from_unit,
)
from pandas._libs.tslibs.fields import get_timedelta_field
from pandas._libs.tslibs.timedeltas import (
    array_to_timedelta64,
    ints_to_pytimedelta,
    parse_timedelta_unit,
)

            

Reported by Pylint.

                  precision_from_unit,
)
from pandas._libs.tslibs.fields import get_timedelta_field
from pandas._libs.tslibs.timedeltas import (
    array_to_timedelta64,
    ints_to_pytimedelta,
    parse_timedelta_unit,
)
from pandas._typing import (

            

Reported by Pylint.

                  precision_from_unit,
)
from pandas._libs.tslibs.fields import get_timedelta_field
from pandas._libs.tslibs.timedeltas import (
    array_to_timedelta64,
    ints_to_pytimedelta,
    parse_timedelta_unit,
)
from pandas._typing import (

            

Reported by Pylint.

                  def f(self) -> np.ndarray:
        values = self.asi8
        result = get_timedelta_field(values, alias)
        if self._hasnans:
            result = self._maybe_mask_results(
                result, fill_value=None, convert="float64"
            )

        return result

            

Reported by Pylint.