text stringlengths 0 20k |
|---|
import pytest
from pandas import TimedeltaIndex
from pandas.tseries.offsets import (
DateOffset,
Day,
Hour,
MonthEnd,
)
class TestFreq:
@pytest.mark.parametrize("values", [["0 days", "2 days", "4 days"], []])
@pytest.mark.parametrize("freq", ["2D", Day(2), "48h", Hour(48)])
def test_freq... |
import numpy as np
from pandas import (
DataFrame,
Index,
Timedelta,
timedelta_range,
)
import pandas._testing as tm
class TestJoin:
def test_append_join_nondatetimeindex(self):
rng = timedelta_range("1 days", periods=10)
idx = Index(["a", "b", "c", "d"])
result = rng.app... |
import numpy as np
import pytest
from pandas import (
Timedelta,
TimedeltaIndex,
timedelta_range,
to_timedelta,
)
import pandas._testing as tm
from pandas.tseries.offsets import (
Day,
Second,
)
class TestTimedeltas:
def test_timedelta_range_unit(self):
# GH#49824
tdi = t... |
from datetime import timedelta
import numpy as np
import pytest
import pandas as pd
from pandas import (
Timedelta,
TimedeltaIndex,
timedelta_range,
to_timedelta,
)
import pandas._testing as tm
from pandas.core.arrays.timedeltas import TimedeltaArray
class TestTimedeltaIndex:
def test_closed_dep... |
import pytest
import pandas as pd
from pandas import (
Series,
TimedeltaIndex,
)
class TestTimedeltaIndexRendering:
def test_repr_round_days_non_nano(self):
# GH#55405
# we should get "1 days", not "1 days 00:00:00" with non-nano
tdi = TimedeltaIndex(["1 days"], freq="D").as_unit(... |
"""
Tests for TimedeltaIndex methods behaving like their Timedelta counterparts
"""
import numpy as np
import pytest
from pandas._libs.tslibs.offsets import INVALID_FREQ_ERR_MSG
from pandas import (
Index,
Series,
Timedelta,
TimedeltaIndex,
timedelta_range,
)
import pandas._testing as tm
class ... |
from pandas import (
TimedeltaIndex,
timedelta_range,
)
import pandas._testing as tm
class TestTimedeltaIndexOps:
def test_infer_freq(self, freq_sample):
# GH#11018
idx = timedelta_range("1", freq=freq_sample, periods=10)
result = TimedeltaIndex(idx.asi8, freq="infer")
tm.a... |
from datetime import datetime
import re
import numpy as np
import pytest
from pandas import (
Index,
NaT,
Timedelta,
TimedeltaIndex,
Timestamp,
notna,
offsets,
timedelta_range,
to_timedelta,
)
import pandas._testing as tm
class TestGetItem:
def test_getitem_slice_keeps_name(s... |
# Arithmetic tests for TimedeltaIndex are generally about the result's `freq` attribute.
# Other cases can be shared in tests.arithmetic.test_timedelta64
import numpy as np
from pandas import (
NaT,
Timedelta,
timedelta_range,
)
import pandas._testing as tm
class TestTimedeltaIndexArithmetic:
def tes... |
import numpy as np
import pytest
from pandas import (
TimedeltaIndex,
Timestamp,
)
import pandas._testing as tm
class TestSearchSorted:
def test_searchsorted_different_argument_classes(self, listlike_box):
idx = TimedeltaIndex(["1 day", "2 days", "3 days"])
result = idx.searchsorted(listl... |
import numpy as np
import pytest
from pandas import (
Index,
Series,
Timedelta,
timedelta_range,
)
import pandas._testing as tm
class TestTimedeltaIndex:
def test_misc_coverage(self):
rng = timedelta_range("1 day", periods=5)
result = rng.groupby(rng.days)
assert isinstanc... |
import pytest
from pandas.errors import NullFrequencyError
import pandas as pd
from pandas import TimedeltaIndex
import pandas._testing as tm
class TestTimedeltaIndexShift:
# -------------------------------------------------------------
# TimedeltaIndex.shift is used by __add__/__sub__
def test_tdi_shi... |
from pandas import (
Index,
NaT,
Timedelta,
TimedeltaIndex,
)
import pandas._testing as tm
class TestFillNA:
def test_fillna_timedelta(self):
# GH#11343
idx = TimedeltaIndex(["1 day", NaT, "3 day"])
exp = TimedeltaIndex(["1 day", "2 day", "3 day"])
tm.assert_index_... |
import numpy as np
from pandas import (
TimedeltaIndex,
factorize,
timedelta_range,
)
import pandas._testing as tm
class TestTimedeltaIndexFactorize:
def test_factorize(self):
idx1 = TimedeltaIndex(["1 day", "1 day", "2 day", "2 day", "3 day", "3 day"])
exp_arr = np.array([0, 0, 1, 1... |
from datetime import timedelta
import numpy as np
import pytest
from pandas._libs import lib
import pandas as pd
from pandas import (
Index,
Timedelta,
TimedeltaIndex,
timedelta_range,
)
import pandas._testing as tm
class TestTimedeltaIndexInsert:
def test_insert(self):
idx = TimedeltaI... |
import numpy as np
from pandas import (
TimedeltaIndex,
timedelta_range,
)
import pandas._testing as tm
class TestRepeat:
def test_repeat(self):
index = timedelta_range("1 days", periods=2, freq="D")
exp = TimedeltaIndex(["1 days", "1 days", "2 days", "2 days"])
for res in [index.... |
from datetime import timedelta
import numpy as np
import pytest
import pandas as pd
from pandas import (
Index,
NaT,
Timedelta,
TimedeltaIndex,
timedelta_range,
)
import pandas._testing as tm
from pandas.core.arrays import TimedeltaArray
class TestTimedeltaIndex:
def test_astype_object(self)... |
from pandas import timedelta_range
import pandas._testing as tm
class TestPickle:
def test_pickle_after_set_freq(self):
tdi = timedelta_range("1 day", periods=4, freq="s")
tdi = tdi._with_freq(None)
res = tm.round_trip_pickle(tdi)
tm.assert_index_equal(res, tdi)
|
import numpy as np
import pytest
import pandas as pd
from pandas import (
Index,
TimedeltaIndex,
timedelta_range,
)
import pandas._testing as tm
from pandas.tseries.offsets import Hour
class TestTimedeltaIndex:
def test_union(self):
i1 = timedelta_range("1day", periods=5)
i2 = timede... |
from pandas import (
TimedeltaIndex,
timedelta_range,
)
import pandas._testing as tm
class TestTimedeltaIndexDelete:
def test_delete(self):
idx = timedelta_range(start="1 Days", periods=5, freq="D", name="idx")
# preserve freq
expected_0 = timedelta_range(start="2 Days", periods=4... |
import pytest
from pandas import (
DatetimeIndex,
date_range,
)
from pandas.tseries.offsets import (
BDay,
DateOffset,
Day,
Hour,
)
class TestFreq:
def test_freq_setter_errors(self):
# GH#20678
idx = DatetimeIndex(["20180101", "20180103", "20180105"])
# setting w... |
from datetime import (
datetime,
timezone,
)
import numpy as np
import pytest
from pandas import (
DataFrame,
DatetimeIndex,
Index,
Timestamp,
date_range,
period_range,
to_datetime,
)
import pandas._testing as tm
from pandas.tseries.offsets import (
BDay,
BMonthEnd,
)
cl... |
from datetime import datetime
import dateutil.tz
import numpy as np
import pytest
import pytz
import pandas as pd
from pandas import (
DatetimeIndex,
NaT,
Series,
)
import pandas._testing as tm
@pytest.fixture(params=["s", "ms", "us", "ns"])
def unit(request):
return request.param
def test_get_val... |
""" test partial slicing on Series/Frame """
from datetime import datetime
import numpy as np
import pytest
from pandas import (
DataFrame,
DatetimeIndex,
Index,
MultiIndex,
Series,
Timedelta,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestSlicing:
def test_stri... |
"""
Tests for DatetimeIndex methods behaving like their Timestamp counterparts
"""
import calendar
from datetime import (
date,
datetime,
time,
)
import locale
import unicodedata
import numpy as np
import pytest
from pandas._libs.tslibs import timezones
from pandas import (
DatetimeIndex,
Index,... |
from datetime import datetime
import pytest
from pandas import (
DatetimeIndex,
Index,
bdate_range,
date_range,
)
import pandas._testing as tm
class TestDatetimeIndexOps:
def test_infer_freq(self, freq_sample):
# GH 11018
idx = date_range("2011-01-01 09:00:00", freq=freq_sample, ... |
# Arithmetic tests specific to DatetimeIndex are generally about `freq`
# rentention or inference. Other arithmetic tests belong in
# tests/arithmetic/test_datetime64.py
import pytest
from pandas import (
Timedelta,
TimedeltaIndex,
Timestamp,
date_range,
timedelta_range,
)
import pandas._testing... |
from datetime import datetime
import pytest
import pytz
from pandas.errors import NullFrequencyError
import pandas as pd
from pandas import (
DatetimeIndex,
Series,
date_range,
)
import pandas._testing as tm
START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
class TestDatetimeIndexShift:
# --... |
import pytest
import pandas as pd
import pandas._testing as tm
class TestDatetimeIndexFillNA:
@pytest.mark.parametrize("tz", ["US/Eastern", "Asia/Tokyo"])
def test_fillna_datetime64(self, tz):
# GH 11343
idx = pd.DatetimeIndex(["2011-01-01 09:00", pd.NaT, "2011-01-01 11:00"])
exp = p... |
from dateutil.tz import tzlocal
import pytest
from pandas.compat import IS64
from pandas import date_range
@pytest.mark.parametrize(
"freq,expected",
[
("YE", "day"),
("QE", "day"),
("ME", "day"),
("D", "day"),
("h", "hour"),
("min", "minute"),
("s", "... |
import pytest
from pandas import (
DatetimeIndex,
Index,
MultiIndex,
Period,
date_range,
)
import pandas._testing as tm
class TestMap:
def test_map(self):
rng = date_range("1/1/2000", periods=10)
f = lambda x: x.strftime("%Y%m%d")
result = rng.map(f)
exp = Ind... |
from pandas import (
DataFrame,
Index,
date_range,
)
import pandas._testing as tm
class TestToFrame:
def test_to_frame_datetime_tz(self):
# GH#25809
idx = date_range(start="2019-01-01", end="2019-01-30", freq="D", tz="UTC")
result = idx.to_frame()
expected = DataFrame(i... |
from datetime import (
datetime,
timezone,
)
import dateutil.parser
import dateutil.tz
from dateutil.tz import tzlocal
import numpy as np
from pandas import (
DatetimeIndex,
date_range,
to_datetime,
)
import pandas._testing as tm
from pandas.tests.indexes.datetimes.test_timezones import FixedOffse... |
from pandas import (
DataFrame,
DatetimeIndex,
date_range,
)
import pandas._testing as tm
def test_isocalendar_returns_correct_values_close_to_new_year_with_tz():
# GH#6538: Check that DatetimeIndex and its TimeStamp elements
# return the same weekofyear accessor close to new year w/ tz
dates ... |
from dateutil.tz import tzlocal
import numpy as np
import pytest
import pandas.util._test_decorators as td
from pandas import (
DatetimeIndex,
NaT,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestNormalize:
def test_normalize(self):
rng = date_range("1/1/2000 9:30", perio... |
import numpy as np
import pytest
from pandas import (
DatetimeIndex,
Index,
date_range,
factorize,
)
import pandas._testing as tm
class TestDatetimeIndexFactorize:
def test_factorize(self):
idx1 = DatetimeIndex(
["2014-01", "2014-01", "2014-02", "2014-02", "2014-03", "2014-03"... |
import pytest
from pandas._libs.tslibs import to_offset
from pandas._libs.tslibs.offsets import INVALID_FREQ_ERR_MSG
from pandas import (
DatetimeIndex,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestDatetimeIndexRound:
def test_round_daily(self):
dti = date_range("20130101 ... |
import pytest
from pandas import (
DatetimeIndex,
date_range,
)
import pandas._testing as tm
@pytest.mark.parametrize("tz", [None, "Asia/Shanghai", "Europe/Berlin"])
@pytest.mark.parametrize("name", [None, "my_dti"])
@pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_dti_snap(name, tz, unit):... |
from datetime import timedelta
from pandas import (
Index,
Timestamp,
date_range,
isna,
)
class TestAsOf:
def test_asof_partial(self):
index = date_range("2010-01-01", periods=2, freq="ME")
expected = Timestamp("2010-02-28")
result = index.asof("2010-02")
assert re... |
import numpy as np
from pandas import (
Index,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestDateTimeIndexToJulianDate:
def test_1700(self):
dr = date_range(start=Timestamp("1710-10-01"), periods=5, freq="D")
r1 = Index([x.to_julian_date() for x in dr])
r2 = ... |
from datetime import datetime
import numpy as np
import pytest
import pytz
from pandas import (
NA,
DatetimeIndex,
Index,
NaT,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestInsert:
@pytest.mark.parametrize("null", [None, np.nan, np.datetime64("NaT"), NaT, NA])
@pyte... |
import dateutil.tz
from dateutil.tz import tzlocal
import pytest
import pytz
from pandas._libs.tslibs.ccalendar import MONTHS
from pandas._libs.tslibs.offsets import MonthEnd
from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
from pandas import (
DatetimeIndex,
Period,
PeriodIndex,
Timestamp,... |
import numpy as np
import pytest
from pandas import (
DatetimeIndex,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestRepeat:
def test_repeat_range(self, tz_naive_fixture):
rng = date_range("1/1/2000", "1/1/2001")
result = rng.repeat(5)
assert result.freq is No... |
from datetime import (
datetime,
timedelta,
)
from pandas import (
DatetimeIndex,
NaT,
Timestamp,
)
import pandas._testing as tm
def test_unique(tz_naive_fixture):
idx = DatetimeIndex(["2017"] * 2, tz=tz_naive_fixture)
expected = idx[:1]
result = idx.unique()
tm.assert_index_equa... |
from datetime import (
datetime,
timedelta,
)
import dateutil.tz
from dateutil.tz import gettz
import numpy as np
import pytest
import pytz
from pandas import (
DatetimeIndex,
Timestamp,
bdate_range,
date_range,
offsets,
to_datetime,
)
import pandas._testing as tm
try:
from zonein... |
import numpy as np
from pandas import (
DatetimeIndex,
Series,
)
import pandas._testing as tm
class TestToSeries:
def test_to_series(self):
naive = DatetimeIndex(["2013-1-1 13:00", "2013-1-2 14:00"], name="B")
idx = naive.tz_localize("US/Pacific")
expected = Series(np.array(idx.t... |
from datetime import datetime
import dateutil
import numpy as np
import pytest
import pytz
import pandas as pd
from pandas import (
DatetimeIndex,
Index,
NaT,
PeriodIndex,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestDatetimeIndex:
@pytest.mark.parametrize("tzstr", ["U... |
import pytest
from pandas import (
DatetimeIndex,
Series,
date_range,
)
import pandas._testing as tm
class TestDelete:
def test_delete(self, unit):
idx = date_range(
start="2000-01-01", periods=5, freq="ME", name="idx", unit=unit
)
# preserve freq
expected... |
from datetime import datetime
import dateutil.tz
from dateutil.tz import gettz
import numpy as np
import pytest
import pytz
from pandas._libs.tslibs import timezones
from pandas import (
DatetimeIndex,
Index,
NaT,
Timestamp,
date_range,
offsets,
)
import pandas._testing as tm
class TestTZCo... |
import pytest
from pandas import (
NaT,
date_range,
to_datetime,
)
import pandas._testing as tm
class TestPickle:
def test_pickle(self):
# GH#4606
idx = to_datetime(["2013-01-01", NaT, "2014-01-06"])
idx_p = tm.round_trip_pickle(idx)
assert idx_p[0] == idx[0]
a... |
import numpy as np
from pandas import date_range
import pandas._testing as tm
class TestSplit:
def test_split_non_utc(self):
# GH#14042
indices = date_range("2016-01-01 00:00:00+0200", freq="s", periods=10)
result = np.split(indices, indices_or_sections=[])[0]
expected = indices._... |
import dateutil.tz
import numpy as np
import pytest
from pandas import (
DatetimeIndex,
date_range,
to_datetime,
)
from pandas.core.arrays import datetimes
class TestDatetimeIndexIteration:
@pytest.mark.parametrize(
"tz", [None, "UTC", "US/Central", dateutil.tz.tzoffset(None, -28800)]
)
... |
"""
Tests for DatetimeIndex timezone-related methods
"""
from datetime import (
datetime,
timedelta,
timezone,
tzinfo,
)
from dateutil.tz import gettz
import numpy as np
import pytest
import pytz
from pandas._libs.tslibs import (
conversion,
timezones,
)
import pandas as pd
from pandas import... |
import datetime as dt
from datetime import date
import re
import numpy as np
import pytest
from pandas.compat.numpy import np_long
import pandas as pd
from pandas import (
DataFrame,
DatetimeIndex,
Index,
Timestamp,
date_range,
offsets,
)
import pandas._testing as tm
class TestDatetimeIndex... |
from datetime import timedelta
import numpy as np
from pandas import (
DatetimeIndex,
date_range,
)
import pandas._testing as tm
class TestDatetimeIndexReindex:
def test_reindex_preserves_tz_if_target_is_empty_list_or_array(self):
# GH#7774
index = date_range("2013-01-01", periods=3, tz=... |
import numpy as np
import pytest
from pandas import (
CategoricalIndex,
DatetimeIndex,
Index,
PeriodIndex,
TimedeltaIndex,
isna,
)
import pandas._testing as tm
from pandas.api.types import (
is_complex_dtype,
is_numeric_dtype,
)
from pandas.core.arrays import BooleanArray
from pandas.co... |
import re
import pytest
from pandas.core.indexes.frozen import FrozenList
@pytest.fixture
def lst():
return [1, 2, 3, 4, 5]
@pytest.fixture
def container(lst):
return FrozenList(lst)
@pytest.fixture
def unicode_container():
return FrozenList(["\u05d0", "\u05d1", "c"])
class TestFrozenList:
def... |
import numpy as np
import pytest
import pandas as pd
from pandas import Index
import pandas._testing as tm
def _isnan(val):
try:
return val is not pd.NA and np.isnan(val)
except TypeError:
return False
def _equivalent_na(dtype, null):
if dtype.na_value is pd.NA and null is pd.NA:
... |
from pandas import (
Index,
Series,
)
import pandas._testing as tm
def test_astype_str_from_bytes():
# https://github.com/pandas-dev/pandas/issues/38607
# GH#49658 pre-2.0 Index called .values.astype(str) here, which effectively
# did a .decode() on the bytes object. In 2.0 we go through
# ... |
from decimal import Decimal
import numpy as np
import pytest
from pandas._libs.missing import is_matching_na
from pandas import Index
import pandas._testing as tm
class TestGetIndexer:
@pytest.mark.parametrize(
"method,expected",
[
("pad", np.array([-1, 0, 1, 1], dtype=np.intp)),
... |
import pytest
from pandas import (
Index,
NaT,
)
def test_astype_invalid_nas_to_tdt64_raises():
# GH#45722 don't cast np.datetime64 NaTs to timedelta64 NaT
idx = Index([NaT.asm8] * 2, dtype=object)
msg = r"Invalid type for timedelta scalar: <class 'numpy.datetime64'>"
with pytest.raises(Type... |
import numpy as np
from pandas import Index
import pandas._testing as tm
class TestWhere:
def test_where_intlike_str_doesnt_cast_ints(self):
idx = Index(range(3))
mask = np.array([True, False, True])
res = idx.where(mask, "2")
expected = Index([0, "2", 2])
tm.assert_index_... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
Index,
MultiIndex,
Series,
)
import pandas._testing as tm
class TestIndexConstructor:
# Tests for the Index constructor, specifically for cases that do
# not return a subclass
@pytest.mark.parametrize("value", [1, np.... |
import numpy as np
import pytest
from pandas._config import using_string_dtype
import pandas._config.config as cf
from pandas import Index
import pandas._testing as tm
class TestIndexRendering:
def test_repr_is_valid_construction_code(self):
# for the case of Index, where the repr is traditional rather ... |
import numpy as np
import pytest
from pandas._libs import index as libindex
import pandas as pd
from pandas import (
Index,
NaT,
)
import pandas._testing as tm
class TestGetSliceBounds:
@pytest.mark.parametrize("side, expected", [("left", 4), ("right", 5)])
def test_get_slice_bounds_within(self, sid... |
"""
Tests for ndarray-like method on the base Index class
"""
import numpy as np
import pytest
import pandas as pd
from pandas import Index
import pandas._testing as tm
class TestReshape:
def test_repeat(self):
repeats = 2
index = Index([1, 2, 3])
expected = Index([1, 1, 2, 2, 3, 3])
... |
from pandas import Index
import pandas._testing as tm
def test_pickle_preserves_object_dtype():
# GH#43188, GH#43155 don't infer numeric dtype
index = Index([1, 2, 3], dtype=object)
result = tm.round_trip_pickle(index)
assert result.dtype == object
tm.assert_index_equal(index, result)
|
from datetime import datetime
import numpy as np
import pytest
import pandas as pd
from pandas import (
Index,
Series,
)
import pandas._testing as tm
from pandas.core.algorithms import safe_sort
def equal_contents(arr1, arr2) -> bool:
"""
Checks if the set of unique elements of arr1 and arr2 are equ... |
from datetime import timedelta
import numpy as np
import pytest
from pandas.core.dtypes.common import is_integer
from pandas import (
DateOffset,
Interval,
IntervalIndex,
Timedelta,
Timestamp,
date_range,
interval_range,
timedelta_range,
)
import pandas._testing as tm
from pandas.tse... |
import pytest
from pandas import (
IntervalIndex,
MultiIndex,
RangeIndex,
)
import pandas._testing as tm
@pytest.fixture
def range_index():
return RangeIndex(3, name="range_index")
@pytest.fixture
def interval_index():
return IntervalIndex.from_tuples(
[(0.0, 1.0), (1.0, 2.0), (1.5, 2.5... |
from functools import partial
import numpy as np
import pytest
import pandas.util._test_decorators as td
from pandas.core.dtypes.common import is_unsigned_integer_dtype
from pandas.core.dtypes.dtypes import IntervalDtype
from pandas import (
Categorical,
CategoricalDtype,
CategoricalIndex,
Index,
... |
import numpy as np
import pytest
from pandas import (
DataFrame,
DatetimeIndex,
Index,
Interval,
IntervalIndex,
Series,
Timedelta,
Timestamp,
)
import pandas._testing as tm
class TestIntervalIndexRendering:
# TODO: this is a test for DataFrame/Series, not IntervalIndex
@pytest... |
import numpy as np
from pandas import (
IntervalIndex,
date_range,
)
class TestEquals:
def test_equals(self, closed):
expected = IntervalIndex.from_breaks(np.arange(5), closed=closed)
assert expected.equals(expected)
assert expected.equals(expected.copy())
assert not expe... |
import pytest
from pandas import IntervalIndex
import pandas._testing as tm
class TestPickle:
@pytest.mark.parametrize("closed", ["left", "right", "both"])
def test_pickle_round_trip_closed(self, closed):
# https://github.com/pandas-dev/pandas/issues/35658
idx = IntervalIndex.from_tuples([(1,... |
import re
import numpy as np
import pytest
from pandas.core.dtypes.dtypes import (
CategoricalDtype,
IntervalDtype,
)
from pandas import (
CategoricalIndex,
Index,
IntervalIndex,
NaT,
Timedelta,
Timestamp,
interval_range,
)
import pandas._testing as tm
class AstypeTests:
"""... |
import numpy as np
import pytest
from pandas import (
Index,
IntervalIndex,
Timestamp,
interval_range,
)
import pandas._testing as tm
def monotonic_index(start, end, dtype="int64", closed="right"):
return IntervalIndex.from_breaks(np.arange(start, end, dtype=dtype), closed=closed)
def empty_ind... |
from itertools import permutations
import numpy as np
import pytest
from pandas._libs.interval import IntervalTree
from pandas.compat import IS64
import pandas._testing as tm
def skipif_32bit(param):
"""
Skip parameters in a parametrize on 32bit systems. Specifically used
here to skip leaf_size paramet... |
"""
Tests involving custom Index subclasses
"""
import numpy as np
from pandas import (
DataFrame,
Index,
)
import pandas._testing as tm
class CustomIndex(Index):
def __new__(cls, data, name=None):
# assert that this index class cannot hold strings
if any(isinstance(val, str) for val in d... |
import numpy as np
import pytest
from pandas import (
Series,
array,
)
@pytest.fixture(params=[None, False])
def sort(request):
"""
Valid values for the 'sort' parameter used in the Index
setops methods (intersection, union, etc.)
Caution:
Don't confuse this one with the "sort" fixtu... |
import re
import numpy as np
import pytest
from pandas._libs import index as libindex
import pandas as pd
@pytest.fixture(
params=[
(libindex.Int64Engine, np.int64),
(libindex.Int32Engine, np.int32),
(libindex.Int16Engine, np.int16),
(libindex.Int8Engine, np.int8),
(libi... |
""" generic datetimelike tests """
import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
class TestDatetimeLike:
@pytest.fixture(
params=[
pd.period_range("20130101", periods=5, freq="D"),
pd.TimedeltaIndex(
[
"0 day... |
from datetime import time
import locale
import numpy as np
import pytest
from pandas.compat import PY311
from pandas import Series
import pandas._testing as tm
from pandas.core.tools.times import to_time
# The tests marked with this are locale-dependent.
# They pass, except when the machine locale is zh_CN or it_IT... |
from datetime import (
time,
timedelta,
)
import numpy as np
import pytest
from pandas.compat import IS64
from pandas.errors import OutOfBoundsTimedelta
import pandas as pd
from pandas import (
Series,
TimedeltaIndex,
isna,
to_timedelta,
)
import pandas._testing as tm
from pandas.core.arrays ... |
""" test orc compat """
import datetime
from decimal import Decimal
from io import BytesIO
import os
import pathlib
import numpy as np
import pytest
import pandas as pd
from pandas import read_orc
import pandas._testing as tm
from pandas.core.arrays import StringArray
pytest.importorskip("pyarrow.orc")
import pyarr... |
"""
Tests for the pandas custom headers in http(s) requests
"""
from functools import partial
import gzip
from io import BytesIO
import pytest
from pandas._config import using_string_dtype
import pandas.util._test_decorators as td
import pandas as pd
import pandas._testing as tm
pytestmark = [
pytest.mark.sing... |
import gzip
import io
import os
from pathlib import Path
import subprocess
import sys
import tarfile
import textwrap
import time
import zipfile
import numpy as np
import pytest
from pandas.compat import is_platform_windows
import pandas as pd
import pandas._testing as tm
import pandas.io.common as icom
@pytest.ma... |
from contextlib import closing
from pathlib import Path
import re
import numpy as np
import pytest
from pandas._libs.tslibs import Timestamp
from pandas.compat import is_platform_windows
import pandas as pd
from pandas import (
DataFrame,
HDFStore,
Index,
Series,
_testing as tm,
date_range,
... |
import datetime
import numpy as np
import pytest
from pandas import (
DataFrame,
DatetimeIndex,
Series,
_testing as tm,
date_range,
period_range,
)
from pandas.tests.io.pytables.common import ensure_clean_store
pytestmark = pytest.mark.single_cpu
@pytest.mark.parametrize("unit", ["us", "ns"... |
import datetime
import re
import numpy as np
import pytest
from pandas._libs.tslibs import Timestamp
from pandas.compat import is_platform_windows
import pandas as pd
from pandas import (
DataFrame,
DatetimeIndex,
Index,
Series,
_testing as tm,
bdate_range,
date_range,
read_hdf,
)
fro... |
import os
import numpy as np
import pytest
from pandas.compat import (
PY311,
is_ci_environment,
is_platform_linux,
is_platform_little_endian,
)
from pandas.errors import (
ClosedFileError,
PossibleDataLossError,
)
from pandas import (
DataFrame,
HDFStore,
Index,
Series,
_... |
import datetime
from io import BytesIO
import re
import numpy as np
import pytest
from pandas import (
CategoricalIndex,
DataFrame,
HDFStore,
Index,
MultiIndex,
_testing as tm,
date_range,
read_hdf,
)
from pandas.tests.io.pytables.common import ensure_clean_store
from pandas.io.pytabl... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.