text stringlengths 0 20k |
|---|
from datetime import datetime
import numpy as np
import pytest
from pytz import UTC
from pandas._libs.tslibs import (
OutOfBoundsTimedelta,
astype_overflowsafe,
conversion,
iNaT,
timezones,
tz_convert_from_utc,
tzconversion,
)
from pandas import (
Timestamp,
date_range,
)
import p... |
"""
Tests for Timestamp parsing, aimed at pandas/_libs/tslibs/parsing.pyx
"""
from datetime import datetime
import re
from dateutil.parser import parse as du_parse
from dateutil.tz import tzlocal
from hypothesis import given
import numpy as np
import pytest
from pandas._libs.tslibs import (
parsing,
strptime,... |
"""Tests that the tslibs API is locked down"""
from pandas._libs import tslibs
def test_namespace():
submodules = [
"base",
"ccalendar",
"conversion",
"dtypes",
"fields",
"nattype",
"np_datetime",
"offsets",
"parsing",
"period",
... |
import numpy as np
import pytest
import pytz
from pandas._libs.tslibs.tzconversion import tz_localize_to_utc
class TestTZLocalizeToUTC:
def test_tz_localize_to_utc_ambiguous_infer(self):
# val is a timestamp that is ambiguous when localized to US/Eastern
val = 1_320_541_200_000_000_000
va... |
import numpy as np
import pytest
from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
from pandas._libs.tslibs.np_datetime import (
OutOfBoundsDatetime,
OutOfBoundsTimedelta,
astype_overflowsafe,
is_unitless,
py_get_unit_from_dtype,
py_td64_to_tdstruct,
)
import pandas._testing as tm
def t... |
import numpy as np
import pytest
from pandas._libs.tslibs import (
iNaT,
to_offset,
)
from pandas._libs.tslibs.period import (
extract_ordinals,
get_period_field_arr,
period_asfreq,
period_ordinal,
)
import pandas._testing as tm
def get_freq_code(freqstr: str) -> int:
off = to_offset(fre... |
from datetime import (
date,
datetime,
timedelta,
timezone,
)
from dateutil.tz.tz import tzoffset
import numpy as np
import pytest
from pandas._libs import (
NaT,
iNaT,
tslib,
)
from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
from pandas._libs.tslibs.np_datetime import OutOfBoundsDa... |
import re
import pytest
from pandas._libs.tslibs import (
Timedelta,
offsets,
to_offset,
)
@pytest.mark.parametrize(
"freq_input,expected",
[
(to_offset("10us"), offsets.Micro(10)),
(offsets.Hour(), offsets.Hour()),
("2h30min", offsets.Minute(150)),
("2h 30min", o... |
from datetime import datetime
import pytest
from pandas._libs import tslib
from pandas import Timestamp
@pytest.mark.parametrize(
"date_str, exp",
[
("2011-01-02", datetime(2011, 1, 2)),
("2011-1-2", datetime(2011, 1, 2)),
("2011-01", datetime(2011, 1, 1)),
("2011-1", dateti... |
import numpy as np
from pandas._libs.tslibs.dtypes import abbrev_to_npy_unit
from pandas._libs.tslibs.vectorized import is_date_array_normalized
# a datetime64 ndarray which *is* normalized
day_arr = np.arange(10, dtype="i8").view("M8[D]")
class TestIsDateArrayNormalized:
def test_is_date_array_normalized_day(s... |
from datetime import (
datetime,
timedelta,
timezone,
)
import dateutil.tz
import pytest
import pytz
from pandas._libs.tslibs import (
conversion,
timezones,
)
from pandas.compat import is_platform_windows
from pandas import Timestamp
def test_is_utc(utc_fixture):
tz = timezones.maybe_get_t... |
"""
Tests for helper functions in the cython tslibs.offsets
"""
from datetime import datetime
import pytest
from pandas._libs.tslibs.ccalendar import (
get_firstbday,
get_lastbday,
)
import pandas._libs.tslibs.offsets as liboffsets
from pandas._libs.tslibs.offsets import roll_qtrday
from pandas import Timest... |
from datetime import (
datetime,
timezone,
)
import numpy as np
import pytest
from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
from pandas._libs.tslibs.strptime import array_strptime
from pandas import (
NaT,
Timestamp,
)
import pandas._testing as tm
creso_infer = NpyDatetimeUnit.NPY_FR_GENERI... |
from datetime import datetime
import numpy as np
import pytest
from pandas._libs import iNaT
import pandas._testing as tm
import pandas.core.algorithms as algos
@pytest.fixture(
params=[
(np.int8, np.int16(127), np.int8),
(np.int8, np.int16(128), np.int16),
(np.int32, 1, np.int32),
... |
"""
Tests for the Index constructor conducting inference.
"""
from datetime import (
datetime,
timedelta,
timezone,
)
from decimal import Decimal
import numpy as np
import pytest
from pandas._libs.tslibs.timezones import maybe_get_tz
from pandas import (
NA,
Categorical,
CategoricalIndex,
... |
import pytest
from pandas.compat import PY311
from pandas import (
offsets,
period_range,
)
import pandas._testing as tm
class TestFreq:
def test_freq_setter_deprecated(self):
# GH#20678
idx = period_range("2018Q1", periods=4, freq="Q")
# no warning for getter
with tm.as... |
import pytest
import pandas as pd
class TestResolution:
@pytest.mark.parametrize(
"freq,expected",
[
("Y", "year"),
("Q", "quarter"),
("M", "month"),
("D", "day"),
("h", "hour"),
("min", "minute"),
("s", "second")... |
import numpy as np
import pytest
from pandas._libs.tslibs import IncompatibleFrequency
from pandas import (
DataFrame,
Index,
PeriodIndex,
date_range,
period_range,
)
import pandas._testing as tm
class TestJoin:
def test_join_outer_indexer(self):
pi = period_range("1/1/2000", "1/20/2... |
from contextlib import nullcontext
from datetime import (
datetime,
time,
)
import locale
import numpy as np
import pytest
import pandas as pd
from pandas import (
PeriodIndex,
Series,
)
import pandas._testing as tm
def get_local_am_pm():
"""Return the AM and PM strings returned by strftime in c... |
import numpy as np
import pytest
from pandas import (
DataFrame,
PeriodIndex,
Series,
date_range,
period_range,
)
import pandas._testing as tm
class TestPeriodIndex:
def test_getitem_periodindex_duplicates_string_slice(
self, using_copy_on_write, warn_copy_on_write
):
# mo... |
"""Tests for PeriodIndex behaving like a vectorized Period scalar"""
import pytest
from pandas import (
Timedelta,
date_range,
period_range,
)
import pandas._testing as tm
class TestPeriodIndexOps:
def test_start_time(self):
# GH#17157
index = period_range(freq="M", start="2016-01-01... |
import numpy as np
import pytest
from pandas import (
NaT,
Period,
PeriodIndex,
date_range,
period_range,
)
import pandas._testing as tm
class TestPeriodRangeKeywords:
def test_required_arguments(self):
msg = (
"Of the three parameters: start, end, and periods, exactly two... |
import numpy as np
import pytest
from pandas import (
Index,
NaT,
Period,
PeriodIndex,
Series,
date_range,
offsets,
period_range,
)
import pandas._testing as tm
class TestPeriodIndex:
def test_view_asi8(self):
idx = PeriodIndex([], freq="M")
exp = np.array([], dty... |
import numpy as np
import pytest
from pandas import (
Period,
PeriodIndex,
period_range,
)
import pandas._testing as tm
class TestPeriodRepresentation:
"""
Wish to match NumPy units
"""
@pytest.mark.parametrize(
"freq, base_date",
[
("W-THU", "1970-01-01"),
... |
import numpy as np
import pytest
from pandas._libs.tslibs import IncompatibleFrequency
from pandas import (
NaT,
Period,
PeriodIndex,
)
import pandas._testing as tm
class TestSearchsorted:
@pytest.mark.parametrize("freq", ["D", "2D"])
def test_searchsorted(self, freq):
pidx = PeriodIndex... |
import numpy as np
import pytest
from pandas import (
PeriodIndex,
period_range,
)
import pandas._testing as tm
class TestPeriodIndexShift:
# ---------------------------------------------------------------
# PeriodIndex.shift is used by __add__ and __sub__
def test_pi_shift_ndarray(self):
... |
from pandas import (
Index,
NaT,
Period,
PeriodIndex,
)
import pandas._testing as tm
class TestFillNA:
def test_fillna_period(self):
# GH#11343
idx = PeriodIndex(["2011-01-01 09:00", NaT, "2011-01-01 11:00"], freq="h")
exp = PeriodIndex(
["2011-01-01 09:00", "2... |
from datetime import datetime
import numpy as np
import pytest
from pandas import (
DatetimeIndex,
NaT,
PeriodIndex,
Timedelta,
Timestamp,
date_range,
period_range,
)
import pandas._testing as tm
class TestToTimestamp:
def test_to_timestamp_non_contiguous(self):
# GH#44100
... |
import pytest
from pandas import PeriodIndex
def test_is_full():
index = PeriodIndex([2005, 2007, 2009], freq="Y")
assert not index.is_full
index = PeriodIndex([2005, 2006, 2007], freq="Y")
assert index.is_full
index = PeriodIndex([2005, 2005, 2007], freq="Y")
assert not index.is_full
... |
import numpy as np
from pandas import PeriodIndex
import pandas._testing as tm
class TestFactorize:
def test_factorize_period(self):
idx1 = PeriodIndex(
["2014-01", "2014-01", "2014-02", "2014-02", "2014-03", "2014-03"],
freq="M",
)
exp_arr = np.array([0, 0, 1, 1,... |
import re
import pytest
from pandas import (
PeriodIndex,
Series,
period_range,
)
import pandas._testing as tm
from pandas.tseries import offsets
class TestPeriodIndex:
def test_asfreq(self):
pi1 = period_range(freq="Y", start="1/1/2001", end="1/1/2001")
pi2 = period_range(freq="Q",... |
import numpy as np
import pytest
from pandas import (
NaT,
PeriodIndex,
period_range,
)
import pandas._testing as tm
class TestInsert:
@pytest.mark.parametrize("na", [np.nan, NaT, None])
def test_insert(self, na):
# GH#18295 (test missing)
expected = PeriodIndex(["2017Q1", NaT, "2... |
import numpy as np
import pytest
from pandas import (
PeriodIndex,
period_range,
)
import pandas._testing as tm
class TestRepeat:
@pytest.mark.parametrize("use_numpy", [True, False])
@pytest.mark.parametrize(
"index",
[
period_range("2000-01-01", periods=3, freq="D"),
... |
import numpy as np
import pytest
from pandas import (
CategoricalIndex,
DatetimeIndex,
Index,
NaT,
Period,
PeriodIndex,
period_range,
)
import pandas._testing as tm
class TestPeriodIndexAsType:
@pytest.mark.parametrize("dtype", [float, "timedelta64", "timedelta64[ns]"])
def test_a... |
import numpy as np
import pytest
from pandas import (
NaT,
PeriodIndex,
period_range,
)
import pandas._testing as tm
from pandas.tseries import offsets
class TestPickle:
@pytest.mark.parametrize("freq", ["D", "M", "Y"])
def test_pickle_round_trip(self, freq):
idx = PeriodIndex(["2016-05-... |
from pandas import (
Period,
PeriodIndex,
)
def test_is_monotonic_increasing():
# GH#17717
p0 = Period("2017-09-01")
p1 = Period("2017-09-02")
p2 = Period("2017-09-03")
idx_inc0 = PeriodIndex([p0, p1, p2])
idx_inc1 = PeriodIndex([p0, p1, p1])
idx_dec0 = PeriodIndex([p2, p1, p0])
... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
PeriodIndex,
date_range,
period_range,
)
import pandas._testing as tm
def _permute(obj):
return obj.take(np.random.default_rng(2).permutation(len(obj)))
class TestPeriodIndex:
def test_union(self, sort):
# union
... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
Index,
Series,
)
import pandas._testing as tm
class TestFloatNumericIndex:
@pytest.fixture(params=[np.float64, np.float32])
def dtype(self, request):
return request.param
@pytest.fixture
def simple_index(self, ... |
import numpy as np
import pytest
import pandas._testing as tm
from pandas.core.indexes.api import Index
class TestJoinInt64Index:
def test_join_non_unique(self):
left = Index([4, 4, 3, 3])
joined, lidx, ridx = left.join(left, return_indexers=True)
exp_joined = Index([4, 4, 4, 4, 3, 3, 3... |
import numpy as np
import pytest
from pandas import (
Index,
to_datetime,
to_timedelta,
)
import pandas._testing as tm
class TestAstype:
def test_astype_float64_to_uint64(self):
# GH#45309 used to incorrectly return Index with int64 dtype
idx = Index([0.0, 5.0, 10.0, 15.0, 20.0], dtyp... |
from datetime import (
datetime,
timedelta,
)
import numpy as np
import pytest
import pandas._testing as tm
from pandas.core.indexes.api import (
Index,
RangeIndex,
)
@pytest.fixture
def index_large():
# large values used in TestUInt64Index where no compat needed with int64/float64
large = [... |
import numpy as np
from pandas import (
Index,
RangeIndex,
)
import pandas._testing as tm
class TestJoin:
def test_join_outer(self):
# join with Index[int64]
index = RangeIndex(start=0, stop=20, step=2)
other = Index(np.arange(25, 14, -1, dtype=np.int64))
res, lidx, ridx ... |
from datetime import datetime
import numpy as np
import pytest
from pandas import (
Index,
RangeIndex,
Series,
)
import pandas._testing as tm
class TestRangeIndexConstructors:
@pytest.mark.parametrize("name", [None, "foo"])
@pytest.mark.parametrize(
"args, kwargs, start, stop, step",
... |
import numpy as np
import pytest
from pandas import (
Index,
RangeIndex,
)
import pandas._testing as tm
class TestGetIndexer:
def test_get_indexer(self):
index = RangeIndex(start=0, stop=20, step=2)
target = RangeIndex(10)
indexer = index.get_indexer(target)
expected = np.... |
from datetime import (
datetime,
timedelta,
)
from hypothesis import (
assume,
given,
strategies as st,
)
import numpy as np
import pytest
from pandas import (
Index,
RangeIndex,
)
import pandas._testing as tm
class TestRangeIndexSetOps:
@pytest.mark.parametrize("dtype", [None, "int6... |
import numpy as np
import pytest
from pandas import (
PeriodIndex,
Series,
date_range,
period_range,
timedelta_range,
)
import pandas._testing as tm
class DropDuplicates:
def test_drop_duplicates_metadata(self, idx):
# GH#10115
result = idx.drop_duplicates()
tm.assert_... |
from pandas import (
Index,
NaT,
date_range,
)
def test_is_monotonic_with_nat():
# GH#31437
# PeriodIndex.is_monotonic_increasing should behave analogously to DatetimeIndex,
# in particular never be monotonic when we have NaT
dti = date_range("2016-01-01", periods=3)
pi = dti.to_perio... |
import numpy as np
from pandas import (
DatetimeIndex,
NaT,
PeriodIndex,
Series,
TimedeltaIndex,
date_range,
period_range,
timedelta_range,
)
import pandas._testing as tm
class TestValueCounts:
# GH#7735
def test_value_counts_unique_datetimeindex(self, tz_naive_fixture):
... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
DatetimeIndex,
Index,
)
import pandas._testing as tm
dtlike_dtypes = [
np.dtype("timedelta64[ns]"),
np.dtype("datetime64[ns]"),
pd.DatetimeTZDtype("ns", "Asia/Tokyo"),
pd.PeriodDtype("ns"),
]
@pytest.mark.parametrize("... |
"""
Tests shared for DatetimeIndex/TimedeltaIndex/PeriodIndex
"""
from datetime import (
datetime,
timedelta,
)
import numpy as np
import pytest
import pandas as pd
from pandas import (
CategoricalIndex,
DatetimeIndex,
Index,
PeriodIndex,
TimedeltaIndex,
date_range,
period_range,
... |
import numpy as np
import pytest
from pandas import (
DatetimeIndex,
NaT,
PeriodIndex,
TimedeltaIndex,
)
import pandas._testing as tm
class NATests:
def test_nat(self, index_without_na):
empty_index = index_without_na[:0]
index_with_na = index_without_na.copy(deep=True)
i... |
import numpy as np
import pytest
from pandas import (
DatetimeIndex,
Index,
NaT,
PeriodIndex,
TimedeltaIndex,
timedelta_range,
)
import pandas._testing as tm
def check_freq_ascending(ordered, orig, ascending):
"""
Check the expected freq on a PeriodIndex/DatetimeIndex/TimedeltaIndex
... |
"""
Tests that can be parametrized over _any_ Index object.
"""
import re
import numpy as np
import pytest
from pandas.errors import InvalidIndexError
import pandas._testing as tm
def test_boolean_context_compat(index):
# GH#7897
with pytest.raises(ValueError, match="The truth value of a"):
if inde... |
import numpy as np
import pytest
from pandas.errors import PerformanceWarning
import pandas as pd
from pandas import (
Index,
MultiIndex,
)
import pandas._testing as tm
def test_drop(idx):
dropped = idx.drop([("foo", "two"), ("qux", "one")])
index = MultiIndex.from_tuples([("foo", "two"), ("qux", "... |
import numpy as np
import pandas as pd
from pandas import (
CategoricalIndex,
Index,
MultiIndex,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestGetLevelValues:
def test_get_level_values_box_datetime64(self):
dates = date_range("1/1/2000", periods=4)
levels = [... |
from itertools import product
import numpy as np
import pytest
from pandas._libs import (
hashtable,
index as libindex,
)
from pandas import (
NA,
DatetimeIndex,
Index,
MultiIndex,
Series,
)
import pandas._testing as tm
@pytest.fixture
def idx_dup():
# compare tests/indexes/multi/co... |
from copy import (
copy,
deepcopy,
)
import pytest
from pandas import MultiIndex
import pandas._testing as tm
def assert_multiindex_copied(copy, original):
# Levels should be (at least, shallow copied)
tm.assert_copy(copy.levels, original.levels)
tm.assert_almost_equal(copy.codes, original.codes... |
import numpy as np
import pytest
from pandas import MultiIndex
import pandas._testing as tm
def test_isin_nan():
idx = MultiIndex.from_arrays([["foo", "bar"], [1.0, np.nan]])
tm.assert_numpy_array_equal(idx.isin([("bar", np.nan)]), np.array([False, True]))
tm.assert_numpy_array_equal(
idx.isin([(... |
import numpy as np
import pytest
import pandas as pd
from pandas import MultiIndex
import pandas._testing as tm
def test_fillna(idx):
# GH 11343
msg = "isna is not defined for MultiIndex"
with pytest.raises(NotImplementedError, match=msg):
idx.fillna(idx[0])
def test_dropna():
# GH 6194
... |
import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
def test_take(idx):
indexer = [4, 3, 0, 2]
result = idx.take(indexer)
expected = idx[indexer]
assert result.equals(expected)
# GH 10791
msg = "'MultiIndex' object has no attribute 'freq'"
with pytest.raises... |
import numpy as np
import pytest
from pandas import (
DataFrame,
Index,
Interval,
MultiIndex,
Series,
StringDtype,
)
import pandas._testing as tm
@pytest.mark.parametrize(
"other", [Index(["three", "one", "two"]), Index(["one"]), Index(["one", "three"])]
)
def test_join_level(idx, other, ... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
Index,
MultiIndex,
)
import pandas._testing as tm
def test_format(idx):
msg = "MultiIndex.format is deprecated"
with tm.assert_produces_warning(FutureWarning, match=msg):
idx.format()
idx[:0].format()
def test... |
import numpy as np
import pytest
from pandas.compat import PY311
from pandas.core.dtypes.dtypes import DatetimeTZDtype
import pandas as pd
from pandas import (
CategoricalIndex,
MultiIndex,
)
import pandas._testing as tm
def assert_matching(actual, expected, check_dtype=False):
# avoid specifying inter... |
import numpy as np
import pytest
from pandas.compat.numpy import np_version_gt2
import pandas as pd
from pandas import (
DataFrame,
MultiIndex,
)
import pandas._testing as tm
def test_to_numpy(idx):
result = idx.to_numpy()
exp = idx.values
tm.assert_numpy_array_equal(result, exp)
def test_arra... |
import re
import numpy as np
import pytest
from pandas._libs import index as libindex
from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
import pandas as pd
from pandas import (
Index,
IntervalIndex,
MultiIndex,
RangeIndex,
)
import pandas._testing as tm
def test_labels_dt... |
import numpy as np
import pytest
from pandas.errors import (
PerformanceWarning,
UnsortedIndexError,
)
from pandas import (
CategoricalIndex,
DataFrame,
Index,
MultiIndex,
RangeIndex,
Series,
Timestamp,
)
import pandas._testing as tm
from pandas.core.indexes.frozen import FrozenLis... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
Index,
MultiIndex,
date_range,
period_range,
)
import pandas._testing as tm
def test_infer_objects(idx):
with pytest.raises(NotImplementedError, match="to_frame"):
idx.infer_objects()
def test_shift(idx):
# GH... |
from pandas import MultiIndex
class TestIsLexsorted:
def test_is_lexsorted(self):
levels = [[0, 1], [0, 1, 2]]
index = MultiIndex(
levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]
)
assert index._is_lexsorted()
index = MultiIndex(
leve... |
import pytest
import pandas as pd
from pandas import MultiIndex
import pandas._testing as tm
def check_level_names(index, names):
assert [level.name for level in index.levels] == list(names)
def test_slice_keep_name():
x = MultiIndex.from_tuples([("a", "b"), (1, 2), ("c", "d")], names=["x", "y"])
asser... |
import numpy as np
import pytest
import pandas as pd
from pandas import MultiIndex
import pandas._testing as tm
def test_numeric_compat(idx):
with pytest.raises(TypeError, match="cannot perform __mul__"):
idx * 1
with pytest.raises(TypeError, match="cannot perform __rmul__"):
1 * idx
di... |
from datetime import datetime
import numpy as np
import pytest
import pytz
import pandas as pd
from pandas import (
Index,
MultiIndex,
)
import pandas._testing as tm
def test_insert(idx):
# key contained in all levels
new_index = idx.insert(0, ("bar", "two"))
assert new_index.equal_levels(idx)
... |
import numpy as np
import pytest
from pandas import (
Index,
MultiIndex,
)
# Note: identical the "multi" entry in the top-level "index" fixture
@pytest.fixture
def idx():
# a MultiIndex used to test the general functionality of the
# general functionality of this object
major_axis = Index(["foo",... |
import numpy as np
import pytest
from pandas.core.dtypes.common import is_any_real_numeric_dtype
import pandas as pd
from pandas import (
Index,
MultiIndex,
Series,
)
import pandas._testing as tm
def test_equals(idx):
assert idx.equals(idx)
assert idx.equals(idx.copy())
assert idx.equals(idx... |
import pytest
from pandas import MultiIndex
def test_pickle_compat_construction():
# this is testing for pickle compat
# need an object to create with
with pytest.raises(TypeError, match="Must pass both levels and codes"):
MultiIndex()
|
import numpy as np
import pytest
from pandas import (
DataFrame,
IndexSlice,
MultiIndex,
date_range,
)
import pandas._testing as tm
@pytest.fixture
def df():
# c1
# 2016-01-01 00:00:00 a 0
# b 1
# c 2
# 2016-01-0... |
import numpy as np
import pytest
from pandas import (
Index,
MultiIndex,
)
def test_is_monotonic_increasing_lexsorted(lexsorted_two_level_string_multiindex):
# string ordering
mi = lexsorted_two_level_string_multiindex
assert mi.is_monotonic_increasing is False
assert Index(mi.values).is_mono... |
import numpy as np
import pytest
from pandas.core.dtypes.dtypes import CategoricalDtype
import pandas._testing as tm
def test_astype(idx):
expected = idx.copy()
actual = idx.astype("O")
tm.assert_copy(actual.levels, expected.levels)
tm.assert_copy(actual.codes, expected.codes)
assert actual.name... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
Index,
MultiIndex,
)
import pandas._testing as tm
def test_reindex(idx):
result, indexer = idx.reindex(list(idx[:4]))
assert isinstance(result, MultiIndex)
assert result.names == ["first", "second"]
assert [level.name f... |
"""
test_indexing tests the following Index methods:
__getitem__
get_loc
get_value
__contains__
take
where
get_indexer
get_indexer_for
slice_locs
asof_locs
The corresponding tests.indexes.[index_type].test_indexing files
contain tests for the corresponding methods specific to th... |
import numpy as np
import pytest
from pandas._libs import index as libindex
from pandas._libs.arrays import NDArrayBacked
import pandas as pd
from pandas import (
Categorical,
CategoricalDtype,
)
import pandas._testing as tm
from pandas.core.indexes.api import (
CategoricalIndex,
Index,
)
class Test... |
import numpy as np
import pytest
from pandas import CategoricalIndex
import pandas._testing as tm
class TestFillNA:
def test_fillna_categorical(self):
# GH#11343
idx = CategoricalIndex([1.0, np.nan, 3.0, 1.0], name="x")
# fill by value in categories
exp = CategoricalIndex([1.0, 1.... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
CategoricalIndex,
Index,
Series,
)
import pandas._testing as tm
@pytest.mark.parametrize(
"data, categories",
[
(list("abcbca"), list("cab")),
(pd.interval_range(0, 3).repeat(3), pd.interval_range(0, 3)),
... |
import numpy as np
import pytest
from pandas import (
Categorical,
CategoricalDtype,
CategoricalIndex,
Index,
)
import pandas._testing as tm
class TestCategoricalIndexConstructors:
def test_construction_disallows_scalar(self):
msg = "must be called with a collection of some kind"
... |
"""
Tests for CategoricalIndex.__repr__ and related methods.
"""
import pytest
from pandas._config import using_string_dtype
import pandas._config.config as cf
from pandas import CategoricalIndex
import pandas._testing as tm
class TestCategoricalIndexRepr:
def test_format_different_scalar_lengths(self):
... |
import numpy as np
import pytest
from pandas.errors import InvalidIndexError
import pandas as pd
from pandas import (
CategoricalIndex,
Index,
IntervalIndex,
Timestamp,
)
import pandas._testing as tm
class TestTake:
def test_take_fill_value(self):
# GH 12631
# numeric category
... |
import pytest
from pandas import (
CategoricalIndex,
Index,
)
import pandas._testing as tm
class TestAppend:
@pytest.fixture
def ci(self):
categories = list("cab")
return CategoricalIndex(list("aabbca"), categories=categories, ordered=False)
def test_append(self, ci):
# a... |
import numpy as np
import pytest
from pandas import (
Categorical,
CategoricalIndex,
Index,
MultiIndex,
)
class TestEquals:
def test_equals_categorical(self):
ci1 = CategoricalIndex(["a", "b"], categories=["a", "b"], ordered=True)
ci2 = CategoricalIndex(["a", "b"], categories=["a"... |
from datetime import date
import numpy as np
import pytest
from pandas import (
Categorical,
CategoricalDtype,
CategoricalIndex,
Index,
IntervalIndex,
)
import pandas._testing as tm
class TestAstype:
def test_astype(self):
ci = CategoricalIndex(list("aabbca"), categories=list("cab"),... |
import numpy as np
import pytest
from pandas import (
CategoricalIndex,
Index,
)
import pandas._testing as tm
@pytest.mark.parametrize("na_value", [None, np.nan])
def test_difference_with_na(na_value):
# GH 57318
ci = CategoricalIndex(["a", "b", "c", None])
other = Index(["c", na_value])
resu... |
import numpy as np
import pytest
from pandas import (
Categorical,
CategoricalIndex,
Index,
Interval,
)
import pandas._testing as tm
class TestReindex:
def test_reindex_list_non_unique(self):
# GH#11586
msg = "cannot reindex on an axis with duplicate labels"
ci = Categoric... |
"""
Collection of tests asserting things that should be true for
any index subclass except for MultiIndex. Makes use of the `index_flat`
fixture defined in pandas/conftest.py.
"""
from copy import (
copy,
deepcopy,
)
import re
import numpy as np
import pytest
from pandas.compat import IS64
from pandas.compat.... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.