text stringlengths 0 20k |
|---|
import pytest
from pandas.util._validators import validate_args
@pytest.fixture
def _fname():
return "func"
def test_bad_min_fname_arg_count(_fname):
msg = "'max_fname_arg_count' must be non-negative"
with pytest.raises(ValueError, match=msg):
validate_args(_fname, (None,), -1, "foo")
def te... |
import pytest
from pandas import Categorical
import pandas._testing as tm
@pytest.mark.parametrize(
"c",
[Categorical([1, 2, 3, 4]), Categorical([1, 2, 3, 4], categories=[1, 2, 3, 4, 5])],
)
def test_categorical_equal(c):
tm.assert_categorical_equal(c, c)
@pytest.mark.parametrize("check_category_order"... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
Categorical,
DataFrame,
Series,
)
import pandas._testing as tm
def _assert_series_equal_both(a, b, **kwargs):
"""
Check that two Series equal.
This check is performed commutatively.
Parameters
----------
a... |
import pytest
from pandas.util._validators import validate_args_and_kwargs
@pytest.fixture
def _fname():
return "func"
def test_invalid_total_length_max_length_one(_fname):
compat_args = ("foo",)
kwargs = {"foo": "FOO"}
args = ("FoO", "BaZ")
min_fname_arg_count = 0
max_length = len(compat_... |
import warnings
import pytest
from pandas.util._exceptions import rewrite_warning
import pandas._testing as tm
@pytest.mark.parametrize(
"target_category, target_message, hit",
[
(FutureWarning, "Target message", True),
(FutureWarning, "Target", True),
(FutureWarning, "get mess", Tr... |
from textwrap import dedent
from pandas.util._decorators import doc
@doc(method="cumsum", operation="sum")
def cumsum(whatever):
"""
This is the {method} method.
It computes the cumulative {operation}.
"""
@doc(
cumsum,
dedent(
"""
Examples
--------
>>> cum... |
import pytest
from pandas.util._validators import (
validate_bool_kwarg,
validate_kwargs,
)
@pytest.fixture
def _fname():
return "func"
def test_bad_kwarg(_fname):
good_arg = "f"
bad_arg = good_arg + "o"
compat_args = {good_arg: "foo", bad_arg + "o": "bar"}
kwargs = {good_arg: "foo", b... |
import numpy as np
import pytest
from pandas import (
NA,
Categorical,
CategoricalIndex,
Index,
MultiIndex,
NaT,
RangeIndex,
)
import pandas._testing as tm
def test_index_equal_levels_mismatch():
msg = """Index are different
Index levels are different
\\[left\\]: 1, Index\\(\\[1, 2,... |
import numpy as np
import pytest
from pandas.util._validators import validate_inclusive
import pandas as pd
@pytest.mark.parametrize(
"invalid_inclusive",
(
"ccc",
2,
object(),
None,
np.nan,
pd.NA,
pd.DataFrame(),
),
)
def test_invalid_inclusive(in... |
import numpy as np
import pytest
from pandas import (
Timestamp,
array,
)
import pandas._testing as tm
from pandas.core.arrays.sparse import SparseArray
@pytest.mark.parametrize(
"kwargs",
[
{}, # Default is check_exact=False
{"check_exact": False},
{"check_exact": True},
... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
Index,
MultiIndex,
Series,
period_range,
timedelta_range,
)
import pandas._testing as tm
from pandas.core.util.hashing import hash_tuples
from pandas.util import (
hash_array,
hash_pandas_object,
)
@p... |
import pytest
from pandas.util._decorators import deprecate_kwarg
import pandas._testing as tm
@deprecate_kwarg("old", "new")
def _f1(new=False):
return new
_f2_mappings = {"yes": True, "no": False}
@deprecate_kwarg("old", "new", _f2_mappings)
def _f2(new=False):
return new
def _f3_mapping(x):
ret... |
import copy
import numpy as np
import pytest
import pandas as pd
from pandas import Timestamp
import pandas._testing as tm
def test_assert_numpy_array_equal_shape_mismatch():
msg = """numpy array are different
numpy array shapes are different
\\[left\\]: \\(2L*,\\)
\\[right\\]: \\(3L*,\\)"""
with pytest.... |
import json
import os
import re
from pandas.util._print_versions import (
_get_dependency_info,
_get_sys_info,
)
import pandas as pd
def test_show_versions(tmpdir):
# GH39701
as_json = os.path.join(tmpdir, "test_output.json")
pd.show_versions(as_json=as_json)
with open(as_json, encoding="u... |
from types import SimpleNamespace
import pytest
from pandas.core.dtypes.common import is_float
import pandas._testing as tm
def test_assert_attr_equal(nulls_fixture):
obj = SimpleNamespace()
obj.na_value = nulls_fixture
tm.assert_attr_equal("na_value", obj, obj)
def test_assert_attr_equal_different_n... |
"""
Tests for the `deprecate_nonkeyword_arguments` decorator
"""
import inspect
from pandas.util._decorators import deprecate_nonkeyword_arguments
import pandas._testing as tm
@deprecate_nonkeyword_arguments(
version="1.1", allowed_args=["a", "b"], name="f_add_inputs"
)
def f(a, b=0, c=0, d=0):
return a + ... |
import pytest
from pandas import interval_range
import pandas._testing as tm
@pytest.mark.parametrize(
"kwargs",
[
{"start": 0, "periods": 4},
{"start": 1, "periods": 5},
{"start": 5, "end": 10, "closed": "left"},
],
)
def test_interval_array_equal(kwargs):
arr = interval_rang... |
import pytest
import pandas.util._test_decorators as td
from pandas import option_context
@td.skip_if_installed("numba")
def test_numba_not_installed_option_context():
with pytest.raises(ImportError, match="Missing optional"):
with option_context("compute.use_numba", True):
pass
|
""""
Test module for testing ``pandas._testing.assert_produces_warning``.
"""
import warnings
import pytest
from pandas.errors import (
DtypeWarning,
PerformanceWarning,
)
import pandas._testing as tm
@pytest.fixture(
params=[
RuntimeWarning,
ResourceWarning,
UserWarning,
... |
import numpy as np
import pytest
from pandas import (
NA,
DataFrame,
Index,
NaT,
Series,
Timestamp,
)
import pandas._testing as tm
def _assert_almost_equal_both(a, b, **kwargs):
"""
Check that two objects are approximately equal.
This check is performed commutatively.
Parame... |
import pytest
@pytest.fixture(params=[True, False])
def check_dtype(request):
return request.param
@pytest.fixture(params=[True, False])
def check_exact(request):
return request.param
@pytest.fixture(params=[True, False])
def check_index_type(request):
return request.param
@pytest.fixture(params=[0.... |
import os
import pytest
from pandas import (
array,
compat,
)
import pandas._testing as tm
def test_numpy_err_state_is_default():
expected = {"over": "warn", "divide": "warn", "invalid": "warn", "under": "ignore"}
import numpy as np
# The error state should be unchanged after that import.
a... |
import pytest
import pandas as pd
from pandas import DataFrame
import pandas._testing as tm
@pytest.fixture(params=[True, False])
def by_blocks_fixture(request):
return request.param
@pytest.fixture(params=["DataFrame", "Series"])
def obj_fixture(request):
return request.param
def _assert_frame_equal_bot... |
import numpy as np
import pandas.util._test_decorators as td
import pandas as pd
import pandas._testing as tm
def test_shares_memory_interval():
obj = pd.interval_range(1, 5)
assert tm.shares_memory(obj, obj)
assert tm.shares_memory(obj, obj._data)
assert tm.shares_memory(obj, obj[::-1])
assert... |
from textwrap import dedent
import pytest
from pandas.util._decorators import deprecate
import pandas._testing as tm
def new_func():
"""
This is the summary. The deprecate directive goes next.
This is the extended summary. The deprecate directive goes before this.
"""
return "new_func called"
... |
"""
Testing that we work in the downstream packages
"""
import array
import subprocess
import sys
import numpy as np
import pytest
from pandas.errors import IntCastingNaNError
import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
DataFrame,
DatetimeIndex,
Series,
Timedelt... |
import re
import numpy as np
import pytest
import pandas.util._test_decorators as td
from pandas import (
DataFrame,
Index,
MultiIndex,
Series,
_testing as tm,
concat,
option_context,
)
@pytest.mark.parametrize("other", [None, Series, Index])
def test_str_cat_name(index_or_series, other... |
import numpy as np
from pandas import (
DataFrame,
Index,
MultiIndex,
Series,
_testing as tm,
)
def test_get_dummies(any_string_dtype):
s = Series(["a|b", "a|c", np.nan], dtype=any_string_dtype)
result = s.str.get_dummies("|")
expected = DataFrame([[1, 1, 0], [1, 0, 1], [0, 0, 0]], co... |
import numpy as np
import pytest
from pandas._libs import lib
from pandas import (
NA,
DataFrame,
Series,
_testing as tm,
option_context,
)
def test_string_array(nullable_string_dtype, any_string_method):
method_name, args, kwargs = any_string_method
data = ["a", "bb", np.nan, "ccc"]
... |
import numpy as np
import pytest
from pandas import (
CategoricalDtype,
DataFrame,
Index,
MultiIndex,
Series,
_testing as tm,
option_context,
)
from pandas.core.strings.accessor import StringMethods
# subset of the full set from pandas/conftest.py
_any_allowed_skipna_inferred_dtype = [
... |
import numpy as np
import pandas as pd
def is_object_or_nan_string_dtype(dtype):
"""
Check if string-like dtype is following NaN semantics, i.e. is object
dtype or a NaN-variant of the StringDtype.
"""
return (isinstance(dtype, np.dtype) and dtype == "object") or (
dtype.na_value is np.na... |
from datetime import datetime
import operator
import numpy as np
import pytest
from pandas import (
Series,
_testing as tm,
)
def test_title(any_string_dtype):
s = Series(["FOO", "BAR", np.nan, "Blah", "blurg"], dtype=any_string_dtype)
result = s.str.title()
expected = Series(["Foo", "Bar", np.n... |
import pytest
from pandas import Series
from pandas.core.strings.accessor import StringMethods
_any_string_method = [
("cat", (), {"sep": ","}),
("cat", (Series(list("zyx")),), {"sep": ",", "join": "left"}),
("center", (10,), {}),
("contains", ("a",), {}),
("count", ("a",), {}),
("decode", ("U... |
import pytest
from pandas.compat._optional import VERSIONS
import pandas as pd
from pandas.core.computation import expr
from pandas.core.computation.engines import ENGINES
from pandas.util.version import Version
def test_compat():
# test we have compat with our version of numexpr
from pandas.core.computati... |
import pickle
import numpy as np
import pytest
from pandas._libs import (
Timedelta,
lib,
writers as libwriters,
)
from pandas.compat import IS64
from pandas import Index
import pandas._testing as tm
class TestMisc:
def test_max_len_string_array(self):
arr = a = np.array(["foo", "b", np.nan... |
from datetime import datetime
from itertools import permutations
import numpy as np
from pandas._libs import algos as libalgos
import pandas._testing as tm
def test_ensure_platform_int():
arr = np.arange(100, dtype=np.intp)
result = libalgos.ensure_platform_int(arr)
assert result is arr
def test_is_... |
import numpy as np
import pytest
from pandas._libs import join as libjoin
from pandas._libs.join import (
inner_join,
left_outer_join,
)
import pandas._testing as tm
class TestIndexer:
@pytest.mark.parametrize(
"dtype", ["int32", "int64", "float32", "float64", "object"]
)
def test_outer_... |
from copy import deepcopy
from operator import methodcaller
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
MultiIndex,
Series,
date_range,
)
import pandas._testing as tm
class TestDataFrame:
@pytest.mark.parametrize("func", ["_set_axis_name", "rename_axis"])... |
from copy import (
copy,
deepcopy,
)
import numpy as np
import pytest
from pandas.core.dtypes.common import is_scalar
from pandas import (
DataFrame,
Index,
Series,
date_range,
)
import pandas._testing as tm
# ----------------------------------------------------------------------
# Generic t... |
import pytest
from pandas.core.dtypes.missing import array_equivalent
import pandas as pd
# Fixtures
# ========
@pytest.fixture
def df():
"""DataFrame with columns 'L1', 'L2', and 'L3'"""
return pd.DataFrame({"L1": [1, 2, 3], "L2": [11, 12, 13], "L3": ["A", "B", "C"]})
@pytest.fixture(params=[[], ["L1"], ... |
import numpy as np
import pytest
from pandas import (
Categorical,
DataFrame,
MultiIndex,
Series,
StringDtype,
date_range,
)
import pandas._testing as tm
from pandas.util.version import Version
xarray = pytest.importorskip("xarray")
class TestDataFrameToXArray:
@pytest.fixture
def df... |
"""Tests dealing with the NDFrame.allows_duplicates."""
import operator
import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
not_implemented = pytest.mark.xfail(reason="Not implemented.")
# ----------------------------------------------------------------------------
# Preservation
cla... |
from operator import methodcaller
import numpy as np
import pytest
import pandas as pd
from pandas import (
MultiIndex,
Series,
date_range,
)
import pandas._testing as tm
class TestSeries:
@pytest.mark.parametrize("func", ["rename_axis", "_set_axis_name"])
def test_set_axis_name_mi(self, func):
... |
import pytest
from pandas.errors import (
AbstractMethodError,
UndefinedVariableError,
)
import pandas as pd
@pytest.mark.parametrize(
"exc",
[
"AttributeConflictWarning",
"CSSWarning",
"CategoricalConversionWarning",
"ClosedFileError",
"DataError",
"D... |
import numpy as np
import pytest
from pandas.core.apply import (
_make_unique_kwarg_list,
maybe_mangle_lambdas,
)
def test_maybe_mangle_lambdas_passthrough():
assert maybe_mangle_lambdas("mean") == "mean"
assert maybe_mangle_lambdas(lambda x: x).__name__ == "<lambda>"
# don't mangel single lambda... |
import numpy as np
import pandas as pd
from pandas import (
DataFrame,
Index,
)
import pandas._testing as tm
def test_pipe():
# Test the pipe method of DataFrameGroupBy.
# Issue #17871
random_state = np.random.default_rng(2)
df = DataFrame(
{
"A": ["foo", "bar", "foo", "... |
"""
Tests that apply to all groupby operation methods.
The only tests that should appear here are those that use the `groupby_func` fixture.
Even if it does use that fixture, prefer a more specific test file if it available
such as:
- test_categorical
- test_groupby_dropna
- test_groupby_subclass
- test_raises
""... |
import numpy as np
import pytest
from pandas._libs import lib
import pandas.util._test_decorators as td
import pandas as pd
import pandas._testing as tm
def assert_block_lengths(x):
assert len(x) == len(x._mgr.blocks[0].mgr_locs)
return 0
def cumsum_max(x):
x.cumsum().max()
return 0
@pytest.mark... |
from itertools import product
from string import ascii_lowercase
import numpy as np
import pytest
from pandas import (
DataFrame,
Index,
MultiIndex,
Period,
Series,
Timedelta,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestCounting:
def test_cumcount(self):
... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
Index,
date_range,
)
import pandas._testing as tm
@pytest.mark.parametrize("func", ["ffill", "bfill"])
def test_groupby_column_index_name_lost_fill_funcs(func):
# GH: 29764 groupby loses index sometimes
df = Data... |
# Test GroupBy._positional_selector positional grouped indexing GH#42864
import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
@pytest.mark.parametrize(
"arg, expected_rows",
[
[0, [0, 1, 4]],
[2, [5]],
[5, []],
[-1, [3, 4, 7]],
[-2, [1, 6]... |
"""
Tests of the groupby API, including internal consistency and with other pandas objects.
Tests in this file should only check the existence, names, and arguments of groupby
methods. It should not test the results of any groupby operation.
"""
import inspect
import pytest
from pandas import (
DataFrame,
S... |
def get_groupby_method_args(name, obj):
"""
Get required arguments for a groupby method.
When parametrizing a test over groupby methods (e.g. "sum", "mean", "fillna"),
it is often the case that arguments are required for certain methods.
Parameters
----------
name: str
Name of the ... |
import pytest
from pandas.compat import is_platform_arm
from pandas import (
DataFrame,
Series,
option_context,
)
import pandas._testing as tm
from pandas.util.version import Version
pytestmark = [pytest.mark.single_cpu]
numba = pytest.importorskip("numba")
pytestmark.append(
pytest.mark.skipif(
... |
import numpy as np
import pytest
from pandas._libs import groupby as libgroupby
from pandas._libs.groupby import (
group_cumprod,
group_cumsum,
group_mean,
group_sum,
group_var,
)
from pandas.core.dtypes.common import ensure_platform_int
from pandas import isna
import pandas._testing as tm
clas... |
import re
import numpy as np
import pytest
from pandas._libs import lib
import pandas as pd
from pandas import (
DataFrame,
Index,
Series,
Timestamp,
date_range,
)
import pandas._testing as tm
from pandas.tests.groupby import get_groupby_method_args
class TestNumericOnly:
# make sure that w... |
import numpy as np
import pytest
from pandas.compat import is_platform_arm
from pandas.errors import NumbaUtilError
from pandas import (
DataFrame,
Series,
option_context,
)
import pandas._testing as tm
from pandas.util.version import Version
pytestmark = [pytest.mark.single_cpu]
numba = pytest.importor... |
from datetime import datetime
import numpy as np
import pytest
from pandas import (
DataFrame,
Index,
Series,
)
import pandas._testing as tm
from pandas.tests.groupby import get_groupby_method_args
pytestmark = pytest.mark.filterwarnings(
"ignore:Passing a BlockManager|Passing a SingleBlockManager:De... |
import numpy as np
import pytest
from pandas import (
DataFrame,
Index,
Series,
date_range,
)
from pandas.core.groupby.base import (
reduction_kernels,
transformation_kernels,
)
@pytest.fixture(params=[True, False])
def sort(request):
return request.param
@pytest.fixture(params=[True, F... |
import numpy as np
import pytest
from pandas import (
DataFrame,
Index,
Series,
)
import pandas._testing as tm
@pytest.mark.parametrize(
"in_vals, out_vals",
[
# Basics: strictly increasing (T), strictly decreasing (F),
# abs val increasing (F), non-strictly increasing (T)
... |
import pytest
from pandas import (
DataFrame,
Index,
Series,
)
import pandas._testing as tm
@pytest.mark.parametrize("n, frac", [(2, None), (None, 0.2)])
def test_groupby_sample_balanced_groups_shape(n, frac):
values = [1] * 10 + [2] * 10
df = DataFrame({"a": values, "b": values})
result = d... |
import numpy as np
import pytest
from pandas.core.dtypes.common import is_integer_dtype
from pandas import (
DataFrame,
Index,
PeriodIndex,
Series,
)
import pandas._testing as tm
@pytest.mark.parametrize("by", ["A", "B", ["A", "B"]])
def test_size(df, by):
grouped = df.groupby(by=by)
result ... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
Index,
)
import pandas._testing as tm
@pytest.mark.parametrize(
"interpolation", ["linear", "lower", "higher", "nearest", "midpoint"]
)
@pytest.mark.parametrize(
"a_vals,b_vals",
[
# Ints
([1, 2, ... |
import numpy as np
import pandas as pd
import pandas._testing as tm
def test_groupby_skew_equivalence():
# Test that that groupby skew method (which uses libgroupby.group_skew)
# matches the results of operating group-by-group (which uses nanops.nanskew)
nrows = 1000
ngroups = 3
ncols = 2
na... |
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
Index,
MultiIndex,
Series,
Timestamp,
date_range,
)
import pandas._testing as tm
def test_apply_describe_bug(multiindex_dataframe_random_data):
grouped = multiindex_dataframe_random_data.groupby(level="fi... |
import numpy as np
from pandas import (
DataFrame,
Index,
Series,
)
import pandas._testing as tm
def test_corrwith_with_1_axis():
# GH 47723
df = DataFrame({"a": [1, 1, 2], "b": [3, 7, 4]})
gb = df.groupby("a")
msg = "DataFrameGroupBy.corrwith with axis=1 is deprecated"
with tm.asser... |
import numpy as np
import pytest
from pandas import (
MultiIndex,
Series,
date_range,
)
import pandas._testing as tm
def test_nlargest():
a = Series([1, 3, 5, 7, 2, 9, 0, 4, 6, 10])
b = Series(list("a" * 5 + "b" * 5))
gb = a.groupby(b)
r = gb.nlargest(3)
e = Series(
[7, 5, 3, ... |
import numpy as np
import pytest
from pandas import (
DataFrame,
NaT,
Series,
Timedelta,
Timestamp,
date_range,
)
import pandas._testing as tm
def test_group_shift_with_null_key():
# This test is designed to replicate the segfault in issue #13813.
n_rows = 1200
# Generate a moder... |
"""
test cython .agg behavior
"""
import numpy as np
import pytest
from pandas.core.dtypes.common import (
is_float_dtype,
is_integer_dtype,
)
import pandas as pd
from pandas import (
DataFrame,
Index,
NaT,
Series,
Timedelta,
Timestamp,
bdate_range,
)
import pandas._testing as tm
... |
import numpy as np
import pytest
from pandas.compat import is_platform_arm
from pandas.errors import NumbaUtilError
from pandas import (
DataFrame,
Index,
NamedAgg,
Series,
option_context,
)
import pandas._testing as tm
from pandas.util.version import Version
pytestmark = [pytest.mark.single_cpu]... |
import numpy as np
import pandas as pd
import pandas._testing as tm
def test_group_by_copy():
# GH#44803
df = pd.DataFrame(
{
"name": ["Alice", "Bob", "Carl"],
"age": [20, 21, 20],
}
).set_index("name")
msg = "DataFrameGroupBy.apply operated on the grouping co... |
import numpy as np
import pytest
from pandas.errors import UnsupportedFunctionCall
import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
DataFrame,
Series,
)
import pandas._testing as tm
@pytest.fixture(
params=[np.int32, np.int64, np.float32, np.float64, "Int64", "Float64"]... |
import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
@pytest.fixture(params=[["inner"], ["inner", "outer"]])
def frame(request):
levels = request.param
df = pd.DataFrame(
{
"outer": ["a", "a", "a", "b", "b", "b"],
"inner": [1, 2, 3, 1, 2, 3],
... |
import numpy as np
import pytest
import pandas as pd
from pandas.core.interchange.utils import dtype_to_arrow_c_fmt
# TODO: use ArrowSchema to get reference C-string.
# At the time, there is no way to access ArrowSchema holding a type format string
# from python. The only way to access it is to export the structure t... |
"""
A verbatim copy (vendored) of the spec tests.
Taken from https://github.com/data-apis/dataframe-api
"""
import ctypes
import math
import pytest
import pandas as pd
@pytest.fixture
def df_from_dict():
def maker(dct, is_categorical=False):
df = pd.DataFrame(dct)
return df.astype("category") if... |
import re
import numpy as np
import pytest
from pandas import DataFrame
import pandas._testing as tm
from pandas.tests.plotting.common import (
_check_axes_shape,
_check_plot_works,
get_x_axis,
get_y_axis,
)
pytest.importorskip("matplotlib")
@pytest.fixture
def hist_df():
df = DataFrame(
... |
import numpy as np
import pytest
import pandas.util._test_decorators as td
from pandas import (
DataFrame,
date_range,
)
from pandas.tests.plotting.common import (
_check_legend_labels,
_check_legend_marker,
_check_text_labels,
)
from pandas.util.version import Version
mpl = pytest.importorskip("... |
""" Test cases for DataFrame.plot """
import pytest
from pandas import DataFrame
from pandas.tests.plotting.common import _check_visible
pytest.importorskip("matplotlib")
class TestDataFramePlotsGroupby:
def _assert_ytickslabels_visibility(self, axes, expected):
for ax, exp in zip(axes, expected):
... |
"""
Module consolidating common testing functions for checking plotting.
"""
from __future__ import annotations
from typing import TYPE_CHECKING
import numpy as np
from pandas.core.dtypes.api import is_list_like
import pandas as pd
from pandas import Series
import pandas._testing as tm
if TYPE_CHECKING:
from ... |
import sys
import types
import pytest
import pandas.util._test_decorators as td
import pandas
@pytest.fixture
def dummy_backend():
db = types.ModuleType("pandas_dummy_backend")
setattr(db, "plot", lambda *args, **kwargs: "used_dummy")
return db
@pytest.fixture
def restore_backend():
"""Restore th... |
import pytest
from pandas import DataFrame
from pandas.tests.plotting.common import (
_check_plot_works,
_check_ticks_props,
_gen_two_subplots,
)
plt = pytest.importorskip("matplotlib.pyplot")
class TestCommon:
def test__check_ticks_props(self):
# GH 34768
df = DataFrame({"b": [0, 1,... |
import pytest
from pandas import Series
pytest.importorskip("matplotlib")
from pandas.plotting._matplotlib.style import get_standard_colors
class TestGetStandardColors:
@pytest.mark.parametrize(
"num_colors, expected",
[
(3, ["red", "green", "blue"]),
(5, ["red", "green",... |
import gc
import numpy as np
import pytest
from pandas import (
DataFrame,
to_datetime,
)
@pytest.fixture(autouse=True)
def mpl_cleanup():
# matplotlib/testing/decorators.py#L24
# 1) Resets units registry
# 2) Resets rc_context
# 3) Closes all figures
mpl = pytest.importorskip("matplotli... |
""" Test cases for GroupBy.plot """
import numpy as np
import pytest
from pandas import (
DataFrame,
Index,
Series,
)
from pandas.tests.plotting.common import (
_check_axes_shape,
_check_legend_labels,
)
pytest.importorskip("matplotlib")
class TestDataFrameGroupByPlots:
def test_series_gro... |
from datetime import (
date,
datetime,
)
import subprocess
import sys
import numpy as np
import pytest
import pandas._config.config as cf
from pandas._libs.tslibs import to_offset
from pandas import (
Index,
Period,
PeriodIndex,
Series,
Timestamp,
arrays,
date_range,
)
import pan... |
import re
import numpy as np
import pytest
from pandas._libs.tslibs.timedeltas import (
array_to_timedelta64,
delta_to_nanoseconds,
ints_to_pytimedelta,
)
from pandas import (
Timedelta,
offsets,
)
import pandas._testing as tm
@pytest.mark.parametrize(
"obj,expected",
[
(np.time... |
import pytest
from pandas._libs.tslibs.parsing import get_rule_month
from pandas.tseries import offsets
@pytest.mark.parametrize(
"obj,expected",
[
("W", "DEC"),
(offsets.Week().freqstr, "DEC"),
("D", "DEC"),
(offsets.Day().freqstr, "DEC"),
("Q", "DEC"),
(offs... |
import numpy as np
import pytest
import pytz
from pandas._libs.tslibs import (
Resolution,
get_resolution,
)
from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
import pandas._testing as tm
def test_get_resolution_nano():
# don't return the fallback RESO_DAY
arr = np.array([1], dtype=np.int64)
... |
import numpy as np
import pytest
from pandas._libs.tslibs import fields
import pandas._testing as tm
@pytest.fixture
def dtindex():
dtindex = np.arange(5, dtype=np.int64) * 10**9 * 3600 * 24 * 32
dtindex.flags.writeable = False
return dtindex
def test_get_date_name_field_readonly(dtindex):
# https... |
from datetime import (
date,
datetime,
)
from hypothesis import given
import numpy as np
import pytest
from pandas._libs.tslibs import ccalendar
from pandas._testing._hypothesis import DATETIME_IN_PD_TIMESTAMP_RANGE_NO_TZ
@pytest.mark.parametrize(
"date_tuple,expected",
[
((2001, 3, 1), 60)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.